Slic3r::GUI::Plater Class Reference

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

Inheritance diagram for Slic3r::GUI::Plater:

Collaboration diagram for Slic3r::GUI::Plater:

Classes
struct	ImexGhostTooltip
class	SuppressSnapshots
class	TakeSnapshot
class	SingleSnapshot
struct	priv

Public Types
enum class	PrinterWarningType { NOT_CONNECTED , INCONSISTENT , UNINSTALL_FILAMENT , EMPTY_FILAMENT }

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 ()
bool	Show (bool show=true)
bool	is_project_dirty () const
bool	is_presets_dirty () const
void	set_plater_dirty (bool is_dirty)
void	update_project_dirty_from_presets ()
void	normalize_bed_types (bool printer_setting_changed)
int	save_project_if_dirty (const wxString &reason)
void	reset_project_dirty_after_save ()
void	reset_project_dirty_initial_presets ()
Sidebar &	sidebar ()
const Model &	model () const
Model &	model ()
const Print &	fff_print () const
Print &	fff_print ()
const SLAPrint &	sla_print () const
SLAPrint &	sla_print ()
std::vector< size_t >	mixed_filament_config_indices () const
std::vector< size_t >	physical_filament_config_indices () const
int	new_project (bool skip_confirm=false, bool silent=false, const wxString &project_name=wxString(), bool reload_presets=true)
void	load_project (wxString const &filename="", wxString const &originfile="-")
int	save_project (bool saveAs=false)
void	import_model_id (wxString download_info)
void	download_project (const wxString &project_id)
void	request_model_download (wxString url)
void	request_download_project (std::string project_id)
bool	up_to_date (bool saved, bool backup)
bool	open_3mf_file (const boost::filesystem::path &file_path)
int	get_3mf_file_count (std::vector< boost::filesystem::path > paths)
void	add_file ()
bool	add_model (bool imperial_units=false, std::string fname="")
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	reload_print ()
void	refresh_belt_view ()
void	calib_pa (const Calib_Params &params)
void	calib_flowrate (bool is_linear, int pass, InfillPattern pattern=ipArchimedeanChords)
void	calib_temp (const Calib_Params &params)
void	calib_max_vol_speed (const Calib_Params &params)
void	calib_retraction (const Calib_Params &params)
void	calib_VFA (const Calib_Params &params)
void	calib_input_shaping_freq (const Calib_Params &params)
void	calib_input_shaping_damp (const Calib_Params &params)
void	Calib_Cornering (const Calib_Params &params)
BuildVolume_Type	get_build_volume_type () const
bool	is_gcode_3mf ()
bool	only_gcode_mode ()
void	set_only_gcode (bool only_gcode)
bool	gcode_settings_loaded () const
bool	using_exported_file ()
void	set_using_exported_file (bool exported_file)
bool	is_empty_project ()
bool	is_multi_extruder_ams_empty ()
bool	is_new_project_and_check_state ()
wxString	get_project_name ()
void	update_all_plate_thumbnails (bool force_update=false)
void	update_plate_thumbnails (int plate_idx, bool force_update)
void	update_obj_preview_thumbnail (ModelObject *, int obj_idx, int vol_idx, std::vector< Slic3r::ColorRGBA > colors, int camera_view_angle_type)
void	invalid_all_plate_thumbnails ()
void	force_update_all_plate_thumbnails ()
const VendorProfile::PrinterModel *	get_curr_printer_model ()
std::map< std::string, std::string >	get_bed_texture_maps ()
bool	get_enable_wrapping_detection ()
bool	preview_zip_archive (const boost::filesystem::path &archive_path)
std::vector< size_t >	load_files (const std::vector< boost::filesystem::path > &input_files, LoadStrategy strategy=LoadStrategy::LoadModel|LoadStrategy::LoadConfig, bool ask_multi=false, bool *published_out=nullptr)
bool	load_files (const wxArrayString &filenames)
const wxString &	get_last_loaded_gcode () const
void	update (bool conside_update_flag=false, bool force_background_processing_update=false)
void	object_list_changed ()
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 no_slice=true)
void	reload_paint_after_background_process_apply ()
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	are_collision_volumes_shown () const
void	show_collision_volumes (bool show)
bool	is_view3D_overhang_shown () const
void	show_view3D_overhang (bool show)
bool	is_sidebar_enabled () const
void	enable_sidebar (bool enabled)
bool	is_sidebar_collapsed () const
void	collapse_sidebar (bool collapse)
Sidebar::DockingState	get_sidebar_docking_state () const
void	reset_window_layout ()
void	add_dock_pane (wxWindow *window, const std::string &name, const wxString &caption, const std::string &dock, const wxSize &size, std::function< void()> on_close)
void	remove_dock_pane (wxWindow *window)
void	show_dock_pane (wxWindow *window, bool show)
void	remove_dock_panes ()
void	update_ui_from_settings ()
void	select_curr_plate_all ()
void	remove_curr_plate_all ()
void	select_all ()
void	deselect_all ()
void	exit_gizmo ()
void	remove (size_t obj_idx)
void	reset (bool apply_presets_change=false, bool reload_presets=true)
void	reset_with_confirm ()
int	close_with_confirm (std::function< bool(bool yes_or_no)> second_check=nullptr)
void	trigger_restore_project (int skip_confirm=0)
bool	delete_object_from_model (size_t obj_idx, bool refresh_immediately=true)
void	delete_all_objects_from_model ()
void	set_selected_visible (bool visible)
void	remove_selected ()
void	increase_instances (size_t num=1)
void	decrease_instances (size_t num=1)
void	set_number_of_copies ()
void	fill_bed_with_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	cut (size_t obj_idx, size_t instance_idx, std::array< Vec3d, 4 > plane_points, ModelObjectCutAttributes attributes)
void	segment (size_t obj_idx, size_t instance_idx, double smoothing_alpha=0.5, int segment_number=5)
void	apply_cut_object_to_model (size_t init_obj_idx, const ModelObjectPtrs &cut_objects)
void	merge (size_t obj_idx, std::vector< int > &vol_indeces)
void	send_to_printer (bool isall=false)
void	export_gcode (bool prefer_removable)
void	export_gcode_3mf (bool export_all=false)
void	send_gcode_finish (wxString name)
void	export_core_3mf ()
bool	export_3mf_copy (const boost::filesystem::path &output_path)
int	export_published_3mf (const std::vector< std::string > &published_keys, const std::vector< Slic3r::PublishedMaterialEntry > &material_keys)
bool	get_pending_published (std::vector< std::string > &out_keys, std::vector< Slic3r::PublishedMaterialEntry > &out_material) const
void	set_pending_published (const std::vector< std::string > &published_keys, const std::vector< Slic3r::PublishedMaterialEntry > &material_keys)
void	export_stl (bool extended=false, bool selection_only=false, bool multi_stls=false, FileType file_type=FT_STL)
int	export_3mf (const boost::filesystem::path &output_path=boost::filesystem::path(), SaveStrategy strategy=SaveStrategy::Default, int export_plate_idx=-1, Export3mfProgressFn proFn=nullptr)
void	reload_from_disk ()
void	replace_with_stl ()
void	replace_all_with_stl ()
void	reload_all_from_disk ()
bool	has_toolpaths_to_export () const
void	export_toolpaths_to_obj () const
void	reslice ()
void	reslice_SLA_supports (const ModelObject &object, bool postpone_error_messages=false)
void	reslice_SLA_hollowing (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)
void	notify_painting_removed ()
void	changed_mesh (int obj_idx)
void	changed_object (ModelObject &object)
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)
BackgroundSlicingProcess &	background_process ()
int	send_gcode (int plate_idx=-1, Export3mfProgressFn proFn=nullptr)
void	send_gcode_legacy (int plate_idx=-1, Export3mfProgressFn proFn=nullptr)
int	export_config_3mf (int plate_idx=-1, Export3mfProgressFn proFn=nullptr)
void	send_calibration_job_finished (wxCommandEvent &evt)
void	print_job_finished (wxCommandEvent &evt)
void	send_job_finished (wxCommandEvent &evt)
void	open_platesettings_dialog (wxCommandEvent &evt)
void	open_filament_map_setting_dialog (wxCommandEvent &evt)
void	on_change_color_mode (SimpleEvent &evt)
void	eject_drive ()
void	take_snapshot (const std::string &snapshot_name)
void	take_snapshot (const std::string &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)
int	update_print_required_data (Slic3r::DynamicPrintConfig config, Slic3r::Model model, Slic3r::PlateDataPtrs plate_data_list, std::string file_name, std::string file_path)
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 ()
bool	leave_gizmos_stack ()
void	on_filament_change (size_t filament_idx)
void	on_filament_count_change (size_t extruders_count)
void	on_filaments_delete (size_t extruders_count, size_t filament_id, int replace_filament_id=-1, const std::vector< unsigned char > &is_mixed_before_delete={})
std::vector< Slic3r::ColorRGBA >	get_extruders_colors ()
void	on_bed_type_change (BedType bed_type)
bool	update_filament_colors_in_full_config ()
void	config_change_notification (const DynamicPrintConfig &config, const std::string &key)
void	on_config_change (const DynamicPrintConfig &config)
void	force_filament_colors_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_filament_colors_render_info () const
std::vector< std::string >	get_filament_color_render_type () const
const std::vector< std::vector< wxColour > > &	get_filament_gradient_ramps () const
std::vector< std::string >	get_colors_for_color_print (const GCodeProcessorResult *const result=nullptr) const
void	set_global_filament_map_mode (FilamentMapMode mode)
void	set_global_filament_map (const std::vector< int > &filament_map)
void	set_global_filament_volume_map (const std::vector< int > &filament_volume_map)
std::vector< int >	get_global_filament_map () const
std::vector< int >	get_global_filament_volume_map () const
FilamentMapMode	get_global_filament_map_mode () const
void	update_menus ()
wxString	get_selected_printer_name_in_combox ()
void	pop_warning_and_go_to_device_page (wxString printer_name, PrinterWarningType type, const wxString &title)
bool	check_printer_initialized (MachineObject *obj, bool only_warning=false, bool popup_warning=true)
bool	is_same_printer_for_connected_and_selected (bool popup_warning=true)
wxString	get_project_filename (const wxString &extension=wxEmptyString) const
wxString	get_export_gcode_filename (const wxString &extension=wxEmptyString, bool only_filename=false, bool export_all=false) const
void	set_project_filename (const wxString &filename)
void	update_print_error_info (int code, std::string msg, std::string extra)
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 (bool exclude_preview=false)
GLCanvas3D *	get_view3D_canvas3D ()
GLCanvas3D *	get_preview_canvas3D ()
GLCanvas3D *	get_assmeble_canvas3D ()
wxWindow *	get_select_machine_dialog ()
class UVEditorCanvas *	get_uv_editor_canvas ()
void	show_uv_editor (bool show)
void	arrange ()
void	orient ()
void	find_new_position (const ModelInstancePtrs &instances)
void	set_prepare_state (int state)
int	get_prepare_state ()
void	get_print_job_data (PrintPrepareData *data)
void	set_print_job_plate_idx (int plate_idx)
int	get_send_calibration_finished_event ()
int	get_print_finished_event ()
int	get_send_finished_event ()
void	set_current_canvas_as_dirty ()
void	unbind_canvas_event_handlers ()
void	reset_canvas_volumes ()
void	on_imex_ghost_click (int physical_head)
ImexGhostTooltip	format_imex_ghost_tooltip (int physical_head) const
PrinterTechnology	printer_technology () const
const DynamicPrintConfig *	config () const
bool	set_printer_technology (PrinterTechnology printer_technology)
void	cut_selection_to_clipboard ()
void	copy_selection_to_clipboard ()
void	paste_from_clipboard ()
void	clone_selection ()
void	center_selection ()
void	drop_selection ()
void	search (bool plater_is_active, Preset::Type type, wxWindow *tag, TextInput *etag, wxWindow *stag)
void	mirror (Axis axis)
void	split_object (bool auto_drop=true)
void	split_object (int obj_idx, bool auto_drop=true)
void	split_volume ()
void	optimize_rotation ()
void	fill_color (int extruder_id)
std::string	get_3mf_filename ()
bool	can_delete () const
bool	can_delete_all () const
bool	can_add_model () const
bool	can_add_plate () const
bool	can_delete_plate () const
bool	can_increase_instances () const
bool	can_decrease_instances () const
bool	can_set_instance_to_object () const
bool	can_fix_through_cgal () const
bool	can_simplify () const
bool	can_smooth_mesh () const
bool	can_split_to_objects () const
bool	can_split_to_volumes () const
bool	can_arrange () const
bool	can_cut_to_clipboard () 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_replace_all_with_stl () const
bool	can_mirror () const
bool	can_split (bool to_objects) const
bool	can_fillcolor () const
bool	has_assmeble_view () const
void	msw_rescale ()
void	sys_color_changed ()
bool	init_collapse_toolbar ()
const Camera &	get_camera () const
Camera &	get_camera ()
PartPlateList &	get_partplate_list ()
void	validate_current_plate (bool &model_fits, bool &validate_error)
bool	refresh_missing_plugin_block (bool *block_toggled=nullptr)
void	revalidate_current_plate_if_plugins_missing ()
void	install_missing_cloud_plugins (const std::vector< std::string > &cloud_refs)
void	enable_inactive_plugins (const std::vector< std::string > &refs)
bool	plugins_block_slicing () const
int	select_plate (int plate_index, bool need_slice=false)
void	apply_background_progress ()
int	select_plate_by_hover_id (int hover_id, bool right_click=false, bool isModidyPlateName=false)
int	add_plate ()
int	delete_plate (int plate_index=-1)
int	duplicate_plate (int plate_index=-1)
int	select_sliced_plate (int plate_index, bool skip_zoom=false)
void	set_bed_position (Vec2d &pos)
bool	is_background_process_slicing () const
void	update_slicing_context_to_current_partplate ()
void	show_object_info ()
void	post_process_string_object_exception (StringObjectException &err)
void	update_objects_position_when_select_preset (const std::function< void()> &select_prest)
bool	check_ams_status (bool is_slice_all)
bool	get_machine_sync_status ()
void	update_machine_sync_status ()
void	update_filament_volume_map (int extruder_id, int volume_type)
const BuildVolume &	build_volume () const
const GLToolbar &	get_collapse_toolbar () const
GLToolbar &	get_collapse_toolbar ()
void	update_preview_bottom_toolbar ()
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	update_flush_volume_matrix (size_t old_nozzle_size, size_t new_nozzle_size)
void	set_bed_shape () const
void	set_bed_shape (const Pointfs &shape, const Pointfs &exclude_area, const Pointfs &wrapping_exclude_area, const double printable_height, std::vector< Pointfs > extruder_areas, std::vector< double > extruder_heights, const std::string &custom_texture, const std::string &custom_model, bool force_as_custom=false) const
const NotificationManager *	get_notification_manager () const
NotificationManager *	get_notification_manager ()
DailyTipsWindow *	get_dailytips () const
void	show_status_message (std::string s)
void	init_notification_manager ()
void	bring_instance_forward ()
bool	need_update () const
void	set_need_update (bool need_update)
void	update_title_dirty_status ()
bool	inside_snapshot_capture ()
void	toggle_render_statistic_dialog ()
bool	is_render_statistic_dialog_visible () const
void	toggle_show_wireframe ()
bool	is_show_wireframe () const
void	enable_wireframe (bool status)
bool	is_wireframe_enabled () const
void	toggle_show_xray ()
bool	is_show_xray () const
bool	PopupMenu (wxMenu *menu, const wxPoint &pos=wxDefaultPosition)
bool	PopupMenu (wxMenu *menu, int x, int y)
bool	PopupObjectTable (int object_id, int volume_id, const wxPoint &position)
bool	PopupObjectTableBySelection ()
wxMenu *	plate_menu ()
wxMenu *	object_menu ()
wxMenu *	part_menu ()
wxMenu *	text_part_menu ()
wxMenu *	svg_part_menu ()
wxMenu *	sla_object_menu ()
wxMenu *	default_menu ()
wxMenu *	instance_menu ()
wxMenu *	layer_menu ()
wxMenu *	multi_selection_menu ()
wxMenu *	filament_action_menu (int active_filament_menu_id)
int	GetPlateIndexByRightMenuInLeftUI ()
void	SetPlateIndexByRightMenuInLeftUI (int)
std::string	get_preview_only_filename ()
bool	last_arrange_job_is_finished ()
void	reset_check_status ()
bool	is_loading_project () const
void	mark_plate_toolbar_image_dirty ()
bool	is_plate_toolbar_image_dirty () const
void	clear_plate_toolbar_image_dirty ()
unsigned	plate_toolbar_image_version () const

Static Public Member Functions
static wxColour	get_next_color_for_filament ()
static wxString	get_slice_warning_string (GCodeProcessorResult::SliceWarning &warning)
static TriangleMesh	combine_mesh_fff (const ModelObject &mo, int instance_id, std::function< void(const std::string &)> notify_func={})
static std::vector< Vec2f >	get_empty_cells (const Vec2f step, const std::vector< BoundingBoxf > &local_exclude_boxes={}, bool include_plate_exclude_areas=true)
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)

Public Attributes
std::atomic< bool >	m_arrange_running {false}

Private Member Functions
void	suppress_snapshots ()
void	allow_snapshots ()
void	single_snapshots_enter (SingleSnapshot *single)
void	single_snapshots_leave (SingleSnapshot *single)
int	start_next_slice ()
void	_calib_pa_pattern (const Calib_Params &params)
void	_calib_pa_pattern_gen_gcode ()
void	_calib_pa_tower (const Calib_Params &params)
void	_calib_pa_select_added_objects ()
void	_calib_apply_belt_mode ()
void	_calib_temp_belt_sectioned (const Calib_Params &params, double belt_angle_rad)
void	cut_horizontal (size_t obj_idx, size_t instance_idx, double z, ModelObjectCutAttributes attributes)
void	on_filament_map_mode_change ()

Private Attributes
std::unique_ptr< priv >	p
std::string	m_3mf_path
bool	m_tracking_popup_menu = false
wxString	m_tracking_popup_menu_error_message
wxString	m_last_loaded_gcode
bool	m_only_gcode { false }
bool	m_gcode_settings_loaded { false }
bool	m_exported_file { false }
bool	skip_thumbnail_invalid { false }
bool	m_loading_project { false }
bool	m_new_project_and_check_state {false}
std::string	m_preview_only_filename
int	m_valid_plates_count { 0 }
int	m_check_status = 0
bool	m_b_plate_toolbar_image_dirty { true }
unsigned	m_plate_toolbar_image_version { 0 }

Friends
class	SuppressBackgroundProcessingUpdate
class	PlaterDropTarget

Detailed Description

---

Class Documentation

Slic3r::GUI::Plater::ImexGhostTooltip

struct Slic3r::GUI::Plater::ImexGhostTooltip

Collaboration diagram for Slic3r::GUI::Plater::ImexGhostTooltip:

Class Members
int	filament_slot_1based
string	label
int	physical_head
ColorRGBA	swatch

Member Enumeration Documentation

PrinterWarningType

enum class Slic3r::GUI::Plater::PrinterWarningType

strong

Enumerator
NOT_CONNECTED
INCONSISTENT
UNINSTALL_FILAMENT
EMPTY_FILAMENT

                                  {
        NOT_CONNECTED,
        INCONSISTENT,
        UNINSTALL_FILAMENT,
        EMPTY_FILAMENT
    };

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
    enable_wireframe(true);
    m_only_gcode = false;
}

References enable_wireframe(), m_only_gcode, and p.

Referenced by Plater(), Plater(), Slic3r::GUI::Plater::priv::priv(), Slic3r::GUI::Plater::SingleSnapshot::SingleSnapshot(), Slic3r::GUI::Plater::SuppressSnapshots::SuppressSnapshots(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

Plater() [2/3]

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

delete

References Plater().

Here is the call graph for this function:

Plater() [3/3]

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

delete

References Plater().

Here is the call graph for this function:

~Plater()

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

default

References Slic3r::ipArchimedeanChords.

Member Function Documentation

_calib_apply_belt_mode()

void Slic3r::GUI::Plater::_calib_apply_belt_mode ( )

private

{
    double angle_rad = 0.;
    Vec3d  axis      = Vec3d::UnitX();
    if (!belt_calib_rotation_params(angle_rad, axis))
        return;
 
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    // Spiral vase stays enabled where the tests request it: the support wedge
    // lies strictly below the object, support layers never spiralize
    // (spiral_vase_enable requires an object layer), and the spiral/support
    // exclusivity check only applies to globally enabled supports — the wedge
    // uses per-object supports.
    // A skirt would be drawn in the first slicing plane, which lies mostly
    // above the belt surface.
    print_config->set_key_value("skirt_loops", new ConfigOptionInt(0));
 
    const Matrix3d cancel_rotation = Eigen::AngleAxisd(angle_rad, axis).toRotationMatrix();
    std::vector<size_t> obj_idxs;
    for (size_t i = 0; i < model().objects.size(); ++i) {
        ModelObject* obj = model().objects[i];
        if (obj->instances.size() != 1)
            continue;
        obj_idxs.emplace_back(i);
 
        // Manual tree support: only the floating bottom face gets a support
        // wedge (via the belt-floor extension in TreeSupport::generate()),
        // leaving the test features untouched. The style is pinned to hybrid
        // because the default style resolves to organic, which bypasses the
        // non-organic generator that hosts the belt-floor extension.
        obj->config.set_key_value("enable_support", new ConfigOptionBool(true));
        obj->config.set_key_value("support_type", new ConfigOptionEnum<SupportType>(stTree));
        obj->config.set_key_value("support_style", new ConfigOptionEnum<SupportMaterialStyle>(smsTreeHybrid));
        obj->config.set_key_value("support_on_build_plate_only", new ConfigOptionBool(false));
        // With the default base pattern, tree support base areas print as
        // hollow outlines (no infill) — the wedge needs a real pattern.
        obj->config.set_key_value("support_base_pattern", new ConfigOptionEnum<SupportMaterialPattern>(smpRectilinear));
 
        // Counter-rotate exactly the way the rotate gizmo would: rotation on
        // the instance, then a plain drop to the bed. This leaves the object
        // in the same state shape as any manually rotated object, which the
        // belt pipeline is known to handle.
        ModelInstance* inst = obj->instances.front();
        inst->rotate(cancel_rotation);
        obj->invalidate_bounding_box();
        obj->ensure_on_bed();
    }
 
    // Each object's support wedge extends upstream of it by roughly its own
    // depth (at 45°), so the tight flat-bed layouts of the multi-part tests
    // leave wedges intersecting the neighbouring parts. Keep the grid rows of
    // the test layouts together and open up the space between rows just
    // enough for the wedge shadow.
    if (obj_idxs.size() > 1) {
        std::vector<ModelObject*> sorted_objs;
        sorted_objs.reserve(obj_idxs.size());
        for (size_t i : obj_idxs)
            sorted_objs.emplace_back(model().objects[i]);
        std::sort(sorted_objs.begin(), sorted_objs.end(), [](const ModelObject* a, const ModelObject* b) {
            return a->instances.front()->get_offset(Y) < b->instances.front()->get_offset(Y);
        });
        std::vector<std::vector<ModelObject*>> rows;
        double row_y = std::numeric_limits<double>::quiet_NaN();
        for (ModelObject* o : sorted_objs) {
            const double oy = o->instances.front()->get_offset(Y);
            if (rows.empty() || oy - row_y > 1.)
                rows.emplace_back();
            rows.back().emplace_back(o);
            row_y = oy;
        }
        const double wedge_factor = std::abs(std::tan(angle_rad));
        double       cursor       = std::numeric_limits<double>::quiet_NaN();
        for (std::vector<ModelObject*>& row : rows) {
            double rmin = std::numeric_limits<double>::max();
            double rmax = std::numeric_limits<double>::lowest();
            for (ModelObject* o : row) {
                const BoundingBoxf3 bb = o->instance_bounding_box(0);
                rmin = std::min(rmin, bb.min.y());
                rmax = std::max(rmax, bb.max.y());
            }
            if (std::isnan(cursor))
                cursor = rmin; // the first row anchors the layout
            const double shift = cursor - rmin;
            for (ModelObject* o : row) {
                ModelInstance* inst = o->instances.front();
                inst->set_offset(Y, inst->get_offset(Y) + shift);
                o->invalidate_bounding_box();
            }
            cursor += (rmax - rmin) * (1. + wedge_factor) + 5.;
        }
    }
 
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    changed_objects(obj_idxs);
}

References Slic3r::GUI::belt_calib_rotation_params(), changed_objects(), Slic3r::ModelObject::config, Slic3r::ModelObject::ensure_on_bed(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, model(), Slic3r::Model::objects, Slic3r::ModelInstance::rotate(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelInstance::set_offset(), Slic3r::smpRectilinear, Slic3r::smsTreeHybrid, Slic3r::stTree, Slic3r::Preset::TYPE_PRINT, and Slic3r::Y.

Referenced by _calib_pa_tower(), Calib_Cornering(), calib_flowrate(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_retraction(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

_calib_pa_pattern()

void Slic3r::GUI::Plater::_calib_pa_pattern ( const Calib_Params & params )

private

{
    std::vector<double> speeds{params.speeds};
    std::vector<double> accels{params.accelerations};
    std::vector<size_t> object_idxs{};
    /* Set common parameters */
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    DynamicPrintConfig& print_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    double nozzle_diameter = printer_config->option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
    set_config_values<bool, ConfigOptionBoolsNullable>(filament_config, "filament_retract_when_changing_layer", false);
    set_config_values<bool, ConfigOptionBoolsNullable>(filament_config, "filament_wipe", false);
    set_config_values<bool, ConfigOptionBools>(printer_config, "wipe", false);
    set_config_values<bool, ConfigOptionBools>(printer_config, "retract_when_changing_layer", false);
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool(false));
 
    //Orca: find acceleration to use in the test
    auto accel = print_config.get_abs_value_at("outer_wall_acceleration", params.extruder_id); // get the outer wall acceleration
    if (accel == 0) // if outer wall accel isnt defined, fall back to inner wall accel
        accel = print_config.get_abs_value_at("inner_wall_acceleration", params.extruder_id);
    if (accel == 0) // if inner wall accel is not defined fall back to default accel
        accel = print_config.get_abs_value_at("default_acceleration", params.extruder_id);
    // Orca: Set all accelerations except first layer, as the first layer accel doesnt affect the PA test since accel
    // is set to the travel accel before printing the pattern.
    if (accels.empty()) {
        accels.assign({accel});
        const auto msg{_L("INFO:") + "\n" +
                       format_wxstr(_L("No accelerations provided for calibration. Use default acceleration value %1%mm/s²"), long(accel))};
        get_notification_manager()->push_notification(msg.utf8_string());
    } else {
        // set max acceleration in case of batch mode to get correct test pattern size
        accel = *std::max_element(accels.begin(), accels.end());
    }
    set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "outer_wall_acceleration", accel);
    print_config.set_key_value( "print_sequence", new ConfigOptionEnum(PrintSequence::ByLayer));
    
    //Orca: find jerk value to use in the test
    if(!has_junction_deviation(printer_config) && print_config.get_abs_value_at("default_jerk", params.extruder_id) > 0){ // we have set a jerk value
        auto jerk = print_config.get_abs_value_at("outer_wall_jerk", params.extruder_id); // get outer wall jerk
        if (jerk == 0) // if outer wall jerk is not defined, get inner wall jerk
            jerk = print_config.get_abs_value_at("inner_wall_jerk", params.extruder_id);
        if (jerk == 0) // if inner wall jerk is not defined, get the default jerk
            jerk = print_config.get_abs_value_at("default_jerk", params.extruder_id);
        
        //Orca: Set jerk values. Again first layer jerk should not matter as it is reset to the travel jerk before the
        // first PA pattern is printed.
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "default_jerk", jerk);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "outer_wall_jerk", jerk);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "inner_wall_jerk", jerk);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "top_surface_jerk", jerk);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "infill_jerk", jerk);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "travel_jerk", jerk);
    }
 
    if (has_junction_deviation(printer_config)){
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "default_junction_deviation", 0);
    }
    
    for (const auto& opt : SuggestedConfigCalibPAPattern().floats_pairs) {
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, opt.first, opt.second[0]);
    }
 
    for (const auto& opt : SuggestedConfigCalibPAPattern().nozzle_ratio_pairs) {
        print_config.set_key_value(
            opt.first,
            new ConfigOptionFloatOrPercent(nozzle_diameter * opt.second / 100, false)
        );
    }
 
    for (const auto& opt : SuggestedConfigCalibPAPattern().int_pairs) {
        print_config.set_key_value(
            opt.first,
            new ConfigOptionInt(opt.second)
        );
    }
 
    print_config.set_key_value(SuggestedConfigCalibPAPattern().brim_pair.first,
        new ConfigOptionEnum<BrimType>(SuggestedConfigCalibPAPattern().brim_pair.second));
 
    print_config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
 
    // Orca: Set the outer wall speed to the optimal speed for the test, cap it with max volumetric speed
    if (speeds.empty()) {
        // TODO: per-variant cap
        double speed = CalibPressureAdvance::find_optimal_PA_speed(
            wxGetApp().preset_bundle->full_config(),
            print_config.get_abs_value("line_width", nozzle_diameter),
            print_config.get_abs_value("layer_height"), 0, 0);
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "outer_wall_speed", speed);
 
        speeds.assign({speed});
        const auto msg{_L("INFO:") + "\n" +
                       format_wxstr(_L("No speeds provided for calibration. Use default optimal speed %1%mm/s"), long(speed))};
        get_notification_manager()->push_notification(msg.utf8_string());
    } else if (speeds.size() == 1) {
        // If we have single value provided, set speed using global configuration.
        // per-object config is not set in this case
        set_config_values<double, ConfigOptionFloatsNullable>(&print_config, "outer_wall_speed", speeds.front());
    }
 
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->reload_config();
 
    const DynamicPrintConfig full_config = wxGetApp().preset_bundle->full_config();
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    const bool is_bbl_machine = preset_bundle->is_bbl_vendor();
    auto cur_plate = get_partplate_list().get_plate(0);
 
    // add "handle" cube
    sidebar().obj_list()->load_generic_subobject("Cube", ModelVolumeType::INVALID);
    auto *cube = model().objects[0];
 
    CalibPressureAdvancePattern pa_pattern(
        params,
        full_config,
        is_bbl_machine,
        *cube,
        cur_plate->get_origin()
    );
 
    /* Having PA pattern configured, we could make a set of polygons resembling N test patterns.
     * We'll arrange this set of polygons, so we would know position of each test pattern and
     * could position test cubes later on
     *
     * We'll take advantage of already existing cube: scale it up to test pattern size to use
     * as a reference for objects arrangement. Polygon is slightly oversized to add spaces between patterns.
     * That arrangement will be used to place 'handle cubes' for each test. */
    auto cube_bb = cube->raw_bounding_box();
    cube->scale((pa_pattern.print_size_x() + 4) / cube_bb.size().x(),
                (pa_pattern.print_size_y() + 4) / cube_bb.size().y(),
                pa_pattern.max_layer_z() / cube_bb.size().z());
 
    arrangement::ArrangePolygons arranged_items;
    {
        arrangement::ArrangeParams ap;
        Points bedpts = arrangement::get_shrink_bedpts(&full_config, ap);
 
        for(size_t i = 0; i < speeds.size() * accels.size(); i++) {
            arrangement::ArrangePolygon p;
            cube->instances[0]->get_arrange_polygon(&p);
            p.bed_idx = 0;
            arranged_items.emplace_back(p);
        }
 
        arrangement::arrange(arranged_items, bedpts, ap);
    }
 
    /* scale cube back to the size of test pattern 'handle' */
    cube_bb = cube->raw_bounding_box();
    cube->scale(pa_pattern.handle_xy_size() / cube_bb.size().x(),
                pa_pattern.handle_xy_size() / cube_bb.size().y(),
                pa_pattern.max_layer_z() / cube_bb.size().z());
 
    /* Set speed and acceleration on per-object basis and arrange anchor object on the plates.
     * Test gcode will be genecated during plate slicing */
    for(size_t test_idx = 0; test_idx < arranged_items.size(); test_idx++) {
        const auto &ai = arranged_items[test_idx];
        size_t plate_idx = arranged_items[test_idx].bed_idx;
        auto tspd = speeds[test_idx % speeds.size()];
        auto tacc = accels[test_idx / speeds.size()];
 
        /* make an own copy of anchor cube for each test */
        auto obj = test_idx == 0 ? cube : model().add_object(*cube);
        auto obj_idx = std::distance(model().objects.begin(), std::find(model().objects.begin(), model().objects.end(), obj));
        obj->name.assign(std::string("pa_pattern_") + std::to_string(int(tspd)) + std::string("_") + std::to_string(int(tacc)));
 
        auto &obj_config = obj->config;
        if (speeds.size() > 1)
            obj_config.set_key_value("outer_wall_speed", new ConfigOptionFloatsNullable(1, tspd));
        if (accels.size() > 1)
            obj_config.set_key_value("outer_wall_acceleration", new ConfigOptionFloatsNullable(1, tacc));
 
        auto cur_plate = get_partplate_list().get_plate(plate_idx);
        if (!cur_plate) {
            plate_idx = get_partplate_list().create_plate();
            cur_plate = get_partplate_list().get_plate(plate_idx);
        }
 
        object_idxs.emplace_back(obj_idx);
        get_partplate_list().add_to_plate(obj_idx, 0, plate_idx);
        const Vec3d obj_offset{unscale<double>(ai.translation(X)),
                               unscale<double>(ai.translation(Y)),
                               0};
        obj->instances[0]->set_offset(cur_plate->get_origin() + obj_offset + pa_pattern.handle_pos_offset());
        obj->ensure_on_bed();
 
        if (obj_idx == 0)
            sidebar().obj_list()->update_name_for_items();
        else
            sidebar().obj_list()->add_object_to_list(obj_idx);
    }
 
    model().calib_pa_pattern = std::make_unique<CalibPressureAdvancePattern>(pa_pattern);
    changed_objects(object_idxs);
}

References _L, Slic3r::Calib_Params::accelerations, Slic3r::Model::add_object(), Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::PartPlateList::add_to_plate(), Slic3r::arrangement::arrange(), Slic3r::ByLayer, Slic3r::Model::calib_pa_pattern, changed_objects(), Slic3r::ModelObject::config, Slic3r::GUI::PartPlateList::create_plate(), Slic3r::ModelObject::ensure_on_bed(), Slic3r::Calib_Params::extruder_id, Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::GUI::format_wxstr(), Slic3r::ConfigBase::get_abs_value(), Slic3r::ConfigBase::get_abs_value_at(), get_notification_manager(), get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::arrangement::get_shrink_bedpts(), Slic3r::CalibPressureAdvancePattern::handle_pos_offset(), Slic3r::CalibPressureAdvancePattern::handle_xy_size(), Slic3r::GUI::has_junction_deviation(), Slic3r::ModelObject::instances, Slic3r::INVALID, Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::CalibPressureAdvancePattern::max_layer_z(), model(), Slic3r::ModelObject::name, Slic3r::nozzle_diameter(), Slic3r::GUI::Sidebar::obj_list(), Slic3r::Model::objects, p, Slic3r::CalibPressureAdvancePattern::print_size_x(), Slic3r::CalibPressureAdvancePattern::print_size_y(), Slic3r::GUI::printer_config(), Slic3r::GUI::NotificationManager::push_notification(), Slic3r::GUI::set_config_values(), Slic3r::DynamicConfig::set_key_value(), Slic3r::ModelConfig::set_key_value(), sidebar(), Slic3r::Calib_Params::speeds, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::unscale(), Slic3r::GUI::ObjectList::update_name_for_items(), Slic3r::X, and Slic3r::Y.

Referenced by calib_pa().

Here is the call graph for this function:

Here is the caller graph for this function:

_calib_pa_pattern_gen_gcode()

void Slic3r::GUI::Plater::_calib_pa_pattern_gen_gcode ( )

private

{
    if (!model().calib_pa_pattern)
        return;
 
    auto cur_plate = get_partplate_list().get_curr_plate();
    if (cur_plate->empty())
        return;
 
    /* Container to store custom g-codes genereted by the test generator.
     * We'll store gcode for all tests on a single plate here. Once the plate handling is done,
     * all the g-codes will be merged into a single one on per-layer basis */
    std::vector<CustomGCode::Info> mgc;
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
 
    /* iterate over all cubes on current plate and generate gcode for them */
    for (auto obj : cur_plate->get_objects_on_this_plate()) {
        auto gcode = model().calib_pa_pattern->generate_custom_gcodes(
                                preset_bundle->full_config(),
                                preset_bundle->is_bbl_vendor(),
                                *obj,
                                cur_plate->get_origin()
        );
        mgc.emplace_back(gcode);
    }
 
    // move first item into model custom gcode
    auto &pcgc = model().plates_custom_gcodes[get_partplate_list().get_curr_plate_index()];
    pcgc = std::move(mgc[0]);
    mgc.erase(mgc.begin());
 
    // concat layer gcodes for each test
    for (size_t i = 0; i < pcgc.gcodes.size(); i++) {
        for (auto &gc : mgc) {
            pcgc.gcodes[i].extra += gc.gcodes[i].extra;
        }
    }
}

References Slic3r::Model::calib_pa_pattern, Slic3r::PresetBundle::full_config(), Slic3r::GUI::gcode(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), get_partplate_list(), Slic3r::PresetBundle::is_bbl_vendor(), model(), and Slic3r::Model::plates_custom_gcodes.

Referenced by reslice().

Here is the call graph for this function:

Here is the caller graph for this function:

_calib_pa_select_added_objects()

void Slic3r::GUI::Plater::_calib_pa_select_added_objects ( )

private

                                            {
    // update printable state for new volumes on canvas3D
    wxGetApp().plater()->canvas3D()->update_instance_printable_state_for_objects({0});
 
    Selection& selection = p->view3D->get_canvas3d()->get_selection();
    selection.clear();
    selection.add_object(0, false);
 
    // BBS: update object list selection
    p->sidebar->obj_list()->update_selections();
    selection.notify_instance_update(-1, -1);
    if (p->view3D->get_canvas3d()->get_gizmos_manager().is_enabled()) {
        // this is required because the selected object changed and the flatten on face an sla support gizmos need to be updated accordingly
        p->view3D->get_canvas3d()->update_gizmos_on_off_state();
    }
}

References Slic3r::GUI::Selection::add_object(), Slic3r::GUI::Selection::clear(), Slic3r::GUI::Selection::notify_instance_update(), and p.

Referenced by _calib_pa_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

_calib_pa_tower()

void Slic3r::GUI::Plater::_calib_pa_tower ( const Calib_Params & params )

private

                                                       {
    if (!add_model(false, Slic3r::resources_dir() + "/calib/pressure_advance/tower_with_seam.drc"))
        return;
 
    auto& print_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
 
    const double nozzle_diameter = printer_config->option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
 
    print_config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats{ 1.0f });
 
 
    auto& obj_cfg = model().objects[0]->config;
 
    obj_cfg.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    auto full_config = wxGetApp().preset_bundle->full_config();
    update_speed_parameter("outer_wall_speed");
    update_speed_parameter("inner_wall_speed");
    obj_cfg.set_key_value("seam_position", new ConfigOptionEnum<SeamPosition>(spRear));
    obj_cfg.set_key_value("wall_loops", new ConfigOptionInt(2));
    obj_cfg.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    obj_cfg.set_key_value("bottom_shell_layers", new ConfigOptionInt(0));
    obj_cfg.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    obj_cfg.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btEar));
    obj_cfg.set_key_value("brim_object_gap", new ConfigOptionFloat(.0f));
    obj_cfg.set_key_value("brim_ears_max_angle", new ConfigOptionFloat(135.f));
    obj_cfg.set_key_value("brim_width", new ConfigOptionFloat(6.f));
    obj_cfg.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
    print_config.set_key_value("max_volumetric_extrusion_rate_slope", new ConfigOptionFloat(0));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->reload_config();
 
    auto new_height = std::ceil((params.end - params.start) / params.step) + 1;
    auto obj_bb = model().objects[0]->bounding_box_exact();
    if (new_height < obj_bb.size().z()) {
        cut_horizontal(0, 0, new_height, ModelObjectCutAttribute::KeepLower);
    }
 
    _calib_apply_belt_mode();
    _calib_pa_select_added_objects();
}

References _calib_apply_belt_mode(), _calib_pa_select_added_objects(), add_model(), Slic3r::btEar, changed_objects(), Slic3r::ConfigOptionFloat, cut_horizontal(), Slic3r::Calib_Params::end, Slic3r::KeepLower, model(), Slic3r::None, Slic3r::nozzle_diameter(), Slic3r::Model::objects, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::spRear, Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::GUI::update_speed_parameter().

Referenced by calib_pa().

Here is the call graph for this function:

Here is the caller graph for this function:

_calib_temp_belt_sectioned()

void Slic3r::GUI::Plater::_calib_temp_belt_sectioned ( const Calib_Params & params, double belt_angle_rad )

private

{
    constexpr double base_temp_tower_nozzle_diameter = 0.4;
    constexpr double base_temp_tower_block_height = 10.0;
    constexpr int base_temp_tower_temp_step = 5;
 
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto print_config    = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
 
    const long start_temp = lround(params.start);
    const long end_temp   = lround(params.end);
    const int  n_blocks   = std::max(1, int((start_temp - end_temp) / base_temp_tower_temp_step) + 1);
 
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
    double nozzle_diameter = base_temp_tower_nozzle_diameter;
    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
    }
    if (nozzle_diameter <= 0.0)
        nozzle_diameter = base_temp_tower_nozzle_diameter;
    const double nozzle_scale = nozzle_diameter / base_temp_tower_nozzle_diameter;
 
    std::vector<size_t> obj_idxs;
    for (int i = 0; i < n_blocks; ++i) {
        const long temp = start_temp - long(i) * base_temp_tower_temp_step;
        const size_t count_before = model().objects.size();
        add_model(false, Slic3r::resources_dir() + "/calib/temperature_tower/temperature_tower.drc");
        if (model().objects.size() <= count_before)
            break; // model failed to load — don't index into an empty list
        // The cut replaces the object at the END of the list, so re-acquire
        // the index after every operation.
        size_t obj_idx = model().objects.size() - 1;
 
        // Isolate this temperature's block (full-tower coordinates, the same
        // 500-down-to-temp indexing the monolithic flow cuts with).
        const double block_bottom = double(lround(double(500 - temp) / base_temp_tower_temp_step)) * base_temp_tower_block_height;
        auto obj_bb = model().objects[obj_idx]->bounding_box_exact();
        if (block_bottom + base_temp_tower_block_height < obj_bb.size().z()) {
            cut_horizontal(obj_idx, 0, block_bottom + base_temp_tower_block_height - EPSILON, ModelObjectCutAttribute::KeepLower);
            obj_idx = model().objects.size() - 1;
        }
        if (block_bottom > 0) {
            cut_horizontal(obj_idx, 0, block_bottom + EPSILON, ModelObjectCutAttribute::KeepUpper);
            obj_idx = model().objects.size() - 1;
        }
 
        ModelObject* obj = model().objects[obj_idx];
        if (std::abs(nozzle_scale - 1.0) > EPSILON)
            obj->scale(nozzle_scale, nozzle_scale, nozzle_scale);
        obj->name = std::string("temp_") + std::to_string(temp);
        obj->config.set_key_value("layer_height", new ConfigOptionFloat(nozzle_diameter / 2));
        obj->config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
        obj->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
        obj->config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
        obj->config.set_key_value("precise_z_height", new ConfigOptionBool(false));
        obj->ensure_on_bed();
        obj_idxs.emplace_back(obj_idx);
    }
 
    // Space the blocks along the belt with strictly increasing layer ranges:
    // each block must start past the previous block's highest slicing plane,
    // which trails its far edge by height / tan(angle). Anchor the row near
    // the gantry so the whole test stays in the plate area.
    const double cot_a  = 1. / std::max(0.1, std::tan(belt_angle_rad));
    double       cursor = 20.;
    for (size_t idx : obj_idxs) {
        ModelObject*        obj  = model().objects[idx];
        ModelInstance*      inst = obj->instances.front();
        const BoundingBoxf3 bb   = obj->instance_bounding_box(0);
        inst->set_offset(Y, inst->get_offset(Y) + (cursor - bb.min.y()));
        obj->invalidate_bounding_box();
        cursor += bb.size().y() + bb.size().z() * cot_a + 5.;
    }
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    filament_config->set_key_value("nozzle_temperature_initial_layer", new ConfigOptionInts(1, (int)start_temp));
    filament_config->set_key_value("nozzle_temperature", new ConfigOptionInts(1, (int)start_temp));
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
    print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(nozzle_diameter / 2));
    print_config->set_key_value("skirt_loops", new ConfigOptionInt(0));
 
    changed_objects(obj_idxs);
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
 
    p->background_process.fff_print()->set_calib_params(params);
}

References add_model(), changed_objects(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, cut_horizontal(), Slic3r::Calib_Params::end, Slic3r::ModelObject::ensure_on_bed(), EPSILON, Slic3r::Calib_Params::extruder_id, Slic3r::ModelInstance::get_offset(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::KeepLower, Slic3r::KeepUpper, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, model(), Slic3r::ModelObject::name, Slic3r::None, Slic3r::nozzle_diameter(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::ModelObject::scale(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelInstance::set_offset(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::Calib_Params::start, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::ConfigOptionVector< double >::values, and Slic3r::Y.

Referenced by calib_temp().

Here is the call graph for this function:

Here is the caller graph for this function:

add_dock_pane()

void Slic3r::GUI::Plater::add_dock_pane	(	wxWindow *	window,
		const std::string &	name,
		const wxString &	caption,
		const std::string &	dock,
		const wxSize &	size,
		std::function< void()>	on_close )

{
    p->add_dock_pane(window, name, caption, dock, size, std::move(on_close));
}

References p.

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_dock_panel().

Here is the caller graph for this function:

add_file()

void Slic3r::GUI::Plater::add_file

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " entry";
    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));
 
    std::string snapshot_label;
    assert(!paths.empty());
 
    snapshot_label = "Import Objects";
    snapshot_label += ": ";
    snapshot_label += encode_path(paths.front().filename().string().c_str());
    for (size_t i = 1; i < paths.size(); ++i) {
        snapshot_label += ", ";
        snapshot_label += encode_path(paths[i].filename().string().c_str());
    }
 
    // BBS: check file types
    auto loadfiles_type  = LoadFilesType::NoFile;
    auto amf_files_count = get_3mf_file_count(paths);
 
    if (paths.size() > 1 && amf_files_count < paths.size()) { loadfiles_type = LoadFilesType::Multiple3MFOther; }
    if (paths.size() > 1 && amf_files_count == paths.size()) { loadfiles_type = LoadFilesType::Multiple3MF; }
    if (paths.size() > 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::MultipleOther; }
    if (paths.size() == 1 && amf_files_count == 1) { loadfiles_type = LoadFilesType::Single3MF; };
    if (paths.size() == 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::SingleOther; };
 
    auto first_file = std::vector<fs::path>{};
    auto tmf_file   = std::vector<fs::path>{};
    auto other_file = std::vector<fs::path>{};
 
    switch (loadfiles_type)
    {
    case LoadFilesType::Single3MF:
        open_3mf_file(paths[0]);
      break;
 
    case LoadFilesType::SingleOther: {
        Plater::TakeSnapshot snapshot(this, snapshot_label);
        if (!load_files(paths, LoadStrategy::LoadModel, false).empty()) {
            if (get_project_name() == _L("Untitled") && paths.size() > 0) {
                boost::filesystem::path full_path(paths[0].string());
                p->set_project_name(from_u8(full_path.stem().string()));
            }
            wxGetApp().mainframe->update_title();
            if (wxGetApp().app_config->get("recent_models") == "true")
                wxGetApp().mainframe->add_to_recent_projects(paths[0].wstring());
        }
        break;
    }
    case LoadFilesType::Multiple3MF:
        first_file = std::vector<fs::path>{paths[0]};
        for (auto i = 0; i < paths.size(); i++) {
            if (i > 0) { other_file.push_back(paths[i]); }
        };
 
        open_3mf_file(first_file[0]);
        if (!load_files(other_file, LoadStrategy::LoadModel).empty()) { wxGetApp().mainframe->update_title(); }
        break;
 
    case LoadFilesType::MultipleOther: {
        Plater::TakeSnapshot snapshot(this, snapshot_label);
        if (!load_files(paths, LoadStrategy::LoadModel, true).empty()) {
            if (get_project_name() == _L("Untitled") && paths.size() > 0) {
                boost::filesystem::path full_path(paths[0].string());
                p->set_project_name(from_u8(full_path.stem().string()));
            }
            wxGetApp().mainframe->update_title();
            if (wxGetApp().app_config->get("recent_models") == "true")
                for (auto &path : paths)
                    wxGetApp().mainframe->add_to_recent_projects(path.wstring());
        }
        break;
    }
    case LoadFilesType::Multiple3MFOther:
        for (const auto &path : paths) {
            if (boost::iends_with(path.filename().string(), ".3mf")) {
                if (first_file.size() <= 0)
                    first_file.push_back(path);
                else
                    tmf_file.push_back(path);
            } else {
                other_file.push_back(path);
            }
        }
 
        open_3mf_file(first_file[0]);
        load_files(tmf_file, LoadStrategy::LoadModel);
        if (!load_files(other_file, LoadStrategy::LoadModel, false).empty()) {
            wxGetApp().mainframe->update_title();
            if (wxGetApp().app_config->get("recent_models") == "true")
                for (auto &file : other_file)
                    wxGetApp().mainframe->add_to_recent_projects(file.wstring());
        }
        break;
    default:break;
    }
}

References _L, Slic3r::empty(), Slic3r::encode_path(), Slic3r::GUI::from_u8(), get_3mf_file_count(), get_project_name(), Slic3r::GUI::into_path(), load_files(), Slic3r::LoadModel, Slic3r::GUI::Multiple3MF, Slic3r::GUI::Multiple3MFOther, Slic3r::GUI::MultipleOther, Slic3r::GUI::NoFile, open_3mf_file(), p, Slic3r::GUI::Single3MF, and Slic3r::GUI::SingleOther.

Here is the call graph for this function:

add_model()

bool Slic3r::GUI::Plater::add_model	(	bool	imperial_units = false,
		std::string	fname = "" )

{
    wxArrayString input_files;
 
    std::vector<fs::path> paths;
    if (fname.empty()) {
        wxGetApp().import_model(this, input_files);
        if (input_files.empty())
            return false;
 
        for (const auto& file : input_files)
            paths.emplace_back(into_path(file));
    }
    else {
        paths.emplace_back(fname);
    }
 
    std::string snapshot_label;
    assert(! paths.empty());
    if (paths.size() == 1) {
        snapshot_label = "Import Object";
        snapshot_label += ": ";
        snapshot_label += encode_path(paths.front().filename().string().c_str());
    } else {
        snapshot_label = "Import Objects";
        snapshot_label += ": ";
        snapshot_label += paths.front().filename().string().c_str();
        for (size_t i = 1; i < paths.size(); ++ i) {
            snapshot_label += ", ";
            snapshot_label += encode_path(paths[i].filename().string().c_str());
        }
    }
 
    Plater::TakeSnapshot snapshot(this, snapshot_label);
 
    // BBS: check file types
    auto loadfiles_type  = LoadFilesType::NoFile;
    auto amf_files_count = get_3mf_file_count(paths);
 
    if (paths.size() > 1 && amf_files_count < paths.size()) { loadfiles_type = LoadFilesType::Multiple3MFOther; }
    if (paths.size() > 1 && amf_files_count == paths.size()) { loadfiles_type = LoadFilesType::Multiple3MF; }
    if (paths.size() > 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::MultipleOther; }
    if (paths.size() == 1 && amf_files_count == 1) { loadfiles_type = LoadFilesType::Single3MF; };
    if (paths.size() == 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::SingleOther; };
 
    bool ask_multi = false;
 
    if (loadfiles_type == LoadFilesType::MultipleOther)
        ask_multi = true;
 
    auto strategy = LoadStrategy::LoadModel;
    if (imperial_units) strategy = strategy | LoadStrategy::ImperialUnits;
    const bool loaded = !load_files(paths, strategy, ask_multi).empty();
    if (loaded) {
 
        if (get_project_name() == _L("Untitled") && paths.size() > 0) {
            boost::filesystem::path full_path(paths[0].string());
            p->set_project_name(from_u8(full_path.stem().string()));
        }
 
        wxGetApp().mainframe->update_title();
    }
    return loaded;
}

References _L, Slic3r::encode_path(), Slic3r::GUI::from_u8(), get_3mf_file_count(), get_project_name(), Slic3r::ImperialUnits, Slic3r::GUI::into_path(), load_files(), Slic3r::LoadModel, Slic3r::GUI::Multiple3MF, Slic3r::GUI::Multiple3MFOther, Slic3r::GUI::MultipleOther, Slic3r::GUI::NoFile, p, Slic3r::GUI::Single3MF, and Slic3r::GUI::SingleOther.

Referenced by _calib_pa_tower(), _calib_temp_belt_sectioned(), Calib_Cornering(), calib_flowrate(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_pa(), calib_retraction(), calib_temp(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

add_plate()

int Slic3r::GUI::Plater::add_plate

(

)

{
    if (!p->can_add_plate())
        return -1;
    take_snapshot("add partplate");
    int new_plate = p->partplate_list.create_plate();
    if (new_plate < 0)
        return new_plate;
    p->partplate_list.select_plate(new_plate);
    update();
 
    // BBS set default view
    //get_camera().select_view("topfront");
    p->camera.requires_zoom_to_plate = REQUIRES_ZOOM_TO_ALL_PLATE;
    return new_plate;
}

References p, REQUIRES_ZOOM_TO_ALL_PLATE, take_snapshot(), and update().

Here is the call graph for this function:

allow_snapshots()

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

private

{ p->allow_snapshots(); }

References p.

apply_background_progress()

void Slic3r::GUI::Plater::apply_background_progress

(

)

{
    PartPlate* part_plate = p->partplate_list.get_curr_plate();
    int plate_index = p->partplate_list.get_curr_plate_index();
    bool result_valid = part_plate->is_slice_result_valid();
    const auto& preset_bundle = wxGetApp().preset_bundle;
    //always apply the current plate's print
    Print::ApplyStatus invalidated;
    if (preset_bundle->get_printer_extruder_count() > 1) {
        std::vector<int> f_maps = part_plate->get_real_filament_maps(preset_bundle->project_config);
        std::vector<int> f_volume_maps = part_plate->get_filament_volume_maps();
        if (f_volume_maps.empty()) {
            f_volume_maps = preset_bundle->get_default_nozzle_volume_types_for_filaments(f_maps);
        }
        invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false, f_maps, f_volume_maps));
    }
    else
        invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false));
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: plate %2%, after apply, invalidated= %3%, previous result_valid %4% ") % __LINE__ % plate_index % invalidated % result_valid;
    if (invalidated & PrintBase::APPLY_STATUS_INVALIDATED)
    {
        part_plate->update_slice_result_valid_state(false);
        //p->ready_to_slice = true;
        p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, true);
    }
}

References Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, Slic3r::GUI::MainFrame::eEventPlateUpdate, Slic3r::GUI::PartPlate::get_filament_volume_maps(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::is_slice_result_valid(), model(), p, and Slic3r::GUI::PartPlate::update_slice_result_valid_state().

Here is the call graph for this function:

apply_cut_object_to_model()

void Slic3r::GUI::Plater::apply_cut_object_to_model	(	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;
    // arrange(w, true);
    // w.wait_for_idle();
}

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

Referenced by cut_horizontal().

Here is the call graph for this function:

Here is the caller graph for this function:

are_collision_volumes_shown()

bool Slic3r::GUI::Plater::are_collision_volumes_shown

(

)

const

{
    return wxGetApp().app_config->get_bool("show_collision_volumes");
}

are_view3D_labels_shown()

bool Slic3r::GUI::Plater::are_view3D_labels_shown

(

)

const

{ return p->are_view3D_labels_shown(); }

References p.

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar().

Here is the caller graph for this function:

arrange()

void Slic3r::GUI::Plater::arrange

(

)

{
    auto &w = get_ui_job_worker();
    if (w.is_idle()) {
        p->take_snapshot(_u8L("Arrange"));
        replace_job(w, std::make_unique<ArrangeJob>());
    }
}

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

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), increase_instances(), Slic3r::GUI::MenuFactory::load_handy_model(), and select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

background_process()

BackgroundSlicingProcess & Slic3r::GUI::Plater::background_process

(

)

{ return p->background_process; }

References p.

Referenced by Slic3r::DevNozzleMappingCtrl::CtrlGetAutoNozzleMappingV0(), and Slic3r::DevUtilBackend::GetNozzleGroupResult().

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 find_new_position(), get_empty_cells(), and Slic3r::GUI::Plater::priv::update_print_volume_state().

Here is the caller graph for this function:

Calib_Cornering()

void Slic3r::GUI::Plater::Calib_Cornering

(

const Calib_Params &

params

)

{
    const auto Calib_Cornering = _L("Cornering test");
    new_project(false, false, Calib_Cornering);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Cornering)
        return;
 
    const std::string cornering_model_path = params.test_model == 0
        ? "/calib/input_shaping/ringing_tower.drc"
        : (params.test_model == 1 ? "/calib/input_shaping/fast_tower_test.drc" : "/calib/cornering/SCV-V2.drc");
    if (!add_model(false, Slic3r::resources_dir() + cornering_model_path))
        return;
    if (params.test_model == 0)
        belt_calib_flip_ringing_tower(model());
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
 
    if (has_junction_deviation(printer_config)) {
        printer_config->set_key_value("machine_max_junction_deviation", new ConfigOptionFloats{params.end});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_junction_deviation", 0);
    } else {
        printer_config->set_key_value("machine_max_jerk_x", new ConfigOptionFloats{params.end});
        printer_config->set_key_value("machine_max_jerk_y", new ConfigOptionFloats{params.end});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_jerk", 0);
    }
 
    zero_pressure_advance_where_disabled(filament_config);
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    printer_config->set_key_value("input_shaping_emit", new ConfigOptionBool{true});
    printer_config->set_key_value("input_shaping_type", new ConfigOptionEnum<InputShaperType>(InputShaperType::Disable));
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_min_speed", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_for_layer_cooling", new ConfigOptionBools{false});
    const double filament_max_volumetric_speed = filament_config->option<ConfigOptionFloats>("filament_max_volumetric_speed")->get_at(0);
    filament_config->set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats{std::max(filament_max_volumetric_speed, 200.0)});
    set_config_values<bool, ConfigOptionBools>(print_config, "enable_overhang_speed", false);
    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config->set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config->set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config->set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config->set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config->set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config->set_key_value("spiral_mode_smooth", new ConfigOptionBool(false));
    print_config->set_key_value("bottom_surface_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
    const double machine_max_speed = std::min(printer_config->option<ConfigOptionFloats>("machine_max_speed_x")->get_at(0), printer_config->option<ConfigOptionFloats>("machine_max_speed_y")->get_at(0));
    const double machine_max_acceleration = printer_config->option<ConfigOptionFloats>("machine_max_acceleration_extruding")->get_at(0);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_speed", machine_max_speed);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_acceleration", machine_max_acceleration);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_acceleration", machine_max_acceleration);
    print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
 
    _calib_apply_belt_mode();
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::GUI::belt_calib_flip_ringing_tower(), Slic3r::btOuterOnly, Slic3r::Calib_Cornering, Calib_Cornering(), changed_objects(), Slic3r::ConfigOptionFloat, Slic3r::Disable, Slic3r::Calib_Params::end, Slic3r::GUI::has_junction_deviation(), Slic3r::ipRectilinear, Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::set_config_values(), TAB_ID_PREPARE, Slic3r::Calib_Params::test_model, Slic3r::tlTraditional, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::GUI::zero_pressure_advance_where_disabled().

Referenced by Calib_Cornering().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_flowrate()

void Slic3r::GUI::Plater::calib_flowrate	(	bool	is_linear,
		int	pass,
		InfillPattern	pattern = ipArchimedeanChords )

                                                                           {
    if (pass != 1 && pass != 2)
        return;
    wxString calib_name;
    if (is_linear) {
        calib_name = pass == 2 ? _L("Orca YOLO Flow Calibration - Perfectionist version") : _L("Orca YOLO Flow Calibration");
    } else
        calib_name = wxString::Format(_L("Flowrate Test - Pass%d"), pass);
 
    if (new_project(false, false, calib_name) == wxID_CANCEL)
        return;
 
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
    if (is_linear) {
        if (pass == 1)
            add_model(false,
                      (boost::filesystem::path(Slic3r::resources_dir()) / "calib" / "filament_flow" / "Orca-LinearFlow.3mf").string());
        else
            add_model(false,
                      (boost::filesystem::path(Slic3r::resources_dir()) / "calib" / "filament_flow" / "Orca-LinearFlow_fine.3mf").string());
    } else {
        if (pass == 1)
            add_model(false,
                      (boost::filesystem::path(Slic3r::resources_dir()) / "calib" / "filament_flow" / "flowrate-test-pass1.3mf").string());
        else
            add_model(false,
                      (boost::filesystem::path(Slic3r::resources_dir()) / "calib" / "filament_flow" / "flowrate-test-pass2.3mf").string());
    }
 
    // ORCA: pass the pattern
    adjust_settings_for_flowrate_calib(model().objects, is_linear, pass, pattern);
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->reload_config();
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
 
    _calib_apply_belt_mode();
 
    // Refresh object after scaling
    const std::vector<size_t> object_idx(boost::counting_iterator<size_t>(0), boost::counting_iterator<size_t>(model().objects.size()));
    changed_objects(object_idx);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::GUI::adjust_settings_for_flowrate_calib(), changed_objects(), model(), new_project(), Slic3r::GUI::printer_config(), Slic3r::resources_dir(), TAB_ID_PREPARE, and Slic3r::Preset::TYPE_PRINTER.

Here is the call graph for this function:

calib_input_shaping_damp()

void Slic3r::GUI::Plater::calib_input_shaping_damp

(

const Calib_Params &

params

)

{
    const auto calib_input_shaping_name = _L("Input shaping Damping test");
    new_project(false, false, calib_input_shaping_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Input_shaping_damp)
        return;
 
    if (!add_model(false, Slic3r::resources_dir() + (params.test_model < 1 ? "/calib/input_shaping/ringing_tower.drc" : "/calib/input_shaping/fast_tower_test.drc")))
        return;
    if (params.test_model < 1)
        belt_calib_flip_ringing_tower(model());
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const auto gcode_flavor_option = printer_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
 
    if (has_junction_deviation(printer_config)) {
        printer_config->set_key_value("machine_max_junction_deviation", new ConfigOptionFloats {(std::max(printer_config->option<ConfigOptionFloats>("machine_max_junction_deviation")->values.front(), 0.25))});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_junction_deviation", 0);
    } else {
        const double jerk_value = (gcode_flavor_option && gcode_flavor_option->value == GCodeFlavor::gcfKlipper) ? 5.0 : 10.0;
        printer_config->set_key_value("machine_max_jerk_x", new ConfigOptionFloats{std::max(printer_config->option<ConfigOptionFloats>("machine_max_jerk_x")->values.front(), jerk_value)});
        printer_config->set_key_value("machine_max_jerk_y", new ConfigOptionFloats{std::max(printer_config->option<ConfigOptionFloats>("machine_max_jerk_y")->values.front(), jerk_value)});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_jerk", 0);
    }
 
    zero_pressure_advance_where_disabled(filament_config);
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    printer_config->set_key_value("input_shaping_emit", new ConfigOptionBool{false});
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_min_speed", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_for_layer_cooling", new ConfigOptionBools{false});
    set_config_values<bool, ConfigOptionBools>(print_config, "enable_overhang_speed", false);
    // A 100% factor sends Klipper MINIMUM_CRUISE_RATIO=0 with every acceleration change, for the whole test.
    print_config->set_key_value("accel_to_decel_enable", new ConfigOptionBool(true));
    print_config->set_key_value("accel_to_decel_factor", new ConfigOptionPercent(100));
    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config->set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config->set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config->set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config->set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config->set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config->set_key_value("spiral_mode_smooth", new ConfigOptionBool(false));
    print_config->set_key_value("bottom_surface_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
    const double machine_max_speed = std::min(printer_config->option<ConfigOptionFloats>("machine_max_speed_x")->get_at(0), printer_config->option<ConfigOptionFloats>("machine_max_speed_y")->get_at(0));
    const double machine_max_acceleration = printer_config->option<ConfigOptionFloats>("machine_max_acceleration_extruding")->get_at(0);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_speed", machine_max_speed);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_acceleration", machine_max_acceleration);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_acceleration", machine_max_acceleration);
    print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
 
    _calib_apply_belt_mode();
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::GUI::belt_calib_flip_ringing_tower(), Slic3r::btOuterOnly, Slic3r::Calib_Input_shaping_damp, changed_objects(), Slic3r::ConfigOptionFloat, Slic3r::gcfKlipper, Slic3r::GUI::has_junction_deviation(), Slic3r::ipRectilinear, Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::set_config_values(), TAB_ID_PREPARE, Slic3r::Calib_Params::test_model, Slic3r::tlTraditional, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::GUI::zero_pressure_advance_where_disabled().

Here is the call graph for this function:

calib_input_shaping_freq()

void Slic3r::GUI::Plater::calib_input_shaping_freq

(

const Calib_Params &

params

)

{
    const auto calib_input_shaping_name = _L("Input shaping Frequency test");
    new_project(false, false, calib_input_shaping_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Input_shaping_freq)
        return;
 
    if (!add_model(false, Slic3r::resources_dir() + (params.test_model < 1 ? "/calib/input_shaping/ringing_tower.drc" : "/calib/input_shaping/fast_tower_test.drc")))
        return;
    if (params.test_model < 1)
        belt_calib_flip_ringing_tower(model());
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const auto gcode_flavor_option = printer_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
 
    if (has_junction_deviation(printer_config)) {
        printer_config->set_key_value("machine_max_junction_deviation", new ConfigOptionFloats {(std::max(printer_config->option<ConfigOptionFloats>("machine_max_junction_deviation")->values.front(), 0.25))});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_junction_deviation", 0);
    } else {
        const double jerk_value = (gcode_flavor_option && gcode_flavor_option->value == GCodeFlavor::gcfKlipper) ? 5.0 : 10.0;
        printer_config->set_key_value("machine_max_jerk_x", new ConfigOptionFloats{std::max(printer_config->option<ConfigOptionFloats>("machine_max_jerk_x")->values.front(), jerk_value)});
        printer_config->set_key_value("machine_max_jerk_y", new ConfigOptionFloats{std::max(printer_config->option<ConfigOptionFloats>("machine_max_jerk_y")->values.front(), jerk_value)});
        set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_jerk", 0);
    }
 
    zero_pressure_advance_where_disabled(filament_config);
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    printer_config->set_key_value("input_shaping_emit", new ConfigOptionBool{false});
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_min_speed", new ConfigOptionFloats { 0.0 });
    filament_config->set_key_value("slow_down_for_layer_cooling", new ConfigOptionBools{false});
    print_config->set_key_value("layer_height", new ConfigOptionFloat(0.2));
    set_config_values<bool, ConfigOptionBools>(print_config, "enable_overhang_speed", false);
    // A 100% factor sends Klipper MINIMUM_CRUISE_RATIO=0 with every acceleration change, for the whole test.
    print_config->set_key_value("accel_to_decel_enable", new ConfigOptionBool(true));
    print_config->set_key_value("accel_to_decel_factor", new ConfigOptionPercent(100));
    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config->set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config->set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config->set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config->set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config->set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config->set_key_value("spiral_mode_smooth", new ConfigOptionBool(false));
    print_config->set_key_value("bottom_surface_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
    const double machine_max_speed = std::min(printer_config->option<ConfigOptionFloats>("machine_max_speed_x")->get_at(0), printer_config->option<ConfigOptionFloats>("machine_max_speed_y")->get_at(0));
    const double machine_max_acceleration = printer_config->option<ConfigOptionFloats>("machine_max_acceleration_extruding")->get_at(0);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_speed", machine_max_speed);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "default_acceleration", machine_max_acceleration);
    set_config_values<double, ConfigOptionFloatsNullable>(print_config, "outer_wall_acceleration", machine_max_acceleration);
    print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
 
    _calib_apply_belt_mode();
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::GUI::belt_calib_flip_ringing_tower(), Slic3r::btOuterOnly, Slic3r::Calib_Input_shaping_freq, changed_objects(), Slic3r::ConfigOptionFloat, Slic3r::gcfKlipper, Slic3r::GUI::has_junction_deviation(), Slic3r::ipRectilinear, Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::set_config_values(), TAB_ID_PREPARE, Slic3r::Calib_Params::test_model, Slic3r::tlTraditional, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::GUI::zero_pressure_advance_where_disabled().

Here is the call graph for this function:

calib_max_vol_speed()

void Slic3r::GUI::Plater::calib_max_vol_speed

(

const Calib_Params &

params

)

{
    const auto calib_vol_speed_name = _L("Max volumetric speed test");
    new_project(false, false, calib_vol_speed_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Vol_speed_Tower)
        return;
    if (!add_model(false, Slic3r::resources_dir() + "/calib/volumetric_speed/SpeedTestStructure.drc"))
        return;
 
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto obj = model().objects[0];
    auto& obj_cfg = obj->config;
 
    auto bed_shape = printer_config->option<ConfigOptionPoints>("printable_area")->values;
    BoundingBoxf bed_ext = get_extents(bed_shape);
    auto scale_obj = (bed_ext.size().x() - 10) / obj->bounding_box_exact().size().x();
    if (scale_obj < 1.0)
        obj->scale(scale_obj, 1, 1);
 
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    assert(nozzle_diameter_config->values.size() > 0);
    double nozzle_diameter = nozzle_diameter_config->values[0];
    double line_width = nozzle_diameter * 1.75;
    double layer_height = nozzle_diameter * 0.8;
 
    auto max_lh = printer_config->option<ConfigOptionFloats>("max_layer_height");
    for (size_t i = 0; i < max_lh->values.size(); ++i) {
        if (max_lh->values[i] < layer_height)
            max_lh->values[i] = layer_height;
    }
 
    const double filament_max_volumetric_speed = filament_config->option<ConfigOptionFloats>("filament_max_volumetric_speed")->get_at(0);
    set_config_values<double, ConfigOptionFloats>(filament_config, "filament_max_volumetric_speed", std::max(filament_max_volumetric_speed, 200.0));
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats{0.0});
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    obj_cfg.set_key_value("enable_overhang_speed", new ConfigOptionBoolsNullable(1, false));
    obj_cfg.set_key_value("wall_loops", new ConfigOptionInt(1));
    obj_cfg.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    obj_cfg.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    obj_cfg.set_key_value("bottom_shell_layers", new ConfigOptionInt(0));
    obj_cfg.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    obj_cfg.set_key_value("outer_wall_line_width", new ConfigOptionFloatOrPercent(line_width, false));
    obj_cfg.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    obj_cfg.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterAndInner));
    obj_cfg.set_key_value("brim_width", new ConfigOptionFloat(5.0));
    obj_cfg.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
    obj_cfg.set_key_value("precise_z_height", new ConfigOptionBool(false));
    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config->set_key_value("max_volumetric_extrusion_rate_slope", new ConfigOptionFloat(0));
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->reload_config();
 
    //  cut upper
    auto obj_bb = obj->bounding_box_exact();
    auto height = (params.end - params.start + 1) / params.step;
    if (height < obj_bb.size().z()) {
        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
    }
 
    _calib_apply_belt_mode();
 
    auto new_params  = params;
    auto mm3_per_mm  = Flow(line_width, layer_height, nozzle_diameter).mm3_per_mm() * filament_config->option<ConfigOptionFloatsNullable>("filament_flow_ratio")->get_at(0);
    new_params.end   = params.end / mm3_per_mm;
    new_params.start = params.start / mm3_per_mm;
    new_params.step  = params.step / mm3_per_mm;
 
    p->background_process.fff_print()->set_calib_params(new_params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::ModelObject::bounding_box_exact(), Slic3r::btOuterAndInner, Slic3r::Calib_Vol_speed_Tower, changed_objects(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, cut_horizontal(), Slic3r::Calib_Params::end, Slic3r::get_extents(), Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Flow::mm3_per_mm(), Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::nozzle_diameter(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::ModelObject::scale(), Slic3r::GUI::set_config_values(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, TAB_ID_PREPARE, Slic3r::tlTraditional, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::ConfigOptionVector< double >::values.

Here is the call graph for this function:

calib_pa()

void Slic3r::GUI::Plater::calib_pa

(

const Calib_Params &

params

)

{
    // ORCA-Belt: PA Line / PA Pattern have the belt plumbing in place
    // (belt kinematics in world-coordinates mode draws them on the belt surface)
    // but are not validated yet — keep them gated to the PA Tower for now.
    {
        double angle_rad = 0.;
        Vec3d  axis      = Vec3d::UnitX();
        if (belt_calib_rotation_params(angle_rad, axis) && params.mode != CalibMode::Calib_PA_Tower) {
            MessageDialog msg_dlg(nullptr, _L("PA Line and PA Pattern tests are not enabled yet on belt printers.\nPlease use the PA Tower method instead."),
                                  wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
    }
    const auto calib_pa_name = _L("Pressure Advance Test");
    new_project(false, false, calib_pa_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    print_config->set_key_value("overhang_reverse", new ConfigOptionBool(false));
    print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
    print_config->set_key_value("wipe_inward", new ConfigOptionBool(false));
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    switch (params.mode) {
        case CalibMode::Calib_PA_Line:
            add_model(false, Slic3r::resources_dir() + "/calib/pressure_advance/pressure_advance_test.drc");
            break;
        case CalibMode::Calib_PA_Pattern:
            _calib_pa_pattern(params);
            break;
        case CalibMode::Calib_PA_Tower:
            _calib_pa_tower(params);
            break;
        default: break;
    }
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_pa_pattern(), _calib_pa_tower(), _L, add_model(), Slic3r::GUI::belt_calib_rotation_params(), Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::Calib_PA_Tower, Slic3r::Calib_Params::mode, new_project(), p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::DPIAware< P >::ShowModal(), and TAB_ID_PREPARE.

Here is the call graph for this function:

calib_retraction()

void Slic3r::GUI::Plater::calib_retraction

(

const Calib_Params &

params

)

{
    const auto calib_retraction_name = _L("Retraction");
    new_project(false, false, calib_retraction_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Retraction_tower)
        return;
 
    if (!add_model(false, Slic3r::resources_dir() + "/calib/retraction/retraction_tower.drc"))
        return;
 
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto obj = model().objects[0];
 
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
    print_config->set_key_value("wipe_inward", new ConfigOptionBool(false));
 
    float nozzle_diameter = printer_config->option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
    float layer_height;
    if (nozzle_diameter <= 0.1f) {
        layer_height = 0.05f;
    } else if (nozzle_diameter <= 0.2f) {
        layer_height = 0.1f;
    } else {
        layer_height = 0.2f;
    }
 
    auto max_lh = printer_config->option<ConfigOptionFloats>("max_layer_height");
    for (size_t i = 0; i < max_lh->values.size(); ++i) {
        if (max_lh->values[i] < layer_height) max_lh->values[i] = layer_height;
    }
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    printer_config->set_key_value("use_firmware_retraction", new ConfigOptionBool(false));
    obj->config.set_key_value("wall_loops", new ConfigOptionInt(2));
    obj->config.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    obj->config.set_key_value("bottom_shell_layers", new ConfigOptionInt(3));
    obj->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
    obj->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    obj->config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    obj->config.set_key_value("seam_position", new ConfigOptionEnum<SeamPosition>(spAligned));
    obj->config.set_key_value("wall_sequence", new ConfigOptionEnum<WallSequence>(WallSequence::InnerOuter));
    obj->config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
    obj->config.set_key_value("precise_z_height", new ConfigOptionBool(false));
    obj->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
 
 
    changed_objects({ 0 });
 
    //  cut upper
    auto obj_bb = obj->bounding_box_exact();
    auto height = 1.0 + 0.4 + ((params.end - params.start)) / params.step - EPSILON;
    if (height < obj_bb.size().z()) {
        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
    }
 
    _calib_apply_belt_mode();
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::ModelObject::bounding_box_exact(), Slic3r::Calib_Retraction_tower, changed_objects(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, cut_horizontal(), Slic3r::Calib_Params::end, EPSILON, Slic3r::InnerOuter, Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::None, Slic3r::nozzle_diameter(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::ModelConfig::set_key_value(), Slic3r::spAligned, Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, and TAB_ID_PREPARE.

Here is the call graph for this function:

calib_temp()

void Slic3r::GUI::Plater::calib_temp

(

const Calib_Params &

params

)

                                                  {
    constexpr double base_temp_tower_nozzle_diameter = 0.4;
    constexpr double base_temp_tower_block_height = 10.0;
    constexpr int base_temp_tower_temp_step = 5;
 
    // A belt provini tower exists only for the ranges it was embossed for, and another
    // range's model would print numbers that do not match its temperatures.  Refuse
    // before the current project is replaced.
    if (params.mode == CalibMode::Calib_Temp_Tower && params.test_model >= 1) {
        const auto &printer_config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
        if (printer_config.has("belt_printer") && printer_config.opt_bool("belt_printer") &&
            ! boost::filesystem::exists(belt_temp_tower_asset(params))) {
            MessageDialog dlg(static_cast<wxWindow *>(wxGetApp().mainframe),
                              format_wxstr(_L("No belt temperature tower is available for the range %1% to %2%℃. "
                                              "Use a range the tower models cover, for example 230 to 190."),
                                           (int) lround(params.start), (int) lround(params.end)),
                              _L("Temperature tower"), wxICON_ERROR | wxOK);
            dlg.ShowModal();
            return;
        }
    }
 
    const auto calib_temp_name = _L("Nozzle temperature test");
    new_project(false, false, calib_temp_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_Temp_Tower)
        return;
 
    // Belt printers build along the conveyor, not vertically — a tall tower cannot
    // be sliced. Instead lay a row of DISCRETE provini (one per temperature) along
    // the belt and change temperature in discrete steps via custom per-layer G-code
    // (M104), injected in the empty gap just before each provino so the nozzle is
    // settled by the time that provino prints. We deliberately do NOT call
    // set_calib_params here: its per-layer interpolation (interpolate_value_across_
    // layers) would overwrite these discrete M104 events.
    {
        auto belt_printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
        if (belt_printer_config->has("belt_printer") && belt_printer_config->opt_bool("belt_printer")) {
            // Belt temperature-tower model selector (Calib_Params::test_model):
            //   0 = "Standard"  -> Joe's counter-rotated sectioned tower.
            //   1 = "Overhang"  -> engraved inverted-L provini that stress overhang
            //                      print-quality at each discrete temperature (below).
            if (params.test_model < 1) {
                double belt_angle_rad = 0.; Vec3d belt_axis = Vec3d::UnitX();
                belt_calib_rotation_params(belt_angle_rad, belt_axis);
                _calib_temp_belt_sectioned(params, std::abs(belt_angle_rad));
                return;
            }
            constexpr int    TEMP_STEP = 5;        // matches Temp_Calibration_Dlg
            // Shared geometry contract with the offline asset generator
            // (resources/calib/temperature_tower/gen_belt_temp_tower.py): provini are
            // replicated along the belt (designed Y) at this pitch. The slicing plane
            // is oblique (belt_slice_rotation_angle), so the per-zone advance in the
            // layer print_z space the custom-gcode matcher uses is PITCH*cos(theta).
            constexpr double PITCH_Y = 74.718;     // designed-Y pitch == gen PITCH
            const double angle = belt_printer_config->has("belt_slice_rotation_angle")
                ? belt_printer_config->opt_float("belt_slice_rotation_angle") : 45.0;
            const double zone_topz = PITCH_Y * std::cos(angle * M_PI / 180.0);
            // The custom-gcode matcher attaches each event to a real sliced layer. The
            // empty inter-provino gap has NO layers, so an event placed there is silently
            // dropped. Fire it 70 layers ABOVE provino i's start instead — inside the
            // provino body, past the gap and the overlap with provino i-1's tail, so the
            // temperature change attaches and applies cleanly. (layer print_z steps by the
            // process layer height.)
            auto belt_print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
            const double layer_h = belt_print_config->has("layer_height")
                ? belt_print_config->opt_float("layer_height") : 0.2;
            const double into_provino = 70.0 * layer_h;
 
            const int t_start = (int) lround(params.start);
            const int t_end   = (int) lround(params.end);
            std::vector<int> temps;
            const int tstep = (t_start >= t_end) ? -TEMP_STEP : TEMP_STEP;
            for (int t = t_start; (tstep < 0) ? (t >= t_end) : (t <= t_end); t += tstep)
                temps.push_back(t);
            if (temps.empty()) temps.push_back(t_start);
 
            const std::string asset = belt_temp_tower_asset(params);
            if (!boost::filesystem::exists(asset))   // refused above, before new_project()
                return;
            if (!add_model(false, asset) || model().objects.empty())
                return;
 
            // Place keel-first asset at the belt entry (designed Y = 0) so Z_gcode
            // starts at 0, centered laterally on the bed, resting on the conveyor.
            ModelObject* obj = model().objects[0];
            obj->ensure_on_bed();
            BoundingBoxf3 obb = obj->bounding_box_exact();
            auto bed_shape = belt_printer_config->option<ConfigOptionPoints>("printable_area")->values;
            BoundingBoxf bed_ext = get_extents(bed_shape);
            obj->translate_instances(Vec3d(bed_ext.center().x() - obb.center().x(), -obb.min.y(), 0.0));
 
            auto belt_filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
            belt_filament_config->set_key_value("nozzle_temperature_initial_layer", new ConfigOptionInts(1, temps.front()));
            belt_filament_config->set_key_value("nozzle_temperature", new ConfigOptionInts(1, temps.front()));
            obj->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btNoBrim));
            obj->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
            obj->config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
            belt_printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
 
            const int plate_idx = get_partplate_list().get_curr_plate_index();
            model().curr_plate_index = plate_idx;
            CustomGCode::Info &cg_info = model().plates_custom_gcodes[plate_idx];
            cg_info.mode = CustomGCode::Mode::SingleExtruder;
            cg_info.gcodes.clear();
            for (size_t i = 1; i < temps.size(); ++i) {
                const double pz = double(i) * zone_topz + into_provino;   // 70 layers into provino i
                cg_info.gcodes.push_back(CustomGCode::Item{
                    pz, CustomGCode::Custom, 1, "",
                    "M104 S" + std::to_string(temps[i]) + " ; belt temp zone " + std::to_string(temps[i]) });
            }
 
            changed_objects({ 0 });
            wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
            wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
            return;
        }
    }
 
    if (!add_model(false, Slic3r::resources_dir() + "/calib/temperature_tower/temperature_tower.drc"))
        return;
    auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto start_temp = lround(params.start);
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
    double nozzle_diameter = base_temp_tower_nozzle_diameter;
    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
    }
    if (nozzle_diameter <= 0.0)
        nozzle_diameter = base_temp_tower_nozzle_diameter;
 
    const double nozzle_scale = nozzle_diameter / base_temp_tower_nozzle_diameter;
    const double block_height = base_temp_tower_block_height;
 
    // cut upper
    auto obj_bb = model().objects[0]->bounding_box_exact();
    auto block_count = lround((500 - params.end) / base_temp_tower_temp_step + 1);
    if (block_count > 0) {
        // subtract EPSILON offset to avoid cutting at the exact location where the flat surface is
        auto new_height = block_count * block_height - EPSILON;
        if (new_height < obj_bb.size().z()) {
            cut_horizontal(0, 0, new_height, ModelObjectCutAttribute::KeepLower);
        }
    }
 
    // cut bottom
    obj_bb = model().objects[0]->bounding_box_exact();
    block_count = lround((500 - params.start) / base_temp_tower_temp_step);
    if (block_count > 0) {
        auto new_height = block_count * block_height + EPSILON;
        if (new_height < obj_bb.size().z()) {
            cut_horizontal(0, 0, new_height, ModelObjectCutAttribute::KeepUpper);
        }
    }
 
    if (params.nozzle_based_resize && std::abs(nozzle_scale - 1.0) > EPSILON)
        model().objects[0]->scale(nozzle_scale, nozzle_scale, nozzle_scale);
 
    model().objects[0]->ensure_on_bed();
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    set_config_values<int, ConfigOptionInts>(filament_config, "nozzle_temperature_initial_layer", (int) start_temp);
    set_config_values<int, ConfigOptionInts>(filament_config, "nozzle_temperature", (int) start_temp);
    // When resizing is disabled the 0.4 mm / 0.2 mm reference model is printed as-is (preset layer height kept).
    if (params.nozzle_based_resize)
        model().objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(nozzle_diameter/2));
    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(5.0));
    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
    model().objects[0]->config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    model().objects[0]->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
    model().objects[0]->config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
    model().objects[0]->config.set_key_value("precise_z_height", new ConfigOptionBool(false));
 
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
    if (params.nozzle_based_resize)
        print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(nozzle_diameter/2));
 
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->reload_config();
 
    p->background_process.fff_print()->set_calib_params(params);
}

References _calib_temp_belt_sectioned(), _L, add_model(), Slic3r::angle(), Slic3r::GUI::belt_calib_rotation_params(), Slic3r::GUI::belt_temp_tower_asset(), Slic3r::ModelObject::bounding_box_exact(), Slic3r::btNoBrim, Slic3r::btOuterOnly, Slic3r::Calib_Temp_Tower, Slic3r::BoundingBox3Base< PointType >::center(), changed_objects(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, Slic3r::Model::curr_plate_index, Slic3r::CustomGCode::Custom, cut_horizontal(), Slic3r::Calib_Params::end, Slic3r::ModelObject::ensure_on_bed(), EPSILON, Slic3r::Calib_Params::extruder_id, Slic3r::GUI::format_wxstr(), Slic3r::CustomGCode::Info::gcodes, Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::get_extents(), get_partplate_list(), Slic3r::KeepLower, Slic3r::KeepUpper, M_PI, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::Calib_Params::mode, Slic3r::CustomGCode::Info::mode, model(), new_project(), Slic3r::None, Slic3r::Calib_Params::nozzle_based_resize, Slic3r::nozzle_diameter(), Slic3r::Model::objects, p, Slic3r::Model::plates_custom_gcodes, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::set_config_values(), Slic3r::ModelConfig::set_key_value(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::CustomGCode::SingleExtruder, Slic3r::Calib_Params::start, TAB_ID_PREPARE, Slic3r::Calib_Params::test_model, Slic3r::ModelObject::translate_instances(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::ConfigOptionVector< double >::values.

Here is the call graph for this function:

calib_VFA()

void Slic3r::GUI::Plater::calib_VFA

(

const Calib_Params &

params

)

{
    const auto calib_vfa_name = _L("VFA test");
    new_project(false, false, calib_vfa_name);
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    if (params.mode != CalibMode::Calib_VFA_Tower)
        return;
 
    if (!add_model(false, Slic3r::resources_dir() + "/calib/vfa/vfa.drc"))
        return;
    auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
 
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
    double nozzle_diameter = vfa_base_nozzle_diameter;
    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
    }
    if (nozzle_diameter <= 0.0)
        nozzle_diameter = vfa_base_nozzle_diameter;
 
    // Resolved layer height: use the (possibly auto-adjusted) value from the dialog, else default to nozzle/2.
    double layer_height = params.vfa_layer_height > 0.0 ? params.vfa_layer_height : nozzle_diameter / 2.0;
 
    // cut upper (on the unscaled model, using the base block height); the scaling below keeps the physical
    // block height (vfa_layers_per_block * layer_height) in sync with the speed stepping in GCode::process_layer.
    // Subtract EPSILON (as the temperature tower does) so the cut lands just below the flat block surface instead
    // of exactly on it, which would otherwise add a degenerate extra layer.
    auto obj_bb = model().objects[0]->bounding_box_exact();
    auto height = vfa_base_block_height * ((params.end - params.start) / params.step + 1) - EPSILON;
    if (height < obj_bb.size().z()) {
        cut_horizontal(0, 0, height, ModelObjectCutAttribute::KeepLower);
    }
 
    // When resizing is enabled, XY scales with the nozzle (footprint / line width) and Z scales so each base
    // block becomes vfa_layers_per_block layers of the resolved layer height. When disabled the 0.4 mm / 0.2 mm
    // reference model is printed as-is (preset layer height kept).
    if (params.nozzle_based_resize) {
        const double xy_scale = nozzle_diameter / vfa_base_nozzle_diameter;
        const double z_scale  = (vfa_layers_per_block * layer_height) / vfa_base_block_height;
        if (std::abs(xy_scale - 1.0) > EPSILON || std::abs(z_scale - 1.0) > EPSILON)
            model().objects[0]->scale(xy_scale, xy_scale, z_scale);
    }
 
    model().objects[0]->ensure_on_bed();
 
    printer_config->set_key_value("resonance_avoidance", new ConfigOptionBool{false});
    filament_config->set_key_value("slow_down_layer_time", new ConfigOptionFloats { 0.0 });
    set_config_values<bool, ConfigOptionBoolsNullable>(print_config, "enable_overhang_speed", false);
    print_config->set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config->set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config->set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    print_config->set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config->set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config->set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config->set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config->set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config->set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
    print_config->set_key_value("precise_z_height", new ConfigOptionBool(false));
    if (params.nozzle_based_resize) {
        print_config->set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
        model().objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    }
    model().objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model().objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    model().objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    changed_objects({ 0 });
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_dirty();
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_ui_from_settings();
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->update_ui_from_settings();
 
    _calib_apply_belt_mode();
    // Pass the resolved layer height on (only meaningful when resized). GCode's VFA stepping is layer-based, so
    // it does not require it, but keep it consistent with the geometry.
    Calib_Params calib_params = params;
    calib_params.vfa_layer_height = params.nozzle_based_resize ? layer_height : 0.0;
    p->background_process.fff_print()->set_calib_params(calib_params);
}

References _calib_apply_belt_mode(), _L, add_model(), Slic3r::btOuterOnly, Slic3r::Calib_VFA_Tower, changed_objects(), Slic3r::ConfigOptionFloat, cut_horizontal(), Slic3r::Calib_Params::end, EPSILON, Slic3r::Calib_Params::extruder_id, Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Calib_Params::mode, model(), new_project(), Slic3r::Calib_Params::nozzle_based_resize, Slic3r::nozzle_diameter(), Slic3r::Model::objects, p, Slic3r::GUI::printer_config(), Slic3r::resources_dir(), Slic3r::GUI::set_config_values(), Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, TAB_ID_PREPARE, Slic3r::tlTraditional, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::ConfigOptionVector< double >::values, Slic3r::vfa_base_block_height, Slic3r::vfa_base_nozzle_diameter, Slic3r::Calib_Params::vfa_layer_height, and Slic3r::vfa_layers_per_block.

Here is the call graph for this function:

can_add_model()

bool Slic3r::GUI::Plater::can_add_model

(

)

const

{ return !is_background_process_slicing(); }

References is_background_process_slicing().

Here is the call graph for this function:

can_add_plate()

bool Slic3r::GUI::Plater::can_add_plate

(

)

const

{ return !is_background_process_slicing() && p->can_add_plate(); }

References is_background_process_slicing(), and p.

Here is the call graph for this function:

can_arrange()

bool Slic3r::GUI::Plater::can_arrange

(

)

const

{ return p->can_arrange(); }

References p.

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

Here is the caller graph for this function:

can_copy_to_clipboard()

bool Slic3r::GUI::Plater::can_copy_to_clipboard

(

)

const

{
    if (!IsShown() || !p->is_view3D_shown())
        return false;
 
    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().

Here is the call graph for this function:

Here is the caller graph for this function:

can_cut_to_clipboard()

bool Slic3r::GUI::Plater::can_cut_to_clipboard

(

)

const

{
    if (is_selection_empty())
        return false;
    return true;
}

References is_selection_empty().

Referenced by cut_selection_to_clipboard().

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

(

)

const

{ return p->can_decrease_instances(); }

References p.

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

Here is the caller graph for this function:

can_delete()

bool Slic3r::GUI::Plater::can_delete

(

)

const

{ return p->can_delete(); }

References p.

can_delete_all()

bool Slic3r::GUI::Plater::can_delete_all

(

)

const

{ return p->can_delete_all(); }

References p.

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

Here is the caller graph for this function:

can_delete_plate()

bool Slic3r::GUI::Plater::can_delete_plate

(

)

const

{ return p->can_delete_plate(); }

References p.

can_fillcolor()

bool Slic3r::GUI::Plater::can_fillcolor

(

)

const

{ return p->can_fillcolor(); }

References p.

Referenced by fill_color().

Here is the caller graph for this function:

can_fix_through_cgal()

bool Slic3r::GUI::Plater::can_fix_through_cgal

(

)

const

{ return p->can_fix_through_cgal(); }

References p.

can_increase_instances()

bool Slic3r::GUI::Plater::can_increase_instances

(

)

const

{ return p->can_increase_instances(); }

References p.

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

Here is the caller graph for this function:

can_layers_editing()

bool Slic3r::GUI::Plater::can_layers_editing

(

)

const

{ return p->can_layers_editing(); }

References p.

can_mirror()

bool Slic3r::GUI::Plater::can_mirror

(

)

const

{ return p->can_mirror(); }

References p.

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

Here is the caller graph for this function:

can_paste_from_clipboard()

bool Slic3r::GUI::Plater::can_paste_from_clipboard

(

)

const

{
    if (!IsShown() || !p->is_view3D_shown()) return false;
 
    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 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

{ return IsShown() && p->is_view3D_shown() && p->m_worker.is_idle() && p->undo_redo_stack().has_redo_snapshot(); }

References p.

can_reload_from_disk()

bool Slic3r::GUI::Plater::can_reload_from_disk

(

)

const

{ return p->can_reload_from_disk(); }

References p.

can_replace_all_with_stl()

bool Slic3r::GUI::Plater::can_replace_all_with_stl

(

)

const

{ return p->can_replace_all_with_stl(); }

References p.

can_replace_with_stl()

bool Slic3r::GUI::Plater::can_replace_with_stl

(

)

const

{ return p->can_replace_with_stl(); }

References p.

can_set_instance_to_object()

bool Slic3r::GUI::Plater::can_set_instance_to_object

(

)

const

{ return p->can_set_instance_to_object(); }

References p.

can_simplify()

bool Slic3r::GUI::Plater::can_simplify

(

)

const

{ return p->can_simplify(); }

References p.

can_smooth_mesh()

bool Slic3r::GUI::Plater::can_smooth_mesh

(

)

const

{ return p->can_smooth_mesh(); }

References p.

can_split()

bool Slic3r::GUI::Plater::can_split

(

bool

to_objects

)

const

{ return p->can_split(to_objects); }

References p.

can_split_to_objects()

bool Slic3r::GUI::Plater::can_split_to_objects

(

)

const

{ return p->can_split_to_objects(); }

References p.

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

Here is the caller graph for this function:

can_split_to_volumes()

bool Slic3r::GUI::Plater::can_split_to_volumes

(

)

const

{ return p->can_split_to_volumes(); }

References p.

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

Here is the caller graph for this function:

can_undo()

bool Slic3r::GUI::Plater::can_undo

(

)

const

{ return IsShown() && p->is_view3D_shown() && p->m_worker.is_idle() && p->undo_redo_stack().has_undo_snapshot(); }

References p.

canvas3D() [1/2]

GLCanvas3D * Slic3r::GUI::Plater::canvas3D

(

)

{
    // BBS modify view3D->get_canvas3d() to current canvas
    return p->get_current_canvas3D();
}

References p.

Referenced by Slic3r::GUI::add_volume_with_gizmo(), increase_instances(), Slic3r::GUI::init_arrange_params(), and search().

Here is the caller graph for this function:

canvas3D() [2/2]

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

(

)

const

{
    // BBS modify view3D->get_canvas3d() to current canvas
    return p->get_current_canvas3D();
}

References p.

center_selection()

void Slic3r::GUI::Plater::center_selection

(

)

{ p->center_selection(); }

References p.

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

changed_object() [1/2]

void Slic3r::GUI::Plater::changed_object

(

int

obj_idx

)

{
    if (obj_idx < 0)
        return;
    ModelObject *object = p->model.objects[obj_idx];
    if (object == nullptr)
        return;
    changed_object(*object);
}

References changed_object(), and p.

Here is the call graph for this function:

changed_object() [2/2]

void Slic3r::GUI::Plater::changed_object

(

ModelObject &

object

)

                                              {
    assert(object.get_model() == &p->model); // is object from same model?
    object.invalidate_bounding_box();
    p->partplate_list.invalidate_exclusion_volume_previews();
 
    // recenter and re - align to Z = 0
    object.ensure_on_bed(p->printer_technology != ptSLA);
 
    if (p->printer_technology == ptSLA) {
        // Update the SLAPrint from the current Model, so that the reload_scene()
        // pulls the correct data, update the 3D scene.
        p->update_restart_background_process(true, false);
    } else
        p->view3D->reload_scene(false);
 
    // update print
    p->schedule_background_process();
        
    // Check outside bed
    get_current_canvas3D()->requires_check_outside_state();
 
    if (!is_loading_project()) {
        LifecycleEventContext ctx;
        ctx.name = object.name;
        ctx.id = std::to_string(object.id().id);
        ctx.source = "geometry";
        fire_lifecycle_event(LifecycleEvent::ObjectChanged, ctx);
    }
}

References Slic3r::fire_lifecycle_event(), get_current_canvas3D(), Slic3r::LifecycleEventContext::id, is_loading_project(), Slic3r::LifecycleEventContext::name, Slic3r::ObjectChanged, p, Slic3r::ptSLA, Slic3r::GUI::GLCanvas3D::requires_check_outside_state(), and Slic3r::LifecycleEventContext::source.

Referenced by changed_object().

Here is the call graph for this function:

Here is the caller graph for this function:

changed_objects()

void Slic3r::GUI::Plater::changed_objects

(

const std::vector< size_t > &

object_idxs

)

{
    if (object_idxs.empty())
        return;
 
    p->partplate_list.invalidate_exclusion_volume_previews();
 
    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();
 
    if (!is_loading_project()) {
        for (size_t obj_idx : object_idxs) {
            if (obj_idx >= p->model.objects.size() || p->model.objects[obj_idx] == nullptr)
                continue;
 
            LifecycleEventContext ctx;
            ctx.name = p->model.objects[obj_idx]->name;
            ctx.id = std::to_string(p->model.objects[obj_idx]->id().id);
            ctx.index = static_cast<int>(obj_idx);
            ctx.source = "geometry";
            fire_lifecycle_event(LifecycleEvent::ObjectChanged, ctx);
        }
    }
}

References Slic3r::fire_lifecycle_event(), Slic3r::LifecycleEventContext::id, Slic3r::LifecycleEventContext::index, is_loading_project(), model(), Slic3r::LifecycleEventContext::name, Slic3r::ObjectChanged, p, Slic3r::ptSLA, Slic3r::SINKING_Z_THRESHOLD, and Slic3r::LifecycleEventContext::source.

Referenced by _calib_apply_belt_mode(), _calib_pa_pattern(), _calib_pa_tower(), _calib_temp_belt_sectioned(), Calib_Cornering(), calib_flowrate(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_retraction(), calib_temp(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

check_ams_status()

bool Slic3r::GUI::Plater::check_ams_status

(

bool

is_slice_all

)

{
    if (m_check_status == 0) {
        if (!p->check_ams_status_impl(is_slice_all)) {
            m_check_status = 0;
            return false;
        }
        else {
            m_check_status = 1;
        }
    }
 
    return true;
}

References m_check_status, and p.

Referenced by select_plate().

Here is the caller graph for this function:

check_printer_initialized()

bool Slic3r::GUI::Plater::check_printer_initialized	(	MachineObject *	obj,
		bool	only_warning = false,
		bool	popup_warning = true )

{
    if (!obj)
        return false;
 
    bool has_been_initialized = true;
 
    const auto& extruders = obj->GetExtderSystem()->GetExtruders();
    for (const DevExtder& extruder : extruders) {
 
        // Skip check if nozzle type is unknown
        if (extruder.GetNozzleType() == NozzleType::ntUndefine) {
            continue;
        }
 
        if (extruder.GetNozzleFlowType() == NozzleFlowType::NONE_FLOWTYPE) {
            has_been_initialized = false;
            break;
        }
    }
 
    if (!has_been_initialized) {
        if (popup_warning) {
            if (!only_warning) {
                if (DevPrinterConfigUtil::get_printer_can_set_nozzle(obj->get_show_printer_type())) {
                    MessageDialog dlg(wxGetApp().plater(), _L("The nozzle type is not set. Please set the nozzle and try again."), _L("Warning"), wxOK | wxICON_WARNING);
                    dlg.ShowModal();
                } else {
                    MessageDialog dlg(wxGetApp().plater(), _L("The nozzle type is not set. Please check."), _L("Warning"), wxOK | wxICON_WARNING);
                    dlg.ShowModal();
                }
 
                PrinterPartsDialog print_parts_dlg(nullptr);
                print_parts_dlg.update_machine_obj(obj);
                print_parts_dlg.ShowModal();
            } else {
                auto printer_name = get_selected_printer_name_in_combox(); // wxString(obj->get_preset_printer_model_name(machine_print_name))
                pop_warning_and_go_to_device_page(printer_name, Plater::PrinterWarningType::NOT_CONNECTED, _L("Sync printer information"));
            }
        }
        return false;
    }
    return true;
}

References _L, Slic3r::DevPrinterConfigUtil::get_printer_can_set_nozzle(), get_selected_printer_name_in_combox(), Slic3r::MachineObject::get_show_printer_type(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetExtruders(), Slic3r::NONE_FLOWTYPE, NOT_CONNECTED, Slic3r::ntUndefine, Slic3r::GUI::plater(), pop_warning_and_go_to_device_page(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::PrinterPartsDialog::update_machine_obj().

Referenced by is_same_printer_for_connected_and_selected().

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

)

{
    ModelObject* mo = model().objects[obj_idx];
 
    // If there are custom supports/seams/mmu/fuzzy skin 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->fuzzy_skin_facets.empty();
        mv->supported_facets.reset();
        mv->seam_facets.reset();
        mv->mmu_segmentation_facets.reset();
        mv->fuzzy_skin_facets.reset();
    }
    if (paint_removed)
        notify_painting_removed();
}

References Slic3r::FacetsAnnotation::empty(), Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::ModelVolume::mmu_segmentation_facets, model(), notify_painting_removed(), Slic3r::Model::objects, Slic3r::FacetsAnnotation::reset(), Slic3r::ModelVolume::seam_facets, Slic3r::ModelVolume::supported_facets, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

clear_plate_toolbar_image_dirty()

void Slic3r::GUI::Plater::clear_plate_toolbar_image_dirty

(

)

{
    m_b_plate_toolbar_image_dirty = false;
}

References m_b_plate_toolbar_image_dirty.

clear_undo_redo_stack_main()

void Slic3r::GUI::Plater::clear_undo_redo_stack_main

(

)

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

References p.

clone_selection()

void Slic3r::GUI::Plater::clone_selection

(

)

{
    if (is_selection_empty())
        return;
    CloneDialog dlg(this);
    dlg.ShowModal();
}

References is_selection_empty(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

close_with_confirm()

int Slic3r::GUI::GUI::Plater::close_with_confirm

(

std::function< bool(bool yes_or_no)>

second_check = nullptr

)

{
    if (up_to_date(false, false)) {
        if (second_check && !second_check(false)) return wxID_CANCEL;
        model().set_backup_path("");
        return wxID_NO;
    }
 
    MessageDialog dlg(static_cast<wxWindow*>(this), _L("The current project has unsaved changes. Would you like to save before continuing\?"),
        wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Save"), wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxCENTRE);
    dlg.show_dsa_button(_L("Remember my choice."));
    auto choise = wxGetApp().app_config->get("save_project_choise");
    auto result = choise.empty() ? dlg.ShowModal() : choise == "yes" ? wxID_YES : wxID_NO;
    if (result == wxID_CANCEL)
        return result;
    else {
        if (dlg.get_checkbox_state())
            wxGetApp().app_config->set("save_project_choise", result == wxID_YES ? "yes" : "no");
        if (result == wxID_YES) {
            result = save_project();
            if (result == wxID_CANCEL) {
                if (choise.empty())
                    return result;
                else
                    result = wxID_NO;
            }
        }
    }
 
    if (second_check && !second_check(result == wxID_YES)) return wxID_CANCEL;
 
    model().set_backup_path("");
    up_to_date(true, false);
    up_to_date(true, true);
 
    return result;
}

References _L, Slic3r::GUI::MsgDialog::get_checkbox_state(), model(), save_project(), Slic3r::GUI::MsgDialog::show_dsa_button(), Slic3r::GUI::DPIAware< P >::ShowModal(), SLIC3R_APP_FULL_NAME, and up_to_date().

Referenced by load_gcode(), load_project(), and new_project().

Here is the call graph for this function:

Here is the caller graph for this function:

collapse_sidebar()

void Slic3r::GUI::Plater::collapse_sidebar

(

bool

collapse

)

{ p->collapse_sidebar(collapse); }

References p.

combine_mesh_fff()

TriangleMesh Slic3r::GUI::Plater::combine_mesh_fff ( const ModelObject & mo, int instance_id, std::function< void(const std::string &)> notify_func = {} )

static

{
    TriangleMesh mesh;
 
    std::vector<csg::CSGPart> csgmesh;
    csgmesh.reserve(2 * mo.volumes.size());
    bool has_splitable_volume = csg::model_to_csgmesh(mo, Transform3d::Identity(), std::back_inserter(csgmesh),
        csg::mpartsPositive | csg::mpartsNegative);
        
    std::string fail_msg = _u8L("Unable to perform boolean operation on model meshes. "
        "Only positive parts will be kept. You may fix the meshes and try again.");
    if (auto fail_reason_name = csg::check_csgmesh_booleans(Range{ std::begin(csgmesh), std::end(csgmesh) }); std::get<0>(fail_reason_name) != csg::BooleanFailReason::OK) {
        std::string name = std::get<1>(fail_reason_name);
        std::map<csg::BooleanFailReason, std::string> fail_reasons = {
            {csg::BooleanFailReason::OK, "OK"},
            {csg::BooleanFailReason::MeshEmpty, Slic3r::format( _u8L("Reason: part \"%1%\" is empty."), name)},
            {csg::BooleanFailReason::NotBoundAVolume, Slic3r::format(_u8L("Reason: part \"%1%\" does not bound a volume."), name)},
            {csg::BooleanFailReason::SelfIntersect, Slic3r::format(_u8L("Reason: part \"%1%\" has self intersection."), name)},
            {csg::BooleanFailReason::NoIntersection, Slic3r::format(_u8L("Reason: \"%1%\" and another part have no intersection."), name)} };
        fail_msg += " " + fail_reasons[std::get<0>(fail_reason_name)];
    }
    else {
        try {
            MeshBoolean::mcut::McutMeshPtr meshPtr = csg::perform_csgmesh_booleans_mcut(Range{ std::begin(csgmesh), std::end(csgmesh) });
            mesh = MeshBoolean::mcut::mcut_to_triangle_mesh(*meshPtr);
        }
        catch (...) {}
#if 0
        // if mcut fails, try again with CGAL
        if (mesh.empty()) {
            try {
                auto meshPtr = csg::perform_csgmesh_booleans(Range{ std::begin(csgmesh), std::end(csgmesh) });
                mesh = MeshBoolean::cgal::cgal_to_triangle_mesh(*meshPtr);
                }
            catch (...) {}
        }
#endif
    }
 
    if (mesh.empty()) {
        if (notify_func)
            notify_func(fail_msg);
 
        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(std::move(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;
}

References _u8L, Slic3r::MeshBoolean::cgal::cgal_to_triangle_mesh(), Slic3r::csg::check_csgmesh_booleans(), Slic3r::TriangleMesh::empty(), Slic3r::format(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), Slic3r::MeshBoolean::mcut::mcut_to_triangle_mesh(), Slic3r::TriangleMesh::merge(), Slic3r::ModelVolume::mesh(), Slic3r::csg::MeshEmpty, Slic3r::csg::model_to_csgmesh(), Slic3r::csg::mpartsNegative, Slic3r::csg::mpartsPositive, Slic3r::csg::NoIntersection, Slic3r::csg::NotBoundAVolume, Slic3r::csg::OK, Slic3r::csg::perform_csgmesh_booleans(), Slic3r::csg::perform_csgmesh_booleans_mcut(), Slic3r::csg::SelfIntersect, Slic3r::TriangleMesh::transform(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::ObjectList::boolean(), and export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

config()

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

(

)

const

{ return p->config; }

References p.

Referenced by config_change_notification(), force_filament_colors_update(), get_extruder_colors_from_plater_config(), get_filament_color_render_type(), get_filament_colors_render_info(), get_filament_gradient_ramps(), import_model_id(), mixed_filament_config_indices(), on_change_color_mode(), on_config_change(), open_filament_map_setting_dialog(), physical_filament_config_indices(), send_gcode_legacy(), and update_print_required_data().

Here is the caller graph for this function:

config_change_notification()

void Slic3r::GUI::Plater::config_change_notification	(	const DynamicPrintConfig &	config,
		const std::string &	key )

{
    GLCanvas3D* view3d_canvas = get_view3D_canvas3D();
    if (key == std::string("print_sequence")) {
        auto seq_print = config.option<ConfigOptionEnum<PrintSequence>>("print_sequence");
        if (seq_print && view3d_canvas && view3d_canvas->is_initialized() && view3d_canvas->is_rendering_enabled()) {
            NotificationManager* notify_manager = get_notification_manager();
            if (seq_print->value == PrintSequence::ByObject) {
                std::string info_text = _u8L("Print By Object: \nWe suggest using auto-arrange to avoid collisions when printing.");
                notify_manager->bbl_show_seqprintinfo_notification(info_text);
            }
            else
                notify_manager->bbl_close_seqprintinfo_notification();
        }
    }
    // notification for more options
}

References _u8L, Slic3r::GUI::NotificationManager::bbl_close_seqprintinfo_notification(), Slic3r::GUI::NotificationManager::bbl_show_seqprintinfo_notification(), Slic3r::ByObject, config(), get_notification_manager(), get_view3D_canvas3D(), Slic3r::GUI::GLCanvas3D::is_initialized(), and Slic3r::GUI::GLCanvas3D::is_rendering_enabled().

Referenced by on_config_change().

Here is the call graph for this function:

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;
 
    TakeSnapshot snapshot(this, conv_type == ConversionType::CONV_FROM_INCH  ? "Convert from imperial units" :
                                conv_type == ConversionType::CONV_TO_INCH    ? "Revert conversion from imperial units" :
                                conv_type == ConversionType::CONV_FROM_METER ? "Convert from meters" : "Revert conversion from meters");
    wxBusyCursor wait;
 
    ModelObjectPtrs objects;
    std::reverse(obj_idxs.begin(), obj_idxs.end());
    for (int obj_idx : obj_idxs) {
        ModelObject *object = p->model.objects[obj_idx];
        object->convert_units(objects, conv_type, volume_idxs);
        remove(obj_idx);
    }
    std::reverse(objects.begin(), objects.end());
    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 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.

Here is the call graph for this function:

cut()

void Slic3r::GUI::Plater::cut	(	size_t	obj_idx,
		size_t	instance_idx,
		std::array< Vec3d, 4 >	plane_points,
		ModelObjectCutAttributes	attributes )

Referenced by cut_horizontal().

Here is the caller graph for this function:

cut_horizontal()

void Slic3r::GUI::Plater::cut_horizontal ( size_t obj_idx, size_t instance_idx, double z, ModelObjectCutAttributes attributes )

private

{
    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");
 
    if (! attributes.has(ModelObjectCutAttribute::KeepUpper) && ! attributes.has(ModelObjectCutAttribute::KeepLower))
        return;
 
    wxBusyCursor wait;
 
    const Vec3d instance_offset = object->instances[instance_idx]->get_offset();
    Cut         cut(object, instance_idx, Geometry::translation_transform(z * Vec3d::UnitZ() - instance_offset), attributes);
    const auto  new_objects = cut.perform_with_plane();
 
    apply_cut_object_to_model(obj_idx, new_objects);
}

References apply_cut_object_to_model(), cut(), Slic3r::enum_bitmask< option_type, typename >::has(), Slic3r::KeepLower, Slic3r::KeepUpper, model(), p, and Slic3r::Geometry::translation_transform().

Referenced by _calib_pa_tower(), _calib_temp_belt_sectioned(), calib_max_vol_speed(), calib_retraction(), calib_temp(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_selection_to_clipboard()

void Slic3r::GUI::Plater::cut_selection_to_clipboard

(

)

{
    Plater::TakeSnapshot snapshot(this, "Cut Selected Objects");
    if (can_cut_to_clipboard() && !p->sidebar->obj_list()->cut_to_clipboard()) {
        p->view3D->get_canvas3d()->get_selection().cut_to_clipboard();
    }
}

References can_cut_to_clipboard(), and p.

Here is the call graph for this function:

decrease_instances()

void Slic3r::GUI::Plater::decrease_instances

(

size_t

num = 1

)

{
    if (! can_decrease_instances()) { return; }
 
    Plater::TakeSnapshot snapshot(this, "Decrease Instances");
 
    int obj_idx = p->get_selected_object_idx();
 
    ModelObject* model_object = p->model.objects[obj_idx];
    if (model_object->instances.size() > num) {
        for (size_t i = 0; i < num; ++ i) {
            p->partplate_list.notify_instance_removed(obj_idx, static_cast<int>(model_object->instances.size()) - 1);
            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();
    //if (wxGetApp().app_config->get("auto_arrange") == "true") {
    //    this->set_prepare_state(Job::PREPARE_STATE_MENU);
    //    this->arrange();
    //}
}

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

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), 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

(

)

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

References p.

delete_all_objects_from_model()

void Slic3r::GUI::Plater::delete_all_objects_from_model

(

)

{
    p->delete_all_objects_from_model();
}

References p.

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

Here is the caller graph for this function:

delete_object_from_model()

bool Slic3r::GUI::Plater::delete_object_from_model	(	size_t	obj_idx,
		bool	refresh_immediately = true )

{ return p->delete_object_from_model(obj_idx, refresh_immediately); }

References p.

delete_plate()

int Slic3r::GUI::Plater::delete_plate

(

int

plate_index = -1

)

{
    int index = plate_index, ret;
 
    if (plate_index == -1)
        index = p->partplate_list.get_curr_plate_index();
 
    take_snapshot("delete partplate");
    ret = p->partplate_list.delete_plate(index);
 
    //BBS: update the current print to the current plate
    p->partplate_list.update_slice_context_to_current_plate(p->background_process);
    p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
    p->sidebar->obj_list()->reload_all_plates();
 
    // BBS update default view
    //get_camera().select_view("topfront");
    //get_camera().requires_zoom_to_plate = REQUIRES_ZOOM_TO_ALL_PLATE;
 
    //need to call update
    update();
    return ret;
}

References p, take_snapshot(), and update().

Referenced by select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

deselect_all()

void Slic3r::GUI::Plater::deselect_all

(

)

{ p->deselect_all(); }

References p.

download_project()

void Slic3r::GUI::Plater::download_project

(

const wxString &

project_id

)

{
    return;
}

drop_selection()

void Slic3r::GUI::Plater::drop_selection

(

)

{ p->drop_selection(); }

References p.

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

Here is the caller graph for this function:

duplicate_plate()

int Slic3r::GUI::Plater::duplicate_plate

(

int

plate_index = -1

)

{
    int index = plate_index, ret;
    if (plate_index == -1)
        index = p->partplate_list.get_curr_plate_index();
 
    ret = p->partplate_list.duplicate_plate(index);
 
    //need to call update
    update();
    return ret;
}

References p, and update().

Here is the call graph for this function:

eject_drive()

void Slic3r::GUI::Plater::eject_drive

(

)

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

References p.

enable_inactive_plugins()

void Slic3r::GUI::Plater::enable_inactive_plugins

(

const std::vector< std::string > &

refs

)

{
    if (refs.empty())
        return;
    // Local and instant — load the plugin and/or enable the capability. The plugin-load callback
    // re-validates the plate and clears (or reclassifies) the notification; no progress dialog needed.
    resolve_inactive_plugins(refs);
}

References Slic3r::resolve_inactive_plugins().

Referenced by refresh_missing_plugin_block().

Here is the call graph for this function:

Here is the caller graph for this function:

enable_preview_moves_slider()

void Slic3r::GUI::Plater::enable_preview_moves_slider

(

bool

enable

)

enable_sidebar()

void Slic3r::GUI::Plater::enable_sidebar

(

bool

enabled

)

{ p->enable_sidebar(enabled); }

References p.

Referenced by load_gcode(), load_project(), new_project(), and Slic3r::GUI::Plater::priv::set_current_panel().

Here is the caller graph for this function:

enable_wireframe()

void Slic3r::GUI::Plater::enable_wireframe

(

bool

status

)

{
    p->wireframe_enabled = status;
}

References p.

Referenced by Plater().

Here is the caller graph for this function:

enter_gizmos_stack()

void Slic3r::GUI::Plater::enter_gizmos_stack

(

)

{ p->enter_gizmos_stack(); }

References p.

exit_gizmo()

void Slic3r::GUI::Plater::exit_gizmo

(

)

{ p->exit_gizmo(); }

References p.

export_3mf()

int Slic3r::GUI::Plater::export_3mf	(	const boost::filesystem::path &	output_path = boost::filesystem::path(),
		SaveStrategy	strategy = SaveStrategy::Default,
		int	export_plate_idx = -1,
		Export3mfProgressFn	proFn = nullptr )

{
    int ret = 0;
    //if (p->model.objects.empty()) {
    //    MessageDialog dialog(nullptr, _L("No objects to export."), _L("Save project"), wxYES);
    //    if (dialog.ShowModal() == wxYES)
    //        return -1;
    //}
 
    if (output_path.empty())
        return -1;
 
    bool export_config = true;
    wxString path = from_path(output_path);
 
    if (!path.Lower().EndsWith(".3mf"))
        return -1;
 
    // take care about private data stored into .3mf
    // modify model
    publish(p->model, strategy);
 
    DynamicPrintConfig cfg = wxGetApp().preset_bundle->full_config_secure();
    const std::string path_u8 = into_u8(path);
    wxBusyCursor wait;
 
    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << boost::format(": path=%1%, backup=%2%, export_plate_idx=%3%, SaveStrategy=%4%")
        %output_path.string()%(strategy & SaveStrategy::Backup)%export_plate_idx %(unsigned int)strategy;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": path=%1%, backup=%2%, export_plate_idx=%3%, SaveStrategy=%4%")
        % std::string("") % (strategy & SaveStrategy::Backup) % export_plate_idx % (unsigned int)strategy;
 
    //BBS: add plate logic for thumbnail generate
    std::vector<ThumbnailData*> thumbnails;
    std::vector<ThumbnailData*> no_light_thumbnails;
    std::vector<ThumbnailData*> calibration_thumbnails;
    std::vector<ThumbnailData*> top_thumbnails;
    std::vector<ThumbnailData*> picking_thumbnails;
    std::vector<PlateBBoxData*> plate_bboxes;
    // BBS: backup
    if (!(strategy & SaveStrategy::Backup)) {
        for (int i = 0; i < p->partplate_list.get_plate_count(); i++) {
            ThumbnailData* thumbnail_data = &p->partplate_list.get_plate(i)->thumbnail_data;
            if (p->partplate_list.get_plate(i)->thumbnail_data.is_valid() &&  using_exported_file()) {
                //no need to generate thumbnail
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": non need to re-generate thumbnail for gcode/exported mode of plate %1%")%i;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": re-generate thumbnail for plate %1%") % i;
                const ThumbnailsParams thumbnail_params = { {}, false, true, true, true, i };
                p->generate_thumbnail(p->partplate_list.get_plate(i)->thumbnail_data, THUMBNAIL_SIZE_3MF.first, THUMBNAIL_SIZE_3MF.second,
                                    thumbnail_params, Camera::EType::Ortho);
            }
            thumbnails.push_back(thumbnail_data);
 
            ThumbnailData *no_light_thumbnail_data = &p->partplate_list.get_plate(i)->no_light_thumbnail_data;
            if (p->partplate_list.get_plate(i)->no_light_thumbnail_data.is_valid() && using_exported_file()) {
                // no need to generate thumbnail
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": non need to re-generate thumbnail for gcode/exported mode of plate %1%") % i;
            } else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": re-generate thumbnail for plate %1%") % i;
                const ThumbnailsParams thumbnail_params = {{}, false, true, true, true, i};
                p->generate_thumbnail(p->partplate_list.get_plate(i)->no_light_thumbnail_data, THUMBNAIL_SIZE_3MF.first, THUMBNAIL_SIZE_3MF.second, thumbnail_params,
                                      Camera::EType::Ortho,  Camera::ViewAngleType::Iso, false, true);
            }
            no_light_thumbnails.push_back(no_light_thumbnail_data);
            //ThumbnailData* calibration_data = &p->partplate_list.get_plate(i)->cali_thumbnail_data;
            //calibration_thumbnails.push_back(calibration_data);
            PlateBBoxData* plate_bbox_data = &p->partplate_list.get_plate(i)->cali_bboxes_data;
            plate_bboxes.push_back(plate_bbox_data);
 
            //generate top and picking thumbnails
            ThumbnailData* top_thumbnail = &p->partplate_list.get_plate(i)->top_thumbnail_data;
            if (top_thumbnail->is_valid() &&  using_exported_file()) {
                //no need to generate thumbnail
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": non need to re-generate top_thumbnail for gcode/exported mode of plate %1%")%i;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": re-generate top_thumbnail for plate %1%") % i;
                const ThumbnailsParams thumbnail_params = { {}, false, true, false, true, i };
                p->generate_thumbnail(p->partplate_list.get_plate(i)->top_thumbnail_data, THUMBNAIL_SIZE_3MF.first, THUMBNAIL_SIZE_3MF.second, thumbnail_params,
                                      Camera::EType::Ortho, Camera::ViewAngleType::Top_Plate, false);
            }
            top_thumbnails.push_back(top_thumbnail);
 
            ThumbnailData* picking_thumbnail = &p->partplate_list.get_plate(i)->pick_thumbnail_data;
            if (picking_thumbnail->is_valid() &&  using_exported_file()) {
                //no need to generate thumbnail
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": non need to re-generate pick_thumbnail for gcode/exported mode of plate %1%")%i;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": re-generate pick_thumbnail for plate %1%") % i;
                const ThumbnailsParams thumbnail_params = { {}, false, true, false, true, i };
                p->generate_thumbnail(p->partplate_list.get_plate(i)->pick_thumbnail_data, THUMBNAIL_SIZE_3MF.first, THUMBNAIL_SIZE_3MF.second, thumbnail_params,
                                      Camera::EType::Ortho, Camera::ViewAngleType::Top_Plate, true,true);
            }
            picking_thumbnails.push_back(picking_thumbnail);
        }
 
        if (p->partplate_list.get_curr_plate()->is_slice_result_valid()) {
            //BBS generate BBS calibration thumbnails
            int index = p->partplate_list.get_curr_plate_index();
            //ThumbnailData* calibration_data = calibration_thumbnails[index];
            //const ThumbnailsParams calibration_params = { {}, false, true, true, true, p->partplate_list.get_curr_plate_index() };
            //p->generate_calibration_thumbnail(*calibration_data, PartPlate::cali_thumbnail_width, PartPlate::cali_thumbnail_height, calibration_params);
            if (using_exported_file()) {
                //do nothing
            }
            else
                *plate_bboxes[index] = p->generate_first_layer_bbox();
        }
    }
 
    //BBS: add bbs 3mf logic
    PlateDataPtrs plate_data_list;
    p->partplate_list.store_to_3mf_structure(plate_data_list, (strategy & SaveStrategy::WithGcode || strategy & SaveStrategy::WithSliceInfo), export_plate_idx,
                                             strategy & SaveStrategy::WithStatistics);
 
    // Orca: non-BBL G-code isn't post-processed in place, so run the scripts on a copy before packing it.
    std::vector<std::string> pp_tmp_files;
    ScopeGuard remove_pp_tmp_files([&pp_tmp_files]() {
        for (const std::string& f : pp_tmp_files) {
            boost::system::error_code ec;
            boost::filesystem::remove(f, ec);
        }
    });
 
    // Backups (SkipStatic) don't pack G-code, so don't run user scripts for them.
    if ((strategy & SaveStrategy::WithGcode) && !(strategy & SaveStrategy::SkipStatic) &&
        p->printer_technology == ptFFF && !wxGetApp().preset_bundle->is_bbl_vendor()) {
        try {
            for (PlateData* pd : plate_data_list) {
                if (pd == nullptr || pd->gcode_file.empty())
                    continue;
                PartPlate* plate = p->partplate_list.get_plate(pd->plate_index);
                if (plate == nullptr)
                    continue;
                PrintBase* print = nullptr;
                plate->get_print(&print, nullptr, nullptr);
                Print* fff_print = dynamic_cast<Print*>(print);
                if (fff_print == nullptr)
                    continue;
 
                std::string src_path    = pd->gcode_file; // in/out: becomes the post-processed copy if a script ran
                std::string output_name = path_u8;        // scripts see the real target; a rename is ignored for 3mf
                if (run_post_process_scripts(src_path, true, "File", output_name, fff_print->full_print_config())) {
                    pp_tmp_files.push_back(src_path);
                    pd->gcode_file = src_path;
                }
            }
        } catch (const std::exception& ex) {
            release_PlateData_list(plate_data_list);
            show_error(this, ex.what(), false);
            return -1;
        }
    }
 
    // BBS: backup
    PresetBundle& preset_bundle = *wxGetApp().preset_bundle;
    std::vector<Preset*> project_presets = preset_bundle.get_current_project_embedded_presets();
 
    StoreParams store_params;
    store_params.path  = path_u8;
    store_params.model = &p->model;
    store_params.plate_data_list = plate_data_list;
    store_params.export_plate_idx = export_plate_idx;
    store_params.project_presets = project_presets;
    store_params.config = export_config ? &cfg : nullptr;
    store_params.thumbnail_data = thumbnails;
    store_params.no_light_thumbnail_data  = no_light_thumbnails;
    store_params.top_thumbnail_data = top_thumbnails;
    store_params.pick_thumbnail_data = picking_thumbnails;
    store_params.calibration_thumbnail_data = calibration_thumbnails;
    store_params.proFn = proFn;
    store_params.id_bboxes = plate_bboxes;//BBS
    store_params.project = &p->project;
    store_params.strategy = strategy | SaveStrategy::Zip64;
 
 
    // get type and color for platedata
    auto* filament_color = dynamic_cast<const ConfigOptionStrings*>(cfg.option("filament_colour"));
    auto* nozzle_diameter_option = dynamic_cast<const ConfigOptionFloats*>(cfg.option("nozzle_diameter"));
    auto* filament_id_opt = dynamic_cast<const ConfigOptionStrings*>(cfg.option("filament_ids"));
    std::string nozzle_diameter_str;
    if (nozzle_diameter_option)
        nozzle_diameter_str = nozzle_diameter_option->serialize();
 
    std::string printer_model_id = preset_bundle.printers.get_edited_preset().get_printer_type(&preset_bundle);
    // The printer reads slice_info.config and knows only its own catalog ids.
    auto* id_agent = preset_bundle.is_bbl_vendor() ? wxGetApp().getAgent() : nullptr;
 
    for (int i = 0; i < plate_data_list.size(); i++) {
        PlateData *plate_data = plate_data_list[i];
        plate_data->printer_model_id = printer_model_id;
        plate_data->nozzle_diameters = nozzle_diameter_str;
        for (auto it = plate_data->slice_filaments_info.begin(); it != plate_data->slice_filaments_info.end(); it++) {
            std::string display_filament_type;
            it->type  = cfg.get_filament_type(display_filament_type, it->id);
            it->filament_id = filament_id_opt ? filament_id_opt->get_at(it->id) : "";
            if (id_agent)
                it->filament_id = id_agent->from_orca_filament_id(it->filament_id);
            it->color = filament_color ? filament_color->get_at(it->id) : "#FFFFFF";
            // save filament info used in curr plate
            int index = p->partplate_list.get_curr_plate_index();
            if (store_params.id_bboxes.size() > index) {
                store_params.id_bboxes[index]->filament_ids.push_back(it->id);
                store_params.id_bboxes[index]->filament_colors.push_back(it->color);
            }
        }
    }
 
    // handle Design Info
    bool has_design_info = false;
    ModelDesignInfo designInfo;
    if (p->model.design_info != nullptr) {
        if (!p->model.design_info->Designer.empty()) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, found designer = " << p->model.design_info->Designer;
            has_design_info = true;
        }
    }
    if (!has_design_info) {
        // add Designed Info
        if (p->model.design_info == nullptr) {
            // set designInfo before export and reset after export
            if (wxGetApp().is_user_login()) {
                p->model.design_info                 = std::make_shared<ModelDesignInfo>();
                //p->model.design_info->Designer       = wxGetApp().getAgent()->get_user_nickname();
                p->model.design_info->Designer       = "";
                p->model.design_info->DesignerUserId = wxGetApp().getAgent()->get_user_id();
                BOOST_LOG_TRIVIAL(trace) << "design_info prepare, designer = "<< "";
                BOOST_LOG_TRIVIAL(trace) << "design_info prepare, designer_user_id = " << p->model.design_info->DesignerUserId;
            }
        }
    }
 
    bool store_result = Slic3r::store_bbs_3mf(store_params);
    // reset designed info
    if (!has_design_info)
        p->model.design_info = nullptr;
 
    if (store_result) {
        if (!(store_params.strategy & SaveStrategy::Silence)) {
            // Success
            p->set_project_filename(path);
            BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << __LINE__ << " call set_project_filename: " << path;
        }
    }
    else {
        ret = -1;
    }
 
    if (project_presets.size() > 0)
    {
        for (unsigned int i = 0; i < project_presets.size(); i++)
        {
            delete project_presets[i];
        }
        project_presets.clear();
    }
 
    release_PlateData_list(plate_data_list);
 
    for (unsigned int i = 0; i < calibration_thumbnails.size(); i++)
    {
        //release the data here, as it will always be generated when export
        calibration_thumbnails[i]->reset();
    }
    for (unsigned int i = 0; i < no_light_thumbnails.size(); i++) {
        // release the data here, as it will always be generated when export
        no_light_thumbnails[i]->reset();
    }
    for (unsigned int i = 0; i < top_thumbnails.size(); i++)
    {
        //release the data here, as it will always be generated when export
        top_thumbnails[i]->reset();
    }
    top_thumbnails.clear();
    for (unsigned int i = 0; i < picking_thumbnails.size(); i++)
    {
        //release the data here, as it will always be generated when export
        picking_thumbnails[i]->reset();;
    }
    picking_thumbnails.clear();
 
    return ret;
}

References Slic3r::Backup, Slic3r::StoreParams::calibration_thumbnail_data, Slic3r::StoreParams::config, Slic3r::StoreParams::export_plate_idx, Slic3r::f(), fff_print(), Slic3r::GUI::from_path(), Slic3r::PresetBundle::get_current_project_embedded_presets(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::DynamicPrintConfig::get_filament_type(), Slic3r::GUI::PartPlate::get_print(), Slic3r::Preset::get_printer_type(), Slic3r::StoreParams::id_bboxes, Slic3r::GUI::into_u8(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::ThumbnailData::is_valid(), Slic3r::GUI::Camera::Iso, Slic3r::StoreParams::model, Slic3r::StoreParams::no_light_thumbnail_data, Slic3r::PlateData::nozzle_diameters, Slic3r::ConfigBase::option(), Slic3r::GUI::Camera::Ortho, p, Slic3r::StoreParams::path, Slic3r::StoreParams::pick_thumbnail_data, Slic3r::StoreParams::plate_data_list, Slic3r::PlateData::printer_model_id, Slic3r::PresetBundle::printers, Slic3r::StoreParams::proFn, Slic3r::StoreParams::project, Slic3r::StoreParams::project_presets, Slic3r::ptFFF, Slic3r::release_PlateData_list(), Slic3r::run_post_process_scripts(), Slic3r::GUI::show_error(), Slic3r::Silence, Slic3r::SkipStatic, Slic3r::PlateData::slice_filaments_info, Slic3r::store_bbs_3mf(), Slic3r::StoreParams::strategy, Slic3r::StoreParams::thumbnail_data, THUMBNAIL_SIZE_3MF, Slic3r::GUI::Camera::Top_Plate, Slic3r::StoreParams::top_thumbnail_data, Slic3r::trace(), using_exported_file(), Slic3r::WithGcode, Slic3r::WithSliceInfo, Slic3r::WithStatistics, and Slic3r::Zip64.

Referenced by export_3mf_copy(), export_config_3mf(), export_core_3mf(), export_gcode_3mf(), export_published_3mf(), save_project(), and send_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

export_3mf_copy()

bool Slic3r::GUI::Plater::export_3mf_copy

(

const boost::filesystem::path &

output_path

)

{
    Model&                  model = p->model;
    SvgArchivePathsRestorer svg_paths(model);
 
    // With no design info, export_3mf() writes the signed-in account's user id as the designer; an
    // empty one keeps it out. export_3mf() also drops design info without a designer name afterwards.
    const std::shared_ptr<ModelDesignInfo> design_info = model.design_info;
    if (design_info == nullptr)
        model.design_info = std::make_shared<ModelDesignInfo>();
    ScopeGuard restore_design_info([&model, design_info]() { model.design_info = design_info; });
 
    // The project save's layout, plus Silence so the project file name stays as it is. Unlike a save
    // it never adds FullPathSources: a copy is for sharing, and those are paths on this machine.
    return export_3mf(output_path, SaveStrategy::SplitModel | SaveStrategy::ShareMesh | SaveStrategy::Silence) == 0;
}

References export_3mf(), model(), p, Slic3r::ShareMesh, Slic3r::Silence, and Slic3r::SplitModel.

Referenced by Slic3r::anonymous_namespace{PluginHostApp.cpp}::export_3mf_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

export_config_3mf()

int Slic3r::GUI::Plater::export_config_3mf	(	int	plate_idx = -1,
		Export3mfProgressFn	proFn = nullptr )

{
    int result = 0;
    /* generate 3mf */
    set_print_job_plate_idx(plate_idx);
 
    PartPlate* plate = get_partplate_list().get_curr_plate();
    try {
        p->m_print_job_data._3mf_config_path = fs::path(plate->get_temp_config_3mf_path());
    }
    catch (std::exception&) {
        BOOST_LOG_TRIVIAL(error) << "generate 3mf path failed";
        return -1;
    }
 
    SaveStrategy strategy = SaveStrategy::Silence | SaveStrategy::SkipModel | SaveStrategy::WithSliceInfo | SaveStrategy::SkipAuxiliary;
    result = export_3mf(p->m_print_job_data._3mf_config_path, strategy, plate_idx, proFn);
 
    return result;
}

References export_3mf(), Slic3r::GUI::PartPlateList::get_curr_plate(), get_partplate_list(), Slic3r::GUI::PartPlate::get_temp_config_3mf_path(), p, set_print_job_plate_idx(), Slic3r::Silence, Slic3r::SkipAuxiliary, Slic3r::SkipModel, and Slic3r::WithSliceInfo.

Here is the call graph for this function:

export_core_3mf()

void Slic3r::GUI::Plater::export_core_3mf

(

)

{
    wxString path = p->get_export_file(FT_3MF);
    if (path.empty()) { return; }
    const std::string path_u8 = into_u8(path);
    export_3mf(path_u8, SaveStrategy::Silence);
}

References export_3mf(), Slic3r::GUI::FT_3MF, Slic3r::GUI::into_u8(), p, and Slic3r::Silence.

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 (get_view3D_canvas3D()->get_gizmos_manager().is_in_editing_mode(true))
    //    return;
 
    if (p->process_completed_with_error == p->partplate_list.get_curr_plate_index())
        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(this->p->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;
    {
        std::string ext = default_output_file.extension().string();
        wxFileDialog dlg(this, (printer_technology() == ptFFF) ? _L("Save G-code file as:") : _L("Save SLA file as:"),
            start_dir,
            from_path(default_output_file.filename()),
            GUI::file_wildcards((printer_technology() == ptFFF) ? FT_GCODE : FT_SL1, ext),
            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());
        //bool path_on_removable_media = false;
        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);
        // 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);
 
        try {
            json j;
            auto printer_config = Slic3r::GUI::wxGetApp().preset_bundle->printers.get_edited_preset_with_vendor_profile().preset;
            if (printer_config.is_system) {
                j["printer_preset"] = printer_config.name;
            } else {
                j["printer_preset"] = printer_config.config.opt_string("inherits");
            }
 
            PresetBundle *preset_bundle = wxGetApp().preset_bundle;
            if (preset_bundle) {
                j["gcode_printer_model"] = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
            }
            NetworkAgent *agent = wxGetApp().getAgent();
        } catch (...) {}
 
    }
}

References _L, 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::GUI::FT_SL1, Slic3r::PresetCollection::get_edited_preset(), Slic3r::AppConfig::get_last_output_dir(), Slic3r::Preset::get_printer_type(), Slic3r::GUI::RemovableDriveManager::get_removable_drive_path(), has_illegal_filename_characters(), Slic3r::GUI::into_path(), p, Slic3r::GUI::printer_config(), printer_technology(), Slic3r::PresetBundle::printers, Slic3r::ptFFF, Slic3r::GUI::RemovableDriveManager::set_and_verify_last_save_path(), Slic3r::GUI::show_error(), Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, and Slic3r::AppConfig::update_last_output_dir().

Here is the call graph for this function:

export_gcode_3mf()

void Slic3r::GUI::Plater::export_gcode_3mf

(

bool

export_all = false

)

{
    if (p->model.objects.empty())
        return;
 
    if (p->process_completed_with_error == p->partplate_list.get_curr_plate_index())
        return;
 
    //calc default_output_file, get default output file from background process
    fs::path default_output_file;
    AppConfig& appconfig = *wxGetApp().app_config;
    std::string start_dir;
    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(this->p->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.replace_extension(".gcode.3mf");
    default_output_file = fs::path(Slic3r::fold_utf8_to_ascii(default_output_file.string()));
 
    //Get a last save path
    start_dir = appconfig.get_last_output_dir(default_output_file.parent_path().string(), false);
 
    fs::path output_path;
    {
        std::string ext = default_output_file.extension().string();
        wxFileDialog dlg(this, _L("Save Sliced file as:"),
            start_dir,
            from_path(default_output_file.filename()),
            GUI::file_wildcards(FT_GCODE_3MF, ""),
            wxFD_SAVE | wxFD_OVERWRITE_PROMPT
        );
        if (dlg.ShowModal() == wxID_OK) {
            output_path = into_path(dlg.GetPath());
            ext = output_path.extension().string();
            if (ext != ".3mf")
                output_path = output_path.string() + ".3mf";
        }
    }
 
    if (!output_path.empty()) {
        //BBS do not set to removable media path
        bool path_on_removable_media = false;
        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;
        //BBS do not save last output path
        p->last_output_path = output_path.string();
        p->last_output_dir_path = output_path.parent_path().string();
        int plate_idx = get_partplate_list().get_curr_plate_index();
        if (export_all)
            plate_idx = PLATE_ALL_IDX;
        SaveStrategy strategy = SaveStrategy::Silence | SaveStrategy::SplitModel | SaveStrategy::WithGcode | SaveStrategy::SkipModel; // BBS: silence
        if (wxGetApp().app_config->get_bool("export_statistics"))
            strategy = strategy | SaveStrategy::WithStatistics;
        if (export_3mf(output_path, strategy, plate_idx) < 0) {
            // No file was written (e.g. a post-processing script failed), don't report a successful export.
            p->exporting_status = ExportingStatus::NOT_EXPORTING;
            return;
        }
 
        RemovableDriveManager& removable_drive_manager = *wxGetApp().removable_drive_manager();
 
 
        bool on_removable = removable_drive_manager.is_path_on_removable_drive(p->last_output_dir_path);
 
 
        // update last output dir
        appconfig.update_last_output_dir(output_path.parent_path().string(), false);
        p->notification_manager->push_exporting_finished_notification(output_path.string(), p->last_output_dir_path, on_removable);
    }
}

References _L, export_3mf(), 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_3MF, Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::AppConfig::get_last_output_dir(), get_partplate_list(), Slic3r::GUI::into_path(), Slic3r::GUI::RemovableDriveManager::is_path_on_removable_drive(), Slic3r::GUI::NOT_EXPORTING, p, PLATE_ALL_IDX, Slic3r::GUI::show_error(), Slic3r::Silence, Slic3r::SkipModel, Slic3r::SplitModel, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, Slic3r::AppConfig::update_last_output_dir(), Slic3r::WithGcode, and Slic3r::WithStatistics.

Here is the call graph for this function:

export_published_3mf()

int Slic3r::GUI::Plater::export_published_3mf	(	const std::vector< std::string > &	published_keys,
		const std::vector< Slic3r::PublishedMaterialEntry > &	material_keys )

{
    wxString path = p->get_export_file(FT_3MF, _L("Publish 3MF file as:"), true);
    if (path.empty() || path == "<cancel>")
        return wxID_CANCEL;
 
    nlohmann::json j = nlohmann::json::array();
    for (const std::string& key : published_keys)
        j.push_back(key);
    nlohmann::json jm = nlohmann::json::array();
    for (const Slic3r::PublishedMaterialEntry& e : material_keys)
        jm.push_back({{"material",
                       {{"filament_type", e.filament_type},
                        {"filament_vendor", e.filament_vendor},
                        {"filament_id", e.filament_id},
                        {"setting_id", e.setting_id},
                        {"name", e.preset_name}}},
                      {"slot", e.slot},
                      {"keys", e.keys},
                      {"full", e.full},
                      {"full_keys", e.full_keys},
                      {"publish_type", e.publish_type},
                      {"type", e.publish_type_value},
                      {"publish_color", e.publish_color},
                      {"color", e.color}});
 
    Model& model = this->model();
    // Save the previous metadata so it can be restored after the export, keeping the in-memory
    // project pristine (the published flag lives only in the exported file).
    const bool had_model_info     = (model.model_info != nullptr);
    const bool had_published      = had_model_info &&
                                    (model.model_info->metadata_items.find(ORCA_PUBLISHED_TAG) != model.model_info->metadata_items.end());
    const bool had_published_keys = had_model_info && (model.model_info->metadata_items.find(ORCA_PUBLISHED_KEYS_TAG) !=
                                                       model.model_info->metadata_items.end());
    const bool had_material_keys  = had_model_info && (model.model_info->metadata_items.find(ORCA_PUBLISHED_MATERIAL_TAG) !=
                                                       model.model_info->metadata_items.end());
    const bool had_payload = had_model_info &&
                             (model.model_info->metadata_items.find(ORCA_PUBLISHED_CONFIG_TAG) != model.model_info->metadata_items.end());
    const std::string prev_published      = had_published ? model.model_info->metadata_items.at(ORCA_PUBLISHED_TAG) : std::string();
    const std::string prev_published_keys = had_published_keys ? model.model_info->metadata_items.at(ORCA_PUBLISHED_KEYS_TAG) :
                                                                 std::string();
    const std::string prev_material_keys  = had_material_keys ? model.model_info->metadata_items.at(ORCA_PUBLISHED_MATERIAL_TAG) :
                                                                std::string();
    const std::string prev_payload        = had_payload ? model.model_info->metadata_items.at(ORCA_PUBLISHED_CONFIG_TAG) : std::string();
 
    SvgArchivePathsRestorer svg_paths(model);
 
    auto restore_temporary_state = [&]() {
        svg_paths.restore();
 
        if (!had_model_info) {
            model.model_info = nullptr;
        } else {
            if (had_published)
                model.model_info->metadata_items[ORCA_PUBLISHED_TAG] = prev_published;
            else
                model.model_info->metadata_items.erase(ORCA_PUBLISHED_TAG);
            if (had_published_keys)
                model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] = prev_published_keys;
            else
                model.model_info->metadata_items.erase(ORCA_PUBLISHED_KEYS_TAG);
            if (had_material_keys)
                model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = prev_material_keys;
            else
                model.model_info->metadata_items.erase(ORCA_PUBLISHED_MATERIAL_TAG);
            if (had_payload)
                model.model_info->metadata_items[ORCA_PUBLISHED_CONFIG_TAG] = prev_payload;
            else
                model.model_info->metadata_items.erase(ORCA_PUBLISHED_CONFIG_TAG);
        }
    };
    bool state_restored = false;
    auto restore_now    = [&]() {
        if (state_restored)
            return;
        restore_temporary_state();
        state_restored = true;
    };
    ScopeGuard restore_guard(restore_now);
 
    if (model.model_info == nullptr)
        model.model_info = std::make_shared<ModelInfo>();
    model.model_info->metadata_items[ORCA_PUBLISHED_TAG]          = "1";
    model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG]     = j.dump();
    model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = jm.dump();
 
    int ret = -1;
    try {
        // Minimal published export: filter full_config to the published keys, material keys,
        // identity fields and plate geometry keys, and omit the project config file, the
        // project-embedded preset dumps and the OrcaSlicer version tag from the archive. The
        // filtered values are serialized into the published_config metadata payload instead, so
        // OrcaSlicer versions without the publish feature fall back to importing the geometry only
        // (keeping the receiver's presets) while new versions rebuild the config from the payload.
        DynamicPrintConfig full_cfg     = wxGetApp().preset_bundle->full_config_secure();
        DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, published_keys, material_keys);
        std::string payload;
        for (const std::string& key : filtered_cfg.keys()) {
            // A value containing a newline would break the INI written below (read_ini throws),
            // so load_from_ini_string discards the whole settings block on import. Skip such
            // keys instead of silently dropping every setting.
            std::string value = filtered_cfg.opt_serialize(key);
            if (value.find('\n') != std::string::npos) {
                BOOST_LOG_TRIVIAL(warning) << "publish: dropping key \"" << key
                                           << "\" from the published payload (value contains a newline)";
                continue;
            }
            payload += key + " = " + value + "\n";
        }
        model.model_info->metadata_items[ORCA_PUBLISHED_CONFIG_TAG] = std::move(payload);
 
        // Same file layout as save_project(), plus Silence (so export_3mf does not set the project
        // filename on success, keeping this a pure export like export_core_3mf()) and MinimalPublished.
        auto save_strategy  = SaveStrategy::SplitModel | SaveStrategy::ShareMesh | SaveStrategy::Silence | SaveStrategy::MinimalPublished;
        bool full_pathnames = wxGetApp().app_config->get_bool("export_sources_full_pathnames");
        if (full_pathnames)
            save_strategy = save_strategy | SaveStrategy::FullPathSources;
        ret = export_3mf(into_path(path), save_strategy, -1, nullptr);
    } catch (...) {
        restore_now();
        MessageDialog(this,
                      _L("Failed to export the published 3MF file.\nPlease check whether the folder exists online or if other programs "
                         "have the file open."),
                      _L("Publish"), wxOK | wxICON_WARNING)
            .ShowModal();
        return wxID_CANCEL;
    }
 
    if (ret < 0) {
        restore_now();
        MessageDialog(this,
                      _L("Failed to export the published 3MF file.\nPlease check whether the folder exists online or if other programs "
                         "have the file open."),
                      _L("Publish"), wxOK | wxICON_WARNING)
            .ShowModal();
        return wxID_CANCEL;
    }
    restore_now();
 
    // Register the exported file in the "Recently opened" list
    wxGetApp().mainframe->add_to_recent_projects(path);
 
    return wxID_YES;
}

References _L, export_3mf(), Slic3r::filter_published_config(), Slic3r::GUI::FT_3MF, Slic3r::FullPathSources, Slic3r::GUI::into_path(), Slic3r::DynamicConfig::keys(), Slic3r::MinimalPublished, model(), Slic3r::ConfigBase::opt_serialize(), Slic3r::ORCA_PUBLISHED_CONFIG_TAG, Slic3r::ORCA_PUBLISHED_KEYS_TAG, Slic3r::ORCA_PUBLISHED_MATERIAL_TAG, Slic3r::ORCA_PUBLISHED_TAG, p, Slic3r::ShareMesh, Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::Silence, and Slic3r::SplitModel.

Here is the call graph for this function:

export_stl()

void Slic3r::GUI::Plater::export_stl	(	bool	extended = false,
		bool	selection_only = false,
		bool	multi_stls = false,
		FileType	file_type = FT_STL )

{
    if (p->model.objects.empty()) { return; }
 
    int quality = 0;
 
    switch (file_type) {
    case FT_DRC:
        AppConfig* app_config = wxGetApp().app_config;
        if (app_config)
            quality = stoi(app_config->get("drc_bits"));
        else
            quality = DRC_BITS_DEFAULT;
        break;
    }
 
    wxString path;
    if (multi_stls) {
        wxDirDialog dlg(this, _L("Choose a directory"), from_u8(wxGetApp().app_config->get_last_dir()),
                        wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
        if (dlg.ShowModal() == wxID_OK) {
            path = dlg.GetPath() + "/";
        }
    } else {
        path = p->get_export_file(file_type);
    }
    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 EXPORT_WITH_BOOLEAN
    if (selection_only && (obj_idx == -1 || selection.is_wipe_tower()))
        return;
#else
    // BBS support selecting multiple objects
    if (selection_only && selection.is_wipe_tower()) return;
 
    // BBS
    if (selection_only) {
        // only support selection single full object and mulitiple full object
        if (!selection.is_single_full_object() && !selection.is_multiple_full_object()) return;
    }
 
    // Following lambda generates a combined mesh for export with normals pointing outwards.
    auto mesh_to_export_fff_no_boolean = [this](const ModelObject &mo, int instance_id) {
        TriangleMesh mesh;
 
        //Prusa export negative parts
        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);
 
        auto csgrange = range(csgmesh);
        if (csg::is_all_positive(csgrange)) {
            mesh = TriangleMesh{csg::csgmesh_merge_positive_parts(csgrange)};
        } else if (std::get<2>(csg::check_csgmesh_booleans(csgrange)) == csgrange.end()) {
            try {
                auto cgalm = csg::perform_csgmesh_booleans(csgrange);
                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;
    };
#endif
    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 (auto m = object->get_mesh_to_print(); m.empty())
            mesh = combine_mesh_fff(mo, instance_id, [this](const std::string& msg) {return get_notification_manager()->push_general_error_notification(msg); });
        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);
                    }
 
                    TriangleMesh inst_object_mesh = object->get_mesh_to_print();
 
                    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)
#if EXPORT_WITH_BOOLEAN
        mesh_to_export = [this](const ModelObject& mo, int instance_id) {return Plater::combine_mesh_fff(mo, instance_id,
            [this](const std::string& msg) {return get_notification_manager()->push_general_error_notification(msg); }); };
#else
        mesh_to_export = mesh_to_export_fff_no_boolean;
#endif
    else
        mesh_to_export = mesh_to_export_sla;
 
    auto get_save_file = [file_type](std::string const & dir, std::string const & name) {
        std::string ext = "";
        switch (file_type) {
        case FT_STL: ext = ".stl"; break;
        case FT_DRC: ext = ".drc"; break;
        }
 
        auto path = dir + name + ext;
        int n = 1;
        while (boost::filesystem::exists(path))
            path = dir + name + "(" + std::to_string(n++) + ")"+ext;
        return path;
    };
 
    TriangleMesh mesh;
    if (selection_only) {
        if (selection.is_single_full_object()) {
            const auto obj_idx = selection.get_object_idx();
            const ModelObject* model_object = p->model.objects[obj_idx];
            if (selection.get_mode() == Selection::Instance)
                mesh = mesh_to_export(*model_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 (model_object->instances.size() == 1) mesh.translate(-model_object->origin_translation.cast<float>());
        }
        else if (selection.is_multiple_full_object() && !multi_stls) {
            const std::set<std::pair<int, int>>& instances_idxs = p->get_selection().get_selected_object_instances();
            for (const std::pair<int, int>& i : instances_idxs) {
                ModelObject* object = p->model.objects[i.first];
                mesh.merge(mesh_to_export(*object, i.second));
            }
        }
        else if (selection.is_multiple_full_object() && multi_stls) {
            const std::set<std::pair<int, int>> &instances_idxs = p->get_selection().get_selected_object_instances();
            for (const std::pair<int, int> &i : instances_idxs) {
                ModelObject *object = p->model.objects[i.first];
                auto mesh = mesh_to_export(*object, i.second);
                mesh.translate(-object->origin_translation.cast<float>());
 
                switch (file_type) {
                case FT_STL: Slic3r::store_stl(get_save_file(path_u8, object->name).c_str(), &mesh, true); break;
                case FT_DRC: Slic3r::store_drc(get_save_file(path_u8, object->name).c_str(), &mesh, quality); break;
                }
            }
            return;
        }
    }
    else if (!multi_stls) {
        for (const ModelObject* o : p->model.objects) {
            mesh.merge(mesh_to_export(*o, -1));
        }
    } else {
        for (const ModelObject* o : p->model.objects) {
            auto mesh = mesh_to_export(*o, -1);
            mesh.translate(-o->origin_translation.cast<float>());
 
            switch (file_type) {
            case FT_STL: Slic3r::store_stl(get_save_file(path_u8, o->name).c_str(), &mesh, true); break;
            case FT_DRC: Slic3r::store_drc(get_save_file(path_u8, o->name).c_str(), &mesh, quality); break;
            }
        }
        return;
    }
 
    switch (file_type) {
    case FT_STL: Slic3r::store_stl(path_u8.c_str(), &mesh, true); break;
    case FT_DRC: Slic3r::store_drc(path_u8.c_str(), &mesh, quality); break;
    }
}

References _L, _u8L, Slic3r::TriangleMesh::bounding_box(), Slic3r::MeshBoolean::cgal::cgal_to_triangle_mesh(), Slic3r::csg::check_csgmesh_booleans(), combine_mesh_fff(), Slic3r::csg::csgmesh_merge_positive_parts(), DRC_BITS_DEFAULT, Slic3r::TriangleMesh::empty(), Slic3r::GUI::from_u8(), Slic3r::GUI::FT_DRC, Slic3r::GUI::FT_STL, Slic3r::AppConfig::get(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::SLAPrintObject::get_mesh_to_print(), Slic3r::GUI::Selection::get_mode(), get_notification_manager(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::ObjectBase::id(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::csg::is_all_positive(), Slic3r::GUI::is_left_handed(), Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_wipe_tower(), Slic3r::TriangleMesh::merge(), Slic3r::ModelVolume::mesh(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::PrintObjectBase::model_object(), Slic3r::csg::model_to_csgmesh(), Slic3r::csg::mpartsDoSplits, Slic3r::csg::mpartsNegative, Slic3r::csg::mpartsPositive, Slic3r::ModelObject::name, Slic3r::ModelObject::origin_translation, p, Slic3r::csg::perform_csgmesh_booleans(), Slic3r::ptFFF, Slic3r::GUI::NotificationManager::push_general_error_notification(), Slic3r::GUI::NotificationManager::push_plater_error_notification(), Slic3r::range(), Slic3r::store_drc(), Slic3r::store_stl(), Slic3r::TriangleMesh::transform(), Slic3r::TriangleMesh::translate(), Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Here is the call 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.

Here is the call 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) }, LoadStrategy::LoadConfig);
}

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

Here is the call graph for this function:

fff_print() [1/2]

Print & Slic3r::GUI::Plater::fff_print

(

)

{ return p->fff_print; }

References p.

fff_print() [2/2]

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

(

)

const

{ return p->fff_print; }

References p.

Referenced by export_3mf().

Here is the caller graph for this function:

filament_action_menu()

wxMenu * Slic3r::GUI::Plater::filament_action_menu

(

int

active_filament_menu_id

)

{ return p->menus.filament_action_menu(active_filament_menu_id); }

References p.

fill_bed_with_copies()

void Slic3r::GUI::Plater::fill_bed_with_copies

(

)

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

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

Here is the call 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(_u8L("Arrange"));
        replace_job(w, std::make_unique<FillBedJob>(true));
    }
}

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

Here is the call graph for this function:

fill_color()

void Slic3r::GUI::Plater::fill_color

(

int

extruder_id

)

{
    if (can_fillcolor()) {
        p->assemble_view->get_canvas3d()->get_selection().fill_color(extruder_id);
    }
}

References can_fillcolor(), and p.

Here is the call graph for this function:

find_new_position()

void Slic3r::GUI::Plater::find_new_position

(

const ModelInstancePtrs &

instances

)

{
    arrangement::ArrangePolygons movable, fixed;
    arrangement::ArrangeParams arr_params = init_arrange_params(this);
 
    for (const ModelObject *mo : p->model.objects)
        for (ModelInstance *inst : mo->instances) {
            auto it = std::find(instances.begin(), instances.end(), inst);
            arrangement::ArrangePolygon arrpoly;
            inst->get_arrange_polygon(&arrpoly);
 
            if (it == instances.end())
                fixed.emplace_back(std::move(arrpoly));
            else {
                arrpoly.setter = [it](const arrangement::ArrangePolygon &p) {
                    if (p.is_arranged() && p.bed_idx == 0) {
                        Vec2d t = p.translation.cast<double>();
                        (*it)->apply_arrange_result(t, p.rotation);
                    }
                };
                movable.emplace_back(std::move(arrpoly));
            }
        }
 
    if (auto wt = get_wipe_tower_arrangepoly(*this))
        fixed.emplace_back(*wt);
 
    arrangement::arrange(movable, fixed, this->build_volume().polygon(), arr_params);
 
    for (auto & m : movable)
        m.apply();
}

References Slic3r::arrangement::arrange(), build_volume(), Slic3r::ModelInstance::get_arrange_polygon(), Slic3r::GUI::get_wipe_tower_arrangepoly(), Slic3r::GUI::init_arrange_params(), Slic3r::ModelObject::instances, p, and Slic3r::arrangement::ArrangePolygon::setter.

Here is the call graph for this function:

force_filament_colors_update()

void Slic3r::GUI::Plater::force_filament_colors_update

(

)

{
//BBS: filament_color logic has been moved out of filament setting
#if 0
    bool update_scheduled = false;
    DynamicPrintConfig* config = p->config;
    const std::vector<std::string> filament_presets = wxGetApp().preset_bundle->filament_presets;
    if (filament_presets.size() > 1 &&
        p->config->option<ConfigOptionStrings>("filament_colour")->values.size() == filament_presets.size())
    {
        const PresetCollection& filaments = wxGetApp().preset_bundle->filaments;
        std::vector<std::string> filament_colors;
        filament_colors.reserve(filament_presets.size());
 
        for (const std::string& filament_preset : filament_presets)
            filament_colors.push_back(filaments.find_preset(filament_preset, true)->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_filament_colors();
    }
 
    if (p->main_frame->is_loaded())
        this->p->schedule_background_process();
#endif
}

References config(), Slic3r::Preset::config, Slic3r::PresetCollection::find_preset(), Slic3r::DynamicConfig::opt_string(), 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) = "bbl_empty";
}

References p.

force_update_all_plate_thumbnails()

void Slic3r::GUI::Plater::force_update_all_plate_thumbnails

(

)

{
    if (using_exported_file() || skip_thumbnail_invalid) {
    }
    else {
        invalid_all_plate_thumbnails();
        update_all_plate_thumbnails(true);
    }
}

References invalid_all_plate_thumbnails(), skip_thumbnail_invalid, update_all_plate_thumbnails(), and using_exported_file().

Here is the call graph for this function:

format_imex_ghost_tooltip()

Plater::ImexGhostTooltip Slic3r::GUI::Plater::format_imex_ghost_tooltip

(

int

physical_head

)

const

{
    ImexGhostTooltip t{physical_head, -1, GLVolume::UNPRINTABLE_COLOR, {}};
 
    const PartPlate* plate = p->partplate_list.get_curr_plate();
    if (!plate) {
        t.label = Slic3r::format(_u8L("T%1% -> (no plate)"), physical_head);
        return t;
    }
 
    const ConfigOptionInts pem = effective_physical_extruder_map(*wxGetApp().preset_bundle);
    const auto map = plate->get_imex_head_filament_map();
    const int logical = resolve_filament_for_head(map, pem, physical_head);
    if (logical < 0) {
        // No filament slot resolves to this physical head. Usually means the printer's
        // extruder count is understated relative to the filament palette (user added a
        // filament without extending printer_extruder_id in the Machine tab).
        // TRN IDEX/IQEX ghost tooltip. %1% is the number of the physical print head.
        t.label = Slic3r::format(_u8L("T%1% — no filament routed\nAdd an extruder in the Machine tab so this head has a filament slot."), physical_head);
        return t;
    }
    t.filament_slot_1based = logical + 1;
    // Reuse the pem/map already hoisted above so label and swatch are derived
    // from one resolution, not two.
    t.swatch = plate->get_imex_head_filament_color(physical_head, pem, map);
    t.swatch.a(1.0f);  // tooltip swatch opaque
    // TRN IDEX/IQEX ghost tooltip. %1% is the number of the physical print head, %2% the filament it prints.
    t.label  = Slic3r::format(_u8L("T%1% -> filament %2%"), physical_head, t.filament_slot_1based);
    return t;
}

References _u8L, Slic3r::ColorRGBA::a(), Slic3r::effective_physical_extruder_map(), Slic3r::GUI::Plater::ImexGhostTooltip::filament_slot_1based, Slic3r::format(), Slic3r::GUI::PartPlate::get_imex_head_filament_color(), Slic3r::GUI::PartPlate::get_imex_head_filament_map(), Slic3r::GUI::Plater::ImexGhostTooltip::label, p, Slic3r::resolve_filament_for_head(), Slic3r::GUI::Plater::ImexGhostTooltip::swatch, and Slic3r::GLVolume::UNPRINTABLE_COLOR.

Here is the call graph for this function:

gcode_settings_loaded()

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

inline

{ return m_only_gcode && m_gcode_settings_loaded; }

References m_gcode_settings_loaded, and m_only_gcode.

get_3mf_file_count()

int Slic3r::GUI::Plater::get_3mf_file_count

(

std::vector< boost::filesystem::path >

paths

)

{
    auto count = 0;
    for (const auto &path : paths) {
        if (boost::iends_with(path.filename().string(), ".3mf")) {
            count++;
        }
    }
    return count;
}

References count.

Referenced by add_file(), add_model(), and load_files().

Here is the caller graph for this function:

get_3mf_filename()

std::string Slic3r::GUI::Plater::get_3mf_filename ( )

inline

{ return m_3mf_path; };

References m_3mf_path.

get_assmeble_canvas3D()

GLCanvas3D * Slic3r::GUI::Plater::get_assmeble_canvas3D

(

)

{
    if (p->assemble_view)
        return p->assemble_view->get_canvas3d();
    return nullptr;
}

References p.

get_bed_texture_maps()

std::map< std::string, std::string > Slic3r::GUI::Plater::get_bed_texture_maps

(

)

{
    auto pm = get_curr_printer_model();
    if (pm) {
        std::map<std::string, std::string> maps;
        if (pm->use_double_extruder_default_texture.size() > 0) {
            maps["use_double_extruder_default_texture"] = pm->use_double_extruder_default_texture;
        }
        if (pm->bottom_texture_end_name.size() > 0) {
            maps["bottom_texture_end_name"] = pm->bottom_texture_end_name;
        }
        if (pm->bottom_texture_rect.size() > 0) {
            maps["bottom_texture_rect"] = pm->bottom_texture_rect;
        }
        if (pm->bottom_texture_rect_longer.size() > 0) {
            maps["bottom_texture_rect_longer"] = pm->bottom_texture_rect_longer;
        }
        if (pm->middle_texture_rect.size() > 0) {
            maps["middle_texture_rect"] = pm->middle_texture_rect;
        }
        return maps;
    }
    return {};
}

References get_curr_printer_model().

Here is the call graph for this function:

get_build_volume_type()

BuildVolume_Type Slic3r::GUI::Plater::get_build_volume_type

(

)

const

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

References p.

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::TextLinesModel::render().

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.

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);
 
    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 {
        //BBS
        colors.reserve(colors.size() + p->model.get_curr_plate_custom_gcodes().gcodes.size());
        for (const CustomGCode::Item& code : p->model.get_curr_plate_custom_gcodes().gcodes) {
            if (code.type == CustomGCode::ColorChange)
                colors.emplace_back(code.color);
        }
    }
 
    return colors;
}

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

Here is the call graph for this function:

get_curr_printer_model()

const VendorProfile::PrinterModel * Slic3r::GUI::Plater::get_curr_printer_model

(

)

{
    auto bundle = wxGetApp().preset_bundle;
    if (bundle) {
        const Preset *curr = &bundle->printers.get_selected_preset();
        if (curr) {
            const VendorProfile::PrinterModel *pm = PresetUtils::system_printer_model(*curr);
            if (!pm) {
                auto curr_parent = bundle->printers.get_selected_preset_parent();
                if (curr_parent) {
                    pm = PresetUtils::system_printer_model(*curr_parent);
                }
            }
            return pm;
        }
    }
    return nullptr;
}

References Slic3r::PresetUtils::system_printer_model().

Referenced by get_bed_texture_maps().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_canvas3D()

GLCanvas3D * Slic3r::GUI::Plater::get_current_canvas3D

(

bool

exclude_preview = false

)

{
    return p->get_current_canvas3D(exclude_preview);
}

References p.

Referenced by Slic3r::GUI::MainFrame::add_common_view_menu_items(), changed_object(), Slic3r::GUI::Plater::priv::get_curr_selection(), Slic3r::GUI::get_selection(), Slic3r::GUI::MainFrame::handle_global_shortcut(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), on_config_change(), Slic3r::GUI::Plater::priv::selection_changed(), Slic3r::GUI::Plater::priv::take_snapshot(), Slic3r::GUI::Plater::priv::undo(), and Slic3r::GUI::Plater::priv::update_after_undo_redo().

Here is the caller graph for this function:

get_dailytips()

DailyTipsWindow * Slic3r::GUI::Plater::get_dailytips

(

)

const

{
    static DailyTipsWindow* dailytips_win = new DailyTipsWindow();
    return dailytips_win;
}

get_empty_cells()

std::vector< Vec2f > Slic3r::GUI::Plater::get_empty_cells ( const Vec2f step, const std::vector< BoundingBoxf > & local_exclude_boxes = {}, bool include_plate_exclude_areas = true )

static

{
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    BoundingBoxf3 build_volume = plate->get_build_volume(true);
    Vec2d vmin(build_volume.min.x(), build_volume.min.y()), vmax(build_volume.max.x(), build_volume.max.y());
    BoundingBoxf bbox(vmin, vmax);
    std::vector<Vec2f> cells;
    auto min_x = step(0)/2;// start_point.x() - step(0) * int((start_point.x() - bbox.min.x()) / step(0));
    auto min_y = step(1)/2;// start_point.y() - step(1) * int((start_point.y() - bbox.min.y()) / step(1));
    std::vector<BoundingBoxf> exclude_boxs;
    if (include_plate_exclude_areas) {
        const auto &exclude_box3s = plate->get_exclude_areas();
        for (const auto &box : exclude_box3s) {
            Vec2d vmin(box.min.x(), box.min.y()), vmax(box.max.x(), box.max.y());
            exclude_boxs.emplace_back(vmin, vmax);
        }
    }
    const Vec3d plate_origin = plate->get_origin();
    for (BoundingBoxf box : local_exclude_boxes) {
        box.translate(Vec2d(plate_origin.x(), plate_origin.y()));
        exclude_boxs.emplace_back(std::move(box));
    }
    for (float x = min_x + bbox.min.x(); x < bbox.max.x() - step(0) / 2; x += step(0))
        for (float y = min_y + bbox.min.y(); y < bbox.max.y() - step(1) / 2; y += step(1)) {
            bool in_exclude = false;
            BoundingBoxf cell(Vec2d(x - step(0) / 2, y - step(1) / 2), Vec2d(x + step(0) / 2, y + step(1) / 2));
            for (auto& box : exclude_boxs) {
                if (box.overlap(cell)) {
                    in_exclude = true;
                    break;
                }
            }
            if(in_exclude)
                continue;
            cells.emplace_back(x, y);
        }
    return cells;
}

References build_volume(), Slic3r::GUI::PartPlate::get_build_volume(), Slic3r::GUI::PartPlate::get_exclude_areas(), Slic3r::GUI::PartPlate::get_origin(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, and Slic3r::BoundingBoxBase< PointType, APointsType >::min.

Referenced by Slic3r::GUI::FillBedJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

get_enable_wrapping_detection()

bool Slic3r::GUI::Plater::get_enable_wrapping_detection

(

)

{
   const DynamicPrintConfig & print_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
   const ConfigOptionBool *  wrapping_detection = print_config.option<ConfigOptionBool>("enable_wrapping_detection");
   return  (wrapping_detection != nullptr) && wrapping_detection->value;
}

References Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

get_export_gcode_filename()

wxString Slic3r::GUI::Plater::get_export_gcode_filename	(	const wxString &	extension = wxEmptyString,
		bool	only_filename = false,
		bool	export_all = false ) const

{
    return p->get_export_gcode_filename(extension, only_filename, export_all);
}

References p.

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->project_config;
        std::vector<std::string> filament_colors;
        if (!config->has("filament_colour")) // in case of a SLA print
            return filament_colors;
 
        filament_colors = (config->option<ConfigOptionStrings>("filament_colour"))->values;
        return filament_colors;
    }
}

References config(), and Slic3r::GCodeProcessorResult::extruder_colors.

Referenced by get_colors_for_color_print(), and get_extruders_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruders_colors()

std::vector< Slic3r::ColorRGBA > Slic3r::GUI::Plater::get_extruders_colors

(

)

{
    unsigned char                     rgba_color[4] = {};
    std::vector<std::string>          colors        = get_extruder_colors_from_plater_config();
    std::vector<Slic3r::ColorRGBA> colors_out(colors.size());
    for (const std::string &color : colors) {
        Slic3r::GUI::BitmapCache::parse_color4(color, rgba_color);
        size_t color_idx      = &color - &colors.front();
        colors_out[color_idx] = {
            float(rgba_color[0]) / 255.f,
            float(rgba_color[1]) / 255.f,
            float(rgba_color[2]) / 255.f,
            float(rgba_color[3]) / 255.f,
        };
    }
    return colors_out;
}

References get_extruder_colors_from_plater_config(), and Slic3r::GUI::BitmapCache::parse_color4().

Here is the call graph for this function:

get_filament_color_render_type()

std::vector< std::string > Slic3r::GUI::Plater::get_filament_color_render_type

(

)

const

{
    const Slic3r::DynamicPrintConfig *config = &wxGetApp().preset_bundle->project_config;
    std::vector<std::string>          ctype;
    if (!config->has("filament_colour_type")) return ctype;
 
    ctype = (config->option<ConfigOptionStrings>("filament_colour_type"))->values;
 
    auto slots = parse_mixed_gradient_slots(*config, ctype.size());
    while (ctype.size() < slots.size()) ctype.push_back("1");
    for (size_t i = 0; i < ctype.size() && i < slots.size(); ++i) {
        if (slots[i].is_gradient)
            ctype[i] = "0";
    }
 
    return ctype;
}

References config().

Here is the call graph for this function:

get_filament_colors_render_info()

std::vector< std::string > Slic3r::GUI::Plater::get_filament_colors_render_info

(

)

const

{
    const Slic3r::DynamicPrintConfig* config = &wxGetApp().preset_bundle->project_config;
    std::vector<std::string> color_packs;
    if (!config->has("filament_multi_colour")) return color_packs;
 
    color_packs = (config->option<ConfigOptionStrings>("filament_multi_colour"))->values;
 
    auto slots = parse_mixed_gradient_slots(*config, color_packs.size());
    for (size_t i = 0; i < color_packs.size(); ++i) {
        if (slots[i].is_gradient)
            color_packs[i] = slots[i].color_from + " " + slots[i].color_to;
    }
 
    return color_packs;
}

References config().

Here is the call graph for this function:

get_filament_gradient_ramps()

const std::vector< std::vector< wxColour > > & Slic3r::GUI::Plater::get_filament_gradient_ramps

(

)

const

{
    // Sampling a ramp walks the measured-blend recipe table once per step and the paint toolbar
    // asks for the ramps every rendered frame, so they are cached against the config values they
    // are built from. The cache is static rather than a Plater member because the extruder icons
    // ask for the ramps from MenuFactory::init(), which runs while this Plater is still inside its
    // own constructor, so wxGetApp().plater_ is not assigned yet.
    static std::string                        s_ramps_key;
    static std::vector<std::vector<wxColour>> s_ramps;
 
    static const char* ramp_keys[] = {"filament_is_mixed",             "filament_mixed_gradient",
                                      "filament_mixed_components",     "filament_colour",
                                      "filament_mixed_gradient_range", "filament_mixed_gradient_curve"};
 
    const Slic3r::DynamicPrintConfig& config = wxGetApp().preset_bundle->project_config;
    std::string key;
    for (const char* opt_key : ramp_keys)
        if (const ConfigOption* opt = config.option(opt_key))
            key += opt->serialize() + '\n';
    if (key == s_ramps_key)
        return s_ramps;
 
    // 64 bands outresolve every swatch drawn from this, all of which resample it down to their
    // own height, so one cached resolution serves the icons and both ImGui filament bars.
    const auto*  colour_opt = config.option<ConfigOptionStrings>("filament_colour");
    const size_t n          = colour_opt ? colour_opt->values.size() : 0;
    s_ramps.assign(n, {});
    for (size_t i = 0; i < n; ++i)
        s_ramps[i] = mixed_gradient_ramp(config, i, 64);
    s_ramps_key = std::move(key);
 
    return s_ramps;
}

References config(), Slic3r::GUI::mixed_gradient_ramp(), and Slic3r::ConfigOptionVector< T >::values.

Here is the call graph for this function:

get_global_filament_map()

std::vector< int > Slic3r::GUI::Plater::get_global_filament_map

(

)

const

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    return project_config.option<ConfigOptionInts>("filament_map")->values;
}

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

Here is the caller graph for this function:

get_global_filament_map_mode()

FilamentMapMode Slic3r::GUI::Plater::get_global_filament_map_mode

(

)

const

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    return project_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode")->value;
}

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

Here is the caller graph for this function:

get_global_filament_volume_map()

std::vector< int > Slic3r::GUI::Plater::get_global_filament_volume_map

(

)

const

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    return project_config.option<ConfigOptionInts>("filament_volume_map")->values;
}

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

Here is the caller graph for this function:

get_last_loaded_gcode()

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

inline

{ return m_last_loaded_gcode; }

References m_last_loaded_gcode.

get_machine_sync_status()

bool Slic3r::GUI::Plater::get_machine_sync_status

(

)

{
    return p->get_machine_sync_status();
}

References p.

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

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.

get_next_color_for_filament()

wxColour Slic3r::GUI::Plater::get_next_color_for_filament ( )

static

{
    static int curr_color_filamenet = 0;
    // refs to https://www.ebaomonthly.com/window/photo/lesson/colorList.htm
    wxColour colors[FILAMENT_SYSTEM_COLORS_NUM] = {
        // ORCA updated all color palette
        wxColour("#00C1AE"),
        wxColour("#F4E2C1"),
        wxColour("#ED1C24"),
        wxColour("#00FF7F"),
        wxColour("#F26722"),
        wxColour("#FFEB31"),
        wxColour("#7841CE"),
        wxColour("#115877"),
        wxColour("#ED1E79"),
        wxColour("#2EBDEF"),
        wxColour("#345B2F"),
        wxColour("#800080"),
        wxColour("#FA8173"),
        wxColour("#800000"),
        wxColour("#F7B763"),
        wxColour("#A4C41E"),
    };
    return colors[curr_color_filamenet++ % FILAMENT_SYSTEM_COLORS_NUM];
}

References FILAMENT_SYSTEM_COLORS_NUM.

Referenced by Slic3r::GUI::Sidebar::add_filament(), Slic3r::GUI::Plater::priv::load_files(), and Slic3r::GUI::Tab::on_value_change().

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.

get_notification_manager() [2/2]

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

(

)

const

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

References p.

Referenced by _calib_pa_pattern(), config_change_notification(), export_stl(), Slic3r::PluginManager::fetch_plugins_from_cloud(), load_gcode(), load_project(), new_project(), notify_painting_removed(), and show_object_info().

Here is the caller graph for this function:

get_partplate_list()

PartPlateList & Slic3r::GUI::Plater::get_partplate_list

(

)

{
    return p->partplate_list;
}

References p.

Referenced by _calib_pa_pattern(), _calib_pa_pattern_gen_gcode(), calib_temp(), export_config_3mf(), export_gcode_3mf(), Slic3r::GUI::init_arrange_params(), invalid_all_plate_thumbnails(), new_project(), on_filament_count_change(), on_filament_map_mode_change(), send_gcode(), send_gcode_legacy(), set_print_job_plate_idx(), Slic3r::GUI::try_pop_up_before_slice(), update_all_plate_thumbnails(), update_filament_volume_map(), update_obj_preview_thumbnail(), and update_plate_thumbnails().

Here is the caller graph for this function:

get_pending_published()

bool Slic3r::GUI::Plater::get_pending_published	(	std::vector< std::string > &	out_keys,
		std::vector< Slic3r::PublishedMaterialEntry > &	out_material ) const

{
    if (!p->m_has_pending_published)
        return false;
    out_keys     = p->m_pending_published_keys;
    out_material = p->m_pending_material_keys;
    return true;
}

References p.

get_prepare_state()

int Slic3r::GUI::Plater::get_prepare_state

(

)

{
    return p->m_job_prepare_state;
}

References p.

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

Here is the caller graph for this function:

get_preview_canvas3D()

GLCanvas3D * Slic3r::GUI::Plater::get_preview_canvas3D

(

)

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

References p.

get_preview_only_filename()

std::string Slic3r::GUI::Plater::get_preview_only_filename ( )

inline

{ return m_preview_only_filename; };

References m_preview_only_filename.

get_print_finished_event()

int Slic3r::GUI::Plater::get_print_finished_event

(

)

{
    return EVT_PRINT_FINISHED;
}

get_print_job_data()

void Slic3r::GUI::Plater::get_print_job_data

(

PrintPrepareData *

data

)

{
    if (data) {
        data->plate_idx = p->m_print_job_data.plate_idx;
        data->_3mf_path = p->m_print_job_data._3mf_path;
        data->_3mf_config_path = p->m_print_job_data._3mf_config_path;
    }
}

References Slic3r::GUI::PrintPrepareData::_3mf_config_path, Slic3r::GUI::PrintPrepareData::_3mf_path, p, and Slic3r::GUI::PrintPrepareData::plate_idx.

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::Plater::priv::get_export_file_path(), Slic3r::GUI::Plater::priv::reset(), save_project(), and Slic3r::GUI::ProjectDirtyStateManager::update_from_presets().

Here is the caller graph for this function:

get_project_name()

wxString Slic3r::GUI::Plater::get_project_name

(

)

{
    return p->get_project_name();
}

References p.

Referenced by add_file(), add_model(), and Slic3r::GUI::Plater::priv::get_export_file_path().

Here is the caller graph for this function:

get_select_machine_dialog()

wxWindow * Slic3r::GUI::Plater::get_select_machine_dialog

(

)

{
    return p->m_select_machine_dlg;
}

References p.

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_increase_instances(), Slic3r::GUI::Plater::priv::can_set_instance_to_object(), Slic3r::GUI::Plater::priv::can_simplify(), Slic3r::GUI::Plater::priv::layers_height_allowed(), Slic3r::GUI::Plater::priv::on_right_click(), and Slic3r::GUI::Plater::priv::split_object().

Here is the caller graph for this function:

get_selected_printer_name_in_combox()

wxString Slic3r::GUI::Plater::get_selected_printer_name_in_combox

(

)

                                                     {
    PresetBundle *        preset_bundle    = wxGetApp().preset_bundle;
    std::string           printer_model    = preset_bundle->printers.get_selected_preset().config.option<ConfigOptionString>("printer_model")->value;
    return printer_model;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_selected_preset(), Slic3r::ConfigBase::option(), and Slic3r::PresetBundle::printers.

Referenced by check_printer_initialized(), and is_same_printer_for_connected_and_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selection()

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

(

)

const

{
    return p->get_selection();
}

References p.

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::Plater::priv::can_delete(), Slic3r::GUI::Plater::priv::can_mirror(), Slic3r::GUI::Plater::priv::can_reload_from_disk(), Slic3r::GUI::Plater::priv::can_replace_all_with_stl(), Slic3r::GUI::Plater::priv::can_replace_with_stl(), Slic3r::GUI::Plater::priv::get_export_file_path(), Slic3r::GUI::Plater::priv::get_selected_object_idx(), Slic3r::GUI::Plater::priv::get_selected_volume_idx(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::Plater::priv::reload_all_from_disk(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), Slic3r::GUI::Plater::priv::replace_with_stl(), show_object_info(), and Slic3r::GUI::Plater::priv::split_object().

Here is the caller graph for this function:

get_send_calibration_finished_event()

int Slic3r::GUI::Plater::get_send_calibration_finished_event

(

)

{
    return EVT_SEND_CALIBRATION_FINISHED;
}

get_send_finished_event()

int Slic3r::GUI::Plater::get_send_finished_event

(

)

{
    return EVT_SEND_FINISHED;
}

get_sidebar_docking_state()

Sidebar::DockingState Slic3r::GUI::Plater::get_sidebar_docking_state

(

)

const

{ return p->get_sidebar_docking_state(); }

References p.

get_slice_warning_string()

wxString Slic3r::GUI::Plater::get_slice_warning_string ( GCodeProcessorResult::SliceWarning & warning )

static

{
    if (warning.msg == BED_TEMP_TOO_HIGH_THAN_FILAMENT) {
        return _L("The current heatbed temperature is relatively high. The nozzle may clog when printing this filament in a closed environment. Please open the front door and/or remove the upper glass.");
    } else if (warning.msg == NOZZLE_HRC_CHECKER) {
        return _L("The nozzle hardness required by the filament is higher than the default nozzle hardness of the printer. Please replace the hardened nozzle or filament, otherwise, the nozzle will be worn down or damaged.");
    } else if (warning.msg == NOT_SUPPORT_TRADITIONAL_TIMELAPSE) {
        return _L("Enabling traditional timelapse photography may cause surface imperfections. It is recommended to change to smooth mode.");
    } else if (warning.msg == NOT_GENERATE_TIMELAPSE) {
        return wxString();
    } else if (warning.msg == SMOOTH_TIMELAPSE_WITHOUT_PRIME_TOWER) {
        return _L("Smooth mode for timelapse is enabled, but the prime tower is off, which may cause print defects. Please enable the prime tower, re-slice and print again.");
    }
    else {
        return wxString(warning.msg);
    }
}

References _L, BED_TEMP_TOO_HIGH_THAN_FILAMENT, Slic3r::GCodeProcessorResult::SliceWarning::msg, NOT_GENERATE_TIMELAPSE, NOT_SUPPORT_TRADITIONAL_TIMELAPSE, NOZZLE_HRC_CHECKER, and SMOOTH_TIMELAPSE_WITHOUT_PRIME_TOWER.

Referenced by Slic3r::GUI::SelectMachineDialog::on_ok_btn().

Here is the caller graph for this function:

get_ui_job_worker() [1/2]

Worker & Slic3r::GUI::Plater::get_ui_job_worker

(

)

{ return p->m_worker; }

References p.

Referenced by arrange(), fill_bed_with_copies(), fill_bed_with_instances(), import_sl1_archive(), optimize_rotation(), orient(), remove_selected(), reslice(), and set_selected_visible().

Here is the caller graph for this function:

get_ui_job_worker() [2/2]

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

(

)

const

{ return p->m_worker; }

References p.

get_uv_editor_canvas()

UVEditorCanvas * Slic3r::GUI::Plater::get_uv_editor_canvas

(

)

{
    return p->uv_editor_canvas;
}

References p.

get_view3D_canvas3D()

GLCanvas3D * Slic3r::GUI::Plater::get_view3D_canvas3D

(

)

{
    return p ? p->view3D->get_canvas3d() : nullptr;
}

References p.

Referenced by config_change_notification(), reslice(), update_obj_preview_thumbnail(), and update_plate_thumbnails().

Here is the caller graph for this function:

GetPlateIndexByRightMenuInLeftUI()

int Slic3r::GUI::Plater::GetPlateIndexByRightMenuInLeftUI

(

)

{ return p->m_is_RightClickInLeftUI; }

References p.

has_assmeble_view()

bool Slic3r::GUI::Plater::has_assmeble_view

(

)

const

{ return p->has_assemble_view(); }

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.

import_model_id()

void Slic3r::GUI::Plater::import_model_id

(

wxString

download_info

)

{
    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << __LINE__ << " download info: " << download_info;
 
    wxString download_origin_url = download_info;
    wxString download_url;
    wxString filename;
    wxString separator = "&name=";
 
    try
    {
        size_t namePos = download_info.Find(separator);
        if (namePos != wxString::npos) {
            download_url = download_info.Mid(0, namePos);
            filename = download_info.Mid(namePos + separator.Length());
 
        }
        else {
            fs::path download_path = fs::path(download_origin_url.wx_str());
            download_url = download_origin_url;
            filename = download_path.filename().string();
        }
 
    }
    catch (const std::exception&)
    {
        //wxString sError = error.what();
    }
 
    // The name comes from the link: reduce it to a plain file name inside the download folder.
    filename = from_u8(sanitize_file_basename(into_u8(filename)));
    if (filename.empty())
        filename = "untitled.3mf";
 
    bool download_ok = false;
    int retry_count = 0;
    const int max_retries = 3;
 
    /* jump to 3D eidtor */
    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
    /* prepare progress dialog */
    bool cont = true;
    bool cont_dlg = true;
    bool cancel = false;
    wxString msg;
    wxString dlg_title = _L("Importing Model");
 
    int percent = 0;
    ProgressDialog dlg(dlg_title,
        wxString(' ', 100) + "\n\n\n\n",
        100,    // range
        this,   // parent
        wxPD_CAN_ABORT |
        wxPD_APP_MODAL |
        wxPD_AUTO_HIDE |
        wxPD_SMOOTH);
 
    boost::filesystem::path target_path;
 
    //reset params
    p->project.reset();
 
    /* prepare project and profile */
    boost::thread import_thread = Slic3r::create_thread([&percent, &cont, &retry_count, &msg, &target_path, &download_ok, download_url, &filename] {
 
        // Orca: NetworkAgent is not needed and only prevents this from running
//        NetworkAgent* m_agent = Slic3r::GUI::wxGetApp().getAgent();
//        if (!m_agent) return;
 
        int res = 0;
        std::string http_body;
 
        msg = _L("Preparing 3MF file...");
 
        target_path = fs::path(wxGetApp().app_config->get("download_path"));
 
        //check file suffix
        wxString extension = fs::path(filename.wx_str()).extension().c_str();
        if (!extension.Contains(".3mf")) {
            msg = _L("Download failed; unknown file format.");
            return;
        }
 
        //never replace an existing file
        std::string unused_filename;
        try {
            if (!find_unused_filename(target_path, into_u8(filename), {}, unused_filename))
                unused_filename.clear();
        } catch (const std::exception&) {
            unused_filename.clear();
        }
        if (unused_filename.empty()) {
            msg = _L("Importing to Orca Slicer failed. Please download the file and manually import it.");
            return;
        }
        filename = from_u8(unused_filename);
 
 
        msg = _L("Downloading project...");
 
        //target_path = wxStandardPaths::Get().GetTempDir().utf8_str().data();
 
 
        //target_path = wxGetApp().get_local_models_path().c_str();
        boost::uuids::uuid uuid = boost::uuids::random_generator()();
        std::string unique = to_string(uuid).substr(0, 6);
 
        //target_path /= (boost::format("%1%_%2%.3mf") % filename % unique).str();
        target_path /= fs::path(filename.wc_str());
 
        fs::path tmp_path = target_path;
        tmp_path += format(".%1%", ".download");
 
        auto filesize = 0;
        bool size_limit = false;
        auto http = Http::get(download_url.ToStdString());
 
        while (cont && retry_count < max_retries) {
            retry_count++;
            http.on_progress([&percent, &cont, &msg, &filesize, &size_limit](Http::Progress progress, bool& cancel) {
 
                    if (!cont) cancel = true;
                    if (progress.dltotal != 0) {
 
                        if (filesize == 0) {
                            filesize = progress.dltotal;
                            double megabytes = static_cast<double>(progress.dltotal) / (1024 * 1024);
                            //The maximum size of a 3mf file is 500mb
                            if (megabytes > 500) {
                                cont = false;
                                size_limit = true;
                            }
                        }
                        percent = progress.dlnow * 100 / progress.dltotal;
                    }
 
                    if (size_limit) {
                        msg = _L("Download failed; File size exception.");
                    }
                    else {
                        msg = wxString::Format(_L("Project downloaded %d%%"), percent);
                    }
                })
                .on_error([&msg, &cont, &retry_count](std::string body, std::string error, unsigned http_status) {
                    (void)body;
                    BOOST_LOG_TRIVIAL(error) << format("Error getting: `%1%`: HTTP %2%, %3%",
                        body,
                        http_status,
                        error);
 
                    if (retry_count == max_retries) {
                        msg = _L("Importing to Orca Slicer failed. Please download the file and manually import it.");
                        cont = false;
                    }
                })
                .on_complete([&cont, &download_ok, &msg, tmp_path, &target_path](std::string body, unsigned /* http_status */) {
                        fs::fstream file(tmp_path, std::ios::out | std::ios::binary | std::ios::trunc);
                        file.write(body.c_str(), body.size());
                        file.close();
                        cont = false;
                        try {
                            // Another file may have taken the name while downloading.
                            std::string unused_filename;
                            if (find_unused_filename(target_path.parent_path(), target_path.filename().string(), {}, unused_filename)) {
                                target_path = target_path.parent_path() / unused_filename;
                                fs::rename(tmp_path, target_path);
                                download_ok = true;
                                return;
                            }
                        } catch (const std::exception &e) {
                            BOOST_LOG_TRIVIAL(error) << "import_model_id: failed to move the download into place: " << e.what();
                        }
                        boost::system::error_code ec;
                        fs::remove(tmp_path, ec);
                        msg = _L("Importing to Orca Slicer failed. Please download the file and manually import it.");
                }).perform_sync();
 
                // for break while
                //cont = false;
        }
 
    });
 
    while (cont && cont_dlg) {
        wxMilliSleep(50);
        cont_dlg = dlg.Update(percent, msg);
        if (!cont_dlg) {
            cont = cont_dlg;
            cancel = true;
        }
 
        if (download_ok)
            break;
    }
 
    if (import_thread.joinable())
        import_thread.join();
 
    dlg.Hide();
 
#ifdef _WIN32
    dlg.Close();
#endif
 
    if (download_ok) {
        BOOST_LOG_TRIVIAL(trace) << "import_model_id: target_path = " << target_path.string();
        /* load project */
        // Orca: If download is a zip file, treat it as if file has been drag and dropped on the plater
        if (target_path.extension() == ".zip")
            { wxArrayString arr; arr.Add(from_path(target_path)); this->load_files(arr); }
        else
            this->load_project(from_path(target_path));
        /*BBS set project info after load project, project info is reset in load project */
        //p->project.project_model_id = model_id;
        //p->project.project_design_id = design_id;
        AppConfig* config = wxGetApp().app_config;
        if (config) {
            p->project.project_country_code = config->get_country_code();
        }
 
        // show save new project
        p->set_project_filename(target_path.wstring());
        p->notification_manager->push_import_finished_notification(target_path.string(), target_path.parent_path().string(), false);
    }
    else {
        if (!msg.empty()) {
            MessageDialog msg_wingow(nullptr, msg, wxEmptyString, wxICON_WARNING | wxOK);
            msg_wingow.SetSize(wxSize(FromDIP(480), -1));
            msg_wingow.ShowModal();
        }
        return;
    }
}

References _L, config(), Slic3r::create_thread(), Slic3r::Http::Progress::dlnow, Slic3r::Http::Progress::dltotal, Slic3r::find_unused_filename(), Slic3r::GUI::format(), Slic3r::GUI::from_path(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), Slic3r::http, Slic3r::GUI::into_u8(), load_files(), load_project(), p, Slic3r::sanitize_file_basename(), Slic3r::GUI::DPIAware< P >::ShowModal(), TAB_ID_PREPARE, Slic3r::GUI::to_string(), Slic3r::trace(), and Slic3r::GUI::ProgressDialog::Update().

Here is the call 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(_u8L("Import SLA archive"));
        replace_job(w, std::make_unique<SLAImportJob>(p->m_sla_import_dlg));
    }
}

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

Here is the call 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);
}

References load_files().

Here is the call graph for this function:

increase_instances()

void Slic3r::GUI::Plater::increase_instances

(

size_t

num = 1

)

{
    if (! can_increase_instances()) { return; }
 
    Plater::TakeSnapshot snapshot(this, "Increase Instances");
 
    int obj_idx = p->get_selected_object_idx();
 
    ModelObject* model_object = p->model.objects[obj_idx];
    ModelInstance* model_instance = 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);
        model_object->add_instance(offset_vec, model_instance->get_scaling_factor(), model_instance->get_rotation(), model_instance->get_mirror());
//        p->print.get_object(obj_idx)->add_copy(Slic3r::to_2d(offset_vec));
    }
    // Register the copies with the plate they land on before the scene reloads: the plate's
    // filament list and wipe tower preview are read from that registry.
    for (size_t i = model_object->instances.size() - num; i < model_object->instances.size(); ++i)
        p->partplate_list.notify_instance_update(obj_idx, static_cast<int>(i));
 
#ifdef SUPPORT_AUTO_CENTER
    if (p->get_config("autocenter") == "true")
        arrange();
#endif
 
    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();
    //if (wxGetApp().app_config->get("auto_arrange") == "true") {
    //    this->set_prepare_state(Job::PREPARE_STATE_MENU);
    //    this->arrange();
    //}
}

References Slic3r::ModelObject::add_instance(), arrange(), can_increase_instances(), canvas3D(), Slic3r::ModelInstance::get_mirror(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelInstance::get_rotation(), Slic3r::ModelInstance::get_scaling_factor(), Slic3r::GUI::GLCanvas3D::get_size_proportional_to_max_bed_size(), Slic3r::GUI::ObjectList::increase_object_instances(), Slic3r::ModelObject::instances, Slic3r::GUI::Sidebar::obj_list(), Slic3r::offset(), p, and sidebar().

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), 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.

inside_snapshot_capture()

bool Slic3r::GUI::Plater::inside_snapshot_capture

(

)

{ return p->inside_snapshot_capture(); }

References p.

install_missing_cloud_plugins()

void Slic3r::GUI::Plater::install_missing_cloud_plugins

(

const std::vector< std::string > &

cloud_refs

)

{
    if (cloud_refs.empty())
        return;
 
    // Shared between the UI-thread dialog/timer and the resolver's worker thread.
    struct InstallProgressState
    {
        std::atomic<bool> cancel{false};
        std::atomic<bool> finished{false};
        std::atomic<bool> torn_down{false};
        std::mutex        mtx;
        std::string       message;
    };
    auto state     = std::make_shared<InstallProgressState>();
    state->message = _u8L("Preparing to install plugins...");
 
    wxWindow* parent = wxGetApp().mainframe;
    auto*     dialog = new wxProgressDialog(_L("Installing plugins"), from_u8(state->message), 100,
                                            parent, wxPD_APP_MODAL | wxPD_CAN_ABORT);
    dialog->Pulse();
 
    // UI-thread timer: animate the pulse, observe the Cancel button, and tear down when the worker
    // signals completion. The timer is deleted via CallAfter so it is never freed inside its own
    // handler.
    auto* timer = new wxTimer();
    timer->Bind(wxEVT_TIMER, [this, dialog, timer, state](wxTimerEvent&) {
        std::string msg;
        {
            std::lock_guard<std::mutex> lock(state->mtx);
            msg = state->message;
        }
        // Once cancellation is requested, the in-flight plugin still has to finish; reflect that.
        if (state->cancel)
            msg = _u8L("Cancelling — finishing the current plugin...");
 
        if (!dialog->Pulse(from_u8(msg)))
            state->cancel = true;
 
        // Tear down exactly once: Stop() prevents further ticks, but guard so a stale queued tick
        // can never double-Destroy the dialog or double-delete the timer.
        if (state->finished && !state->torn_down.exchange(true)) {
            timer->Stop();
            dialog->Destroy();
            wxGetApp().CallAfter([timer]() { delete timer; });
            revalidate_current_plate_if_plugins_missing();
        }
    });
    timer->Start(100);
 
    PluginInstallProgress progress;
    progress.on_plugin_begin = [state](const std::string& name, std::size_t /*index*/, std::size_t /*total*/) {
        std::lock_guard<std::mutex> lock(state->mtx);
        state->message = (boost::format(_u8L("Installing %1%...")) % name).str();
    };
    progress.is_cancelled = [state]() { return state->cancel.load(); };
    progress.on_finished  = [state]() { state->finished = true; };
 
    resolve_missing_plugins(cloud_refs, std::move(progress));
}

References _L, _u8L, Slic3r::GUI::from_u8(), Slic3r::PluginInstallProgress::is_cancelled, Slic3r::PluginInstallProgress::on_finished, Slic3r::PluginInstallProgress::on_plugin_begin, Slic3r::resolve_missing_plugins(), and revalidate_current_plate_if_plugins_missing().

Referenced by refresh_missing_plugin_block().

Here is the call graph for this function:

Here is the caller graph for this function:

instance_menu()

wxMenu * Slic3r::GUI::Plater::instance_menu

(

)

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

References p.

invalid_all_plate_thumbnails()

void Slic3r::GUI::Plater::invalid_all_plate_thumbnails

(

)

{
    if (using_exported_file() || skip_thumbnail_invalid)
        return;
    BOOST_LOG_TRIVIAL(info) << "thumb: invalid all";
    for (int i = 0; i < get_partplate_list().get_plate_count(); i++) {
        PartPlate* plate = get_partplate_list().get_plate(i);
        plate->thumbnail_data.reset();
        plate->no_light_thumbnail_data.reset();
    }
    mark_plate_toolbar_image_dirty();
}

References get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), mark_plate_toolbar_image_dirty(), Slic3r::GUI::PartPlate::no_light_thumbnail_data, Slic3r::ThumbnailData::reset(), skip_thumbnail_invalid, Slic3r::GUI::PartPlate::thumbnail_data, and using_exported_file().

Referenced by force_update_all_plate_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

is_background_process_slicing()

bool Slic3r::GUI::Plater::is_background_process_slicing

(

)

const

{
    return p->m_is_slicing;
}

References p.

Referenced by can_add_model(), and can_add_plate().

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

bool Slic3r::GUI::Plater::is_empty_project

(

)

                              {
    return model().objects.empty();
}

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

Here is the call graph for this function:

is_export_gcode_scheduled()

bool Slic3r::GUI::Plater::is_export_gcode_scheduled

(

)

const

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

References p.

is_gcode_3mf()

bool Slic3r::GUI::Plater::is_gcode_3mf ( )

inline

{ return m_exported_file; }

References m_exported_file.

Referenced by normalize_bed_types().

Here is the caller graph for this function:

is_loading_project()

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

inline

{ return m_loading_project; }

References m_loading_project.

Referenced by changed_object(), and changed_objects().

Here is the caller graph for this function:

is_multi_extruder_ams_empty()

bool Slic3r::GUI::Plater::is_multi_extruder_ams_empty

(

)

{
    std::vector<std::string>        extruder_ams_count_str = p->config->option<ConfigOptionStrings>("extruder_ams_count", true)->values;
    std::vector<std::map<int, int>> extruder_ams_counts    = get_extruder_ams_count(extruder_ams_count_str);
    for (auto extruder_ams_count : extruder_ams_counts) {
        for (auto iter = extruder_ams_count.begin(); iter != extruder_ams_count.end(); ++iter) {
            if (iter->second != 0)
                return false;
        }
    }
    return true;
}

References Slic3r::get_extruder_ams_count(), and p.

Here is the call graph for this function:

is_new_project_and_check_state()

bool Slic3r::GUI::Plater::is_new_project_and_check_state ( )

inline

{ return m_new_project_and_check_state; }

References m_new_project_and_check_state.

Referenced by update().

Here is the caller graph for this function:

is_plate_toolbar_image_dirty()

bool Slic3r::GUI::Plater::is_plate_toolbar_image_dirty

(

)

const

{
    return m_b_plate_toolbar_image_dirty;
}

References m_b_plate_toolbar_image_dirty.

is_presets_dirty()

bool Slic3r::GUI::Plater::is_presets_dirty

(

)

const

{ return p->is_presets_dirty(); }

References p.

is_preview_loaded()

bool Slic3r::GUI::Plater::is_preview_loaded

(

)

const

{ return p->is_preview_loaded(); }

References p.

Referenced by export_toolpaths_to_obj().

Here is the caller graph for this function:

is_preview_shown()

bool Slic3r::GUI::Plater::is_preview_shown

(

)

const

{ return p->is_preview_shown(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::schedule_auto_reslice_if_needed(), search(), select_plate(), Slic3r::GUI::Plater::priv::trigger_auto_reslice_now(), and Slic3r::GUI::Plater::priv::update().

Here is the caller graph for this function:

is_project_dirty()

bool Slic3r::GUI::Plater::is_project_dirty

(

)

const

{ return p->is_project_dirty(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::update_title_dirty_status().

Here is the caller graph for this function:

is_render_statistic_dialog_visible()

bool Slic3r::GUI::Plater::is_render_statistic_dialog_visible

(

)

const

{
    return p->show_render_statistic_dialog;
}

References p.

is_same_printer_for_connected_and_selected()

bool Slic3r::GUI::Plater::is_same_printer_for_connected_and_selected

(

bool

popup_warning = true

)

{
    if (!wxGetApp().getDeviceManager()) {
        return false;
    }
    MachineObject *obj = wxGetApp().getDeviceManager()->get_selected_machine();
    if (obj == nullptr) {
        return false;
    }
    if (!check_printer_initialized(obj, true, popup_warning))
        return false;
    const std::string machine_model = obj->printer_type;
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    const std::string selected_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
    if (!DevPrinterConfigUtil::is_optional_printer_model_id(machine_model) &&
        !DevPrinterConfigUtil::is_optional_printer_model_id(selected_model) &&
        !get_printer_preset(obj)) {
        return false;
    }
 
    if (wxGetApp().is_blocking_printing()) {
        if (popup_warning) {
            auto printer_name = get_selected_printer_name_in_combox(); // wxString(obj->get_preset_printer_model_name(machine_print_name))
            pop_warning_and_go_to_device_page(printer_name, PrinterWarningType::INCONSISTENT, _L("Synchronize AMS Filament Information"));
        }
        return false;
    }
    return true;
}

References _L, check_printer_initialized(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::get_printer_preset(), Slic3r::Preset::get_printer_type(), get_selected_printer_name_in_combox(), INCONSISTENT, Slic3r::DevPrinterConfigUtil::is_optional_printer_model_id(), pop_warning_and_go_to_device_page(), Slic3r::MachineObject::printer_type, and Slic3r::PresetBundle::printers.

Here is the call graph for this function:

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 Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), can_copy_to_clipboard(), can_cut_to_clipboard(), and clone_selection().

Here is the caller graph for this function:

is_show_wireframe()

bool Slic3r::GUI::Plater::is_show_wireframe

(

)

const

{
    return p->show_wireframe;
}

References p.

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar().

Here is the caller graph for this function:

is_show_xray()

bool Slic3r::GUI::Plater::is_show_xray

(

)

const

{
    return p->show_xray;
}

References p.

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar().

Here is the caller graph for this function:

is_sidebar_collapsed()

bool Slic3r::GUI::Plater::is_sidebar_collapsed

(

)

const

{ return p->sidebar_layout.is_collapsed; }

References p.

Referenced by Slic3r::GUI::Plater::priv::init_collapse_toolbar().

Here is the caller graph for this function:

is_sidebar_enabled()

bool Slic3r::GUI::Plater::is_sidebar_enabled

(

)

const

{ return p->sidebar_layout.is_enabled; }

References p.

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

bool Slic3r::GUI::Plater::is_view3D_overhang_shown

(

)

const

{ return p->is_view3D_overhang_shown(); }

References p.

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar().

Here is the caller graph for this function:

is_view3D_shown()

bool Slic3r::GUI::Plater::is_view3D_shown

(

)

const

{ return p->is_view3D_shown(); }

References p.

Referenced by select_plate().

Here is the caller graph for this function:

is_wireframe_enabled()

bool Slic3r::GUI::Plater::is_wireframe_enabled

(

)

const

{
    return p->wireframe_enabled;
}

References p.

last_arrange_job_is_finished()

bool Slic3r::GUI::Plater::last_arrange_job_is_finished ( )

inline

    {
        bool prevRunning = false;
        return m_arrange_running.compare_exchange_strong(prevRunning, true);
    };

References m_arrange_running.

Referenced by select_plate_by_hover_id().

Here is the caller graph for this function:

layer_menu()

wxMenu * Slic3r::GUI::Plater::layer_menu

(

)

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

References p.

leave_gizmos_stack()

bool Slic3r::GUI::Plater::leave_gizmos_stack

(

)

{ return p->leave_gizmos_stack(); } // BBS: return false if not changed

References p.

load_files() [1/2]

std::vector< size_t > Slic3r::GUI::Plater::load_files	(	const std::vector< boost::filesystem::path > &	input_files,
		LoadStrategy	strategy = LoadStrategy::LoadModel|LoadStrategy::LoadConfig,
		bool	ask_multi = false,
		bool *	published_out = nullptr )

References Slic3r::LoadConfig, and Slic3r::LoadModel.

Referenced by add_file(), add_model(), extract_config_from_project(), import_model_id(), import_zip_archive(), load_files(), Slic3r::GUI::MenuFactory::load_handy_model(), load_project(), open_3mf_file(), Slic3r::GUI::GUI_App::post_init(), and preview_zip_archive().

Here is the caller graph for this function:

load_files() [2/2]

bool Slic3r::GUI::Plater::load_files

(

const wxArrayString &

filenames

)

{
    const std::regex pattern_drop(".*[.](stp|step|stl|oltp|obj|amf|3mf|svg|zip|drc|glb|gltf|fbx)", std::regex::icase);
    const std::regex pattern_gcode_drop(".*[.](gcode|g)", std::regex::icase);
 
    std::vector<fs::path> normal_paths;
    std::vector<fs::path> gcode_paths;
 
    for (const auto& filename : filenames) {
        fs::path path(into_path(filename));
        if (std::regex_match(path.string(), pattern_drop))
            normal_paths.push_back(std::move(path));
        else if (std::regex_match(path.string(), pattern_gcode_drop))
            gcode_paths.push_back(std::move(path));
        else
            continue;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": normal_paths %1%, gcode_paths %2%")%normal_paths.size() %gcode_paths.size();
    if (normal_paths.empty() && gcode_paths.empty()) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": can not find valid path, return directly");
        // Likely no supported files
        return false;
    }
    else if (normal_paths.empty()){
        //only gcode files
        if (gcode_paths.size() > 1) {
            show_info(this, _L("Only one G-code file can be opened at a time."), _L("G-code loading"));
            return false;
        }
        load_gcode(from_path(gcode_paths.front()));
        return true;
    }
 
    if (!gcode_paths.empty()) {
        show_info(this, _L("G-code files and models cannot be loaded together!"), _L("G-code loading"));
        return false;
    }

    //for (std::vector<fs::path>::const_reverse_iterator it = normal_paths.rbegin(); it != normal_paths.rend(); ++it) {
    //    std::string filename = (*it).filename().string();
    //    ////BBS: only 3mf will be treated as project file
    //    if (open_3mf_file((*it)))
    //        return true;
    //}

    std::string snapshot_label;
    assert(!normal_paths.empty());
    if (normal_paths.size() == 1) {
        snapshot_label = "Load File";
        snapshot_label += ": ";
        snapshot_label += encode_path(normal_paths.front().filename().string().c_str());
    } else {
        snapshot_label = "Load Files";
        snapshot_label += ": ";
        snapshot_label += encode_path(normal_paths.front().filename().string().c_str());
        for (size_t i = 1; i < normal_paths.size(); ++i) {
            snapshot_label += ", ";
            snapshot_label += encode_path(normal_paths[i].filename().string().c_str());
        }
    }
 
    //Plater::TakeSnapshot snapshot(this, snapshot_label);
    //load_files(normal_paths, LoadStrategy::LoadModel);
 
    // BBS: check file types
    std::sort(normal_paths.begin(), normal_paths.end(), [](fs::path obj1, fs::path obj2) { return obj1.filename().string() < obj2.filename().string(); });
 
    auto loadfiles_type  = LoadFilesType::NoFile;
    auto amf_files_count = get_3mf_file_count(normal_paths);
 
    if (normal_paths.size() > 1 && amf_files_count < normal_paths.size()) { loadfiles_type = LoadFilesType::Multiple3MFOther; }
    if (normal_paths.size() > 1 && amf_files_count == normal_paths.size()) { loadfiles_type = LoadFilesType::Multiple3MF; }
    if (normal_paths.size() > 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::MultipleOther; }
    if (normal_paths.size() == 1 && amf_files_count == 1) { loadfiles_type = LoadFilesType::Single3MF; };
    if (normal_paths.size() == 1 && amf_files_count == 0) { loadfiles_type = LoadFilesType::SingleOther; };
 
    auto first_file = std::vector<fs::path>{};
    auto tmf_file   = std::vector<fs::path>{};
    auto other_file = std::vector<fs::path>{};
    auto res        = true;
 
    if (this->m_only_gcode || this->m_exported_file) {
        if ((loadfiles_type == LoadFilesType::SingleOther)
            || (loadfiles_type == LoadFilesType::MultipleOther)) {
            show_info(this, _L("Unable to add models in preview mode"), _L("Add Models"));
            return false;
        }
    }
 
    // Orca: Iters through given paths and imports files from zip then remove zip from paths
    // returns true if zip files were found
    auto handle_zips = [this](std::vector<fs::path>& paths) { // NOLINT(*-no-recursion) - Recursion is intended and should be managed properly
        bool res = false;
        for (auto it = paths.begin(); it != paths.end();) {
            if (boost::algorithm::iends_with(it->string(), ".zip")) {
                res = true;
                preview_zip_archive(*it);
                it = paths.erase(it);
            } else
                it++;
        }
        return res;
    };
 
    switch (loadfiles_type) {
    case LoadFilesType::Single3MF:
        open_3mf_file(normal_paths[0]);
        break;
 
    case LoadFilesType::SingleOther: {
        Plater::TakeSnapshot snapshot(this, snapshot_label);
        if (handle_zips(normal_paths)) return true;
        if (load_files(normal_paths, LoadStrategy::LoadModel, false).empty()) { res = false; }
        break;
    }
    case LoadFilesType::Multiple3MF:
        first_file = std::vector<fs::path>{normal_paths[0]};
        for (auto i = 0; i < normal_paths.size(); i++) {
            if (i > 0) { other_file.push_back(normal_paths[i]); }
        };
 
        open_3mf_file(first_file[0]);
        if (load_files(other_file, LoadStrategy::LoadModel).empty()) {  res = false;  }
        break;
 
    case LoadFilesType::MultipleOther: {
        Plater::TakeSnapshot snapshot(this, snapshot_label);
        if (handle_zips(normal_paths)) {
            if (normal_paths.empty()) return true;
        }
        if (load_files(normal_paths, LoadStrategy::LoadModel, true).empty()) { res = false; }
        break;
    }
 
    case LoadFilesType::Multiple3MFOther:
        for (const auto &path : normal_paths) {
            if (boost::iends_with(path.filename().string(), ".3mf")){
                if (first_file.size() <= 0)
                    first_file.push_back(path);
                else
                    tmf_file.push_back(path);
            } else {
                other_file.push_back(path);
            }
        }
 
        open_3mf_file(first_file[0]);
        if (load_files(tmf_file, LoadStrategy::LoadModel).empty()) {  res = false;  }
        if (res && handle_zips(other_file)) {
            if (normal_paths.empty()) return true;
        }
        if (load_files(other_file, LoadStrategy::LoadModel, false).empty()) {  res = false;  }
        break;
    default: break;
    }
 
    return res;
}

References _L, Slic3r::empty(), Slic3r::encode_path(), Slic3r::GUI::from_path(), get_3mf_file_count(), Slic3r::GUI::into_path(), load_files(), load_gcode(), Slic3r::LoadModel, m_exported_file, m_only_gcode, Slic3r::GUI::Multiple3MF, Slic3r::GUI::Multiple3MFOther, Slic3r::GUI::MultipleOther, Slic3r::GUI::NoFile, open_3mf_file(), preview_zip_archive(), Slic3r::GUI::show_info(), Slic3r::GUI::Single3MF, and Slic3r::GUI::SingleOther.

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

)

{
    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << __LINE__ << " entry and filename: " << filename;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__;
    if (! is_gcode_file(into_u8(filename))
        || (m_last_loaded_gcode == filename && m_only_gcode)
        )
        return;
 
    m_last_loaded_gcode = filename;
 
    // An OrcaSlicer G-code carries the settings it was sliced with. They replace the selected presets as a
    // .gcode.3mf's do, so unsaved preset changes get the save-or-discard choice of opening a project rather
    // than the new project's choice to keep them.
    PresetBundle*                     preset_bundle = wxGetApp().preset_bundle;
    const std::string                 path          = into_u8(filename);
    std::optional<DynamicPrintConfig> file_config;
    ConfigSubstitutions               substitutions;
    {
        wxBusyCursor wait;
        try {
            file_config = preset_bundle->config_from_gcode(path, ForwardCompatibilitySubstitutionRule::Enable, substitutions);
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": no settings to load from " << path << ": " << ex.what();
        }
    }
 
    // BSS: create a new project when load_gcode, force close previous one
    if (file_config) {
        auto check = [](bool yes_or_no) {
            return yes_or_no || wxGetApp().check_and_save_current_preset_changes(_L("Load project"), _L("Some presets are modified."));
        };
        if (close_with_confirm(check) == wxID_CANCEL || new_project(true, true) != wxID_YES)
            return;
    } else if (new_project(false, true) != wxID_YES)
        return;
 
    m_only_gcode = true;
    m_gcode_settings_loaded = false;
    // A previewed G-code's settings are not the selection the app should remember.
    PresetBundle::SelectionExportBlocker no_selection_export(*preset_bundle);
    // What loading the file's settings replaces, to put back if that load fails or the file is rejected.
    std::optional<PresetBundle::Selection> previous;
    if (file_config) {
        previous = preset_bundle->selection();
        if (!previous)
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": project presets are still loaded, not loading the settings of " << path;
    }
    auto unload_file_settings = [this, preset_bundle, &previous]() {
        if (!previous)
            return;
        preset_bundle->restore_selection(*previous);
        wxGetApp().load_current_presets(false, false);
        // Switching back to the previous printer re-derives some project settings (TabPrinter::on_preset_loaded),
        // and only the printer refresh shows them in the sidebar's flow selectors.
        preset_bundle->project_config = std::move(previous->project_config);
        sidebar().update_presets(Preset::TYPE_PRINTER);
        reset_project_dirty_initial_presets();
        update_project_dirty_from_presets();
        m_gcode_settings_loaded = false;
        // The rejections after the switch to the preview have already shown the sidebar with the file's settings.
        enable_sidebar(false);
        previous.reset();
    };
    if (previous) {
        try {
            preset_bundle->load_config_model(path, std::move(*file_config));
            m_gcode_settings_loaded = true;
        } catch (const std::exception& ex) {
            unload_file_settings();
            get_notification_manager()->push_notification(NotificationType::CustomNotification,
                                                          NotificationManager::NotificationLevel::WarningNotificationLevel,
                                                          GUI::format(_L("Failed loading file \"%1%\". An invalid configuration was found."), path) +
                                                              "\n" + ex.what());
        }
    }
    if (m_gcode_settings_loaded) {
        wxGetApp().load_current_presets(false, false);
        sync_loaded_project_filament_config(preset_bundle->project_config);
        sidebar().update_presets(Preset::TYPE_FILAMENT);
        reset_project_dirty_initial_presets();
        update_project_dirty_from_presets();
        if (!substitutions.empty())
            show_substitutions_info(substitutions, path);
    }
 
    // cleanup view before to start loading/processing
    //BBS: update gcode to current partplate's
    GCodeProcessorResult* current_result = p->partplate_list.get_current_slice_result();
    Print& current_print = p->partplate_list.get_current_fff_print();
    //BBS:already reset in new_project
    //current_result->reset();
    //p->gcode_result.reset();
    //reset_gcode_toolpaths();
    p->preview->reload_print(m_only_gcode);
    wxGetApp().mainframe->select_tab(TAB_ID_PREVIEW);
    p->set_current_panel(p->preview, true);
    p->get_current_canvas3D()->render();
    //p->notification_manager->bbl_show_plateinfo_notification(into_u8(_L("Preview only mode for gcode file.")));
 
    wxBusyCursor wait;
 
    // process gcode
    GCodeProcessor processor;
    processor.init_filament_maps_and_nozzle_type_when_import_only_gcode();
    try
    {
        GCodeProcessor::s_IsBBLPrinter = wxGetApp().preset_bundle->is_bbl_vendor();
        processor.process_file(filename.ToUTF8().data());
    }
    catch (const std::exception& ex)
    {
        unload_file_settings();
        show_error(this, ex.what());
        return;
    }
    *current_result = std::move(processor.extract_result());
    //current_result->filename = filename;
 
    BedType bed_type = current_result->bed_type;
    if (bed_type != BedType::btCount) {
        DynamicPrintConfig &proj_config = wxGetApp().preset_bundle->project_config;
        proj_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(bed_type));
        on_bed_type_change(bed_type);
    }
 
    current_print.apply(this->model(), wxGetApp().preset_bundle->full_config());
 
    current_print.apply_config_for_render(processor.export_config_for_render());
 
    //BBS: add cost info when drag in gcode
    auto& ps = current_result->print_statistics;
    double total_cost = 0.0;
    for (auto volume : ps.total_volumes_per_extruder) {
        size_t extruder_id = volume.first;
        double density = current_result->filament_densities.at(extruder_id);
        double cost = current_result->filament_costs.at(extruder_id);
        double weight = volume.second * density * 0.001;
        total_cost += weight * cost * 0.001;
    }
    current_print.print_statistics().total_cost = total_cost;
 
    current_print.set_gcode_file_ready();
 
    // Belt printer: detect the belt tilt from the loaded G-code header and enable
    // belt view mode on the GCodeViewer so the "Show designed view" toggle appears.
    if (current_result->belt_tilt_angle > 0.f) {
        float angle = current_result->belt_tilt_angle;
        p->preview->get_canvas3d()->get_gcode_viewer().set_belt_printer(true, angle);
    } else {
        p->preview->get_canvas3d()->get_gcode_viewer().set_belt_printer(false, 0.f);
    }
 
    // show results
    p->preview->reload_print(m_only_gcode);
    //BBS: zoom to bed 0 for gcode preview
    //p->preview->get_canvas3d()->zoom_to_gcode();
    p->preview->get_canvas3d()->zoom_to_plate(0);
 
    if (p->preview->get_canvas3d()->get_gcode_layers_zs().empty()) {
        unload_file_settings();
        MessageDialog(this, format_wxstr(_L("The selected file:\n%1%\ndoes not contain valid G-code."), filename),
            wxString(GCODEVIEWER_APP_NAME) + " - " + _L("An Error has occurred while loading the G-code file."), wxCLOSE | wxICON_WARNING | wxCENTRE).ShowModal();
        set_project_filename(_L(DEFAULT_PROJECT_NAME));
    } else {
        set_project_filename(filename);
    }
 
    // Orca: Fix crash when loading gcode file multiple times
    if (m_only_gcode) {
        p->view3D->get_canvas3d()->remove_raycasters_for_picking(SceneRaycaster::EType::Bed);
    }
 
    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false, false); //20250416 ban gcode to send print
}

References _L, Slic3r::angle(), Slic3r::Print::apply(), Slic3r::Print::apply_config_for_render(), Slic3r::GUI::SceneRaycaster::Bed, Slic3r::GCodeProcessorResult::bed_type, Slic3r::GCodeProcessorResult::belt_tilt_angle, Slic3r::btCount, close_with_confirm(), Slic3r::PresetBundle::config_from_gcode(), Slic3r::GUI::CustomNotification, Slic3r::GUI::DEFAULT_PROJECT_NAME, Slic3r::GUI::MainFrame::eEventPlateUpdate, Slic3r::Enable, enable_sidebar(), Slic3r::GCodeProcessor::export_config_for_render(), Slic3r::GCodeProcessor::extract_result(), Slic3r::GCodeProcessorResult::filament_costs, Slic3r::GCodeProcessorResult::filament_densities, Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::PresetBundle::full_config(), GCODEVIEWER_APP_NAME, get_notification_manager(), Slic3r::GCodeProcessor::init_filament_maps_and_nozzle_type_when_import_only_gcode(), Slic3r::GUI::into_u8(), Slic3r::is_gcode_file(), Slic3r::PresetBundle::load_config_model(), m_gcode_settings_loaded, m_last_loaded_gcode, m_only_gcode, model(), new_project(), on_bed_type_change(), p, Slic3r::GCodeProcessorResult::print_statistics, Slic3r::Print::print_statistics(), Slic3r::GCodeProcessor::process_file(), Slic3r::PresetBundle::project_config, Slic3r::GUI::NotificationManager::push_notification(), reset_project_dirty_initial_presets(), Slic3r::PresetBundle::restore_selection(), Slic3r::GCodeProcessor::s_IsBBLPrinter, Slic3r::PresetBundle::selection(), Slic3r::Print::set_gcode_file_ready(), Slic3r::DynamicConfig::set_key_value(), set_project_filename(), Slic3r::GUI::show_error(), Slic3r::GUI::show_substitutions_info(), Slic3r::GUI::DPIAware< P >::ShowModal(), sidebar(), Slic3r::GUI::sync_loaded_project_filament_config(), TAB_ID_PREVIEW, Slic3r::PrintStatistics::total_cost, Slic3r::trace(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, Slic3r::GUI::Sidebar::update_presets(), update_project_dirty_from_presets(), and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Here is the call graph for this function:

load_project()

void Slic3r::GUI::Plater::load_project	(	wxString const &	filename = "",
		wxString const &	originfile = "-" )

{
    model().calib_pa_pattern.reset(nullptr);
    model().plates_custom_gcodes.clear();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "filename is: " << filename2 << "and originfile is: " << originfile;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__;
    auto filename = filename2;
    auto check = [&filename, this] (bool yes_or_no) {
        if (!yes_or_no && !wxGetApp().check_and_save_current_preset_changes(_L("Load project"),
                _L("Some presets are modified.")))
            return false;
        if (filename.empty()) {
            // Ask user for a project file name.
            wxGetApp().load_project(this, filename);
        }
        return !filename.empty();
    };
 
    // BSS: save project, force close
    int result;
    if ((result = close_with_confirm(check)) == wxID_CANCEL) {
        return;
    }
 
    // BBS
    if (m_loading_project) {
        //some error cases happens
        //return directly
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": current loading other project, return directly");
        return;
    }
 
    m_loading_project = true;
    ScopeGuard loading_project_sc([this]() { m_loading_project = false; }); // Make sure state restored on any early return
 
    m_only_gcode = false;
    m_exported_file = false;
    get_notification_manager()->bbl_close_plateinfo_notification();
    get_notification_manager()->bbl_close_preview_only_notification();
    get_notification_manager()->bbl_close_3mf_warn_notification();
    get_notification_manager()->close_notification_of_type(NotificationType::PlaterError);
    get_notification_manager()->close_notification_of_type(NotificationType::PlaterWarning);
    get_notification_manager()->close_notification_of_type(NotificationType::SlicingError);
    get_notification_manager()->close_notification_of_type(NotificationType::SlicingSeriousWarning);
    get_notification_manager()->close_notification_of_type(NotificationType::SlicingWarning);
 
    auto path     = into_path(filename);
 
    auto strategy = LoadStrategy::LoadModel | LoadStrategy::LoadConfig;
    if (originfile == "<silence>") {
        strategy = strategy | LoadStrategy::Silence;
    } else if (originfile == "<loadall>") {
        // Do nothing
    } else if (originfile != "-") {
        strategy = strategy | LoadStrategy::Restore;
    } else {
        switch (determine_load_type(filename.ToStdString())) {
            case LoadType::OpenProject: break; // Do nothing
            case LoadType::LoadGeometry:; strategy = LoadStrategy::LoadModel; break;
            default: return; // User cancelled
        }
    }
    bool load_restore = strategy & LoadStrategy::Restore;
 
    // Take the Undo / Redo snapshot.
    reset();
 
    Plater::TakeSnapshot snapshot(this, "Load Project", UndoRedo::SnapshotType::ProjectSeparator);
 
    std::vector<fs::path> input_paths;
    input_paths.push_back(path);
    if (strategy & LoadStrategy::Restore)
        input_paths.push_back(into_u8(originfile));
 
    bool loaded_published   = false;
    std::vector<size_t> res = load_files(input_paths, strategy, false, &loaded_published);
 
    reset_project_dirty_initial_presets();
    update_project_dirty_from_presets();
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
 
    // if res is empty no data has been loaded
    if (!res.empty() && !loaded_published && (load_restore || !(strategy & LoadStrategy::Silence))) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " call set_project_filename: " << (load_restore ? originfile : filename);
        p->set_project_filename(load_restore ? originfile : filename);
        if (load_restore && originfile.IsEmpty()) {
        p->set_project_name(_L("Untitled"));
        }
 
        {
            Slic3r::LifecycleEventContext ctx;
            ctx.name = into_u8(load_restore ? originfile : filename);
            ctx.code = Slic3r::LifecycleEvtCode::Ok;
            Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ProjectOpened, ctx);
        }
 
    } else {
        if (using_exported_file()) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " using ecported set project filename: " << filename;
            p->set_project_filename(filename);
        } else if (loaded_published && !res.empty()) {
            // A "published" 3MF loads as a new project: its path must not become the project
            // filename (Save/Ctrl-S prompts for a destination instead of overwriting it);
            // reset() already cleared the project name, so restore the default title and keep
            // the file in recents. Only on a successful load (res not empty): a failed or
            // cancelled load must not pollute "Recently opened".
            p->set_project_name(_L("Untitled"));
            if (!filename.IsEmpty())
                wxGetApp().mainframe->add_to_recent_projects(filename);
        }
 
    }
 
    // BBS set default 3D view and direction after loading project
    //p->select_view_3D("3D");
    if (!m_exported_file) {
        p->select_view("topfront");
        p->camera.requires_zoom_to_plate = REQUIRES_ZOOM_TO_ALL_PLATE;
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
    }
    else {
        p->partplate_list.select_plate_view();
    }
 
    enable_sidebar(!m_only_gcode);
 
    wxGetApp().app_config->update_last_backup_dir(model().get_backup_path());
    if (load_restore && !originfile.empty()) {
        wxGetApp().app_config->update_skein_dir(into_path(originfile).parent_path().string());
        wxGetApp().app_config->update_config_dir(into_path(originfile).parent_path().string());
    }
 
    if (!load_restore)
        up_to_date(true, false);
    else
        p->dirty_state.update_from_undo_redo_stack(true);
    up_to_date(true, true);
 
    // Clear plate overrides that are incompatible with the selected printer.
    normalize_bed_types(false);
 
    wxGetApp().params_panel()->switch_to_object_if_has_object_configs();
 
    auto       has_modify = is_flush_config_modified();
    sidebar().set_flushing_volume_warning(has_modify);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " load project done";
}

References _L, Slic3r::GUI::NotificationManager::bbl_close_3mf_warn_notification(), Slic3r::GUI::NotificationManager::bbl_close_plateinfo_notification(), Slic3r::GUI::NotificationManager::bbl_close_preview_only_notification(), Slic3r::Model::calib_pa_pattern, Slic3r::GUI::NotificationManager::close_notification_of_type(), close_with_confirm(), Slic3r::LifecycleEventContext::code, Slic3r::GUI::determine_load_type(), enable_sidebar(), Slic3r::fire_lifecycle_event(), get_notification_manager(), Slic3r::GUI::into_path(), Slic3r::GUI::into_u8(), is_flush_config_modified(), load_files(), Slic3r::LoadConfig, Slic3r::GUI::LoadGeometry, Slic3r::LoadModel, m_exported_file, m_loading_project, m_only_gcode, model(), Slic3r::LifecycleEventContext::name, normalize_bed_types(), Slic3r::Ok, Slic3r::GUI::OpenProject, p, Slic3r::GUI::PlaterError, Slic3r::GUI::PlaterWarning, Slic3r::Model::plates_custom_gcodes, Slic3r::ProjectOpened, Slic3r::UndoRedo::ProjectSeparator, REQUIRES_ZOOM_TO_ALL_PLATE, reset(), reset_project_dirty_initial_presets(), Slic3r::Restore, Slic3r::GUI::Sidebar::set_flushing_volume_warning(), sidebar(), Slic3r::Silence, Slic3r::GUI::SlicingError, Slic3r::GUI::SlicingSeriousWarning, Slic3r::GUI::SlicingWarning, TAB_ID_PREPARE, up_to_date(), update_project_dirty_from_presets(), and using_exported_file().

Referenced by import_model_id(), and open_3mf_file().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_plate_toolbar_image_dirty()

void Slic3r::GUI::Plater::mark_plate_toolbar_image_dirty

(

)

{
    m_b_plate_toolbar_image_dirty = true;
    ++m_plate_toolbar_image_version;
}

References m_b_plate_toolbar_image_dirty, and m_plate_toolbar_image_version.

Referenced by invalid_all_plate_thumbnails().

Here is the caller graph for this function:

merge()

void Slic3r::GUI::Plater::merge	(	size_t	obj_idx,
		std::vector< int > &	vol_indeces )

mirror()

void Slic3r::GUI::Plater::mirror

(

Axis

axis

)

{ p->mirror(axis); }

References p.

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

Here is the caller graph for this function:

mixed_filament_config_indices()

std::vector< size_t > Slic3r::GUI::Plater::mixed_filament_config_indices

(

)

const

{
    std::vector<size_t> indices;
    auto& config = wxGetApp().preset_bundle->project_config;
    auto* opt = config.option<ConfigOptionBools>("filament_is_mixed");
    if (!opt) return indices;
    for (size_t i = 0; i < opt->values.size(); ++i)
        if (opt->values[i]) indices.push_back(i);
    return indices;
}

References config().

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

Here is the call graph for this function:

Here is the caller graph for this function:

model() [1/2]

Model & Slic3r::GUI::Plater::model

(

)

{ return p->model; }

References p.

model() [2/2]

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

(

)

const

{ return p->model; }

References p.

Referenced by _calib_apply_belt_mode(), _calib_pa_pattern(), _calib_pa_pattern_gen_gcode(), _calib_pa_tower(), _calib_temp_belt_sectioned(), apply_background_progress(), apply_cut_object_to_model(), Slic3r::GUI::belt_calib_flip_ringing_tower(), Calib_Cornering(), calib_flowrate(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_retraction(), calib_temp(), calib_VFA(), changed_mesh(), changed_objects(), clear_before_change_mesh(), close_with_confirm(), cut_horizontal(), export_3mf_copy(), export_published_3mf(), is_empty_project(), load_gcode(), load_project(), new_project(), on_change_color_mode(), on_filament_count_change(), on_filaments_delete(), open_3mf_file(), reslice(), save_project(), select_plate(), select_plate_by_hover_id(), show_object_info(), and update_print_required_data().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::Plater::msw_rescale

(

)

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

References p.

multi_selection_menu()

wxMenu * Slic3r::GUI::Plater::multi_selection_menu

(

)

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

References p.

need_update()

bool Slic3r::GUI::Plater::need_update

(

)

const

{
    return p->need_update();
}

References p.

Referenced by set_need_update(), and update().

Here is the caller graph for this function:

new_project()

int Slic3r::GUI::Plater::new_project	(	bool	skip_confirm = false,
		bool	silent = false,
		const wxString &	project_name = wxString(),
		bool	reload_presets = true )

{
    model().calib_pa_pattern.reset(nullptr);
    model().plates_custom_gcodes.clear();
 
    bool transfer_preset_changes = false;
    // BBS: save confirm
    auto check = [this,&transfer_preset_changes](bool yes_or_no) {
        m_new_project_and_check_state = true;
        wxString header = _L("Some presets are modified.") + "\n" +
            (yes_or_no ? _L("You can keep the modified presets for the new project or discard them") :
                _L("You can keep the modified presets for the new project, discard, or save changes as new presets."));
        int act_buttons = ActionButtons::KEEP | ActionButtons::REMEMBER_CHOISE;
        if (!yes_or_no)
            act_buttons |= ActionButtons::SAVE;
        if (m_exported_file) { //.gcode.3mf ignore presets modify
            m_exported_file = false;
        }
        bool result = wxGetApp().check_and_keep_current_preset_changes(_L("Creating a new project"), header, act_buttons, &transfer_preset_changes);
        m_new_project_and_check_state = false;
        return result;
    };
    int result;
    if (!skip_confirm && (result = close_with_confirm(check)) == wxID_CANCEL)
        return wxID_CANCEL;
 
    m_only_gcode = false;
    m_exported_file = false;
    m_loading_project = false;
    get_notification_manager()->clear_all();
 
    if (!silent)
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
    //get_partplate_list().reinit();
    //get_partplate_list().update_slice_context_to_current_plate(p->background_process);
    //p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
    if (!silent) {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::NewProject, ctx);
    }
    {
        // Same rationale as in Plater::priv::reset(): the whole reset + preset-reload +
        // baseline-reset sequence below settles into its final dirty state only once it
        // completes, so hold notifications until then to avoid firing on transient flips.
        ProjectDirtyStateManager::NotificationSuppressor dirty_notify_suppressor(p->dirty_state);
 
        reset(transfer_preset_changes, reload_presets);
        reset_project_dirty_after_save();
        reset_project_dirty_initial_presets();
        wxGetApp().update_saved_preset_from_current_preset();
        update_project_dirty_from_presets();
 
        //reset project
        p->project.reset();
        //set project name
        if (project_name.empty())
            p->set_project_name(_L("Untitled"));
        else
            p->set_project_name(project_name);
 
        Plater::TakeSnapshot snapshot(this, "New Project", UndoRedo::SnapshotType::ProjectSeparator);
    }
 
    Model m;
    model().load_from(m); // new id avoid same path name
 
    //select first plate
    get_partplate_list().select_plate(0);
    SimpleEvent event(EVT_GLCANVAS_PLATE_SELECT);
    p->on_plate_selected(event);
 
    p->load_auxiliary_files();
    wxGetApp().app_config->update_last_backup_dir(model().get_backup_path());
 
    // BBS set default view and zoom
    p->select_view_3D("3D");
    p->select_view("topfront");
    p->camera.requires_zoom_to_bed = true;
    enable_sidebar(!m_only_gcode);
 
    up_to_date(true, false);
    up_to_date(true, true);
    return wxID_YES;
}

References _L, Slic3r::Model::calib_pa_pattern, Slic3r::GUI::NotificationManager::clear_all(), close_with_confirm(), Slic3r::LifecycleEventContext::code, enable_sidebar(), Slic3r::fire_lifecycle_event(), get_notification_manager(), get_partplate_list(), Slic3r::GUI::KEEP, Slic3r::Model::load_from(), m_exported_file, m_loading_project, m_new_project_and_check_state, m_only_gcode, model(), Slic3r::NewProject, Slic3r::Ok, p, Slic3r::Model::plates_custom_gcodes, Slic3r::UndoRedo::ProjectSeparator, Slic3r::GUI::REMEMBER_CHOISE, reset(), reset_project_dirty_after_save(), reset_project_dirty_initial_presets(), Slic3r::GUI::SAVE, Slic3r::GUI::PartPlateList::select_plate(), TAB_ID_PREPARE, up_to_date(), and update_project_dirty_from_presets().

Referenced by Calib_Cornering(), calib_flowrate(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_pa(), calib_retraction(), calib_temp(), calib_VFA(), and load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_bed_types()

void Slic3r::GUI::Plater::normalize_bed_types

(

bool

printer_setting_changed

)

{
    if (only_gcode_mode() || is_gcode_3mf())
        return;
 
    auto &preset_bundle = *wxGetApp().preset_bundle;
    // Keep FFF plate settings intact while an SLA printer is selected.
    if (preset_bundle.printers.get_edited_preset().printer_technology() != ptFFF)
        return;
 
    const auto &printer_config = preset_bundle.printers.get_edited_preset().config;
 
    const bool supports_multiple_bed_types =
        preset_bundle.is_bbl_vendor() || printer_config.opt_bool("support_multi_bed_types");
    // Clear local overrides for single-bed printers.
    const bool overrides_reset = !supports_multiple_bed_types &&
        !p->partplate_list.check_all_plate_local_bed_type({});
 
    if (overrides_reset) {
        set_plater_dirty(true);
        show_info(this,
                  _L("The selected printer does not support multiple bed types.\nBed type overrides were reset to the global bed type."),
                  _L("Plate bed types reset"));
    }
 
    // Refresh the controls after a capability change, even when no override was reset.
    if (multi_bed_changed || overrides_reset) {
        sidebar().update_all_preset_comboboxes();
        wxGetApp().obj_list()->update_and_show_object_settings_item();
    }
}

References _L, is_gcode_3mf(), only_gcode_mode(), p, Slic3r::GUI::printer_config(), Slic3r::ptFFF, set_plater_dirty(), Slic3r::GUI::show_info(), sidebar(), and Slic3r::GUI::Sidebar::update_all_preset_comboboxes().

Referenced by load_project().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_painting_removed()

void Slic3r::GUI::Plater::notify_painting_removed

(

)

{
    get_notification_manager()->push_notification(
                NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
                NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                _u8L("Custom supports and color painting were removed before repairing."));
}

References _u8L, Slic3r::GUI::CustomSupportsAndSeamRemovedAfterRepair, get_notification_manager(), Slic3r::GUI::NotificationManager::PrintInfoNotificationLevel, and Slic3r::GUI::NotificationManager::push_notification().

Referenced by clear_before_change_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

object_list_changed()

void Slic3r::GUI::Plater::object_list_changed

(

)

{ p->object_list_changed(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::delete_all_objects_from_model(), Slic3r::GUI::Plater::priv::delete_object_from_model(), Slic3r::GUI::Plater::priv::remove(), and Slic3r::GUI::Plater::priv::reset().

Here is the caller graph for this function:

object_menu()

wxMenu * Slic3r::GUI::Plater::object_menu

(

)

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

References p.

on_activate()

void Slic3r::GUI::Plater::on_activate

(

)

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

References p.

on_bed_type_change()

void Slic3r::GUI::Plater::on_bed_type_change

(

BedType

bed_type

)

{
    sidebar().on_bed_type_change(bed_type);
}

References Slic3r::GUI::Sidebar::on_bed_type_change(), and sidebar().

Referenced by load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

void Slic3r::GUI::Plater::on_change_color_mode

(

SimpleEvent &

evt

)

References config(), and model().

Here is the call 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;
    bool exclusion_preview_changed = false;
    bool imex_changed = false;
    //bool print_sequence_changed = false;
    t_config_option_keys diff_keys = p->config->diff(config);
 
    size_t old_nozzle_size = 1, new_nozzle_size = 1;
    auto * opt_old = p->config->option<ConfigOptionFloats>("nozzle_diameter");
    auto * opt_new = config.option<ConfigOptionFloats>("nozzle_diameter");
    if (opt_old && opt_new) {
        old_nozzle_size = opt_old->values.size();
        new_nozzle_size = opt_new->values.size();
    }
 
    for (auto opt_key : diff_keys) {
        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->update_mixed_filament_list();
                p->partplate_list.invalidate_exclusion_volume_previews();
                p->sidebar->obj_list()->update_filament_colors();
                p->sidebar->update_dynamic_filament_list();
                continue;
            }
        }
        if (opt_key == "filament_type") {
            update_filament_colors_in_full_config();
            p->sidebar->update_mixed_filament_list();
            continue;
        }
        // The mixed-filament type check folds filament_is_support into the component type
        // (DynamicPrintConfig::get_filament_type -> "PLA-S"), so a support-preset switch must
        // refresh the list even though filament_type itself did not change.
        if (opt_key == "filament_is_support") {
            p->config->set_key_value(opt_key, config.option(opt_key)->clone());
            p->sidebar->update_mixed_filament_list();
            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 == "bed_exclude_volume_mode" || opt_key == "bed_exclude_area" ||
            opt_key == "bed_exclude_volumes" || opt_key == "extruder_bed_exclude_volumes" || opt_key == "extruder_offset" ||
            opt_key == "master_extruder_id" || opt_key == "nozzle_diameter" ||
            opt_key == "printable_height" || opt_key == "extruder_colour")
            exclusion_preview_changed = true;
 
        if (opt_key == "printer_technology") {
            this->set_printer_technology(config.opt_enum<PrinterTechnology>(opt_key));
            // print technology is changed, so we should to update a search list
            p->sidebar->update_searcher();
            p->reset_gcode_toolpaths();
            p->view3D->get_canvas3d()->reset_sequential_print_clearance();
            p->preview->get_canvas3d()->reset_volumes();
            //BBS: invalid all the slice results
            p->partplate_list.invalid_all_slice_result();
        }
        //BBS: add bed_exclude_area
        else if (opt_key == "printable_area" || opt_key == "bed_exclude_volume_mode" || opt_key == "bed_exclude_area"
            || opt_key == "bed_exclude_volumes" || opt_key == "extruder_bed_exclude_volumes" || opt_key == "extruder_offset"
            || opt_key == "bed_custom_texture" || opt_key == "bed_custom_model"
            || opt_key == "extruder_clearance_height_to_lid"
            || opt_key == "extruder_clearance_height_to_rod") {
            bed_shape_changed = true;
            update_scheduled = true;
        }
        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, "enable_prime_tower") ||
            boost::starts_with(opt_key, "prime_tower") ||
            boost::starts_with(opt_key, "wipe_tower") ||
            opt_key == "filament_minimal_purge_on_wipe_tower" ||
            opt_key == "single_extruder_multi_material" ||
            // BBS
            opt_key == "prime_volume") {
            update_scheduled = true;
        }
        else if(opt_key == "extruder_colour") {
            update_scheduled = true;
            p->partplate_list.invalidate_exclusion_volume_previews();
            //p->sidebar->obj_list()->update_extruder_colors();
        }
        else if (opt_key == "printable_height") {
            bed_shape_changed = true;
            update_scheduled = true;
        }
        else if (opt_key == "print_sequence") {
            update_scheduled = true;
            //print_sequence_changed = true;
        }
        else if (opt_key == "printer_model") {
            p->reset_gcode_toolpaths();
            if (old_nozzle_size != new_nozzle_size) {
                update_flush_volume_matrix(old_nozzle_size, new_nozzle_size);
            }
 
            // update to force bed selection(for texturing)
            bed_shape_changed = true;
            update_scheduled = true;
        }
        // Orca: update when *_filament changed
        else if (opt_key == "support_interface_filament" || opt_key == "support_filament" ||
                 opt_key == "outer_wall_filament_id" || opt_key == "inner_wall_filament_id" ||
                 opt_key == "sparse_infill_filament_id" || opt_key == "internal_solid_filament_id" ||
                 opt_key == "top_surface_filament_id" || opt_key == "bottom_surface_filament_id" ||
                 opt_key == "enable_support" || opt_key == "raft_layers" || opt_key == "wall_loops" ||
                 opt_key == "sparse_infill_density" || opt_key == "top_shell_layers" ||
                 opt_key == "bottom_shell_layers" || opt_key == "brim_type" || opt_key == "brim_width") {
            update_scheduled = true;
            p->partplate_list.invalidate_exclusion_volume_previews();
        }
        // IDEX/IQEX: when is_imex toggles the mode icon needs to be repositioned on every plate.
        // set_shape() short-circuits when the bed geometry is unchanged, so we refresh explicitly.
        // Defer until after the loop so bed_shape_changed / set_bed_shape() run first if needed.
        else if (opt_key == "is_imex") {
            imex_changed = true;
            update_scheduled = true;
        }
        // Orca: the center of mass markers weigh the parts by it.
        else if (opt_key == "filament_density" && wxGetApp().show_center_of_mass())
            p->view3D->get_canvas3d()->set_as_dirty();
    }
 
    if (bed_shape_changed) {
        set_bed_shape();
        get_current_canvas3D()->requires_check_outside_state();
    }
 
    if (exclusion_preview_changed)
        p->partplate_list.invalidate_exclusion_volume_previews();
 
    if (bed_shape_changed || exclusion_preview_changed)
        get_current_canvas3D()->request_extra_frame();
 
    // After any bed-shape or is_imex change, ensure the IMEX mode icon geometry and
    // raycaster are correct.  set_shape() short-circuits when the bed is unchanged,
    // so we call refresh_imex_icons() explicitly whenever is_imex is active.
    // Always done AFTER set_bed_shape() so m_shape is current.
    if (bed_shape_changed || imex_changed) {
        auto* is_imex_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionBool>("is_imex");
        if (is_imex_opt && is_imex_opt->value)
            p->partplate_list.refresh_imex_icons();
    }
 
    config_change_notification(config, std::string("print_sequence"));
 
    if (update_scheduled)
        update();
 
    if (p->main_frame->is_loaded()) {
        this->p->schedule_background_process();
        update_title_dirty_status();
        p->schedule_auto_reslice_if_needed();
    }
}

References config(), config_change_notification(), get_current_canvas3D(), Slic3r::DynamicConfig::opt_enum(), p, Slic3r::GUI::GLCanvas3D::request_extra_frame(), Slic3r::GUI::GLCanvas3D::requires_check_outside_state(), set_bed_shape(), set_printer_technology(), update(), update_filament_colors_in_full_config(), update_flush_volume_matrix(), update_title_dirty_status(), and Slic3r::ConfigOptionVector< double >::values.

Here is the call graph for this function:

on_filament_change()

void Slic3r::GUI::Plater::on_filament_change

(

size_t

filament_idx

)

{
    auto& filament_presets = wxGetApp().preset_bundle->filament_presets;
    if (filament_idx >= filament_presets.size())
        return;
    Slic3r::Preset* filament = wxGetApp().preset_bundle->filaments.find_preset(filament_presets[filament_idx]);
    if (filament == nullptr)
        return;
    std::string filament_type = filament->config.option<ConfigOptionStrings>("filament_type")->values[0];
}

References Slic3r::Preset::config, Slic3r::filament_type(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target().

Here is the call graph for this function:

Here is the caller graph for this function:

on_filament_count_change()

void Slic3r::GUI::Plater::on_filament_count_change

(

size_t

extruders_count

)

{
    // only update elements in plater
    update_filament_colors_in_full_config();
    sidebar().on_filament_count_change(num_filaments);
    sidebar().obj_list()->update_objects_list_filament_column(num_filaments);
 
    Slic3r::GUI::PartPlateList &plate_list = get_partplate_list();
    plate_list.set_filament_count(num_filaments);
    for (int i = 0; i < plate_list.get_plate_count(); ++i) {
        PartPlate* part_plate = plate_list.get_plate(i);
        part_plate->update_first_layer_print_sequence(num_filaments);
    }
 
    for (ModelObject* mo : wxGetApp().model().objects) {
        for (ModelVolume* mv : mo->volumes) {
            mv->update_extruder_count(num_filaments);
        }
    }
}

References get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), model(), Slic3r::GUI::Sidebar::obj_list(), Slic3r::GUI::Sidebar::on_filament_count_change(), Slic3r::GUI::PartPlateList::set_filament_count(), sidebar(), Slic3r::ModelVolume::update_extruder_count(), update_filament_colors_in_full_config(), Slic3r::GUI::PartPlate::update_first_layer_print_sequence(), Slic3r::GUI::ObjectList::update_objects_list_filament_column(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

on_filament_map_mode_change()

void Slic3r::GUI::Plater::on_filament_map_mode_change ( )

private

{
    auto& plate_list = this->get_partplate_list();
    int plate_count = plate_list.get_plate_count();
    for (int idx = 0; idx < plate_count; ++idx) {
        auto plate=plate_list.get_plate(idx);
        auto plate_map_mode = plate->get_filament_map_mode();
        if (plate_map_mode == fmmDefault)
            plate->clear_filament_map();
    }
}

References Slic3r::fmmDefault, and get_partplate_list().

Referenced by set_global_filament_map_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

on_filaments_delete()

void Slic3r::GUI::Plater::on_filaments_delete	(	size_t	extruders_count,
		size_t	filament_id,
		int	replace_filament_id = -1,
		const std::vector< unsigned char > &	is_mixed_before_delete = {} )

{
    // only update elements in plater
    update_filament_colors_in_full_config();
 
    // update fisrt print sequence and other layer sequence
    //move to partplate->on_filament_deleted
    /*Slic3r::GUI::PartPlateList &plate_list = get_partplate_list();
    for (int i = 0; i < plate_list.get_plate_count(); ++i) {
        PartPlate *part_plate = plate_list.get_plate(i);
        part_plate->update_first_layer_print_sequence_when_delete_filament(filament_id);
    }*/
 
    // update mmu info
    // A volume assigned to a mixed slot legitimately sits past the physical filament count, so
    // the paint cleanup must know which slots were mixed. Callers that already shrank the arrays
    // pass the pre-delete flags; otherwise read the current ones.
    const auto &is_mixed = is_mixed_before_delete.empty()
        ? wxGetApp().preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed")->values
        : is_mixed_before_delete;
    for (ModelObject *mo : wxGetApp().model().objects) {
        for (ModelVolume *mv : mo->volumes) {
            mv->update_extruder_count_when_delete_filament(num_filaments, filament_id + 1, replace_filament_id + 1, is_mixed);  // this function is 1 base
        }
    }
 
    // update object/volume/support(object and volume) filament id
    // Must run before UI update which triggers update_mixed_filament_list() →
    // update_objects_list_filament_column() that clips extruders above total count.
    sidebar().obj_list()->update_objects_list_filament_column_when_delete_filament(filament_id, num_filaments, replace_filament_id);
 
    // update global support filament
    static const char *keys[] = {"support_filament", "support_interface_filament"};
    for (auto key : keys)
        if (p->config->has(key)) {
            if(p->config->opt_int(key) == filament_id + 1)
                (*(p->config)).erase(key);
            else {
                int new_value = p->config->opt_int(key) > filament_id ? p->config->opt_int(key) - 1 : p->config->opt_int(key);
                (*(p->config)).set_key_value(key, new ConfigOptionInt(new_value));
            }
        }
 
    // update UI — runs after remap so update_mixed_filament_list() won't clip remapped extruder IDs
    sidebar().on_filaments_delete(filament_id);
 
    // update customize gcode
    for (auto item = p->model.plates_custom_gcodes.begin(); item != p->model.plates_custom_gcodes.end(); ++item) {
        auto iter = std::remove_if(item->second.gcodes.begin(), item->second.gcodes.end(), [filament_id](const CustomGCode::Item& gcode_item) {
            return (gcode_item.type == CustomGCode::Type::ToolChange && gcode_item.extruder == filament_id + 1);
        });
        if (replace_filament_id == -1)
            item->second.gcodes.erase(iter, item->second.gcodes.end());
        else if(iter != item->second.gcodes.end()) {
            iter->extruder = replace_filament_id + 1;
        }
 
        for (auto& item : item->second.gcodes) {
            if (item.type == CustomGCode::Type::ToolChange && item.extruder > filament_id)
                item.extruder--;
        }
    }
}

References model(), Slic3r::GUI::Sidebar::obj_list(), Slic3r::GUI::Sidebar::on_filaments_delete(), p, sidebar(), Slic3r::CustomGCode::ToolChange, Slic3r::ModelVolume::update_extruder_count_when_delete_filament(), update_filament_colors_in_full_config(), Slic3r::GUI::ObjectList::update_objects_list_filament_column_when_delete_filament(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

on_imex_ghost_click()

void Slic3r::GUI::Plater::on_imex_ghost_click

(

int

physical_head

)

{
    const ConfigOptionInts pem = effective_physical_extruder_map(*wxGetApp().preset_bundle);
 
    int lane_count = 0;
    for (int pv : pem.values) if (pv == physical_head) ++lane_count;
    if (lane_count < 2) return;  // single-lane head -> click is a no-op, tooltip conveyed status
 
    PartPlate* plate = p->partplate_list.get_curr_plate();
    if (!plate) return;
 
    auto* picker = new IMEXFilamentPickerPopover(
        p->view3D->get_canvas3d()->get_wxglcanvas(),
        plate, pem, physical_head,
        [this]() {
            take_snapshot("edit imex head filament");
            update_project_dirty_from_presets();
            set_plater_dirty(true);
            update();
        });
    picker->popup_at_cursor();
}

References Slic3r::effective_physical_extruder_map(), p, and Slic3r::ConfigOptionVector< int >::values.

Here is the call graph for this function:

only_gcode_mode()

bool Slic3r::GUI::Plater::only_gcode_mode ( )

inline

{ return m_only_gcode; }

References m_only_gcode.

Referenced by normalize_bed_types().

Here is the caller graph for this function:

open_3mf_file()

bool Slic3r::GUI::Plater::open_3mf_file

(

const boost::filesystem::path &

file_path

)

{
    std::string filename = encode_path(file_path.filename().string().c_str());
    if (!boost::algorithm::iends_with(filename, ".3mf")) {
        return false;
    }
 
    bool not_empty_plate = !model().objects.empty();
    bool load_setting_ask_when_relevant = wxGetApp().app_config->get(SETTING_PROJECT_LOAD_BEHAVIOUR) == OPTION_PROJECT_LOAD_BEHAVIOUR_ASK_WHEN_RELEVANT;
    LoadType load_type = determine_load_type(filename, (not_empty_plate && load_setting_ask_when_relevant) ? OPTION_PROJECT_LOAD_BEHAVIOUR_ALWAYS_ASK : "");
 
    if (load_type == LoadType::Unknown) return false;
 
    switch (load_type) {
        case LoadType::OpenProject: {
            if (wxGetApp().can_load_project())
                load_project(from_path(file_path), "<loadall>");
            break;
        }
        case LoadType::LoadGeometry: {
            Plater::TakeSnapshot snapshot(this, "Import Object");
            load_files({file_path}, LoadStrategy::LoadModel);
            break;
        }
        case LoadType::LoadConfig: {
            load_files({file_path}, LoadStrategy::LoadConfig);
            break;
        }
        case LoadType::Unknown: {
            assert(false);
            break;
        }
    }
 
    return true;
}

References Slic3r::GUI::determine_load_type(), Slic3r::encode_path(), Slic3r::GUI::from_path(), load_files(), load_project(), Slic3r::GUI::LoadConfig, Slic3r::LoadConfig, Slic3r::GUI::LoadGeometry, Slic3r::LoadModel, model(), Slic3r::Model::objects, Slic3r::GUI::OpenProject, OPTION_PROJECT_LOAD_BEHAVIOUR_ALWAYS_ASK, OPTION_PROJECT_LOAD_BEHAVIOUR_ASK_WHEN_RELEVANT, SETTING_PROJECT_LOAD_BEHAVIOUR, and Slic3r::GUI::Unknown.

Referenced by add_file(), and load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

open_filament_map_setting_dialog()

void Slic3r::GUI::Plater::open_filament_map_setting_dialog

(

wxCommandEvent &

evt

)

{
    PartPlate* curr_plate = p->partplate_list.get_curr_plate();
    int value = evt.GetInt(); //1 means from gcode view
    bool need_slice = value ==1;  // If from gcode view, should slice
 
    const auto& project_config = wxGetApp().preset_bundle->project_config;
    auto filament_colors = config()->option<ConfigOptionStrings>("filament_colour")->values;
    auto filament_types = config()->option<ConfigOptionStrings>("filament_type")->values;
 
    auto plate_filament_maps = curr_plate->get_real_filament_maps(project_config);
    auto plate_filament_map_mode = curr_plate->get_filament_map_mode();
    auto plate_filament_volume_maps = curr_plate->get_real_filament_volume_maps(project_config);
    if (plate_filament_maps.size() != filament_colors.size())  // refine it later, save filament map to app config
        plate_filament_maps.resize(filament_colors.size(), 1);
    if (plate_filament_volume_maps.size() != filament_colors.size())
        plate_filament_volume_maps.resize(filament_colors.size(), 0);
 
    FilamentMapDialog filament_dlg(this,
        filament_colors,
        filament_types,
        plate_filament_maps,
        plate_filament_volume_maps,
        curr_plate->get_extruders(true),
        plate_filament_map_mode,
        this->get_machine_sync_status(),
        false
    );
 
    if (filament_dlg.ShowModal() == wxID_OK) {
        std::vector<int> new_filament_maps = filament_dlg.get_filament_maps();
        std::vector<int> old_filament_maps = curr_plate->get_real_filament_maps(project_config);
 
        FilamentMapMode  old_map_mode = curr_plate->get_filament_map_mode();
        FilamentMapMode  new_map_mode = filament_dlg.get_mode();
 
        std::vector<int> new_filament_volume_maps = filament_dlg.get_filament_volume_maps();
        std::vector<int> old_filament_volume_maps = curr_plate->get_real_filament_volume_maps(project_config);
 
        if (new_map_mode != old_map_mode) {
            curr_plate->set_filament_map_mode(new_map_mode);
        }
 
        if (new_map_mode == fmmManual){
            curr_plate->set_filament_maps(new_filament_maps);
            curr_plate->set_filament_volume_maps(new_filament_volume_maps);
        }
 
        bool need_invalidate = (old_map_mode != new_map_mode ||
                                old_filament_maps != new_filament_maps ||
                                old_filament_volume_maps != new_filament_volume_maps);
 
        if (need_invalidate) {
            if (need_slice) {
                wxPostEvent(this, SimpleEvent(EVT_GLTOOLBAR_SLICE_PLATE));
            }
            else {
                curr_plate->update_slice_result_valid_state(false);
                set_plater_dirty(true);
                update();
            }
        }
    }
    return;
}

References config(), Slic3r::GUI::filament_types, Slic3r::fmmManual, Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_filament_map_mode(), Slic3r::GUI::FilamentMapDialog::get_filament_maps(), Slic3r::GUI::FilamentMapDialog::get_filament_volume_maps(), Slic3r::GUI::FilamentMapDialog::get_mode(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::get_real_filament_volume_maps(), Slic3r::ConfigBase::option(), p, Slic3r::ConfigOptionVector< T >::resize(), Slic3r::GUI::PartPlate::set_filament_map_mode(), Slic3r::GUI::PartPlate::set_filament_maps(), Slic3r::GUI::PartPlate::set_filament_volume_maps(), set_plater_dirty(), Slic3r::GUI::FilamentMapDialog::ShowModal(), Slic3r::ConfigOptionVector< T >::size(), update(), and Slic3r::GUI::PartPlate::update_slice_result_valid_state().

Here is the call graph for this function:

open_platesettings_dialog()

void Slic3r::GUI::Plater::open_platesettings_dialog

(

wxCommandEvent &

evt

)

                                                          {
    int plate_index = evt.GetInt();
    PlateSettingsDialog dlg(this, _L("Plate Settings"), evt.GetString() == "only_layer_sequence");
    PartPlate* curr_plate = p->partplate_list.get_curr_plate();
    dlg.sync_bed_type(curr_plate->get_bed_type());
 
    auto curr_print_seq = curr_plate->get_print_seq();
    if (curr_print_seq != PrintSequence::ByDefault) {
        dlg.sync_print_seq(int(curr_print_seq) + 1);
    }
    else
        dlg.sync_print_seq(0);
 
    auto first_layer_print_seq = curr_plate->get_first_layer_print_sequence();
    if (first_layer_print_seq.empty())
        dlg.sync_first_layer_print_seq(0);
    else
        dlg.sync_first_layer_print_seq(1, curr_plate->get_first_layer_print_sequence());
 
    auto other_layers_print_seq = curr_plate->get_other_layers_print_sequence();
    if (other_layers_print_seq.empty())
        dlg.sync_other_layers_print_seq(0, {});
    else {
        dlg.sync_other_layers_print_seq(1, curr_plate->get_other_layers_print_sequence());
    }
 
    dlg.sync_spiral_mode(curr_plate->get_spiral_vase_mode(), !curr_plate->has_spiral_mode_config());
 
    dlg.Bind(EVT_SET_BED_TYPE_CONFIRM, [this, plate_index, &dlg](wxCommandEvent& e) {
        PartPlate* curr_plate = p->partplate_list.get_curr_plate();
        BedType old_bed_type = curr_plate->get_bed_type();
        auto bt_sel = dlg.get_bed_type_choice();
        if (old_bed_type != bt_sel) {
            curr_plate->set_bed_type(bt_sel);
            update_project_dirty_from_presets();
            set_plater_dirty(true);
        }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("select bed type %1% for plate %2% at plate side") % bt_sel % plate_index;
 
        if (dlg.get_first_layer_print_seq_choice() != 0)
            curr_plate->set_first_layer_print_sequence(dlg.get_first_layer_print_seq());
        else
            curr_plate->set_first_layer_print_sequence({});
 
        if (dlg.get_other_layers_print_seq_choice() != 0)
            curr_plate->set_other_layers_print_sequence(dlg.get_other_layers_print_seq_infos());
        else
            curr_plate->set_other_layers_print_sequence({});
 
        int ps_sel = dlg.get_print_seq_choice();
        if (ps_sel != 0)
            curr_plate->set_print_seq(PrintSequence(ps_sel - 1));
        else
            curr_plate->set_print_seq(PrintSequence::ByDefault);
 
        int spiral_sel = dlg.get_spiral_mode_choice();
        if (spiral_sel == 1) {
            curr_plate->set_spiral_vase_mode(true, false);
        }
        else if (spiral_sel == 2) {
            curr_plate->set_spiral_vase_mode(false, false);
        }
        else {
            curr_plate->set_spiral_vase_mode(false, true);
        }
 
        update_project_dirty_from_presets();
        set_plater_dirty(true);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("select print sequence %1% for plate %2% at plate side") % ps_sel % plate_index;
        auto plate_config = *(curr_plate->config());
        wxGetApp().plater()->config_change_notification(plate_config, std::string("print_sequence"));
        update();
        wxGetApp().obj_list()->update_selections();
        });
    dlg.set_plate_name(from_u8(curr_plate->get_plate_name()));
 
    dlg.ShowModal();
    curr_plate->set_plate_name(dlg.get_plate_name().ToUTF8().data());
}

References _L, Slic3r::ByDefault, Slic3r::GUI::PartPlate::config(), Slic3r::GUI::from_u8(), Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::GUI::PlateSettingsDialog::get_bed_type_choice(), Slic3r::GUI::PlateSettingsDialog::get_first_layer_print_seq(), Slic3r::GUI::PlateSettingsDialog::get_first_layer_print_seq_choice(), Slic3r::GUI::PartPlate::get_first_layer_print_sequence(), Slic3r::GUI::PlateSettingsDialog::get_other_layers_print_seq_choice(), Slic3r::GUI::PlateSettingsDialog::get_other_layers_print_seq_infos(), Slic3r::GUI::PartPlate::get_other_layers_print_sequence(), Slic3r::GUI::PartPlate::get_plate_name(), Slic3r::GUI::PlateSettingsDialog::get_plate_name(), Slic3r::GUI::PartPlate::get_print_seq(), Slic3r::GUI::PlateSettingsDialog::get_print_seq_choice(), Slic3r::GUI::PlateSettingsDialog::get_spiral_mode_choice(), Slic3r::GUI::PartPlate::get_spiral_vase_mode(), Slic3r::GUI::PartPlate::has_spiral_mode_config(), p, Slic3r::GUI::PartPlate::set_bed_type(), Slic3r::GUI::PartPlate::set_first_layer_print_sequence(), Slic3r::GUI::PartPlate::set_other_layers_print_sequence(), Slic3r::GUI::PartPlate::set_plate_name(), Slic3r::GUI::PlateSettingsDialog::set_plate_name(), set_plater_dirty(), Slic3r::GUI::PartPlate::set_print_seq(), Slic3r::GUI::PartPlate::set_spiral_vase_mode(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::PlateSettingsDialog::sync_bed_type(), Slic3r::GUI::PlateSettingsDialog::sync_first_layer_print_seq(), Slic3r::GUI::PlateSettingsDialog::sync_other_layers_print_seq(), Slic3r::GUI::PlateSettingsDialog::sync_print_seq(), Slic3r::GUI::PlateSettingsDialog::sync_spiral_mode(), update(), and update_project_dirty_from_presets().

Here is the call graph for this function:

operator=() [1/2]

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

delete

References Plater().

Here is the call graph for this function:

operator=() [2/2]

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

delete

References Plater().

Here is the call graph for this function:

optimize_rotation()

void Slic3r::GUI::Plater::optimize_rotation

(

)

{
    auto &w = get_ui_job_worker();
    if (w.is_idle()) {
        p->take_snapshot(_u8L("Optimize Rotation"));
        replace_job(w, std::make_unique<OrientJob>());
    }
}

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

Here is the call graph for this function:

orient()

void Slic3r::GUI::Plater::orient

(

)

{
    auto &w = get_ui_job_worker();
    if (w.is_idle()) {
        p->take_snapshot(_u8L("Orient"));
        replace_job(w, std::make_unique<OrientJob>());
    }
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

part_menu()

wxMenu * Slic3r::GUI::Plater::part_menu

(

)

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

References p.

paste_from_clipboard()

void Slic3r::GUI::Plater::paste_from_clipboard

(

)

{
    if (!can_paste_from_clipboard())
        return;
 
    Plater::TakeSnapshot snapshot(this, "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 can_paste_from_clipboard(), and p.

Here is the call graph for this function:

physical_filament_config_indices()

std::vector< size_t > Slic3r::GUI::Plater::physical_filament_config_indices

(

)

const

{
    std::vector<size_t> indices;
    auto& config = wxGetApp().preset_bundle->project_config;
    auto* opt = config.option<ConfigOptionBools>("filament_is_mixed");
    size_t total = wxGetApp().preset_bundle->filament_presets.size();
    for (size_t i = 0; i < total; ++i) {
        if (!opt || i >= opt->values.size() || !opt->values[i])
            indices.push_back(i);
    }
    return indices;
}

References config().

Here is the call graph for this function:

plate_menu()

wxMenu * Slic3r::GUI::Plater::plate_menu

(

)

{ return p->menus.plate_menu();             }

References p.

plate_toolbar_image_version()

unsigned Slic3r::GUI::Plater::plate_toolbar_image_version ( ) const

inline

{ return m_plate_toolbar_image_version; }

References m_plate_toolbar_image_version.

plugins_block_slicing()

bool Slic3r::GUI::Plater::plugins_block_slicing

(

)

const

{
    // Single source of truth: slicing is blocked while PluginResolver still has unresolved plugin
    // references — missing (download), inactive (activate), or broken (capability unavailable).
    return has_missing_plugins() || has_inactive_plugins() || has_broken_plugins();
}

References Slic3r::has_broken_plugins(), Slic3r::has_inactive_plugins(), and Slic3r::has_missing_plugins().

Here is the call graph for this function:

pop_warning_and_go_to_device_page()

void Slic3r::GUI::Plater::pop_warning_and_go_to_device_page	(	wxString	printer_name,
		PrinterWarningType	type,
		const wxString &	title )

{
    printer_name.Replace("Bambu Lab", "", false);
    wxString content;
    MainFrame* frame       = wxGetApp().mainframe;
    bool       device_page = frame != nullptr && frame->m_monitor_page->in_book();
    if (type == PrinterWarningType::NOT_CONNECTED) {
        if (device_page) {
            content = wxString::Format(_L("Printer not connected. Please go to the device page to connect %s before syncing."),
                                       printer_name);
        } else {
            content = wxString::Format(
                _L("OrcaSlicer can't connect to %s. Please check if the printer is powered on and connected to the network."), printer_name);
        }
    } else if (type == PrinterWarningType::INCONSISTENT) {
        content = wxString::Format(_L("The currently connected printer on the device page is not %s. Please switch to %s before syncing."), printer_name, printer_name);
    } else if (type == PrinterWarningType::UNINSTALL_FILAMENT) {
        content = _L("There are no filaments on the printer. Please load the filaments on the printer first.");
    } else if (type == PrinterWarningType::EMPTY_FILAMENT) {
        content = _L("The filaments on the printer are all unknown types. Please go to the printer screen or software device page to set the filament type.");
    }
    MessageDialog dlg(this, content, title, wxOK | wxFORWARD | wxICON_WARNING, _L("Device Page"));
    auto          result = dlg.ShowModal();
    if (result == wxFORWARD) {
        wxGetApp().mainframe->select_tab(TAB_ID_MONITOR);
    }
}

References _L, EMPTY_FILAMENT, INCONSISTENT, Slic3r::GUI::MainFrame::m_monitor_page, NOT_CONNECTED, Slic3r::GUI::DPIAware< P >::ShowModal(), TAB_ID_MONITOR, and UNINSTALL_FILAMENT.

Referenced by check_printer_initialized(), and is_same_printer_for_connected_and_selected().

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 = wxGetApp().mainframe->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, Slic3r::GUI::show_error(), and SuppressBackgroundProcessingUpdate.

Here is the call graph for this function:

PopupMenu() [2/2]

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

inline

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

References PopupMenu().

Referenced by PopupMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

PopupObjectTable()

bool Slic3r::GUI::Plater::PopupObjectTable	(	int	object_id,
		int	volume_id,
		const wxPoint &	position )

{
    if (dynamic_cast<TabPrinter *>(wxGetApp().get_tab(Preset::TYPE_PRINTER))->m_extruders_count > 1) {
        MessageDialog dlg(this, _L("Currently, the object configuration form cannot be used with a multiple-extruder printer."), _L("Not available"), wxOK | wxICON_WARNING);
        dlg.ShowModal();
        return false;
    }
    return p->PopupObjectTable(object_id, volume_id, position);
}

References _L, p, Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::Preset::TYPE_PRINTER.

Here is the call graph for this function:

PopupObjectTableBySelection()

bool Slic3r::GUI::Plater::PopupObjectTableBySelection

(

)

{
    wxDataViewItem item;
    int obj_idx, vol_idx;
    const wxPoint pos = wxPoint(0, 0);  //Fake position
    wxGetApp().obj_list()->get_selected_item_indexes(obj_idx, vol_idx, item);
    return p->PopupObjectTable(obj_idx, vol_idx, pos);
}

References p.

post_process_string_object_exception()

void Slic3r::GUI::Plater::post_process_string_object_exception

(

StringObjectException &

err

)

{
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (err.type == StringExceptionType::STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE) {
        try {
            int extruder_id = atoi(err.params[2].c_str()) - 1;
            if (extruder_id < preset_bundle->filament_presets.size()) {
                std::string filament_name = preset_bundle->filament_presets[extruder_id];
                // ORCA: Prefer the selected preset's alias/name and trim any @Printer suffix for display.
                for (auto filament_it = preset_bundle->filaments.begin(); filament_it != preset_bundle->filaments.end(); filament_it++) {
                    if (filament_it->name == filament_name) {
                        if (!filament_it->alias.empty()) {
                            filament_name = filament_it->alias;
                        } else {
                            char target = '@';
                            size_t pos  = filament_name.find(target);
                            if (pos != std::string::npos) {
                                filament_name = filament_name.substr(0, pos - 1);
                            }
                        }
                        break;
                    }
                }
                err.string = format(_L("Plate %d: %s is not suggested for use printing filament %s (%s). If you still want to do this print job, please set this filament\'s bed temperature to a number that is not zero."),
                             err.params[0], err.params[1], err.params[2], filament_name);
                err.string += "\n";
            }
        } catch (...) {
            ;
        }
    }
 
    return;
}

References _L, Slic3r::PresetCollection::begin(), Slic3r::PresetCollection::end(), Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::GUI::format(), Slic3r::StringObjectException::params, Slic3r::StringObjectException::string, Slic3r::STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE, and Slic3r::StringObjectException::type.

Referenced by validate_current_plate().

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 &

archive_path

)

{
    //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;
                        std::string name = Slic3r::decode_archive_entry_path(&archive, stat);
                        fs::path archive_path(name);
 
                        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 = path.extension().string();
                            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) {
                                // TRN: First argument = path to file, second argument = error description
                                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;
    }
 
    // 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);
        load_files(non_project_paths, LoadStrategy::LoadModel);
        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, LoadStrategy::LoadModel);
    load_files(non_project_paths, LoadStrategy::LoadModel);
 
 
    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::close_zip_reader(), Slic3r::decode_archive_entry_path(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), load_files(), Slic3r::LoadModel, Slic3r::open_zip_reader(), Slic3r::GUI::show_error(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

print_job_finished()

void Slic3r::GUI::Plater::print_job_finished

(

wxCommandEvent &

evt

)

{
    //start print failed
    if (p) {
#ifdef __APPLE__
        p->hide_select_machine_dlg();
#else
        if (Slic3r::GUI::wxGetApp().get_inf_dialog_contect().empty()) {
            p->hide_select_machine_dlg();
        } else {
            p->enter_prepare_mode();
        }
#endif // __APPLE__
    }
 
 
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    const std::string dev_id = evt.GetString().ToStdString();
    MachineObject* selected = dev->get_selected_machine();
    // After a LAN print, the completion event reselects the same printer.
    // Keep the active session while asynchronous status traffic may still be in flight.
    if (!selected || selected->get_dev_id() != dev_id || selected->connection_type() != "lan")
        dev->set_selected_machine(dev_id);
    p->main_frame->request_select_tab(TAB_ID_MONITOR);
    // Selects the status page on a built Device tab; one built by the switch starts there.
    MonitorPanel* curr_monitor = MonitorPanel::if_built();
    if(curr_monitor)
       curr_monitor->get_tabpanel()->ChangeSelection(MonitorPanel::PrinterTab::PT_STATUS);
}

References Tabbook::ChangeSelection(), Slic3r::MachineObject::connection_type(), Slic3r::empty(), Slic3r::MachineObject::get_dev_id(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::MonitorPanel::get_tabpanel(), Slic3r::GUI::LazyInstance< MonitorPanel >::if_built(), p, Slic3r::GUI::MonitorPanel::PT_STATUS, Slic3r::DeviceManager::set_selected_machine(), and TAB_ID_MONITOR.

Here is the call graph for this function:

printer_technology()

PrinterTechnology Slic3r::GUI::Plater::printer_technology

(

)

const

{
    return p->printer_technology;
}

References p.

Referenced by export_gcode(), export_toolpaths_to_obj(), reslice(), set_printer_technology(), Slic3r::GUI::MainFrame::technology_changed(), and Slic3r::GUI::MainFrame::update_menubar().

Here is the caller graph for this function:

redo()

void Slic3r::GUI::Plater::redo

(

)

{ p->redo(); }

References p.

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

void Slic3r::GUI::Plater::refresh_belt_view

(

)

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

References p.

refresh_missing_plugin_block()

bool Slic3r::GUI::Plater::refresh_missing_plugin_block

(

bool *

block_toggled = nullptr

)

{
    // PluginResolver owns the per-preset-type missing sets; rebuild them from each preset's own
    // "plugins" manifest so the state is always fresh. A plugin is resolved when it is
    // installed/loaded, or when no active setting references it any more (refresh drops it then).
    // The block is derived solely from PluginResolver; snapshot it before the refresh to detect a
    // toggle (so the caller can refresh the Slice button).
    const bool was_blocked = has_missing_plugins() || has_inactive_plugins() || has_broken_plugins();
    refresh_missing_plugins(*wxGetApp().preset_bundle);
 
    const auto missing_refs = [](const std::vector<MissingPlugin>& missing) {
        std::vector<std::string> refs;
        refs.reserve(missing.size());
        for (const MissingPlugin& m : missing)
            refs.emplace_back(create_full_ref(m.ref));
        return refs;
    };
 
    const auto signature = [&missing_refs](const std::vector<MissingPlugin>& missing) {
        std::vector<std::string> refs = missing_refs(missing);
        std::sort(refs.begin(), refs.end());
        std::string sig;
        for (const std::string& r : refs) { sig += r; sig += '\n'; }
        return sig;
    };
 
    // Show/refresh the non-closable notification for one missing set. Only (re)create it when the
    // set changes; pushing every validate would close+recreate it (flicker, reset hover) since
    // validate runs on many triggers. shown_sig also gates plugin-load re-validation.
    const auto update = [&](NotificationType type, const std::vector<MissingPlugin>& missing,
                            std::string* shown_sig, const std::string& header,
                            const std::string& resolve_label,
                            std::function<bool(wxEvtHandler*)> resolve_action) {
        if (missing.empty()) {
            if (!shown_sig->empty()) {
                p->notification_manager->close_notification_of_type(type);
                shown_sig->clear();
            }
            return;
        }
        const std::string sig = signature(missing);
        if (*shown_sig != sig) {
            std::vector<JumpTo> body;
            for (const auto& m : missing)
                body.emplace_back(JumpTo{m.ref.capability_name, m.opt, m.opt_type});
 
            p->notification_manager->push_plugin_missing_notification(
                type, header, resolve_label, std::move(body), std::move(resolve_action));
            *shown_sig = sig;
        }
    };
 
    const std::vector<MissingPlugin> missing_cloud = get_missing_cloud_plugins();
    const std::vector<MissingPlugin> missing_local = get_missing_local_plugins();
    const std::vector<std::string> missing_cloud_refs = missing_refs(missing_cloud);
    const std::vector<std::string> missing_local_refs = missing_refs(missing_local);
 
    update(NotificationType::OrcaCloudPluginMissingError, missing_cloud,
           &p->m_cloud_missing_shown_sig,
           _u8L("OrcaCloud plugins required by the current preset are not installed:"),
           _u8L("Install Plugins"),
           [this, missing_cloud_refs](wxEvtHandler*) { install_missing_cloud_plugins(missing_cloud_refs); return false; });
    // "Find on OrcaCloud" is only a suggestion: it opens the browser but cannot resolve the missing
    // plugin in-session, so it never closes the notification or unblocks slicing. The user resolves a
    // local plugin by installing it or by changing the setting that needs it.
    update(NotificationType::OrcaLocalPluginMissingError, missing_local,
           &p->m_local_missing_shown_sig,
           _u8L("Local plugins required by the current preset are missing:"),
           _u8L("Find on OrcaCloud"),
           [missing_local_refs](wxEvtHandler*) { open_missing_plugins_on_cloud(missing_local_refs); return false; });
 
    const std::vector<MissingPlugin> inactive      = get_inactive_plugins();
    const std::vector<MissingPlugin> broken        = get_broken_plugins();
    const std::vector<std::string>   inactive_refs = missing_refs(inactive);
    const std::vector<std::string>   broken_refs   = missing_refs(broken);
 
    update(NotificationType::OrcaPluginInactiveError, inactive,
           &p->m_inactive_shown_sig,
           _u8L("Plugins required by the current preset are not activated:"),
           _u8L("Activate Now"),
           [this, inactive_refs](wxEvtHandler*) { enable_inactive_plugins(inactive_refs); return false; });
    update(NotificationType::OrcaPluginCapabilityUnavailableError, broken,
           &p->m_broken_shown_sig,
           _u8L("The installed plugin does not provide the required capability — it may be outdated:"),
           _u8L("Find on OrcaCloud"),
           [broken_refs](wxEvtHandler*) { open_missing_plugins_on_cloud(broken_refs); return false; });
 
    const bool blocked = has_missing_plugins() || has_inactive_plugins() || has_broken_plugins();
    if (block_toggled)
        *block_toggled = (was_blocked != blocked);
    return blocked;
}

References _u8L, Slic3r::create_full_ref(), enable_inactive_plugins(), Slic3r::get_broken_plugins(), Slic3r::get_inactive_plugins(), Slic3r::get_missing_cloud_plugins(), Slic3r::get_missing_local_plugins(), Slic3r::has_broken_plugins(), Slic3r::has_inactive_plugins(), Slic3r::has_missing_plugins(), install_missing_cloud_plugins(), Slic3r::open_missing_plugins_on_cloud(), Slic3r::GUI::OrcaCloudPluginMissingError, Slic3r::GUI::OrcaLocalPluginMissingError, Slic3r::GUI::OrcaPluginCapabilityUnavailableError, Slic3r::GUI::OrcaPluginInactiveError, p, Slic3r::refresh_missing_plugins(), and update().

Referenced by reslice(), and validate_current_plate().

Here is the call graph for this function:

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.

reload_from_disk()

void Slic3r::GUI::Plater::reload_from_disk

(

)

{
    p->reload_from_disk();
}

References p.

Referenced by 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.

Here is the call graph for this function:

reload_paint_after_background_process_apply()

void Slic3r::GUI::Plater::reload_paint_after_background_process_apply

(

)

                                                         {
    p->preview->set_reload_paint_after_background_process_apply(true);
}

References p.

reload_print()

void Slic3r::GUI::Plater::reload_print

(

)

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

References p.

Referenced by select_plate(), and select_plate_by_hover_id().

Here is the caller graph for this function:

remove()

void Slic3r::GUI::Plater::remove

(

size_t

obj_idx

)

{ 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_curr_plate_all()

void Slic3r::GUI::Plater::remove_curr_plate_all

(

)

{ p->remove_curr_plate_all(); }

References p.

remove_dock_pane()

void Slic3r::GUI::Plater::remove_dock_pane

(

wxWindow *

window

)

{ p->remove_dock_pane(window); }

References p.

remove_dock_panes()

void Slic3r::GUI::Plater::remove_dock_panes

(

)

{
    while (!p->m_dock_panes.empty())
        p->remove_dock_pane(p->m_dock_panes.begin()->first);
}

References p.

remove_selected()

void Slic3r::GUI::Plater::remove_selected

(

)

{
    /*if (p->get_selection().is_empty())
        return;*/
    if (p->get_curr_selection().is_empty())
        return;
 
    // BBS: check before deleting object
    if (!p->can_delete())
        return;
 
    Plater::TakeSnapshot snapshot(this, "Delete Selected Objects");
    get_ui_job_worker().cancel_all();
 
    //BBS delete current selected
    // p->view3D->delete_selected();
    p->get_current_canvas3D()->delete_selected();
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

replace_all_with_stl()

void Slic3r::GUI::Plater::replace_all_with_stl

(

)

{
    p->replace_all_with_stl();
}

References p.

replace_with_stl()

void Slic3r::GUI::Plater::replace_with_stl

(

)

{
    p->replace_with_stl();
}

References p.

request_download_project()

void Slic3r::GUI::Plater::request_download_project

(

std::string

project_id

)

{
    wxCommandEvent* event = new wxCommandEvent(EVT_DOWNLOAD_PROJECT);
    event->SetString(project_id);
    wxQueueEvent(this, event);
}

request_model_download()

void Slic3r::GUI::Plater::request_model_download

(

wxString

url

)

{
    wxCommandEvent* event = new wxCommandEvent(EVT_IMPORT_MODEL_ID);
    event->SetString(url);
    wxQueueEvent(this, event);
}

reset()

void Slic3r::GUI::Plater::reset	(	bool	apply_presets_change = false,
		bool	reload_presets = true )

{ p->reset(apply_presets_change, reload_presets); }

References p.

Referenced by load_project(), 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.

reset_check_status()

void Slic3r::GUI::Plater::reset_check_status ( )

inline

{ m_check_status = 0; }

References m_check_status.

reset_gcode_toolpaths()

void Slic3r::GUI::Plater::reset_gcode_toolpaths

(

)

{
    //BBS: add some logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": reset the gcode viewer's toolpaths");
    p->reset_gcode_toolpaths();
}

References p.

Referenced by Slic3r::GUI::Plater::priv::delete_all_objects_from_model(), Slic3r::GUI::Plater::priv::reset(), reslice(), select_plate(), Slic3r::GUI::Plater::priv::set_current_panel(), 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

{ m_last_loaded_gcode = ""; }

References m_last_loaded_gcode.

reset_project_dirty_after_save()

void Slic3r::GUI::Plater::reset_project_dirty_after_save

(

)

{ p->reset_project_dirty_after_save(); }

References p.

Referenced by new_project(), and save_project().

Here is the caller graph for this function:

reset_project_dirty_initial_presets()

void Slic3r::GUI::Plater::reset_project_dirty_initial_presets

(

)

{ p->reset_project_dirty_initial_presets(); }

References p.

Referenced by load_gcode(), load_project(), and new_project().

Here is the caller graph for this function:

reset_window_layout()

void Slic3r::GUI::Plater::reset_window_layout

(

)

{
    p->reset_window_layout();
#ifdef SLIC3R_CAD
    // The Design tab docks its own sidebar.
    if (DesignPanel* design = DesignPanel::if_built())
        design->reset_window_layout();
#endif
}

References Slic3r::GUI::LazyInstance< DesignPanel >::if_built(), and p.

Here is the call graph for this function:

reset_with_confirm()

void Slic3r::GUI::Plater::reset_with_confirm

(

)

{
    if (p->model.objects.empty() || MessageDialog(static_cast<wxWindow *>(this), _L("All objects will be removed, continue?"),
                                                  wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Delete All"), wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxCENTRE)
                                            .ShowModal() == wxID_YES) {
        reset();
        // BBS: jump to plater panel
        wxGetApp().mainframe->select_tab(TAB_ID_HOME);
    }
}

References _L, p, reset(), SLIC3R_APP_FULL_NAME, and TAB_ID_HOME.

Here is the call graph for this function:

reslice()

void Slic3r::GUI::Plater::reslice

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: enter, process_completed_with_error=%2%")%__LINE__ %p->process_completed_with_error;
    // There is "invalid data" button instead "slice now"
    if (p->process_completed_with_error == p->partplate_list.get_curr_plate_index())
    {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": process_completed_with_error, return directly");
        reset_gcode_toolpaths();
        return;
    }
 
    // A mixed filament with deleted or type-mismatched components cannot be resolved at slicing
    // time. MainFrame::get_enable_slice_status() already disables the Slice button for it, but the
    // Preview-tab switch, auto-slice and queued slice events reach reslice() directly, so refuse
    // here too instead of letting the engine slice the broken slot as a plain filament.
    if (sidebar().has_broken_mixed_filament()) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": broken mixed filament detected, refuse to slice";
        return;
    }
 
    // In case SLA gizmo is in editing mode, refuse to continue
    // and notify user that he should leave it first.
    if (get_view3D_canvas3D()->get_gizmos_manager().is_in_editing_mode(true))
        return;
 
    // Enforce the missing-plugin block at the slicing choke point: menu/keyboard/queued triggers can
    // carry a stale enabled state while plugins load asynchronously. refresh_missing_plugin_block
    // rebuilds the missing sets and notifications from the active presets without running
    // Print::validate; all other validation keeps upstream behavior and is surfaced by
    // update_background_process() below.
    if (refresh_missing_plugin_block()) {
        p->partplate_list.get_curr_plate()->update_slice_ready_status(false);
        p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": required plugins missing; slicing blocked.";
        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;
    }
 
    // Orca: regenerate CalibPressureAdvancePattern custom G-code to apply changes
    if (model().calib_pa_pattern) {
        _calib_pa_pattern_gen_gcode();
    }
 
    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.
    //BBS: jusdge the result
    bool result = this->p->restart_background_process(state | priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: restart background,state=%2%, result=%3%")%__LINE__%state %result;
    if ((state & priv::UPDATE_BACKGROUND_PROCESS_INVALID) != 0)
    {
        //BBS: add logs
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": state %1% is UPDATE_BACKGROUND_PROCESS_INVALID, can not slice") % state;
        p->update_fff_scene_only_shells();
        return;
    }
 
    if ((!result) && p->m_slice_all && (p->m_cur_slice_plate < (p->partplate_list.get_plate_count() - 1)))
    {
        //slice next
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": in slicing all, current plate %1% already sliced, skip to next") % p->m_cur_slice_plate ;
        SlicingProcessCompletedEvent evt(EVT_PROCESS_COMPLETED, 0,
            SlicingProcessCompletedEvent::Finished, nullptr);
        // Post the "complete" callback message, so that it will slice the next plate soon
        wxQueueEvent(this, evt.Clone());
        p->m_is_slicing = true;
        if (p->m_cur_slice_plate == 0)
            reset_gcode_toolpaths();
        return;
    }
 
    if (result) {
        p->m_is_slicing = true;
    }
 
    bool clean_gcode_toolpaths = true;
    // BBS
    if (p->background_process.running())
    {
        //p->ready_to_slice = false;
        p->main_frame->update_slice_print_status(MainFrame::eEventSliceUpdate, false);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": background process is running, m_is_slicing is true");
    }
    else if (!p->background_process.empty() && !p->background_process.idle()) {
        //p->show_action_buttons(true);
        //p->ready_to_slice = true;
        p->main_frame->update_slice_print_status(MainFrame::eEventSliceUpdate, true);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": background process changes to not_idle, set ready_to_slice back to true");
    }
    else {
        //BBS: add reset logic for empty plate
        PartPlate * current_plate = p->background_process.get_current_plate();
 
        if (!current_plate->has_printable_instances()) {
            clean_gcode_toolpaths = true;
            current_plate->update_slice_result_valid_state(false);
        }
        else {
            clean_gcode_toolpaths = false;
            current_plate->update_slice_result_valid_state(true);
        }
        p->main_frame->update_slice_print_status(MainFrame::eEventSliceUpdate, false);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": background process in idle state, use previous result, clean_gcode_toolpaths=%1%")%clean_gcode_toolpaths;
    }
 
    if (clean_gcode_toolpaths)
        reset_gcode_toolpaths();
 
    p->preview->reload_print();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": finished, started slicing for plate %1%") % p->partplate_list.get_curr_plate_index();
}

References _calib_pa_pattern_gen_gcode(), Slic3r::SlicingProcessCompletedEvent::Clone(), Slic3r::GUI::MainFrame::eEventPlateUpdate, Slic3r::GUI::MainFrame::eEventSliceUpdate, Slic3r::SlicingProcessCompletedEvent::Finished, Slic3r::sla::Generating, get_ui_job_worker(), get_view3D_canvas3D(), Slic3r::GUI::PartPlate::has_printable_instances(), model(), Slic3r::sla::NoPoints, p, printer_technology(), Slic3r::ptSLA, refresh_missing_plugin_block(), reset_gcode_toolpaths(), sidebar(), Slic3r::GUI::stop_queue(), Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE, and Slic3r::GUI::PartPlate::update_slice_result_valid_state().

Referenced by select_plate(), Slic3r::GUI::Plater::priv::set_current_panel(), and Slic3r::GUI::Plater::priv::trigger_auto_reslice_now().

Here is the call graph for this function:

Here is the caller graph for this function:

reslice_SLA_hollowing()

void Slic3r::GUI::Plater::reslice_SLA_hollowing	(	const ModelObject &	object,
		bool	postpone_error_messages = false )

{
    reslice_SLA_until_step(slaposDrillHoles, object, postpone_error_messages);
}

References reslice_SLA_until_step(), and Slic3r::slaposDrillHoles.

Here is the call graph for this function:

reslice_SLA_supports()

void Slic3r::GUI::Plater::reslice_SLA_supports	(	const ModelObject &	object,
		bool	postpone_error_messages = false )

{
    reslice_SLA_until_step(slaposPad, object, postpone_error_messages);
}

References reslice_SLA_until_step(), and Slic3r::slaposPad.

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 )

{
    //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_SLA_hollowing(), and reslice_SLA_supports().

Here is the caller graph for this function:

revalidate_current_plate_if_plugins_missing()

void Slic3r::GUI::Plater::revalidate_current_plate_if_plugins_missing

(

)

{
    // Only do work while a missing-plugin notification is up, so the plugin-load hook does not
    // trigger a full validation for every plugin that loads during normal startup/use.
    if (p->m_local_missing_shown_sig.empty() && p->m_cloud_missing_shown_sig.empty() &&
        p->m_inactive_shown_sig.empty() && p->m_broken_shown_sig.empty())
        return;
    bool model_fits = true, validate_error = false;
    validate_current_plate(model_fits, validate_error);
}

References p, and validate_current_plate().

Referenced by install_missing_cloud_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

save_project()

int Slic3r::GUI::Plater::save_project

(

bool

saveAs = false

)

{
    //if (up_to_date(false, false)) // should we always save
    //    return;
    auto filename = get_project_filename(".3mf");
    if (!saveAs && filename.IsEmpty())
        saveAs = true;
    if (saveAs)
        filename = p->get_export_file(FT_3MF);
    if (filename.empty())
        return wxID_NO;
    if (filename == "<cancel>")
        return wxID_CANCEL;
 
    //BBS export 3mf without gcode
    auto save_strategy = SaveStrategy::SplitModel | SaveStrategy::ShareMesh;
    bool full_pathnames = wxGetApp().app_config->get_bool("export_sources_full_pathnames");
    if (full_pathnames) {
        save_strategy = save_strategy | SaveStrategy::FullPathSources;
    }
    {
        Slic3r::LifecycleEventContext ctx;
        ctx.name = into_u8(filename);
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ProjectBeforeSave, ctx);
    }
    if (export_3mf(into_path(filename), save_strategy) < 0) {
        MessageDialog(this, _L("Failed to save the project.\nPlease check whether the folder exists online or if other programs have the project file open."),
            _L("Save project"), wxOK | wxICON_WARNING).ShowModal();
        return wxID_CANCEL;
    }
    {
        Slic3r::LifecycleEventContext ctx;
        ctx.name = into_u8(filename);
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ProjectAfterSave, ctx);
    }
 
    Slic3r::remove_backup(model(), false);
 
    p->set_project_filename(filename);
    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << __LINE__ << " call set_project_filename: " << filename;
 
    up_to_date(true, false);
    up_to_date(true, true);
 
    wxGetApp().update_saved_preset_from_current_preset();
    reset_project_dirty_after_save();
    try {
        json j;
        boost::uintmax_t size = boost::filesystem::file_size(into_path(filename));
        j["file_size"] = size;
        j["file_name"] = std::string(filename.mb_str());
 
        NetworkAgent* agent = wxGetApp().getAgent();
    }
    catch (...) {}
 
    update_title_dirty_status();
    return wxID_YES;
}

References _L, Slic3r::LifecycleEventContext::code, export_3mf(), Slic3r::fire_lifecycle_event(), Slic3r::GUI::FT_3MF, Slic3r::FullPathSources, get_project_filename(), Slic3r::GUI::into_path(), Slic3r::GUI::into_u8(), model(), Slic3r::LifecycleEventContext::name, Slic3r::Ok, p, Slic3r::ProjectAfterSave, Slic3r::ProjectBeforeSave, Slic3r::remove_backup(), reset_project_dirty_after_save(), Slic3r::ShareMesh, Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::SplitModel, Slic3r::trace(), up_to_date(), and update_title_dirty_status().

Referenced by close_with_confirm().

Here is the call graph for this function:

Here is the caller graph for this function:

save_project_if_dirty()

int Slic3r::GUI::Plater::save_project_if_dirty

(

const wxString &

reason

)

{ return p->save_project_if_dirty(reason); }

References p.

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::anonymous_namespace{NativeCommands.cpp}::build_command_catalog().

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 select_plate_by_hover_id(), and Slic3r::GUI::Plater::priv::update().

Here is the caller graph for this function:

search()

void Slic3r::GUI::Plater::search	(	bool	plater_is_active,
		Preset::Type	type,
		wxWindow *	tag,
		TextInput *	etag,
		wxWindow *	stag )

{
    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->get_searcher().show_dialog(type, tag, etag, stag);
}

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

Referenced by 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:

segment()

void Slic3r::GUI::Plater::segment	(	size_t	obj_idx,
		size_t	instance_idx,
		double	smoothing_alpha = 0.5,
		int	segment_number = 5 )

select_all()

void Slic3r::GUI::Plater::select_all

(

)

{ p->select_all(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::reload_all_from_disk().

Here is the caller graph for this function:

select_curr_plate_all()

void Slic3r::GUI::Plater::select_curr_plate_all

(

)

{ p->select_curr_plate_all(); }

References p.

select_plate()

int Slic3r::GUI::Plater::select_plate	(	int	plate_index,
		bool	need_slice = false )

{
    int ret;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: plate %2%, need_slice %3% ")%__LINE__ %plate_index  %need_slice;
    take_snapshot("select partplate!");
    ret = p->partplate_list.select_plate(plate_index);
    if (!ret) {
        if (is_view3D_shown())
            wxGetApp().plater()->canvas3D()->render();
    }
    const auto& preset_bundle = wxGetApp().preset_bundle;
 
    if ((!ret) && (p->background_process.can_switch_print()))
    {
        //select successfully
        p->partplate_list.update_slice_context_to_current_plate(p->background_process);
        p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
        p->update_print_volume_state();
 
        PartPlate* part_plate = p->partplate_list.get_curr_plate();
        bool result_valid = part_plate->is_slice_result_valid();
        PrintBase* print = nullptr;
        GCodeResult* gcode_result = nullptr;
        Print::ApplyStatus invalidated;
 
        part_plate->get_print(&print, &gcode_result, NULL);
 
        //always apply the current plate's print
        if (preset_bundle->get_printer_extruder_count() > 1) {
            std::vector<int> f_maps = part_plate->get_real_filament_maps(preset_bundle->project_config);
            std::vector<int> f_volume_maps = part_plate->get_filament_volume_maps();
            if (f_volume_maps.empty()) {
                f_volume_maps = preset_bundle->get_default_nozzle_volume_types_for_filaments(f_maps);
            }
            invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false, f_maps, f_volume_maps));
        }
        else
            invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false));
        bool model_fits, validate_err;
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: plate %2%, after apply, invalidated= %3%, previous result_valid %4% ")%__LINE__ %plate_index  %invalidated %result_valid;
        if (result_valid)
        {
            if (is_preview_shown())
            {
                if (need_slice) { //from preview's thumbnail
                    if ((invalidated & PrintBase::APPLY_STATUS_INVALIDATED) || (gcode_result->moves.empty())){
                        if (invalidated & PrintBase::APPLY_STATUS_INVALIDATED)
                            part_plate->update_slice_result_valid_state(false);
                        p->process_completed_with_error = -1;
                        p->m_slice_all = false;
                        reset_gcode_toolpaths();
                        reslice();
                    }
                    else {
                        validate_current_plate(model_fits, validate_err);
                        //just refresh_print
                        reload_print();
                        p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false, true);
                    }
                }
                else {// from multiple slice's next
                    //do nothing
                }
            }
            else
            {
                validate_current_plate(model_fits, validate_err);
                if (invalidated & PrintBase::APPLY_STATUS_INVALIDATED)
                {
                    part_plate->update_slice_result_valid_state(false);
                    // BBS
                    //p->show_action_buttons(true);
                    //p->ready_to_slice = true;
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, true);
                }
                else
                {
                    // BBS
                    //p->show_action_buttons(false);
                    //p->ready_to_slice = false;
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
 
                    reload_print();
                }
            }
        }
        else
        {
            //check inside status
            //model_fits = p->view3D->get_canvas3d()->check_volumes_outside_state() != ModelInstancePVS_Partly_Outside;
            //bool validate_err = false;
            validate_current_plate(model_fits, validate_err);
            if (model_fits && !validate_err) {
                p->process_completed_with_error = -1;
            }
            else {
                p->process_completed_with_error = p->partplate_list.get_curr_plate_index();
            }
            if (is_preview_shown())
            {
                if (need_slice)
                {
                    //p->process_completed_with_error = -1;
                    p->m_slice_all = false;
                    reset_gcode_toolpaths();
                    if (model_fits && !validate_err) {
                        if (!check_ams_status(false)){
                            return ret;
                        }
                        reslice();
                    }
                    else {
                        p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
                        //sometimes the previous print's sliced result is still valid, but the newly added object is laid over the boundary
                        //then the print toolpath will be shown, so we should not refresh print here, only onload shell
                        //refresh_print();
                        p->update_fff_scene_only_shells();
                    }
                }
                else {
                    //p->ready_to_slice = false;
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
                    reload_print();
                }
            }
            else
            {
                //validate_current_plate(model_fits, validate_err);
                //check inside status
                /*if (model_fits && !validate_err){
                    p->process_completed_with_error = -1;
                }
                else {
                    p->process_completed_with_error = p->partplate_list.get_curr_plate_index();
                }*/
 
                // BBS: don't show action buttons
                //p->show_action_buttons(true);
                //p->ready_to_slice = true;
                if (model_fits && part_plate->has_printable_instances())
                {
                    //p->view3D->get_canvas3d()->post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, true));
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, true);
                }
                else
                {
                    //p->view3D->get_canvas3d()->post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, false));
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
                }
            }
        }
    }
 
    SimpleEvent event(EVT_GLCANVAS_PLATE_SELECT);
    p->on_plate_selected(event);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: plate %2%, return %3%")%__LINE__ %plate_index %ret;
    return ret;
}

References Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, check_ams_status(), Slic3r::GUI::MainFrame::eEventPlateUpdate, Slic3r::GUI::PartPlate::get_filament_volume_maps(), Slic3r::GUI::PartPlate::get_print(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::has_printable_instances(), is_preview_shown(), Slic3r::GUI::PartPlate::is_slice_result_valid(), is_view3D_shown(), model(), Slic3r::GCodeProcessorResult::moves, p, reload_print(), reset_gcode_toolpaths(), reslice(), take_snapshot(), Slic3r::GUI::PartPlate::update_slice_result_valid_state(), and validate_current_plate().

Referenced by select_plate_by_hover_id(), and select_sliced_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

select_plate_by_hover_id()

int Slic3r::GUI::Plater::select_plate_by_hover_id	(	int	hover_id,
		bool	right_click = false,
		bool	isModidyPlateName = false )

{
    int ret;
    int action, plate_index;
 
    plate_index = hover_id / PartPlate::GRABBER_COUNT;
    action      = isModidyPlateName ? PartPlate::PLATE_NAME_HOVER_ID : hover_id % PartPlate::GRABBER_COUNT;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": enter, hover_id %1%, plate_index %2%, action %3%")%hover_id % plate_index %action;
    if (action == 0)
    {
        //select plate
        ret = p->partplate_list.select_plate(plate_index);
        if (!ret) {
            SimpleEvent event(EVT_GLCANVAS_PLATE_SELECT);
            p->on_plate_selected(event);
        }
        if ((!ret)&&(p->background_process.can_switch_print()))
        {
            //select successfully
            p->partplate_list.update_slice_context_to_current_plate(p->background_process);
            p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
            p->update_print_volume_state();
 
            PartPlate* part_plate = p->partplate_list.get_curr_plate();
            bool result_valid = part_plate->is_slice_result_valid();
            PrintBase* print = nullptr;
            GCodeResult* gcode_result = nullptr;
            Print::ApplyStatus invalidated;
 
            const auto& preset_bundle = wxGetApp().preset_bundle;
 
            part_plate->get_print(&print, &gcode_result, NULL);
            //always apply the current plate's print
            if (preset_bundle->get_printer_extruder_count() > 1) {
                std::vector<int> f_maps = part_plate->get_real_filament_maps(preset_bundle->project_config);
                std::vector<int> f_volume_maps = part_plate->get_filament_volume_maps();
                if (f_volume_maps.empty()) {
                    f_volume_maps = preset_bundle->get_default_nozzle_volume_types_for_filaments(f_maps);
                }
                invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false, f_maps, f_volume_maps));
            }
            else
                invalidated = p->background_process.apply(this->model(), preset_bundle->full_config(false));
            bool model_fits, validate_err;
            validate_current_plate(model_fits, validate_err);
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: after apply, invalidated= %2%, previous result_valid %3% ")%__LINE__ % invalidated %result_valid;
            if (result_valid)
            {
                if (invalidated & PrintBase::APPLY_STATUS_INVALIDATED)
                {
                    //bool model_fits, validate_err;
                    //validate_current_plate(model_fits, validate_err);
                    part_plate->update_slice_result_valid_state(false);
 
                    // BBS
                    //p->show_action_buttons(true);
                    //p->ready_to_slice = true;
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, true);
                }
                else
                {
                    // BBS
                    //p->show_action_buttons(false);
                    //validate_current_plate(model_fits, validate_err);
                    //p->ready_to_slice = false;
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
 
                    reload_print();
                }
            }
            else
            {
                //check inside status
                if (model_fits && !validate_err){
                    p->process_completed_with_error = -1;
                }
                else {
                    p->process_completed_with_error = p->partplate_list.get_curr_plate_index();
                }
 
                // BBS: don't show action buttons
                //p->show_action_buttons(true);
                //p->ready_to_slice = true;
                if (model_fits && part_plate->has_printable_instances())
                {
                    //p->view3D->get_canvas3d()->post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, true));
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": will set can_slice to true");
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, true);
                }
                else
                {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": will set can_slice to false, has_printable_instances %1%")%part_plate->has_printable_instances();
                    //p->view3D->get_canvas3d()->post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, false));
                    p->main_frame->update_slice_print_status(MainFrame::eEventPlateUpdate, false);
                }
            }
        }
    }
    else if ((action == 1)&&(!right_click))
    {
        //delete plate
        ret = delete_plate(plate_index);
    }
    else if ((action == 2)&&(!right_click))
    {
        //arrange the plate
        //take_snapshot("select_orient partplate");
        ret = select_plate(plate_index);
        if (!ret)
        {
            set_prepare_state(Job::PREPARE_STATE_MENU);
            orient();
        }
        else
        {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    }
    else if ((action == 3)&&(!right_click))
    {
        //arrange the plate
        //take_snapshot("select_arrange partplate");
        ret = select_plate(plate_index);
        if (!ret)
        {
            if (last_arrange_job_is_finished()) {
                set_prepare_state(Job::PREPARE_STATE_MENU);
                arrange();
            }
        }
        else
        {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    }
    else if ((action == 4)&&(!right_click))
    {
        //lock the plate
        take_snapshot("lock partplate");
        ret = p->partplate_list.lock_plate(plate_index, !p->partplate_list.is_locked(plate_index));
    }
    else if ((action == 5)&&(!right_click))
    {
        // set the plate type
        ret = select_plate(plate_index);
        if (!ret) {
            wxCommandEvent evt(EVT_OPEN_PLATESETTINGSDIALOG);
            evt.SetInt(plate_index);
            evt.SetEventObject(this);
            wxPostEvent(this, evt);
 
            this->schedule_background_process();
        } else {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    }
    else if ((action == PartPlate::PLATE_FILAMENT_MAP_ID) && (!right_click)) {
        ret = select_plate(plate_index);
        if (!ret) {
            PartPlate *         curr_plate = p->partplate_list.get_curr_plate();
            wxCommandEvent evt(EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG);
            evt.SetInt(0); // 0 means not from gcodeviewer
            evt.SetEventObject(this);
            wxPostEvent(this, evt);
        } else {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    }
    else if ((action == 6) && (!right_click)) {
        // set the plate type
        ret = select_plate(plate_index);
        if (!ret) {
            PlateNameEditDialog dlg(this, wxID_ANY, _L("Edit Plate Name"));
            PartPlate *         curr_plate = p->partplate_list.get_curr_plate();
 
            wxString curr_plate_name = from_u8(curr_plate->get_plate_name());
            dlg.set_plate_name(curr_plate_name);
 
            int result=dlg.ShowModal();
            if (result == wxID_YES) {
                wxString dlg_plate_name = dlg.get_plate_name();
                curr_plate->set_plate_name(dlg_plate_name.ToUTF8().data());
            }
        } else {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    } else if ((action == 7) && (!right_click)) {
        // move plate to the front
        take_snapshot("move plate to the front");
        ret = p->partplate_list.move_plate_to_index(plate_index,0);
        p->partplate_list.update_slice_context_to_current_plate(p->background_process);
        p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
        p->sidebar->obj_list()->reload_all_plates();
        p->partplate_list.update_plates();
        update();
        p->partplate_list.select_plate(0);
    }
    else if (action == (int)PartPlate::PLATE_IMEX_MODE_ID)
    {
        ret = select_plate(plate_index);
        if (!ret) {
            PartPlate* curr_plate = p->partplate_list.get_curr_plate();
            // Ordered mode list: kImexPrimaryMode first, then each named mode once.
            const std::vector<std::string> modes =
                imex_plate_mode_choices(wxGetApp().preset_bundle->printers.get_edited_preset().config);
 
            if (right_click) {
                // Show a popup menu with all modes.
                wxMenu menu;
                std::string current = curr_plate->get_imex_mode();
                std::vector<int> mode_ids;
                mode_ids.reserve(modes.size());
                for (size_t i = 0; i < modes.size(); ++i) {
                    int id = wxNewId();
                    mode_ids.push_back(id);
                    const wxString label = (modes[i] == kImexPrimaryMode) ? _L("Primary") : from_u8(modes[i]);
                    wxMenuItem* item = menu.AppendRadioItem(id, label);
                    if (modes[i] == current)
                        item->Check(true);
                }
                menu.Bind(wxEVT_MENU, [this, curr_plate, modes, mode_ids](wxCommandEvent& e) {
                    auto it = std::find(mode_ids.begin(), mode_ids.end(), e.GetId());
                    if (it == mode_ids.end()) return;
                    const size_t idx = std::distance(mode_ids.begin(), it);
                    take_snapshot("set imex mode");
                    curr_plate->set_imex_mode(modes[idx]);
                    update_project_dirty_from_presets();
                    set_plater_dirty(true);
                    update();
                });
                p->view3D->get_canvas3d()->get_wxglcanvas()->PopupMenu(&menu);
                ret = 1; // signal to caller: popup was shown, suppress plate context menu
            } else {
                // Left-click: always cycles mode. The IMEX ghost renderer exposes
                // the per-head filament picker on the plate itself; no popover here.
                const std::string current_mode = curr_plate->get_imex_mode();
                auto it = std::find(modes.begin(), modes.end(), current_mode);
                size_t next_idx = (it == modes.end()) ? 0 : ((it - modes.begin() + 1) % modes.size());
                std::string next_mode = modes[next_idx];
                if (next_mode != current_mode) {
                    take_snapshot("set imex mode");
                    curr_plate->set_imex_mode(next_mode);
                    update_project_dirty_from_presets();
                    set_plater_dirty(true);
                    update();
                }
            }
        } else {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "can not select plate %1%" << plate_index;
            ret = -1;
        }
    }
    else
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "invalid action %1%, with right_click=%2%" << action << right_click;
        ret = -1;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: return %2%")%__LINE__ % ret;
    return ret;
}

References _L, Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, arrange(), delete_plate(), Slic3r::GUI::MainFrame::eEventPlateUpdate, Slic3r::GUI::from_u8(), Slic3r::GUI::PartPlate::get_filament_volume_maps(), Slic3r::GUI::PartPlate::get_imex_mode(), Slic3r::GUI::PartPlate::get_plate_name(), Slic3r::GUI::PlateNameEditDialog::get_plate_name(), Slic3r::GUI::PartPlate::get_print(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::GRABBER_COUNT, Slic3r::GUI::PartPlate::has_printable_instances(), Slic3r::imex_plate_mode_choices(), Slic3r::GUI::PartPlate::is_slice_result_valid(), Slic3r::kImexPrimaryMode, last_arrange_job_is_finished(), model(), orient(), p, Slic3r::GUI::PartPlate::PLATE_FILAMENT_MAP_ID, Slic3r::GUI::PartPlate::PLATE_IMEX_MODE_ID, Slic3r::GUI::PartPlate::PLATE_NAME_HOVER_ID, Slic3r::GUI::Job::PREPARE_STATE_MENU, reload_print(), schedule_background_process(), select_plate(), Slic3r::GUI::PartPlate::set_imex_mode(), Slic3r::GUI::PartPlate::set_plate_name(), Slic3r::GUI::PlateNameEditDialog::set_plate_name(), set_plater_dirty(), set_prepare_state(), Slic3r::GUI::DPIAware< P >::ShowModal(), take_snapshot(), update(), update_project_dirty_from_presets(), Slic3r::GUI::PartPlate::update_slice_result_valid_state(), and validate_current_plate().

Here is the call graph for this function:

select_sliced_plate()

int Slic3r::GUI::Plater::select_sliced_plate	(	int	plate_index,
		bool	skip_zoom = false )

{
    int ret = 0;
    BOOST_LOG_TRIVIAL(info) << "select_sliced_plate plate_idx=" << plate_index;
 
    Freeze();
    ret = select_plate(plate_index, true);
    if (ret)
    {
        BOOST_LOG_TRIVIAL(error) << "select_plate error for plate_idx=" << plate_index;
        Thaw();
        return -1;
    }
    if(skip_zoom)
        p->partplate_list.select_plate_view();
    Thaw();
 
    return ret;
}

References p, and select_plate().

Here is the call graph for this function:

select_view()

void Slic3r::GUI::Plater::select_view

(

const std::string &

direction

)

{ p->select_view(direction); }

References p.

select_view_3D()

void Slic3r::GUI::Plater::select_view_3D	(	const std::string &	name,
		bool	no_slice = true )

{ p->select_view_3D(name, no_slice); }

References p.

send_calibration_job_finished()

void Slic3r::GUI::Plater::send_calibration_job_finished

(

wxCommandEvent &

evt

)

{
    p->main_frame->request_select_tab(TAB_ID_CALIBRATION);
    CalibrationPanel* calibration_panel = CalibrationPanel::ensure();
    if (calibration_panel) {
        auto curr_wizard = static_cast<CalibrationWizard*>(calibration_panel->get_tabpanel()->GetPage(evt.GetInt()));
        wxCommandEvent event(EVT_CALIBRATION_JOB_FINISHED);
        event.SetString(evt.GetString());
        event.SetEventObject(curr_wizard);
        wxPostEvent(curr_wizard, event);
    }
    evt.Skip();
}

References Slic3r::GUI::LazyInstance< CalibrationPanel >::ensure(), Slic3r::GUI::CalibrationPanel::get_tabpanel(), p, and TAB_ID_CALIBRATION.

Here is the call graph for this function:

send_gcode()

int Slic3r::GUI::Plater::send_gcode	(	int	plate_idx = -1,
		Export3mfProgressFn	proFn = nullptr )

{
    int result = 0;
    /* generate 3mf */
    set_print_job_plate_idx(plate_idx);
 
    PartPlate* plate = get_partplate_list().get_curr_plate();
    try {
        p->m_print_job_data._3mf_path = fs::path(plate->get_tmp_gcode_path());
        p->m_print_job_data._3mf_path.replace_extension("3mf");
    }
    catch (std::exception&) {
        BOOST_LOG_TRIVIAL(error) << "generate 3mf path failed";
        return -1;
    }
 
    SaveStrategy strategy = SaveStrategy::Silence | SaveStrategy::SkipModel | SaveStrategy::WithGcode | SaveStrategy::SkipAuxiliary;
#if !BBL_RELEASE_TO_PUBLIC
    //only save model in QA environment
    std::string sel = get_app_config()->get("iot_environment");
    if (sel == ENV_PRE_HOST)
        strategy = SaveStrategy::Silence | SaveStrategy::SplitModel | SaveStrategy::WithGcode;
#endif
 
    result = export_3mf(p->m_print_job_data._3mf_path, strategy, plate_idx, proFn);
 
    return result;
}

References ENV_PRE_HOST, export_3mf(), Slic3r::AppConfig::get(), Slic3r::GUI::get_app_config(), Slic3r::GUI::PartPlateList::get_curr_plate(), get_partplate_list(), Slic3r::GUI::PartPlate::get_tmp_gcode_path(), p, set_print_job_plate_idx(), Slic3r::Silence, Slic3r::SkipAuxiliary, Slic3r::SkipModel, Slic3r::SplitModel, and Slic3r::WithGcode.

Referenced by send_gcode_legacy().

Here is the call graph for this function:

Here is the caller graph for this function:

send_gcode_finish()

void Slic3r::GUI::Plater::send_gcode_finish

(

wxString

name

)

{
    auto out_str = GUI::format(_L("The file %s has been sent to the printer's storage space and can be viewed on the printer."), name);
    p->notification_manager->push_exporting_finished_notification(out_str, "", false);
}

References _L, Slic3r::GUI::format(), and p.

Referenced by send_job_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

send_gcode_legacy()

void Slic3r::GUI::Plater::send_gcode_legacy	(	int	plate_idx = -1,
		Export3mfProgressFn	proFn = nullptr )

{
    // if physical_printer is selected, send gcode for this printer
    // DynamicPrintConfig* physical_printer_config = wxGetApp().preset_bundle->physical_printers.get_selected_printer_config();
    DynamicPrintConfig* physical_printer_config = &Slic3r::GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
    if (! physical_printer_config || p->model.objects.empty())
        return;
 
    PrintHostJob upload_job(physical_printer_config);
    if (upload_job.empty())
        return;
 
    // Orca: the use_3mf printer option makes us send a .gcode.3mf to the printer
    const auto* use_3mf_opt = physical_printer_config->option<ConfigOptionBool>("use_3mf");
    const bool  use_3mf     = use_3mf_opt != nullptr && use_3mf_opt->value;
 
    upload_job.upload_data.use_3mf = use_3mf;
    // Orca: the concrete plate to export/send (PLATE_CURRENT_IDX resolves to the current plate).
    const int resolved_plate_idx = plate_idx == PLATE_CURRENT_IDX ? get_partplate_list().get_curr_plate_index() : plate_idx;
 
    // 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(this->p->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()));
    if (use_3mf) {
        // Orca: a gcode-in-3mf bundle is named ".gcode.3mf" (matching "Export plate sliced file")
        default_output_file.replace_extension(".gcode.3mf");
    }
 
    // 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;
        }
    }
 
    {
        auto        preset_bundle = wxGetApp().preset_bundle;
        auto        config        = get_app_config();
 
        const auto host_type_opt        = physical_printer_config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type            = host_type_opt != nullptr ? host_type_opt->value : htElegooLink;
        const auto* ff_serial_opt       = physical_printer_config->option<ConfigOptionString>("flashforge_serial_number");
        const auto* ff_code_opt         = physical_printer_config->option<ConfigOptionString>("printhost_apikey");
        const bool flashforge_local_api = host_type == htFlashforge && ff_serial_opt != nullptr && !ff_serial_opt->value.empty() &&
                                          ff_code_opt != nullptr && !ff_code_opt->value.empty();
 
        std::unique_ptr<PrintHostSendDialog> pDlg;
        if (host_type == htElegooLink) {
            pDlg = std::make_unique<ElegooPrintHostSendDialog>(default_output_file, upload_job.printhost->get_post_upload_actions(), groups,
                                                               storage_paths, storage_names,
                                                               config->get_bool("open_device_tab_post_upload"));
        } else if (host_type == htCrealityPrint) {
            pDlg = std::make_unique<CrealityPrintHostSendDialog>(default_output_file, upload_job.printhost->get_post_upload_actions(), groups,
                                                                 storage_paths, storage_names,
                                                                 config->get_bool("open_device_tab_post_upload"),
                                                                 upload_job.printhost.get());
        } else if (flashforge_local_api) {
            auto* flashforge_host = dynamic_cast<Flashforge*>(upload_job.printhost.get());
            if (flashforge_host == nullptr) {
                show_error(this, _L("Flashforge host is not available."), false);
                return;
            }
 
            std::vector<FlashforgeMaterialSlot> slots;
            bool                                supports_material_station = false;
            {
                wxBusyCursor wait;
                wxString     msg;
                if (!flashforge_host->fetch_material_slots(slots, &supports_material_station, msg)) {
                    show_error(this, msg.empty() ? _L("Unable to log in to the Flashforge printer.") : msg, false);
                    return;
                }
            }
 
            std::vector<FilamentInfo> project_filaments;
            PlateDataPtrs               plate_data_list;
            DynamicPrintConfig          cfg                 = wxGetApp().preset_bundle->full_config();
            const auto*                 filament_color      = dynamic_cast<const ConfigOptionStrings*>(cfg.option("filament_colour"));
            const auto*                 filament_id_opt     = dynamic_cast<const ConfigOptionStrings*>(cfg.option("filament_ids"));
            auto enrich_project_filaments = [&](std::vector<FilamentInfo>& filaments) {
                for (auto& filament : filaments) {
                    if (filament.id < 0)
                        continue;
 
                    std::string display_filament_type;
                    try {
                        filament.type = cfg.get_filament_type(display_filament_type, filament.id);
                    } catch (...) {
                    }
 
                    if (filament.type.empty())
                        filament.type = display_filament_type;
                    if (filament.type.empty())
                        filament.type = "Unknown";
 
                    filament.filament_id = filament_id_opt ? filament_id_opt->get_at(static_cast<size_t>(filament.id)) : "";
                    filament.color       = filament_color ? filament_color->get_at(static_cast<size_t>(filament.id)) : "#FFFFFF";
                    if (filament.color.empty())
                        filament.color = "#FFFFFF";
                }
            };
 
            p->partplate_list.store_to_3mf_structure(plate_data_list, true, plate_idx);
            PlateData* selected_plate_data = (resolved_plate_idx >= 0 && resolved_plate_idx < static_cast<int>(plate_data_list.size())) ? plate_data_list[resolved_plate_idx] : nullptr;
            if (selected_plate_data == nullptr && !plate_data_list.empty())
                selected_plate_data = plate_data_list.front();
 
            if (selected_plate_data != nullptr)
                project_filaments = selected_plate_data->slice_filaments_info;
 
            if (project_filaments.empty()) {
                if (PartPlate* plate = get_partplate_list().get_plate(resolved_plate_idx); plate != nullptr)
                    project_filaments = plate->get_slice_filaments_info();
            }
 
            if (!project_filaments.empty())
                enrich_project_filaments(project_filaments);
            release_PlateData_list(plate_data_list);
 
            pDlg = std::make_unique<FlashforgePrintHostSendDialog>(default_output_file, upload_job.printhost->get_post_upload_actions(), groups,
                                                                   storage_paths, storage_names,
                                                                   config->get_bool("open_device_tab_post_upload"),
                                                                   flashforge_host,
                                                                   supports_material_station,
                                                                   std::move(slots),
                                                                   project_filaments);
        } else {
            pDlg = std::make_unique<PrintHostSendDialog>(default_output_file, upload_job.printhost->get_post_upload_actions(), groups,
                                                         storage_paths, storage_names, config->get_bool("open_device_tab_post_upload"));
        }
 
        pDlg->init();
        if (pDlg->ShowModal() != wxID_OK) {
            return;
        }
 
        config->set_bool("open_device_tab_post_upload", pDlg->switch_to_device_tab());
        // PrintHostUpload upload_data;
        upload_job.switch_to_device_tab    = pDlg->switch_to_device_tab();
        upload_job.upload_data.upload_path = pDlg->filename();
        upload_job.upload_data.post_action = pDlg->post_action();
        upload_job.upload_data.group       = pDlg->group();
        upload_job.upload_data.storage     = pDlg->storage();
        upload_job.upload_data.extended_info = pDlg->extendedInfo();
        // Orca: gcode inside a .gcode.3mf is index-coded (Metadata/plate_<N>.gcode) and a bundle may
        // carry several of them, so the upload must name which plate to print via a 1-based plateindex.
        // Even a single-plate bundle needs it, since its gcode entry is still indexed. The host upload
        // forwards the field and servers that don't use it ignore it. "All plates" points at the
        // current plate — the bundle still carries every plate's gcode.
        if (use_3mf) {
            const int plateindex = (plate_idx == PLATE_ALL_IDX ? get_partplate_list().get_curr_plate_index() : resolved_plate_idx) + 1;
            upload_job.upload_data.extended_info["plateindex"] = std::to_string(plateindex);
        }
    }
 
    // 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;
    }
 
    if (use_3mf) {
        // Process gcode
        const int result = send_gcode(resolved_plate_idx, nullptr);
 
        if (result < 0) {
            wxString msg = _L("Abnormal print file data. Please slice again");
            show_error(this, msg, false);
            return;
        }
 
        upload_job.upload_data.source_path = p->m_print_job_data._3mf_path;
    }
 
    p->export_gcode(fs::path(), false, std::move(upload_job));
}

References _L, config(), Slic3r::PrintHostJob::empty(), Slic3r::PrintHostUpload::extended_info, Slic3r::fold_utf8_to_ascii(), Slic3r::GUI::get_app_config(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::DynamicPrintConfig::get_filament_type(), get_partplate_list(), Slic3r::PrintHostUpload::group, Slic3r::htCrealityPrint, Slic3r::htElegooLink, Slic3r::htFlashforge, Slic3r::GUI::into_path(), Slic3r::ConfigBase::option(), p, PLATE_ALL_IDX, PLATE_CURRENT_IDX, Slic3r::PrintHostUpload::post_action, Slic3r::PrintHostJob::printhost, Slic3r::release_PlateData_list(), send_gcode(), Slic3r::GUI::show_error(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::PlateData::slice_filaments_info, Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, Slic3r::PrintHostUpload::storage, Slic3r::PrintHostJob::switch_to_device_tab, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, Slic3r::PrintHostJob::upload_data, Slic3r::PrintHostUpload::upload_path, Slic3r::PrintHostUpload::use_3mf, Slic3r::use_3mf(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

send_job_finished()

void Slic3r::GUI::Plater::send_job_finished

(

wxCommandEvent &

evt

)

{
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
    //dev->set_selected_machine(evt.GetString().ToStdString());
 
    send_gcode_finish(evt.GetString());
    p->hide_send_to_printer_dlg();
    //p->main_frame->request_select_tab(TAB_ID_MONITOR);
    //MonitorPanel* curr_monitor = p->main_frame->m_monitor;
    //if (curr_monitor)
    //    curr_monitor->get_tabpanel()->ChangeSelection(MonitorPanel::PrinterTab::PT_STATUS);
}

References p, and send_gcode_finish().

Here is the call graph for this function:

send_to_printer()

void Slic3r::GUI::Plater::send_to_printer

(

bool

isall = false

)

{
    p->on_action_send_to_printer(isall);
}

References p.

set_bed_position()

void Slic3r::GUI::Plater::set_bed_position

(

Vec2d &

pos

)

{
    p->bed.set_position(pos);
}

References p.

set_bed_shape() [1/2]

void Slic3r::GUI::Plater::set_bed_shape

(

)

const

{
    std::string texture_filename;
    auto bundle = wxGetApp().preset_bundle;
    if (bundle != nullptr) {
        const Preset* curr = &bundle->printers.get_selected_preset();
        if (curr->is_system)
            texture_filename = PresetUtils::system_printer_bed_texture(*curr);
        else {
            auto *printer_model = curr->config.opt<ConfigOptionString>("printer_model");
            if (printer_model != nullptr && ! printer_model->value.empty()) {
                texture_filename = bundle->get_texture_for_printer_model(printer_model->value);
            }
        }
    }
    const ConfigOptionPoints *bed_exclude_area = p->config->option<ConfigOptionPoints>("bed_exclude_area");
    set_bed_shape(p->config->option<ConfigOptionPoints>("printable_area")->values,
        //BBS: add bed exclude areas
        bed_exclude_area->values,
        p->config->option<ConfigOptionPoints>("wrapping_exclude_area")->values,
        p->config->option<ConfigOptionFloat>("printable_height")->value,
        p->config->option<ConfigOptionPointsGroups>("extruder_printable_area")->values,
        p->config->option<ConfigOptionFloatsNullable>("extruder_printable_height")->values,
        p->config->option<ConfigOptionString>("bed_custom_texture")->value.empty() ? texture_filename : p->config->option<ConfigOptionString>("bed_custom_texture")->value,
        p->config->option<ConfigOptionString>("bed_custom_model")->value);
}

References Slic3r::Preset::config, Slic3r::Preset::is_system, Slic3r::DynamicConfig::opt(), p, set_bed_shape(), Slic3r::PresetUtils::system_printer_bed_texture(), Slic3r::ConfigOptionSingle< T >::value, and Slic3r::ConfigOptionVector< T >::values.

Referenced by on_config_change(), and set_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 Pointfs &	exclude_area,
		const Pointfs &	wrapping_exclude_area,
		const double	printable_height,
		std::vector< Pointfs >	extruder_areas,
		std::vector< double >	extruder_heights,
		const std::string &	custom_texture,
		const std::string &	custom_model,
		bool	force_as_custom = false ) const

{
    p->set_bed_shape(make_counter_clockwise(shape), exclude_area, wrapping_exclude_area, printable_height, extruder_areas, extruder_heights, custom_texture, custom_model, force_as_custom);
}

References Slic3r::make_counter_clockwise(), p, and Slic3r::printable_height().

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.

set_global_filament_map()

void Slic3r::GUI::Plater::set_global_filament_map

(

const std::vector< int > &

filament_map

)

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    project_config.option<ConfigOptionInts>("filament_map")->values = filament_map;
    p->partplate_list.invalidate_exclusion_volume_previews();
}

References Slic3r::filament_map(), and p.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_global_filament_map_mode()

void Slic3r::GUI::Plater::set_global_filament_map_mode

(

FilamentMapMode

mode

)

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto mode_ptr = project_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode");
    FilamentMapMode old_mode = mode_ptr->value;
    if(mode != old_mode)
        on_filament_map_mode_change();
    mode_ptr->value = mode;
}

References on_filament_map_mode_change().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_global_filament_volume_map()

void Slic3r::GUI::Plater::set_global_filament_volume_map

(

const std::vector< int > &

filament_volume_map

)

{
    auto& project_config = wxGetApp().preset_bundle->project_config;
    project_config.option<ConfigOptionInts>("filament_volume_map")->values = filament_volume_map;
}

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

Here is the caller graph for this function:

set_need_update()

void Slic3r::GUI::Plater::set_need_update

(

bool

need_update

)

{
    p->set_need_update(need_update);
}

References need_update(), and p.

Here is the call graph for this function:

set_number_of_copies()

void Slic3r::GUI::Plater::set_number_of_copies

(

)

{
    int obj_idx = p->get_selected_object_idx();
    if (obj_idx == -1)
        return;
 
    ModelObject* model_object = p->model.objects[obj_idx];
 
    const int num = GetNumberFromUser( " ", _L("Number of copies:"),
                                    _L("Copies of the selected object"), model_object->instances.size(), 0, 1000, this );
    if (num < 0)
        return;
 
    Plater::TakeSnapshot snapshot(this, (boost::format("Set numbers of copies to %1%")%num).str());
 
    int diff = num - (int)model_object->instances.size();
    if (diff > 0)
        increase_instances(diff);
    else if (diff < 0)
        decrease_instances(-diff);
}

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

Here is the call graph for this function:

set_only_gcode()

void Slic3r::GUI::Plater::set_only_gcode ( bool only_gcode )

inline

{ m_only_gcode = only_gcode; }

References m_only_gcode.

set_pending_published()

void Slic3r::GUI::Plater::set_pending_published	(	const std::vector< std::string > &	published_keys,
		const std::vector< Slic3r::PublishedMaterialEntry > &	material_keys )

{
    p->m_has_pending_published = true;
    p->m_pending_published_keys = published_keys;
    p->m_pending_material_keys  = material_keys;
}

References p.

set_plater_dirty()

void Slic3r::GUI::Plater::set_plater_dirty

(

bool

is_dirty

)

{ p->set_plater_dirty(is_dirty); }

References p.

Referenced by normalize_bed_types(), open_filament_map_setting_dialog(), open_platesettings_dialog(), and select_plate_by_hover_id().

Here is the caller graph for this function:

set_prepare_state()

void Slic3r::GUI::Plater::set_prepare_state

(

int

state

)

{
    p->m_job_prepare_state = state;
}

References p.

Referenced by Slic3r::GUI::MenuFactory::load_handy_model(), and select_plate_by_hover_id().

Here is the caller graph for this function:

set_print_job_plate_idx()

void Slic3r::GUI::Plater::set_print_job_plate_idx

(

int

plate_idx

)

{
    if (plate_idx == PLATE_CURRENT_IDX) {
        p->m_print_job_data.plate_idx = get_partplate_list().get_curr_plate_index();
    }
    else {
        p->m_print_job_data.plate_idx = plate_idx;
    }
}

References Slic3r::GUI::PartPlateList::get_curr_plate_index(), get_partplate_list(), p, and PLATE_CURRENT_IDX.

Referenced by export_config_3mf(), and send_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

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->sidebar->get_searcher().set_printer_technology(printer_technology);
 
    p->notification_manager->set_fff(printer_technology == ptFFF);
    p->notification_manager->set_slicing_progress_hidden();
 
    return ret;
}

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

Referenced by Slic3r::GUI::MainFrame::load_config(), 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:

set_selected_visible()

void Slic3r::GUI::Plater::set_selected_visible

(

bool

visible

)

{
    if (p->get_curr_selection().is_empty())
        return;
 
    Plater::TakeSnapshot snapshot(this, "Set Selected Objects Visible in AssembleView");
    get_ui_job_worker().cancel_all();
 
    p->get_current_canvas3D()->set_selected_visible(visible);
}

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

Here is the call graph for this function:

set_using_exported_file()

void Slic3r::GUI::Plater::set_using_exported_file ( bool exported_file )

inline

                                                     {
        m_exported_file = exported_file;
    }

References m_exported_file.

SetPlateIndexByRightMenuInLeftUI()

void Slic3r::GUI::Plater::SetPlateIndexByRightMenuInLeftUI

(

int

index

)

{ p->m_is_RightClickInLeftUI = index; }

References p.

Show()

bool Slic3r::GUI::Plater::Show

(

bool

show = true

)

{
    if (wxGetApp().mainframe)
        wxGetApp().mainframe->show_option(show);
    return wxPanel::Show(show);
}

show_collision_volumes()

void Slic3r::GUI::Plater::show_collision_volumes

(

bool

show

)

{
    wxGetApp().app_config->set_bool("show_collision_volumes", show);
    p->partplate_list.invalidate_exclusion_volume_previews();
    p->view3D->get_canvas3d()->set_as_dirty();
    p->view3D->get_canvas3d()->request_extra_frame();
}

References p.

show_dock_pane()

void Slic3r::GUI::Plater::show_dock_pane	(	wxWindow *	window,
		bool	show )

{ p->show_dock_pane(window, show); }

References p.

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::handle_show().

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("Invalid name, 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_object_info()

void Slic3r::GUI::Plater::show_object_info

(

)

{
    NotificationManager *notify_manager = get_notification_manager();
    const Selection& selection = get_selection();
    int selCount = selection.get_volume_idxs().size();
    ModelObjectPtrs objects = model().objects;
    int obj_idx = selection.get_object_idx();
    std::string info_text;
 
    if (selCount > 1 && !selection.is_single_full_object()) {
        notify_manager->bbl_close_objectsinfo_notification();
        if (selection.get_mode() == Selection::EMode::Volume) {
            info_text += (boost::format(_utf8(L("Number of currently selected parts: %1%\n"))) % selCount).str();
        } else if (selection.get_mode() == Selection::EMode::Instance) {
            int content_count = selection.get_content().size();
            info_text += (boost::format(_utf8(L("Number of currently selected objects: %1%\n"))) % content_count).str();
        }
        notify_manager->bbl_show_objectsinfo_notification(info_text, false, !(p->current_panel == p->view3D));
        return;
    }
    else if (objects.empty() || (obj_idx < 0) || (obj_idx >= objects.size()) ||
        objects[obj_idx]->volumes.empty() ||// hack to avoid crash when deleting the last object on the bed
        (selection.is_single_full_object() && objects[obj_idx]->instances.size()> 1) ||
        !(selection.is_single_full_instance() || selection.is_single_volume()))
    {
        notify_manager->bbl_close_objectsinfo_notification();
        return;
    }
 
    const ModelObject* model_object = objects[obj_idx];
    int inst_idx = selection.get_instance_idx();
    if ((inst_idx < 0) || (inst_idx >= model_object->instances.size()))
    {
        notify_manager->bbl_close_objectsinfo_notification();
        return;
    }
    bool imperial_units = wxGetApp().app_config->get("use_inches") == "1";
    double koef = imperial_units ? GizmoObjectManipulation::mm_to_in : 1.0f;
 
    ModelVolume* vol = nullptr;
    Transform3d t;
    int face_count;
    Vec3d size;
    if (selection.is_single_volume()) {
        std::vector<int> obj_idxs, vol_idxs;
        wxGetApp().obj_list()->get_selection_indexes(obj_idxs, vol_idxs);
        if (vol_idxs.size() != 1)
        {
            //corner case when merge/split/remove
            return;
        }
        vol = model_object->volumes[vol_idxs[0]];
        t = model_object->instances[inst_idx]->get_matrix() * vol->get_matrix();
        info_text += (boost::format(_utf8(L("Part name: %1%\n"))) % vol->name).str();
        face_count = static_cast<int>(vol->mesh().facets_count());
        size = vol->get_convex_hull().transformed_bounding_box(t).size();
    }
    else {
        //int obj_idx, vol_idx;
        //wxGetApp().obj_list()->get_selected_item_indexes(obj_idx, vol_idx);
        //if (obj_idx < 0) {
        //    //corner case when merge/split/remove
        //    return;
        //}
        info_text += (boost::format(_utf8(L("Object name: %1%\n"))) % model_object->name).str();
        face_count = static_cast<int>(model_object->facets_count());
        size = model_object->instance_convex_hull_bounding_box(inst_idx).size();
    }
 
    //Vec3d size = vol ? vol->mesh().transformed_bounding_box(t).size() : model_object->instance_bounding_box(inst_idx).size();
    if (imperial_units)
        info_text += (boost::format(_utf8(L("Size: %1% x %2% x %3% in\n"))) %(size(0)*koef) %(size(1)*koef) %(size(2)*koef)).str();
    else
        info_text += (boost::format(_utf8(L("Size: %1% x %2% x %3% mm\n"))) %size(0) %size(1) %size(2)).str();
 
    const TriangleMeshStats& stats = vol ? vol->mesh().stats() : model_object->get_object_stl_stats();
    double volume_val = stats.volume;
    if (vol)
        volume_val *= std::fabs(t.matrix().block(0, 0, 3, 3).determinant());
    volume_val = volume_val * pow(koef,3);
    if (imperial_units)
        info_text += (boost::format(_utf8(L("Volume: %1% in³\n"))) %volume_val).str();
    else
        info_text += (boost::format(_utf8(L("Volume: %1% mm³\n"))) %volume_val).str();
    info_text += (boost::format(_utf8(L("Triangles: %1%\n"))) %face_count).str();
 
    wxString info_manifold;
    int non_manifold_edges = 0;
    auto mesh_errors = p->sidebar->obj_list()->get_mesh_errors_info(&info_manifold, &non_manifold_edges);
 
        if (non_manifold_edges > 0) {
            info_manifold += "\n" + _L("Tips:") + "\n" + _L("Use \"Fix Model\" to repair the mesh.");
        }
 
    info_manifold = "<Error>" + info_manifold + "</Error>";
    info_text += into_u8(info_manifold);
    notify_manager->bbl_show_objectsinfo_notification(info_text, non_manifold_edges > 0, !(p->current_panel == p->view3D));
}

References _L, _utf8, Slic3r::GUI::NotificationManager::bbl_close_objectsinfo_notification(), Slic3r::GUI::NotificationManager::bbl_show_objectsinfo_notification(), Slic3r::ModelObject::facets_count(), Slic3r::GUI::Selection::get_content(), Slic3r::ModelVolume::get_convex_hull(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::Selection::get_mode(), get_notification_manager(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::ModelObject::get_object_stl_stats(), get_selection(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instance_convex_hull_bounding_box(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_single_volume(), L, Slic3r::ModelVolume::mesh(), Slic3r::GUI::GizmoObjectManipulation::mm_to_in, model(), Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::Model::objects, p, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::TriangleMesh::stats(), Slic3r::TriangleMesh::transformed_bounding_box(), Slic3r::GUI::Selection::Volume, Slic3r::TriangleMeshStats::volume, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

show_status_message()

void Slic3r::GUI::Plater::show_status_message

(

std::string

s

)

{
    BOOST_LOG_TRIVIAL(trace) << "show_status_message:" << s;
}

References Slic3r::trace().

Here is the call graph for this function:

show_uv_editor()

void Slic3r::GUI::Plater::show_uv_editor

(

bool

show

)

{
    if (p->uv_editor_panel == nullptr)
        return;
    const wxAuiPaneInfo &pane = p->m_aui_mgr.GetPane(p->uv_editor_panel);
    if (!pane.IsOk() || pane.IsShown() == show)
        return;
 
    // Deferred, because GLGizmoTextureDisplacement calls this from its ImGui panel - that is, from
    // the middle of the 3D canvas's GL frame. Showing an AUI pane re-lays out the window and
    // delivers the resulting size/paint events synchronously, and the UV canvas painting itself
    // makes its own surface current in the app's *shared* GL context, which mid-frame is the one
    // the 3D canvas is drawing into. Doing the layout once the frame is over avoids that entirely.
    CallAfter([this, show]() {
        wxAuiPaneInfo &deferred_pane = p->m_aui_mgr.GetPane(p->uv_editor_panel);
        if (!deferred_pane.IsOk() || deferred_pane.IsShown() == show)
            return;
        deferred_pane.Show(show);
        p->m_aui_mgr.Update();
    });
}

References p.

show_view3D_labels()

void Slic3r::GUI::Plater::show_view3D_labels

(

bool

show

)

{ p->show_view3D_labels(show); }

References p.

show_view3D_overhang()

void Slic3r::GUI::Plater::show_view3D_overhang

(

bool

show

)

{  p->show_view3D_overhang(show); }

References p.

sidebar()

Sidebar & Slic3r::GUI::Plater::sidebar

(

)

{ return *p->sidebar; }

References p.

Referenced by _calib_pa_pattern(), apply_cut_object_to_model(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), decrease_instances(), increase_instances(), load_gcode(), load_project(), normalize_bed_types(), on_bed_type_change(), on_filament_count_change(), on_filaments_delete(), and reslice().

Here is the caller graph for this function:

single_snapshots_enter()

void Slic3r::GUI::Plater::single_snapshots_enter ( SingleSnapshot * single )

private

{
    p->single_snapshots_enter(single);
}

References p.

single_snapshots_leave()

void Slic3r::GUI::Plater::single_snapshots_leave ( SingleSnapshot * single )

private

{
    p->single_snapshots_leave(single);
}

References p.

sla_object_menu()

wxMenu * Slic3r::GUI::Plater::sla_object_menu

(

)

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

References p.

sla_print() [1/2]

SLAPrint & Slic3r::GUI::Plater::sla_print

(

)

{ return p->sla_print; }

References p.

sla_print() [2/2]

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

(

)

const

{ return p->sla_print; }

References p.

split_object() [1/2]

void Slic3r::GUI::Plater::split_object

(

bool

auto_drop = true

)

{ p->split_object(auto_drop); }

References p.

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

Here is the caller graph for this function:

split_object() [2/2]

void Slic3r::GUI::Plater::split_object	(	int	obj_idx,
		bool	auto_drop = true )

split_volume()

void Slic3r::GUI::Plater::split_volume

(

)

{ p->split_volume(); }

References p.

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

Here is the caller graph for this function:

start_next_slice()

int Slic3r::GUI::Plater::start_next_slice ( )

private

{
    // Stop arrange and (or) optimize rotation tasks.
    //this->stop_jobs();
 
    //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, false, false);
    if (state & priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE)
        this->p->view3D->reload_scene(false);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": update_background_process returns %1%")%state;
    if (!p->partplate_list.get_curr_plate()->can_slice()) {
        p->process_completed_with_error = p->partplate_list.get_curr_plate_index();
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": found invalidated apply in update_background_process.");
        return -1;
    }
 
    // Only restarts if the state is valid.
    bool result = this->p->restart_background_process(state | priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART);
    if (!result)
    {
        //slice next
        SlicingProcessCompletedEvent evt(EVT_PROCESS_COMPLETED, 0,
                SlicingProcessCompletedEvent::Finished, nullptr);
        // Post the "complete" callback message, so that it will slice the next plate soon
        wxQueueEvent(this, evt.Clone());
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": restart_background_process returns %1%")%result;
 
    return 0;
}

References Slic3r::SlicingProcessCompletedEvent::Clone(), Slic3r::SlicingProcessCompletedEvent::Finished, p, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART, and Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE.

Here is the call 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

{ p->suppress_snapshots(); }

References p.

svg_part_menu()

wxMenu * Slic3r::GUI::Plater::svg_part_menu

(

)

{ return p->menus.svg_part_menu();          }

References p.

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();
    if (p->m_select_machine_dlg) p->m_select_machine_dlg->sys_color_changed();
 
    Layout();
    GetParent()->Layout();
}

References p.

take_snapshot() [1/2]

void Slic3r::GUI::Plater::take_snapshot

(

const std::string &

snapshot_name

)

{ p->take_snapshot(snapshot_name); }

References p.

Referenced by add_plate(), delete_plate(), Slic3r::GUI::Plater::priv::enter_gizmos_stack(), select_plate(), and select_plate_by_hover_id().

Here is the caller graph for this function:

take_snapshot() [2/2]

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

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

References p.

text_part_menu()

wxMenu * Slic3r::GUI::Plater::text_part_menu

(

)

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

References p.

toggle_render_statistic_dialog()

void Slic3r::GUI::Plater::toggle_render_statistic_dialog

(

)

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

References p.

toggle_show_wireframe()

void Slic3r::GUI::Plater::toggle_show_wireframe

(

)

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

References p.

toggle_show_xray()

void Slic3r::GUI::Plater::toggle_show_xray

(

)

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

References p.

trigger_restore_project()

void Slic3r::GUI::Plater::trigger_restore_project

(

int

skip_confirm = 0

)

{
    auto evt = new wxCommandEvent(EVT_RESTORE_PROJECT, this->GetId());
    evt->SetInt(skip_confirm);
    wxQueueEvent(this, evt);
    //wxPostEvent(this, *evt);
}

unbind_canvas_event_handlers()

void Slic3r::GUI::Plater::unbind_canvas_event_handlers

(

)

{
    p->unbind_canvas_event_handlers();
}

References p.

undo()

void Slic3r::GUI::Plater::undo

(

)

{ p->undo(); }

References p.

undo_redo_stack_main()

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

(

)

const

{ return p->undo_redo_stack_main(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::up_to_date().

Here is the caller graph for this function:

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.

up_to_date()

bool Slic3r::GUI::Plater::up_to_date	(	bool	saved,
		bool	backup )

{
    if (saved) {
        Slic3r::clear_other_changes(backup);
        return p->up_to_date(saved, backup);
    }
    // A Design-tab project is object-less until it is committed to the plate, but its feature
    // tree is real work: treating it as an empty project skipped both the autosave and the
    // "unsaved changes" prompt, so quitting threw it away without asking. Non-CAD projects
    // never carry a recipe, so the empty-project shortcut is unchanged for them.
    return (p->model.objects.empty() && p->model.cad_recipe.empty()) ||
           (p->up_to_date(saved, backup) && !Slic3r::has_other_changes(backup));
}

References Slic3r::clear_other_changes(), Slic3r::has_other_changes(), and p.

Referenced by close_with_confirm(), load_project(), new_project(), and save_project().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void Slic3r::GUI::Plater::update	(	bool	conside_update_flag = false,
		bool	force_background_processing_update = false )

{
    if (is_new_project_and_check_state()) {
        return;
    }
    unsigned int flag = force_background_processing_update ? (unsigned int)Plater::priv::UpdateParams::FORCE_BACKGROUND_PROCESSING_UPDATE : 0;
    if (conside_update_flag) {
        if (need_update()) {
            p->update(flag);
            p->set_need_update(false);
        }
    }
    else
        p->update(flag);
}

References Slic3r::GUI::Plater::priv::FORCE_BACKGROUND_PROCESSING_UPDATE, is_new_project_and_check_state(), need_update(), and p.

Referenced by add_plate(), apply_cut_object_to_model(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), changed_mesh(), Slic3r::GUI::Plater::priv::delete_all_objects_from_model(), Slic3r::GUI::Plater::priv::delete_object_from_model(), delete_plate(), duplicate_plate(), force_filament_colors_update(), on_config_change(), open_filament_map_setting_dialog(), open_platesettings_dialog(), refresh_missing_plugin_block(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::remove(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), Slic3r::GUI::Plater::priv::replace_with_stl(), Slic3r::GUI::Plater::priv::reset(), select_plate_by_hover_id(), Slic3r::GUI::try_pop_up_before_slice(), Slic3r::GUI::Plater::priv::undo_redo_to(), Slic3r::GUI::Plater::priv::update_after_undo_redo(), and Slic3r::GUI::Plater::priv::update_objects_position_when_select_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

update_all_plate_thumbnails()

void Slic3r::GUI::Plater::update_all_plate_thumbnails

(

bool

force_update = false

)

{
    for (int i = 0; i < get_partplate_list().get_plate_count(); i++)
        update_plate_thumbnails(i, force_update);
}

References get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate_count(), and update_plate_thumbnails().

Referenced by force_update_all_plate_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_colors_in_full_config()

bool Slic3r::GUI::Plater::update_filament_colors_in_full_config

(

)

{
    DynamicPrintConfig& project_config = wxGetApp().preset_bundle->project_config;
    const auto& full_config = wxGetApp().preset_bundle->full_config();
    ConfigOptionStrings* color_opt = project_config.option<ConfigOptionStrings>("filament_colour");
    const ConfigOptionStrings* type_opt = full_config.option<ConfigOptionStrings>("filament_type");
 
    p->config->option<ConfigOptionStrings>("filament_colour")->values = color_opt->values;
    p->config->option<ConfigOptionStrings>("filament_type")->values = type_opt->values;
    return true;
}

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

Referenced by on_config_change(), on_filament_count_change(), and on_filaments_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_volume_map()

void Slic3r::GUI::Plater::update_filament_volume_map	(	int	extruder_id,
		int	volume_type )

{
    // Hybrid is a per-extruder mix, not a per-filament volume; reset the affected filaments
    // to Standard so the manual grouping dialog starts from a concrete assignment.
    int   selected_volume_type = volume_type == static_cast<int>(NozzleVolumeType::nvtHybrid) ? static_cast<int>(NozzleVolumeType::nvtStandard) : volume_type;
    auto& partplate_list       = get_partplate_list();
    for (int idx = 0; idx < partplate_list.get_plate_count(); ++idx) {
        auto plate = partplate_list.get_plate(idx);
        if (!plate) continue;
        auto filament_map        = plate->get_filament_maps();
        auto filament_volume_map = plate->get_filament_volume_maps();
        if (filament_map.empty() || filament_volume_map.empty()) continue;
        if (filament_volume_map.size() < filament_map.size()) {
            filament_volume_map.resize(filament_map.size(), static_cast<int>(NozzleVolumeType::nvtStandard));
        }
        for (size_t i = 0; i < filament_map.size(); ++i) {
            if (filament_map[i] == extruder_id + 1) {
                filament_volume_map[i] = selected_volume_type;
            }
        }
        plate->set_filament_volume_maps(filament_volume_map);
    }
}

References Slic3r::filament_map(), get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::nvtHybrid, and Slic3r::nvtStandard.

Here is the call graph for this function:

update_flush_volume_matrix()

void Slic3r::GUI::Plater::update_flush_volume_matrix	(	size_t	old_nozzle_size,
		size_t	new_nozzle_size )

{
    size_t nozzle_nums = wxGetApp().preset_bundle->get_printer_extruder_count();
    Slic3r::DynamicPrintConfig *project_config = &wxGetApp().preset_bundle->project_config;
 
    // Verify whether it is the first time start Studio
    size_t filament_nums = project_config->option<ConfigOptionStrings>("filament_colour")->values.size();
    size_t flush_volume_size = project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values.size();
 
    assert(nozzle_nums == new_nozzle_size);
    if (old_nozzle_size < new_nozzle_size) {
 
        std::vector<double>  first_flush_volume_mtx = get_flush_volumes_matrix(project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values, -1, old_nozzle_size);
        if (first_flush_volume_mtx.size() == filament_nums * filament_nums * new_nozzle_size) { // load file
            set_flush_volumes_matrix(project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values, first_flush_volume_mtx, -1, new_nozzle_size);
        } else {
            first_flush_volume_mtx.resize(filament_nums * filament_nums, 0);
            std::vector<double> flush_volume_mtx;
            for (size_t i = 0; i < new_nozzle_size; ++i) {
                flush_volume_mtx.insert(flush_volume_mtx.end(), first_flush_volume_mtx.begin(), first_flush_volume_mtx.end());
            }
            set_flush_volumes_matrix(project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values, flush_volume_mtx, -1, new_nozzle_size);
        }
        std::vector<double> flush_multipliers = project_config->option<ConfigOptionFloats>("flush_multiplier")->values;
        flush_multipliers.resize(nozzle_nums, 1.f);
        project_config->option<ConfigOptionFloats>("flush_multiplier")->values = flush_multipliers;
    }
    else if (old_nozzle_size > new_nozzle_size) {
        std::vector<double> new_flush_volume_mtx;
        for (size_t i = 0; i < new_nozzle_size; ++i) {
            std::vector<double> flush_volume_mtx = get_flush_volumes_matrix(project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values, -1, old_nozzle_size);
            flush_volume_mtx.resize(filament_nums * filament_nums, 0);
            new_flush_volume_mtx.insert(new_flush_volume_mtx.end(), flush_volume_mtx.begin(), flush_volume_mtx.end());
        }
 
        std::vector<double> flush_multipliers = project_config->option<ConfigOptionFloats>("flush_multiplier")->values;
        flush_multipliers.resize(nozzle_nums, 1.f);
        set_flush_volumes_matrix(project_config->option<ConfigOptionFloats>("flush_volumes_matrix")->values, new_flush_volume_mtx, -1, new_nozzle_size);
        project_config->option<ConfigOptionFloats>("flush_multiplier")->values = flush_multipliers;
    }
}

References Slic3r::get_flush_volumes_matrix(), Slic3r::ConfigBase::option(), Slic3r::set_flush_volumes_matrix(), and Slic3r::ConfigOptionVector< T >::size().

Referenced by on_config_change().

Here is the call graph for this function:

Here is the caller graph for this function:

update_machine_sync_status()

void Slic3r::GUI::Plater::update_machine_sync_status

(

)

{
    DeviceManager *dev_maneger = wxGetApp().getDeviceManager();
    if (!dev_maneger) {
        GUI::wxGetApp().sidebar().update_sync_status(nullptr);
        return;
    }
    MachineObject *obj = wxGetApp().getDeviceManager()->get_selected_machine();
    GUI::wxGetApp().sidebar().update_sync_status(obj);
}

update_menus()

void Slic3r::GUI::Plater::update_menus

(

)

{ p->menus.update(); }

References p.

update_obj_preview_thumbnail()

void Slic3r::GUI::Plater::update_obj_preview_thumbnail	(	ModelObject *	mo,
		int	obj_idx,
		int	vol_idx,
		std::vector< Slic3r::ColorRGBA >	colors,
		int	camera_view_angle_type )

{
    PartPlate *      plate            = get_partplate_list().get_plate(0);
    ThumbnailsParams thumbnail_params = {{}, false, true, true, true, 0, false};
    GLVolumeCollection cur_volumes;
    cur_volumes.load_object_volume(mo, obj_idx, vol_idx, 0, "volume", true, false, false, false);
    ModelObjectPtrs model_objects;
    model_objects.emplace_back(mo);
    get_view3D_canvas3D()->render_thumbnail(plate->obj_preview_thumbnail_data, colors, plate->plate_thumbnail_width, plate->plate_thumbnail_height, thumbnail_params,
                                            model_objects, cur_volumes, Camera::EType::Ortho, (Camera::ViewAngleType) camera_view_angle_type, false, false);
}

References get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), get_view3D_canvas3D(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GUI::PartPlate::obj_preview_thumbnail_data, Slic3r::GUI::Camera::Ortho, Slic3r::GUI::PartPlate::plate_thumbnail_height, Slic3r::GUI::PartPlate::plate_thumbnail_width, and Slic3r::GUI::GLCanvas3D::render_thumbnail().

Here is the call graph for this function:

update_objects_position_when_select_preset()

void Slic3r::GUI::Plater::update_objects_position_when_select_preset

(

const std::function< void()> &

select_prest

)

{
    p->update_objects_position_when_select_preset(select_prest);
}

References p.

Referenced by Slic3r::GUI::Plater::priv::on_select_preset().

Here is the caller graph for this function:

update_plate_thumbnails()

void Slic3r::GUI::Plater::update_plate_thumbnails	(	int	plate_idx,
		bool	force_update )

{
    PartPlate* plate = get_partplate_list().get_plate(plate_idx);
    ThumbnailsParams thumbnail_params = { {}, false, true, true, true, plate_idx};
    if (force_update || !plate->thumbnail_data.is_valid()) {
        get_view3D_canvas3D()->render_thumbnail(plate->thumbnail_data, plate->plate_thumbnail_width, plate->plate_thumbnail_height, thumbnail_params, Camera::EType::Ortho);
    }
    if (force_update || !plate->no_light_thumbnail_data.is_valid()) {
        get_view3D_canvas3D()->render_thumbnail(plate->no_light_thumbnail_data, plate->plate_thumbnail_width, plate->plate_thumbnail_height, thumbnail_params,
                                                Camera::EType::Ortho, Camera::ViewAngleType::Iso, false, true);
    }
}

References get_partplate_list(), Slic3r::GUI::PartPlateList::get_plate(), get_view3D_canvas3D(), Slic3r::ThumbnailData::is_valid(), Slic3r::GUI::Camera::Iso, Slic3r::GUI::PartPlate::no_light_thumbnail_data, Slic3r::GUI::Camera::Ortho, Slic3r::GUI::PartPlate::plate_thumbnail_height, Slic3r::GUI::PartPlate::plate_thumbnail_width, Slic3r::GUI::GLCanvas3D::render_thumbnail(), and Slic3r::GUI::PartPlate::thumbnail_data.

Referenced by update_all_plate_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

update_preview_bottom_toolbar()

void Slic3r::GUI::Plater::update_preview_bottom_toolbar

(

)

{
    p->update_preview_bottom_toolbar();
}

References p.

update_preview_moves_slider()

void Slic3r::GUI::Plater::update_preview_moves_slider

(

)

update_print_error_info()

void Slic3r::GUI::Plater::update_print_error_info	(	int	code,
		std::string	msg,
		std::string	extra )

{
    if (p->m_select_machine_dlg) {
        p->m_select_machine_dlg->update_print_error_info(code, msg, extra);
    }
 
    if (p->m_send_to_sdcard_dlg) {
        p->m_send_to_sdcard_dlg->update_print_error_info(code, msg, extra);
    }
    if (CalibrationPanel* calibration = CalibrationPanel::if_built())
        calibration->update_print_error_info(code, msg, extra);
}

References Slic3r::GUI::LazyInstance< CalibrationPanel >::if_built(), and p.

Here is the call graph for this function:

update_print_required_data()

int Slic3r::GUI::Plater::update_print_required_data	(	Slic3r::DynamicPrintConfig	config,
		Slic3r::Model	model,
		Slic3r::PlateDataPtrs	plate_data_list,
		std::string	file_name,
		std::string	file_path )

{
    return p->update_print_required_data(config, model, plate_data_list, file_name, file_path);
}

References config(), model(), and p.

Here is the call graph for this function:

update_project_dirty_from_presets()

void Slic3r::GUI::Plater::update_project_dirty_from_presets

(

)

{ p->update_project_dirty_from_presets(); }

References p.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), load_gcode(), load_project(), new_project(), open_platesettings_dialog(), and select_plate_by_hover_id().

Here is the caller graph for this function:

update_slicing_context_to_current_partplate()

void Slic3r::GUI::Plater::update_slicing_context_to_current_partplate

(

)

{
    p->partplate_list.update_slice_context_to_current_plate(p->background_process);
    p->preview->update_gcode_result(p->partplate_list.get_current_slice_result());
}

References p.

update_title_dirty_status()

void Slic3r::GUI::Plater::update_title_dirty_status

(

)

{
    p->update_title_dirty_status();
}

References p.

Referenced by on_config_change(), save_project(), and Slic3r::GUI::Plater::priv::undo_redo_to().

Here is the caller graph for this function:

update_ui_from_settings()

void Slic3r::GUI::Plater::update_ui_from_settings

(

)

{ p->update_ui_from_settings(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::on_create_filament(), and Slic3r::GUI::Plater::priv::on_modify_filament().

Here is the caller graph for this function:

using_exported_file()

bool Slic3r::GUI::Plater::using_exported_file ( )

inline

{ return m_exported_file; }

References m_exported_file.

Referenced by export_3mf(), force_update_all_plate_thumbnails(), invalid_all_plate_thumbnails(), and load_project().

Here is the caller graph for this function:

validate_current_plate()

void Slic3r::GUI::Plater::validate_current_plate	(	bool &	model_fits,
		bool &	validate_error )

{
    ObjectFilamentResults object_results;
    ModelInstanceEPrintVolumeState state = p->view3D->get_canvas3d()->check_volumes_outside_state(&object_results);
    model_fits = (state != ModelInstancePVS_Partly_Outside);
 
    PartPlate *cur_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    if (model_fits) {  // TPU check
        bool  tpu_valid = cur_plate->check_tpu_printable_status(wxGetApp().preset_bundle->full_config(), wxGetApp().preset_bundle->get_used_tpu_filaments(cur_plate->get_extruders(true)));
        model_fits &= tpu_valid;
    }
 
    if (model_fits) { // Filament printable check
        wxString filament_printable_error_msg;
        bool filament_printable = cur_plate->check_filament_printable(wxGetApp().preset_bundle->full_config(), filament_printable_error_msg);
        model_fits &= filament_printable;
    }
 
    model_fits = model_fits && object_results.filaments.empty();
    validate_error = false;
    if (p->printer_technology == ptFFF) {
        //std::string plater_text = _u8L("An object is laid over the boundary of plate or exceeds the height limit.\n"
        //            "Please solve the problem by moving it totally on or off the plate, and confirming that the height is within the build volume.");;
        std::vector<StringObjectException> warnings;
        Polygons polygons;
        std::vector<std::pair<Polygon, float>> height_polygons;
        p->background_process.fff_print()->set_check_multi_filaments_compatibility(wxGetApp().app_config->get("enable_high_low_temp_mixed_printing") == "false");
        StringObjectException err = p->background_process.validate(&warnings, &polygons, &height_polygons);
        // update string by type
        post_process_string_object_exception(err);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": validate err=%1%, warnings=%2%, model_fits %3%")%err.string%warnings.size() %model_fits;
 
        // The same check update_background_process() applies. Without it this path clears
        // the invalid flag and closes the notification on a plate that is still unslicable.
        // model_fits is set too, mirroring the missing-plugin block further down: the slice
        // is already gated by m_apply_invalid, but leaving m_ready_for_slice true would be a
        // trap for any future consumer that reads it on its own.
        if (err.string.empty()) {
            err.string = imex_placement_error(p->partplate_list.get_curr_plate());
            if (!err.string.empty())
                model_fits = false;
        }
 
        if (err.string.empty()) {
            p->partplate_list.get_curr_plate()->update_apply_result_invalid(false);
            p->notification_manager->set_all_slicing_errors_gray(true);
            p->notification_manager->close_notification_of_type(NotificationType::ValidateError);
            p->notification_manager->bbl_close_3mf_warn_notification();
 
            p->process_validation_warnings(warnings);
            p->view3D->get_canvas3d()->reset_sequential_print_clearance();
            p->view3D->get_canvas3d()->set_as_dirty();
            p->view3D->get_canvas3d()->request_extra_frame();
        }
        else {
            // The print is not valid.
            p->partplate_list.get_curr_plate()->update_apply_result_invalid(true);
            // Show error as notification.
            p->notification_manager->push_validate_error_notification(err);
            p->process_validation_warnings(warnings);
            //model_fits = false;
            validate_error = true;
            p->view3D->get_canvas3d()->set_sequential_print_clearance_visible(true);
            p->view3D->get_canvas3d()->set_sequential_print_clearance_render_fill(true);
            p->view3D->get_canvas3d()->set_sequential_print_clearance_polygons(polygons, height_polygons);
        }
 
        std::string clashed_text = get_object_clashed_text();
        if (state == ModelInstancePVS_Partly_Outside) {
            p->notification_manager->push_plater_error_notification(clashed_text);
        }
        else {
            p->notification_manager->close_plater_error_notification(clashed_text);
        }
        std::string left_unprintable_text = get_left_extruder_unprintable_text(), right_unprintable_text = get_right_extruder_unprintable_text();
        if (!left_unprintable_text.empty())
        {
            p->notification_manager->bbl_show_filament_map_invalid_notification_before_slice(NotificationType::LeftExtruderUnprintableError, left_unprintable_text);
        }
        else {
            p->notification_manager->bbl_close_filament_map_invalid_notification_before_slice(NotificationType::LeftExtruderUnprintableError);
        }
 
        if (!right_unprintable_text.empty())
        {
            p->notification_manager->bbl_show_filament_map_invalid_notification_before_slice(NotificationType::RightExtruderUnprintableError,right_unprintable_text);
        }
        else {
            p->notification_manager->bbl_close_filament_map_invalid_notification_before_slice(NotificationType::RightExtruderUnprintableError);
        }
 
        /*if (state == ModelInstancePVS_Limited) {
            p->notification_manager->push_plater_warning_notification(get_object_limited_text());
        }
        else {
            p->notification_manager->close_plater_warning_notification(get_object_limited_text());
        }*/
    }
 
    // Missing-plugin validation (both technologies): block slicing while the active preset(s)
    // reference plugin capabilities that are not installed/loadable here. The helper rebuilds the
    // missing sets, manages the notifications, and reports whether slicing is blocked. plugins_block_changed
    // is set when the block toggled, so the Slice button can be refreshed below.
    bool plugins_block_changed = false;
    if (refresh_missing_plugin_block(&plugins_block_changed)) {
        model_fits     = false;
        validate_error = true;
    }
 
    PartPlate* part_plate = p->partplate_list.get_curr_plate();
    part_plate->update_slice_ready_status(model_fits);
 
    // The toolbar Slice button is normally refreshed only by the canvas
    // (EVT_GLCANVAS_ENABLE_ACTION_BUTTONS) on geometry updates. When the missing-plugin block toggles
    // without a geometry change (e.g. a plugin finishing loading, or a setting edit that drops the
    // last missing plugin), refresh it here — AFTER update_slice_ready_status set the plate's
    // can_slice() flag that get_enable_slice_status() reads — so the button doesn't lag until the
    // next bed click.
    if (plugins_block_changed && !p->background_process.running())
        p->main_frame->update_slice_print_status(MainFrame::eEventObjectUpdate, model_fits);
 
    return;
}

References Slic3r::GUI::PartPlate::check_filament_printable(), Slic3r::GUI::PartPlate::check_tpu_printable_status(), Slic3r::GUI::MainFrame::eEventObjectUpdate, Slic3r::GUI::filament_printable_error_msg, Slic3r::ObjectFilamentResults::filaments, Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::get_left_extruder_unprintable_text(), Slic3r::GUI::get_object_clashed_text(), Slic3r::GUI::get_right_extruder_unprintable_text(), Slic3r::GUI::LeftExtruderUnprintableError, Slic3r::ModelInstancePVS_Partly_Outside, p, post_process_string_object_exception(), Slic3r::ptFFF, refresh_missing_plugin_block(), Slic3r::GUI::RightExtruderUnprintableError, Slic3r::StringObjectException::string, Slic3r::GUI::PartPlate::update_slice_ready_status(), and Slic3r::GUI::ValidateError.

Referenced by revalidate_current_plate_if_plugins_missing(), select_plate(), and select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

PlaterDropTarget

friend class PlaterDropTarget

friend

References PlaterDropTarget.

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

SuppressBackgroundProcessingUpdate

friend class SuppressBackgroundProcessingUpdate

friend

References SuppressBackgroundProcessingUpdate.

Referenced by PopupMenu(), and SuppressBackgroundProcessingUpdate.

Member Data Documentation

m_3mf_path

std::string Slic3r::GUI::Plater::m_3mf_path

private

Referenced by get_3mf_filename().

m_arrange_running

std::atomic<bool> Slic3r::GUI::Plater::m_arrange_running {false}

{false};

Referenced by last_arrange_job_is_finished().

m_b_plate_toolbar_image_dirty

bool Slic3r::GUI::Plater::m_b_plate_toolbar_image_dirty { true }

private

{ true };

Referenced by clear_plate_toolbar_image_dirty(), is_plate_toolbar_image_dirty(), and mark_plate_toolbar_image_dirty().

m_check_status

int Slic3r::GUI::Plater::m_check_status = 0

private

Referenced by check_ams_status(), and reset_check_status().

m_exported_file

bool Slic3r::GUI::Plater::m_exported_file { false }

private

{ false };

Referenced by is_gcode_3mf(), load_files(), load_project(), new_project(), set_using_exported_file(), and using_exported_file().

m_gcode_settings_loaded

bool Slic3r::GUI::Plater::m_gcode_settings_loaded { false }

private

{ false };

Referenced by gcode_settings_loaded(), and load_gcode().

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_loading_project

bool Slic3r::GUI::Plater::m_loading_project { false }

private

{ false };

Referenced by is_loading_project(), load_project(), and new_project().

m_new_project_and_check_state

bool Slic3r::GUI::Plater::m_new_project_and_check_state {false}

private

{false};

Referenced by is_new_project_and_check_state(), and new_project().

m_only_gcode

bool Slic3r::GUI::Plater::m_only_gcode { false }

private

{ false };//just for .gcode file not for .gcode.3mf

Referenced by Plater(), gcode_settings_loaded(), load_files(), load_gcode(), load_project(), new_project(), only_gcode_mode(), and set_only_gcode().

m_plate_toolbar_image_version

unsigned Slic3r::GUI::Plater::m_plate_toolbar_image_version { 0 }

private

{ 0 };

Referenced by mark_plate_toolbar_image_dirty(), and plate_toolbar_image_version().

m_preview_only_filename

std::string Slic3r::GUI::Plater::m_preview_only_filename

private

Referenced by get_preview_only_filename().

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

m_valid_plates_count

int Slic3r::GUI::Plater::m_valid_plates_count { 0 }

private

{ 0 };

p

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

private

Referenced by Plater(), _calib_pa_pattern(), _calib_pa_select_added_objects(), _calib_temp_belt_sectioned(), add_dock_pane(), add_file(), add_model(), add_plate(), allow_snapshots(), apply_background_progress(), apply_cut_object_to_model(), are_view3D_labels_shown(), arrange(), background_process(), bring_instance_forward(), build_volume(), Calib_Cornering(), calib_input_shaping_damp(), calib_input_shaping_freq(), calib_max_vol_speed(), calib_pa(), calib_retraction(), calib_temp(), calib_VFA(), can_add_plate(), can_arrange(), can_copy_to_clipboard(), can_decrease_instances(), can_delete(), can_delete_all(), can_delete_plate(), can_fillcolor(), can_fix_through_cgal(), can_increase_instances(), can_layers_editing(), can_mirror(), can_paste_from_clipboard(), can_redo(), can_reload_from_disk(), can_replace_all_with_stl(), can_replace_with_stl(), can_set_instance_to_object(), can_simplify(), can_smooth_mesh(), can_split(), can_split_to_objects(), can_split_to_volumes(), can_undo(), canvas3D(), canvas3D(), center_selection(), changed_mesh(), changed_object(), changed_object(), changed_objects(), check_ams_status(), clear_undo_redo_stack_main(), collapse_sidebar(), Slic3r::GUI::collect_imex_warnings(), config(), convert_unit(), copy_selection_to_clipboard(), cut_horizontal(), cut_selection_to_clipboard(), decrease_instances(), default_menu(), delete_all_objects_from_model(), delete_object_from_model(), delete_plate(), deselect_all(), drop_selection(), duplicate_plate(), eject_drive(), enable_sidebar(), enable_wireframe(), enter_gizmos_stack(), exit_gizmo(), export_3mf(), export_3mf_copy(), export_config_3mf(), export_core_3mf(), export_gcode(), export_gcode_3mf(), export_published_3mf(), export_stl(), export_toolpaths_to_obj(), fff_print(), fff_print(), filament_action_menu(), fill_bed_with_copies(), fill_bed_with_instances(), fill_color(), find_new_position(), force_filament_colors_update(), force_print_bed_update(), format_imex_ghost_tooltip(), get_assmeble_canvas3D(), get_build_volume_type(), get_camera(), get_camera(), get_collapse_toolbar(), get_collapse_toolbar(), get_colors_for_color_print(), get_current_canvas3D(), get_export_gcode_filename(), get_machine_sync_status(), get_mouse3d_controller(), get_mouse3d_controller(), get_notification_manager(), get_notification_manager(), get_partplate_list(), get_pending_published(), get_prepare_state(), get_preview_canvas3D(), get_print_job_data(), get_project_filename(), get_project_name(), get_select_machine_dialog(), get_selected_object_idx(), get_selection(), get_sidebar_docking_state(), get_ui_job_worker(), get_ui_job_worker(), get_uv_editor_canvas(), get_view3D_canvas3D(), GetPlateIndexByRightMenuInLeftUI(), has_assmeble_view(), has_toolpaths_to_export(), import_model_id(), import_sl1_archive(), increase_instances(), init_collapse_toolbar(), init_notification_manager(), inside_snapshot_capture(), instance_menu(), is_background_process_slicing(), is_background_process_update_scheduled(), is_export_gcode_scheduled(), is_multi_extruder_ams_empty(), is_presets_dirty(), is_preview_loaded(), is_preview_shown(), is_project_dirty(), is_render_statistic_dialog_visible(), is_selection_empty(), is_show_wireframe(), is_show_xray(), is_sidebar_collapsed(), is_sidebar_enabled(), is_single_full_object_selection(), is_view3D_overhang_shown(), is_view3D_shown(), is_wireframe_enabled(), layer_menu(), leave_gizmos_stack(), load_gcode(), load_project(), mirror(), model(), model(), msw_rescale(), multi_selection_menu(), need_update(), new_project(), normalize_bed_types(), object_list_changed(), object_menu(), on_activate(), on_config_change(), on_filaments_delete(), on_imex_ghost_click(), open_filament_map_setting_dialog(), open_platesettings_dialog(), optimize_rotation(), orient(), part_menu(), paste_from_clipboard(), plate_menu(), PopupObjectTable(), PopupObjectTableBySelection(), print_job_finished(), printer_technology(), redo(), redo_to(), refresh_belt_view(), refresh_missing_plugin_block(), reload_all_from_disk(), reload_from_disk(), reload_paint_after_background_process_apply(), reload_print(), remove(), remove_curr_plate_all(), remove_dock_pane(), remove_dock_panes(), remove_selected(), replace_all_with_stl(), replace_with_stl(), reset(), reset_canvas_volumes(), reset_gcode_toolpaths(), reset_project_dirty_after_save(), reset_project_dirty_initial_presets(), reset_window_layout(), reset_with_confirm(), reslice(), reslice_SLA_until_step(), revalidate_current_plate_if_plugins_missing(), save_project(), save_project_if_dirty(), scale_selection_to_fit_print_volume(), schedule_background_process(), search(), search_string_getter(), select_all(), select_curr_plate_all(), select_plate(), select_plate_by_hover_id(), select_sliced_plate(), select_view(), select_view_3D(), send_calibration_job_finished(), send_gcode(), send_gcode_finish(), send_gcode_legacy(), send_job_finished(), send_to_printer(), set_bed_position(), set_bed_shape(), set_bed_shape(), set_current_canvas_as_dirty(), Slic3r::GUI::Plater::priv::set_current_panel(), set_global_filament_map(), set_need_update(), set_number_of_copies(), set_pending_published(), set_plater_dirty(), set_prepare_state(), set_print_job_plate_idx(), set_printer_technology(), set_project_filename(), set_selected_visible(), SetPlateIndexByRightMenuInLeftUI(), show_collision_volumes(), show_dock_pane(), show_object_info(), show_uv_editor(), show_view3D_labels(), show_view3D_overhang(), sidebar(), single_snapshots_enter(), single_snapshots_leave(), sla_object_menu(), sla_print(), sla_print(), split_object(), split_volume(), start_next_slice(), suppress_background_process(), suppress_snapshots(), svg_part_menu(), sys_color_changed(), take_snapshot(), take_snapshot(), text_part_menu(), toggle_render_statistic_dialog(), toggle_show_wireframe(), toggle_show_xray(), unbind_canvas_event_handlers(), undo(), undo_redo_stack_main(), undo_redo_string_getter(), undo_redo_topmost_string_getter(), undo_to(), up_to_date(), update(), update_filament_colors_in_full_config(), update_menus(), update_objects_position_when_select_preset(), update_preview_bottom_toolbar(), update_print_error_info(), update_print_required_data(), update_project_dirty_from_presets(), update_slicing_context_to_current_partplate(), update_title_dirty_status(), update_ui_from_settings(), and validate_current_plate().

skip_thumbnail_invalid

bool Slic3r::GUI::Plater::skip_thumbnail_invalid { false }

private

{ false };

Referenced by force_update_all_plate_thumbnails(), and invalid_all_plate_thumbnails().

---

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

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