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

Inheritance diagram for Slic3r::GUI::PartPlateList:

Collaboration diagram for Slic3r::GUI::PartPlateList:

Classes
class	BedTextureInfo
struct	Rect

Public Types
using	Timestamp = uint64_t

Public Member Functions
void	set_default_wipe_tower_pos_for_plate (int plate_idx, bool init_pos=false)
	PartPlateList (int width, int depth, double height, Plater platerObj, Model modelObj, PrinterTechnology tech=ptFFF)
	PartPlateList (Plater platerObj, Model modelObj, PrinterTechnology tech=ptFFF)
	~PartPlateList ()
void	reset_size (int width, int depth, double height, bool reload_objects=true, bool update_shapes=false)
void	clear (bool delete_plates=false, bool release_print_list=false, bool except_locked=false, int plate_index=-1)
void	reset (bool do_init)
Vec3d	compute_origin_using_new_size (int i, int new_width, int new_depth)
void	reinit ()
double	plate_stride_x ()
double	plate_stride_y ()
void	get_plate_size (int &width, int &depth, double &height)
void	update_plates ()
void	invalidate_exclusion_volume_previews ()
void	render_exclusion_volume_intersections (const Transform3d &view_matrix, const Transform3d &projection_matrix)
int	create_plate (bool adjust_position=true)
int	duplicate_plate (int index)
int	destroy_print (int print_index)
int	delete_plate (int index)
void	delete_selected_plate ()
bool	check_all_plate_local_bed_type (const std::vector< BedType > &cur_bed_types)
PartPlate *	get_plate (int index)
void	get_height_limits (float &height_to_lid, float &height_to_rod)
void	set_height_limits_mode (PartPlate::HeightLimitMode mode)
int	get_curr_plate_index () const
PartPlate *	get_curr_plate ()
const PartPlate *	get_curr_plate () const
std::vector< PartPlate * > &	get_plate_list ()
PartPlate *	get_selected_plate ()
std::vector< PartPlate * >	get_nonempty_plate_list ()
std::vector< const GCodeProcessorResult * >	get_nonempty_plates_slice_results ()
Vec3d	get_current_plate_origin ()
Vec2d	get_current_shape_position ()
Pointfs	get_exclude_area ()
Pointfs	get_wrapping_exclude_area () const
std::set< int >	get_extruders (bool conside_custom_gcode=false) const
int	select_plate (int index)
int	get_plate_count () const
void	invalidate_all_imex_ghosts ()
void	update_plate_cols ()
void	update_all_plates_pos_and_size (bool adjust_position=true, bool with_unprintable_move=true, bool switch_plate_type=false, bool do_clear=true)
int	get_plate_cols ()
int	move_plate_to_index (int old_index, int new_index)
int	lock_plate (int index, bool state)
bool	is_locked (int index)
int	find_plate_by_print_index (int index)
int	find_instance (int obj_id, int instance_id)
int	find_instance (BoundingBoxf3 &bounding_box)
int	find_instance_belongs (int obj_id, int instance_id)
int	notify_instance_update (int obj_id, int instance_id, bool is_new=false)
int	notify_instance_removed (int obj_id, int instance_id)
int	add_to_plate (int obj_id, int instance_id, int plate_id)
int	reload_all_objects (bool except_locked=false, int plate_index=-1)
int	construct_objects_list_for_new_plate (int plate_index)
int	compute_plate_index (arrangement::ArrangePolygon &arrange_polygon)
bool	preprocess_arrange_polygon (int obj_index, int instance_index, arrangement::ArrangePolygon &arrange_polygon, bool selected)
bool	preprocess_arrange_polygon_other_locked (int obj_index, int instance_index, arrangement::ArrangePolygon &arrange_polygon, bool selected)
bool	preprocess_exclude_areas (arrangement::ArrangePolygons &unselected, const DynamicPrintConfig &config, bool enable_wrapping_detect, int num_plates=16, float inflation=0)
bool	preprocess_nonprefered_areas (arrangement::ArrangePolygons &regions, int num_plates=1, float inflation=0)
void	postprocess_bed_index_for_selected (arrangement::ArrangePolygon &arrange_polygon)
void	postprocess_bed_index_for_unselected (arrangement::ArrangePolygon &arrange_polygon)
void	postprocess_bed_index_for_current_plate (arrangement::ArrangePolygon &arrange_polygon)
void	postprocess_arrange_polygon (arrangement::ArrangePolygon &arrange_polygon, bool selected)
void	on_change_color_mode (bool is_dark)
void	render (const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, bool only_current=false, bool only_body=false, int hover_id=-1, bool render_cali=false, bool show_grid=true, bool hide_chrome=false, bool hide_inactive=false)
void	set_render_option (bool bedtype_texture, bool plate_settings)
void	set_render_cali (bool value=true)
void	render_hover_tooltip () const
void	clear_hover_tooltip ()
void	register_raycasters_for_picking (GLCanvas3D &canvas)
BoundingBoxf3 &	get_bounding_box ()
int	select_plate_by_obj (int obj_index, int instance_index)
void	calc_bounding_boxes ()
void	select_plate_view ()
bool	set_shapes (const Pointfs &shape, const Pointfs &exclude_areas, const Pointfs &wrapping_exclude_areas, const std::vector< Pointfs > &extruder_areas, const std::vector< double > &extruder_heights, const std::string &custom_texture, float height_to_lid, float height_to_rod)
void	set_hover_id (int id)
void	reset_hover_id ()
bool	intersects (const BoundingBoxf3 &bb)
bool	contains (const BoundingBoxf3 &bb)
const std::string &	get_logo_texture_filename ()
void	update_logo_texture_filename (const std::string &texture_filename)
void	update_slice_context_to_current_plate (BackgroundSlicingProcess &process)
Print &	get_current_fff_print () const
GCodeProcessorResult *	get_current_slice_result () const
int	create_plate_from_gcode_file (const std::string &filename)
void	invalid_all_slice_result ()
void	update_current_slice_result_state (bool valid)
bool	is_all_slice_results_valid () const
bool	is_all_slice_results_ready_for_print () const
bool	is_all_plates_ready_for_slice () const
bool	is_all_slice_result_ready_for_export () const
void	print () const
void	get_sliced_result (std::vector< bool > &sliced_result, std::vector< std::string > &gcode_paths)
int	rebuild_plates_after_deserialize (std::vector< bool > &previous_sliced_result, std::vector< std::string > &previous_gcode_paths)
int	rebuild_plates_after_arrangement (bool recycle_plates=true, bool except_locked=false, int plate_index=-1)
int	store_to_3mf_structure (PlateDataPtrs &plate_data_list, bool with_slice_info=true, int plate_idx=-1, bool with_statistics=false)
int	load_from_3mf_structure (PlateDataPtrs &plate_data_list, int filament_count=1)
int	load_gcode_files ()
template<class Archive>
void	serialize (Archive &ar)
bool	calc_extruder_only_area (Rect &left_only_rect, Rect &right_only_rect)
void	init_bed_type_info ()
bool	init_extruder_only_area_info ()
void	load_bedtype_textures ()
bool	load_next_bedtype_texture ()
void	load_extruder_only_area_textures ()
bool	load_next_extruder_only_area_texture ()
bool	load_logo_texture ()
void	show_cali_texture (bool show=true)
void	init_cali_texture_info ()
void	load_cali_textures ()
bool	load_next_cali_texture ()
bool	icon_textures_loaded () const
void	load_icon_textures ()
bool	load_next_plate_texture ()
void	on_extruder_count_changed (int extruder_count)
void	refresh_imex_icons ()
void	set_filament_count (int filament_count)
void	on_filament_deleted (int filament_count, int filament_id)
void	on_filament_added (int filament_count)
ObjectID	id () const
virtual Timestamp	timestamp () const

Public Attributes
std::map< int, bool >	m_allow_bed_type_in_double_nozzle
BedTextureInfo	bed_texture_info [btCount]
BedTextureInfo	cali_texture_info
BedTextureInfo	extruder_only_area_info [(unsigned char) Slic3r::ExtruderOnlyAreaType::btAreaCount]

Static Public Attributes
static constexpr unsigned int	MAX_PLATES_COUNT = MAX_PLATE_COUNT
static GLTexture	bed_textures [(unsigned int) btCount]
static bool	is_load_bedtype_textures = false
static bool	is_load_cali_texture = false
static bool	is_load_extruder_only_area_textures = false

Protected Member Functions
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Private Member Functions
void	init ()
Vec3d	compute_origin (int index, int column_count)
Vec3d	compute_origin_for_unprintable ()
Vec2d	compute_shape_position (int index, int cols)
void	generate_icon_textures ()
void	release_icon_textures ()

Static Private Member Functions
static ObjectID	generate_new_id ()
template<class Archive>
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
Plater *	m_plater
Model *	m_model
PrinterTechnology	printer_technology
std::vector< PartPlate * >	m_plate_list
std::map< int, PrintBase * >	m_print_list
std::map< int, GCodeResult * >	m_gcode_result_list
std::mutex	m_plates_mutex
int	m_plate_count
int	m_plate_cols
int	m_current_plate
int	m_print_index
int	m_plate_width
int	m_plate_depth
double	m_plate_height
float	m_height_to_lid
float	m_height_to_rod
PartPlate::HeightLimitMode	m_height_limit_mode {PartPlate::HEIGHT_LIMIT_BOTH}
PartPlate	unprintable_plate
Pointfs	m_shape
Pointfs	m_exclude_areas
Pointfs	m_wrapping_exclude_areas
std::vector< Pointfs >	m_extruder_areas
std::vector< double >	m_extruder_heights
BoundingBoxf3	m_bounding_box
bool	m_intialized
std::string	m_logo_texture_filename
GLTexture	m_logo_texture
GLTexture	m_del_texture
GLTexture	m_del_hovered_texture
GLTexture	m_move_front_hovered_texture
GLTexture	m_move_front_texture
GLTexture	m_arrange_texture
GLTexture	m_arrange_hovered_texture
GLTexture	m_orient_texture
GLTexture	m_orient_hovered_texture
GLTexture	m_locked_texture
GLTexture	m_locked_hovered_texture
GLTexture	m_lockopen_texture
GLTexture	m_lockopen_hovered_texture
GLTexture	m_plate_settings_texture
GLTexture	m_plate_settings_changed_texture
GLTexture	m_plate_settings_hovered_texture
GLTexture	m_plate_settings_changed_hovered_texture
GLTexture	m_plate_set_filament_map_texture
GLTexture	m_plate_set_filament_map_hovered_texture
GLTexture	m_plate_name_edit_texture
GLTexture	m_plate_name_edit_hovered_texture
std::array< GLTexture, 4 >	m_imex_mode_textures
std::array< GLTexture, 4 >	m_imex_mode_hovered_textures
GLTexture	m_imex_warn_texture
GLTexture	m_idx_textures [MAX_PLATE_COUNT]
bool	render_bedtype_logo = true
bool	render_plate_settings = true
bool	render_cali_logo = true
std::string	m_hover_tooltip
bool	m_is_dark = false
bool	m_icon_textures_dark = false
int	m_filament_count = 1
size_t	m_next_bedtype_texture { 0 }
size_t	m_next_cali_texture { 0 }
size_t	m_next_extruder_only_area_texture { 0 }
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	cereal::access
class	UndoRedo::StackImpl
class	PartPlate

Detailed Description

Class Documentation

◆ Slic3r::GUI::PartPlateList::Rect

struct Slic3r::GUI::PartPlateList::Rect

Class Members
int	h
int	w
int	x
int	y

Member Typedef Documentation

◆ Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Constructor & Destructor Documentation

◆ PartPlateList() [1/2]

Slic3r::GUI::PartPlateList::PartPlateList	(	int	width,
		int	depth,
		double	height,
		Plater *	platerObj,
		Model *	modelObj,
		PrinterTechnology	tech = ptFFF )

  :m_plate_width(width), m_plate_depth(depth), m_plate_height(height), m_plater(platerObj), m_model(modelObj), printer_technology(tech),
  unprintable_plate(this, Vec3d(0.0 + width * (1. + LOGICAL_PART_PLATE_GAP), 0.0, 0.0), width, depth, height, platerObj, modelObj, false, tech)
{
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":plate_width %1%, plate_depth %2%, plate_height %3%") % width % depth % height;
 
  init();
}

References init(), LOGICAL_PART_PLATE_GAP, m_model, m_plate_depth, m_plate_height, m_plate_width, m_plater, printer_technology, and unprintable_plate.

Here is the call graph for this function:

◆ PartPlateList() [2/2]

Slic3r::GUI::PartPlateList::PartPlateList	(	Plater *	platerObj,
		Model *	modelObj,
		PrinterTechnology	tech = ptFFF )

  :m_plate_width(0), m_plate_depth(0), m_plate_height(0), m_plater(platerObj), m_model(modelObj), printer_technology(tech),
  unprintable_plate(this, Vec3d(0.0, 0.0, 0.0), m_plate_width, m_plate_depth, m_plate_height, platerObj, modelObj, false, tech)
{
  init();
}

References init(), m_model, m_plate_depth, m_plate_height, m_plate_width, m_plater, printer_technology, and unprintable_plate.

Here is the call graph for this function:

◆ ~PartPlateList()

Slic3r::GUI::PartPlateList::~PartPlateList ( )

{
  clear(true, true);
  release_icon_textures();
}

References clear(), and release_icon_textures().

Here is the call graph for this function:

Member Function Documentation

◆ add_to_plate()

int Slic3r::GUI::PartPlateList::add_to_plate	(	int	obj_id,
		int	instance_id,
		int	plate_id )

{
  int ret = 0, index;
  PartPlate* plate = NULL;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plate_id %1%, found obj_id %2%, instance_id %3%") % plate_id % obj_id % instance_id;
  index = find_instance(obj_id, instance_id);
  if (index != -1)
  {
    //found it added before
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in previous plate %1%") % index;
    if (index != plate_id)
    {
      //remove it from original plate first
      plate = m_plate_list[index];
      plate->remove_instance(obj_id, instance_id);
    }
    else
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": already in this plate, no need to be added");
      return 0;
    }
  }
  else
  {
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": not added to plate before, add it to center");
  }
  plate = get_plate(plate_id);
  if (!plate)
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":can not get plate for index %1%, size %2%") % index % m_plate_list.size();
    return -1;
  }
  ret = plate->add_instance(obj_id, instance_id, true);
 
  return ret;
}

References Slic3r::GUI::PartPlate::add_instance(), find_instance(), get_plate(), m_plate_list, PartPlate, and Slic3r::GUI::PartPlate::remove_instance().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::Model, Slic3r::ModelObject, and Slic3r::ModelVolume.

95{ this->set_new_unique_id(); }

Slic3r::ObjectBase::set_new_unique_id

void set_new_unique_id()

Definition ObjectID.hpp:89

References set_new_unique_id().

Here is the call graph for this function:

◆ calc_bounding_boxes()

void Slic3r::GUI::PartPlateList::calc_bounding_boxes ( )

{
  m_bounding_box.reset();
  std::vector<PartPlate*>::iterator it = m_plate_list.begin();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    m_bounding_box.merge((*it)->get_bounding_box(true));
  }
}

References m_bounding_box, and m_plate_list.

Referenced by create_plate(), delete_plate(), reinit(), and set_shapes().

Here is the caller graph for this function:

◆ calc_extruder_only_area()

bool Slic3r::GUI::PartPlateList::calc_extruder_only_area	(	Rect &	left_only_rect,
		Rect &	right_only_rect )

{
    auto                convert_to_rect         = [](const Pointfs &pts, Rect &rect) {
    rect.x = pts[0].x();
        rect.y = pts[0].y();
        rect.w = pts[1].x() - pts[0].x();
        rect.h = pts[2].y() - pts[1].y();
    };
    auto is_single_extruder = wxGetApp().preset_bundle->get_printer_extruder_count() ==1;
    if (is_single_extruder) {
    return false;
  }
    if (m_extruder_areas.size() == 2) {
        Rect printable_rect, left_extruder_printable_area, right_extruder_printable_area;
        convert_to_rect(m_shape, printable_rect);
        convert_to_rect(m_extruder_areas[0], left_extruder_printable_area);
        convert_to_rect(m_extruder_areas[1], right_extruder_printable_area);
        left_only_rect.x = left_extruder_printable_area.x;
        left_only_rect.y = left_extruder_printable_area.y;
        left_only_rect.w = printable_rect.w - right_extruder_printable_area.w;
        left_only_rect.h = left_extruder_printable_area.h;
 
        right_only_rect.x = left_extruder_printable_area.x + left_extruder_printable_area.w;
        right_only_rect.y = right_extruder_printable_area.y;
        right_only_rect.w = printable_rect.w - left_extruder_printable_area.w;
        right_only_rect.h = right_extruder_printable_area.h;
        if (left_only_rect.w < 0 || right_only_rect.w < 0) {
      return false;
    }
        return true;
  }
    return false;
}

References Slic3r::GUI::PartPlateList::Rect::h, m_extruder_areas, m_shape, Slic3r::GUI::PartPlateList::Rect::w, Slic3r::GUI::PartPlateList::Rect::x, and Slic3r::GUI::PartPlateList::Rect::y.

Referenced by init_extruder_only_area_info().

Here is the caller graph for this function:

◆ check_all_plate_local_bed_type()

bool Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type ( const std::vector< BedType > & cur_bed_types )

{
    std::string bed_type_key = "curr_bed_type";
    bool        is_ok        = true;
    for (int i = 0; i < m_plate_list.size(); i++) {
        PartPlate *plate = m_plate_list[i];
        if (plate->config()  && plate->config()->has(bed_type_key)) {
            BedType bed_type = plate->config()->opt_enum<BedType>(bed_type_key);
            if (bed_type == BedType::btDefault)
                continue;
            bool    find     = false;
            for (auto tmp_type : cur_bed_types) {
                if (bed_type == tmp_type) {
                    find = true;
                    break;
                }
            }
            if (!find) {
                plate->set_bed_type(BedType::btDefault);
                is_ok = false;
            }
        }
    }
    return is_ok;
}

References Slic3r::btDefault, Slic3r::GUI::PartPlate::config(), Slic3r::ConfigOptionResolver::has(), m_plate_list, Slic3r::DynamicConfig::opt_enum(), PartPlate, and Slic3r::GUI::PartPlate::set_bed_type().

Here is the call graph for this function:

◆ clear()

void Slic3r::GUI::PartPlateList::clear	(	bool	delete_plates = false,
		bool	release_print_list = false,
		bool	except_locked = false,
		int	plate_index = -1 )

{
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    if (except_locked && plate->is_locked())
      plate->clear(false);
    else if ((plate_index != -1) && (plate_index != i))
      plate->clear(false);
    else
      plate->clear();
    if (delete_plates)
      delete plate;
  }
 
  if (delete_plates)
  {
    //also delete print related to the plate
    m_plate_list.clear();
    m_current_plate = 0;
  }
 
  if (release_print_list)
  {
    for (std::map<int, PrintBase*>::iterator it = m_print_list.begin(); it != m_print_list.end(); ++it)
    {
      PrintBase* print = it->second;
      assert(print != NULL);
 
      delete print;
    }
    m_print_list.clear();
    for (std::map<int, GCodeResult*>::iterator it = m_gcode_result_list.begin(); it != m_gcode_result_list.end(); ++it)
    {
      GCodeResult* gcode = it->second;
      assert(gcode != NULL);
 
      delete gcode;
    }
    m_gcode_result_list.clear();
  }
 
  unprintable_plate.clear();
}

References Slic3r::GUI::PartPlate::clear(), Slic3r::GUI::gcode(), Slic3r::GUI::PartPlate::is_locked(), m_current_plate, m_gcode_result_list, m_plate_list, m_print_list, PartPlate, print(), and unprintable_plate.

Referenced by ~PartPlateList(), Slic3r::GUI::ArrangeJob::finalize(), load_from_3mf_structure(), reinit(), reload_all_objects(), reset(), reset_size(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_hover_tooltip()

void Slic3r::GUI::PartPlateList::clear_hover_tooltip ( )

inline

1061{ m_hover_tooltip.clear(); }

Slic3r::GUI::PartPlateList::m_hover_tooltip

std::string m_hover_tooltip

Definition PartPlate.hpp:830

References m_hover_tooltip.

◆ compute_origin()

Vec3d Slic3r::GUI::PartPlateList::compute_origin	(	int	index,
		int	column_count )

private

{
  Vec3d origin;
  Vec2d pos = compute_shape_position(i, cols);
  origin    = Vec3d(pos.x(), pos.y(), 0);
 
  return origin;
}

References compute_shape_position().

Referenced by compute_origin_for_unprintable(), create_plate(), delete_plate(), get_current_plate_origin(), move_plate_to_index(), and update_all_plates_pos_and_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_origin_for_unprintable()

Vec3d Slic3r::GUI::PartPlateList::compute_origin_for_unprintable ( )

private

{
  int max_count = m_plate_cols * m_plate_cols;
  if (m_plate_count == max_count)
    return compute_origin(max_count + m_plate_cols - 1, m_plate_cols + 1);
  else
    return compute_origin(m_plate_count, m_plate_cols);
}

References compute_origin(), m_plate_cols, and m_plate_count.

Referenced by create_plate(), delete_plate(), reinit(), and update_all_plates_pos_and_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_origin_using_new_size()

Vec3d Slic3r::GUI::PartPlateList::compute_origin_using_new_size	(	int	i,
		int	new_width,
		int	new_depth )

{
  Vec3d origin;
  int row, col;
 
  row = i / m_plate_cols;
  col = i % m_plate_cols;
 
  origin(0) = col * (new_width * (1. + LOGICAL_PART_PLATE_GAP));
  origin(1) = -row * (new_depth * (1. + LOGICAL_PART_PLATE_GAP));
  origin(2) = 0;
 
  return origin;
}

References LOGICAL_PART_PLATE_GAP, and m_plate_cols.

◆ compute_plate_index()

int Slic3r::GUI::PartPlateList::compute_plate_index ( arrangement::ArrangePolygon & arrange_polygon )

{
  int row, col;
 
  float col_value = (unscale<double>(arrange_polygon.translation(X))) / plate_stride_x();
  float row_value = (plate_stride_y() - unscale<double>(arrange_polygon.translation(Y))) / plate_stride_y();
 
  row = round(row_value);
  col = round(col_value);
 
  return row * m_plate_cols + col;
}

References m_plate_cols, plate_stride_x(), plate_stride_y(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

◆ compute_shape_position()

Vec2d Slic3r::GUI::PartPlateList::compute_shape_position	(	int	index,
		int	cols )

private

{
  Vec2d pos;
  int row, col;
 
  row = index / cols;
  col = index % cols;
 
  pos(0) = col * plate_stride_x();
  pos(1) = -row * plate_stride_y();
 
  return pos;
}

References plate_stride_x(), and plate_stride_y().

Referenced by compute_origin(), create_plate(), delete_plate(), get_current_shape_position(), rebuild_plates_after_deserialize(), reinit(), select_plate(), and set_shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_objects_list_for_new_plate()

int Slic3r::GUI::PartPlateList::construct_objects_list_for_new_plate ( int plate_index )

{
  int ret = 0;
  unsigned int i, j, k;
  PartPlate* new_plate = m_plate_list[plate_index];
  bool already_included;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": m_model->objects.size() is %1%") % m_model->objects.size();
  unprintable_plate.clear();
  //try to find a new plate
  for (i = 0; i < (unsigned int)m_model->objects.size(); ++i)
  {
    ModelObject* object = m_model->objects[i];
    for (j = 0; j < (unsigned int)object->instances.size(); ++j)
    {
      ModelInstance* instance = object->instances[j];
      already_included = false;
 
      for (k = 0; k < (unsigned int)plate_index; ++k)
      {
        PartPlate* plate = m_plate_list[k];
        if (plate->contain_instance(i, j))
        {
          already_included = true;
          break;
        }
      }
 
      if (already_included)
        continue;
 
      BoundingBoxf3 boundingbox = object->instance_convex_hull_bounding_box(j);
      if (new_plate->intersect_instance(i, j, &boundingbox))
      {
        //found a new plate, add it to plate
        ret |= new_plate->add_instance(i, j, false, &boundingbox);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": added to plate_id %1%, for obj_id %2%, instance_id %3%") % plate_index % i % j;
 
        continue;
      }
 
      if ( (unprintable_plate.intersect_instance(i, j, &boundingbox)))
      {
        //found in unprintable plate, add it to plate
        unprintable_plate.add_instance(i, j, false, &boundingbox);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found in unprintable plate, obj_id %1%, instance_id %2%") % i % j;
      }
    }
  }
 
  return ret;
}

References Slic3r::GUI::PartPlate::add_instance(), Slic3r::GUI::PartPlate::contain_instance(), Slic3r::GUI::PartPlate::intersect_instance(), m_model, m_plate_list, PartPlate, and unprintable_plate.

Referenced by create_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains()

bool Slic3r::GUI::PartPlateList::contains ( const BoundingBoxf3 & bb )

{
  bool result = false;
  std::vector<PartPlate*>::iterator it = m_plate_list.begin();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    if ((*it)->contains(bb)) {
      result = true;
    }
  }
  return result;
}

References m_plate_list.

◆ copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase & rhs )

inlineprotectedinherited

92{ m_id = rhs.id(); }

Slic3r::ObjectBase::m_id

ObjectID m_id

Definition ObjectID.hpp:98

References ObjectBase(), id(), and m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_plate()

int Slic3r::GUI::PartPlateList::create_plate ( bool adjust_position = true )

{
  PartPlate* plate = NULL;
  Vec3d origin;
  int new_index;
 
  new_index = m_plate_list.size();
  if (new_index >= MAX_PLATES_COUNT)
    return -1;
  int cols = compute_colum_count(new_index + 1);
  int old_cols = compute_colum_count(new_index);
  // Orca: Rebuild plate membership before moving instances during a grid reflow.
  if (adjust_position && old_cols != cols)
    reload_all_objects();
 
  origin = compute_origin(new_index, cols);
  plate = new PartPlate(this, origin, m_plate_width, m_plate_depth, m_plate_height, m_plater, m_model, true, printer_technology);
  assert(plate != NULL);
 
  if (printer_technology == ptFFF)
  {
    Print* print = new Print();
    GCodeResult* gcode = new GCodeResult();
    m_print_list.emplace(m_print_index, print);
    m_gcode_result_list.emplace(m_print_index, gcode);
    plate->set_print(print, gcode, m_print_index);
    m_print_index++;
  }
 
  plate->set_filament_count(m_filament_count);
 
  plate->set_index(new_index);
  Vec2d pos = compute_shape_position(new_index, cols);
  plate->set_shape(m_shape, m_exclude_areas, m_extruder_areas, m_extruder_heights, pos, m_height_to_lid, m_height_to_rod);
  m_plate_list.emplace_back(plate);
  update_plate_cols();
  if (old_cols != cols)
  {
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":old_cols %1% -> new_cols %2%") % old_cols % cols;
    //update the origin of each plate
    update_all_plates_pos_and_size(adjust_position, false);
    set_shapes(m_shape, m_exclude_areas, m_wrapping_exclude_areas, m_extruder_areas, m_extruder_heights, m_logo_texture_filename, m_height_to_lid, m_height_to_rod);
 
    if (m_plater) {
      Vec2d pos = compute_shape_position(m_current_plate, cols);
      m_plater->set_bed_position(pos);
    }
  }
  else
  {
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": the same cols %1%") % old_cols;
    Vec3d origin2 = compute_origin_for_unprintable();
    unprintable_plate.set_pos_and_size(origin2, m_plate_width, m_plate_depth, m_plate_height, false);
 
    //update bounding_boxes
    calc_bounding_boxes();
  }
 
  // update wipe tower config
  if (m_plater) {
    // In GUI mode
        set_default_wipe_tower_pos_for_plate(new_index, true);
  }
 
  unprintable_plate.set_index(new_index+1);
 
  //reload all objects here
  if (adjust_position)
    construct_objects_list_for_new_plate(new_index);
 
  if (m_plater) {
    // In GUI mode
        wxGetApp().obj_list()->on_plate_added(plate);
  }
 
    if (m_plater != nullptr && m_intialized && !m_plater->is_loading_project()) {
        LifecycleEventContext ctx;
        ctx.name = plate->get_plate_name();
        ctx.index = new_index;
        fire_lifecycle_event(LifecycleEvent::PlateCreated, ctx);
    }
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":created a new plate %1%") % new_index;
  return new_index;
}

References calc_bounding_boxes(), compute_colum_count(), compute_origin(), compute_origin_for_unprintable(), compute_shape_position(), construct_objects_list_for_new_plate(), Slic3r::fire_lifecycle_event(), Slic3r::GUI::gcode(), Slic3r::GUI::PartPlate::get_plate_name(), Slic3r::LifecycleEventContext::index, m_current_plate, m_exclude_areas, m_extruder_areas, m_extruder_heights, m_filament_count, m_gcode_result_list, m_height_to_lid, m_height_to_rod, m_intialized, m_logo_texture_filename, m_model, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_plater, m_print_index, m_print_list, m_shape, m_wrapping_exclude_areas, MAX_PLATES_COUNT, Slic3r::LifecycleEventContext::name, PartPlate, Slic3r::PlateCreated, print(), printer_technology, Slic3r::ptFFF, reload_all_objects(), set_default_wipe_tower_pos_for_plate(), Slic3r::GUI::PartPlate::set_filament_count(), Slic3r::GUI::PartPlate::set_index(), Slic3r::GUI::PartPlate::set_print(), Slic3r::GUI::PartPlate::set_shape(), set_shapes(), unprintable_plate, update_all_plates_pos_and_size(), and update_plate_cols().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), duplicate_plate(), load_from_3mf_structure(), and postprocess_bed_index_for_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_plate_from_gcode_file()

int Slic3r::GUI::PartPlateList::create_plate_from_gcode_file ( const std::string & filename )

{
  int ret = 0;
 
  return ret;
}

◆ delete_plate()

int Slic3r::GUI::PartPlateList::delete_plate ( int index )

{
  int ret = 0;
  PartPlate* plate = NULL;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":delete plate %1%, count %2%") % index % m_plate_list.size();
  if (index >= m_plate_list.size())
  {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":can not find plate");
    return -1;
  }
  if (m_plate_list.size() <= 1)
  {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":only one plate left, can not delete");
    return -1;
  }
 
  plate = m_plate_list[index];
  if (index != plate->get_index())
  {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":plate %1%, has an invalid index %2%") % index % plate->get_index();
    return -1;
  }
  const std::string plate_name = plate->get_plate_name();
 
  if (m_plater) {
    // In GUI mode
    // BBS: add wipe tower logic
    DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
    ConfigOptionFloats* wipe_tower_x = proj_cfg.opt<ConfigOptionFloats>("wipe_tower_x");
    ConfigOptionFloats* wipe_tower_y = proj_cfg.opt<ConfigOptionFloats>("wipe_tower_y");
    // wipe_tower_x and wip_tower_y may be less than plate count in the following case:
    // 1. wipe_tower is enabled after creating new plates
    // 2. wipe tower is not enabled
    if (index < wipe_tower_x->values.size())
      wipe_tower_x->values.erase(wipe_tower_x->values.begin() + index);
    if (index < wipe_tower_y->values.size())
      wipe_tower_y->values.erase(wipe_tower_y->values.begin() + index);
  }
 
  int cols = compute_colum_count(m_plate_list.size() - 1);
  int old_cols = compute_colum_count(m_plate_list.size());
 
  m_plate_list.erase(m_plate_list.begin() + index);
  update_plate_cols();
  //update this plate
  //move this plate's instance to the end
  Vec3d current_origin;
  current_origin = compute_origin_for_unprintable();
  plate->set_pos_and_size(current_origin, m_plate_width, m_plate_depth, m_plate_height, true);
 
  //update the plates after it
  for (unsigned int i = index; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    plate->set_index(i);
    Vec3d origin = compute_origin(i, m_plate_cols);
    plate->set_pos_and_size(origin, m_plate_width, m_plate_depth, m_plate_height, true);
 
    //update render shapes
    Vec2d pos = compute_shape_position(i, m_plate_cols);
    plate->set_shape(m_shape, m_exclude_areas, m_extruder_areas, m_extruder_heights, pos, m_height_to_lid, m_height_to_rod);
  }
 
  //update current_plate if delete current
  if (m_current_plate == index && index == 0) {
    select_plate(0);
  }
  else if (m_current_plate >= index) {
    select_plate(m_current_plate - 1);
  }
  else {
    //delete the plate behind current, just need to update the position of Bed3D
    Vec2d pos = compute_shape_position(m_current_plate, m_plate_cols);
    if (m_plater)
      m_plater->set_bed_position(pos);
  }
 
  unprintable_plate.set_index(m_plate_list.size());
 
  if (old_cols != cols)
  {
    //update the origin of each plate
    update_all_plates_pos_and_size();
    set_shapes(m_shape, m_exclude_areas, m_wrapping_exclude_areas, m_extruder_areas, m_extruder_heights, m_logo_texture_filename, m_height_to_lid, m_height_to_rod);
  }
  else
  {
    //update the position of the unprintable plate
    Vec3d origin2 = compute_origin_for_unprintable();
    unprintable_plate.set_pos_and_size(origin2, m_plate_width, m_plate_depth, m_plate_height, true);
 
    //update bounding_boxes
    calc_bounding_boxes();
  }
 
  plate->move_instances_to(*(m_plate_list[m_plate_list.size()-1]), unprintable_plate);
  //destroy the print object
  int print_index;
  plate->get_print(nullptr, nullptr, &print_index);
  destroy_print(print_index);
 
  delete plate;
 
    if (m_plater != nullptr && m_intialized && !m_plater->is_loading_project()) {
        LifecycleEventContext ctx;
        ctx.name = plate_name;
        ctx.index = index;
        fire_lifecycle_event(LifecycleEvent::PlateDeleted, ctx);
    }
 
    // FIX: context of BackgroundSliceProcess and gcode preview need to be updated before ObjectList::reload_all_plates().
#if 0
  if (m_plater != nullptr) {
    // In GUI mode
    wxGetApp().obj_list()->reload_all_plates();
  }
#endif
  return ret;
}

References calc_bounding_boxes(), compute_colum_count(), compute_origin(), compute_origin_for_unprintable(), compute_shape_position(), destroy_print(), Slic3r::fire_lifecycle_event(), Slic3r::GUI::PartPlate::get_index(), Slic3r::GUI::PartPlate::get_plate_name(), Slic3r::GUI::PartPlate::get_print(), Slic3r::LifecycleEventContext::index, m_current_plate, m_exclude_areas, m_extruder_areas, m_extruder_heights, m_height_to_lid, m_height_to_rod, m_intialized, m_logo_texture_filename, m_plate_cols, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_plater, m_shape, m_wrapping_exclude_areas, Slic3r::GUI::PartPlate::move_instances_to(), Slic3r::LifecycleEventContext::name, Slic3r::DynamicConfig::opt(), PartPlate, Slic3r::PlateDeleted, select_plate(), Slic3r::GUI::PartPlate::set_index(), Slic3r::GUI::PartPlate::set_pos_and_size(), Slic3r::GUI::PartPlate::set_shape(), set_shapes(), unprintable_plate, update_all_plates_pos_and_size(), update_plate_cols(), Slic3r::ConfigOptionVector< double >::values, and Slic3r::wipe_tower_y().

Referenced by delete_selected_plate(), and rebuild_plates_after_arrangement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_selected_plate()

void Slic3r::GUI::PartPlateList::delete_selected_plate ( )

{
  delete_plate(m_current_plate);
}

References delete_plate(), and m_current_plate.

Here is the call graph for this function:

◆ destroy_print()

int Slic3r::GUI::PartPlateList::destroy_print ( int print_index )

{
  int result = 0;
 
  if (print_index >= 0)
  {
    std::map<int, PrintBase*>::iterator it = m_print_list.find(print_index);
    if (it != m_print_list.end())
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":delete Print %1% for print_index %2%") % it->second % print_index;
      delete it->second;
      m_print_list.erase(it);
    }
    else
    {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":can not find Print for print_index %1%") % print_index;
      result = -1;
    }
    std::map<int, GCodeResult*>::iterator it2 = m_gcode_result_list.find(print_index);
    if (it2 != m_gcode_result_list.end())
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":delete GCodeResult %1% for print_index %2%") % it2->second % print_index;
      delete it2->second;
      m_gcode_result_list.erase(it2);
    }
    else
    {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":can not find GCodeResult for print_index %1%") % print_index;
      result = -1;
    }
  }
 
  return result;
}

References m_gcode_result_list, and m_print_list.

Referenced by delete_plate(), and rebuild_plates_after_deserialize().

Here is the caller graph for this function:

◆ duplicate_plate()

int Slic3r::GUI::PartPlateList::duplicate_plate ( int index )

{
    // create a new plate
    int new_plate_index = create_plate(true);
    PartPlate* old_plate = NULL;
    PartPlate* new_plate = NULL;
    old_plate = get_plate(index);
    new_plate = get_plate(new_plate_index);
 
    // get the offset between plate centers
    Vec3d plate_to_plate_offset = new_plate->m_origin - old_plate->m_origin;
 
    // iterate over all the objects in this plate
    ModelObjectPtrs obj_ptrs = old_plate->get_objects_on_this_plate();
    for (ModelObject* object : obj_ptrs){
        // copy and move the object to the same relative position in the new plate
        ModelObject* object_copy = m_model->add_object(*object);
        int new_obj_id = new_plate->m_model->objects.size() - 1;
        // go over the instances and pair with the object
        for (size_t new_instance_id = 0; new_instance_id < object_copy->instances.size(); new_instance_id++){
            new_plate->obj_to_instance_set.emplace(std::pair(new_obj_id, new_instance_id));
            new_plate->invalidate_exclusion_volume_preview();
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": duplicate object into plate: index_pair [%1%,%2%], obj_id %3%") % new_obj_id % new_instance_id % object_copy->id().id;
        }
    }
    new_plate->translate_all_instance(plate_to_plate_offset);
    // update the plates
    wxGetApp().obj_list()->reload_all_plates();
    return new_plate_index;
}

References create_plate(), Slic3r::GUI::PartPlate::get_objects_on_this_plate(), get_plate(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::ModelObject::instances, Slic3r::GUI::PartPlate::invalidate_exclusion_volume_preview(), Slic3r::GUI::PartPlate::m_model, m_model, Slic3r::GUI::PartPlate::m_origin, Slic3r::GUI::PartPlate::obj_to_instance_set, Slic3r::Model::objects, PartPlate, and Slic3r::GUI::PartPlate::translate_all_instance().

Here is the call graph for this function:

◆ find_instance() [1/2]

int Slic3r::GUI::PartPlateList::find_instance ( BoundingBoxf3 & bounding_box )

{
  int ret = -1;
 
  //update the plates after it
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    if (plate->intersects(bounding_box))
      return i;
  }
 
  //return -1 for not found
  return ret;
}

References Slic3r::bounding_box(), Slic3r::GUI::PartPlate::intersects(), m_plate_list, and PartPlate.

Here is the call graph for this function:

◆ find_instance() [2/2]

int Slic3r::GUI::PartPlateList::find_instance	(	int	obj_id,
		int	instance_id )

{
  int ret = -1;
 
  //update the plates after it
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    if (plate->contain_instance(obj_id, instance_id))
      return i;
  }
 
  //return -1 for not found
  return ret;
}

References Slic3r::GUI::PartPlate::contain_instance(), m_plate_list, and PartPlate.

Referenced by add_to_plate(), Slic3r::GUI::ObjectList::can_drop(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::GLGizmoAlignment::get_items_count(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), notify_instance_removed(), notify_instance_update(), Slic3r::GUI::OrientJob::prepare_selection(), and select_plate_by_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_instance_belongs()

int Slic3r::GUI::PartPlateList::find_instance_belongs	(	int	obj_id,
		int	instance_id )

{
  int ret = -1;
 
  //update the plates after it
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    if (plate->contain_instance_totally(obj_id, instance_id))
      return i;
  }
 
  //return -1 for not found
  return ret;
}

References Slic3r::GUI::PartPlate::contain_instance_totally(), m_plate_list, and PartPlate.

Referenced by Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::ObjectGridTable::construct_object_configs(), and Slic3r::GUI::ObjectList::update_plate_values_for_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_plate_by_print_index()

int Slic3r::GUI::PartPlateList::find_plate_by_print_index ( int index )

{
  int plate_index = -1;
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
 
    if (plate->m_print_index == print_index)
    {
      plate_index = i;
      break;
    }
  }
 
  return plate_index;
}

References m_plate_list, Slic3r::GUI::PartPlate::m_print_index, and PartPlate.

Referenced by rebuild_plates_after_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_icon_textures()

void Slic3r::GUI::PartPlateList::generate_icon_textures ( )

private

{
  m_icon_textures_dark = m_is_dark;
  // use higher resolution images if graphic card and opengl version allow
  GLint max_tex_size = OpenGLManager::get_gl_info().get_max_tex_size(), icon_size = max_tex_size / 8;
  std::string path = resources_dir() + "/images/";
  std::string file_name;
 
  if (icon_size > 256)
    icon_size = 256;
  //if (m_del_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_close_dark.svg" : "plate_close.svg");
    if (!m_del_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_del_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_close_hover_dark.svg" : "plate_close_hover.svg");
    if (!m_del_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  
  // if (m_move_front_texture.get_id() == 0)
    {
        file_name = path + (m_is_dark ? "plate_move_front_dark.svg" : "plate_move_front.svg");
        if (!m_move_front_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
        }
    }
 
    // if (m_move_front_hovered_texture.get_id() == 0)
    {
        file_name = path + (m_is_dark ? "plate_move_front_hover_dark.svg" : "plate_move_front_hover.svg");
        if (!m_move_front_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
        }
    }
 
  //if (m_arrange_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_arrange_dark.svg" : "plate_arrange.svg");
    if (!m_arrange_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_arrange_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_arrange_hover_dark.svg" : "plate_arrange_hover.svg");
    if (!m_arrange_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_orient_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_orient_dark.svg" : "plate_orient.svg");
    if (!m_orient_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_orient_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_orient_hover_dark.svg" : "plate_orient_hover.svg");
    if (!m_orient_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_locked_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_locked_dark.svg" : "plate_locked.svg");
    if (!m_locked_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_locked_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_locked_hover_dark.svg" : "plate_locked_hover.svg");
    if (!m_locked_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_lockopen_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_unlocked_dark.svg" : "plate_unlocked.svg");
    if (!m_lockopen_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_lockopen_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_unlocked_hover_dark.svg" : "plate_unlocked_hover.svg");
    if (!m_lockopen_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_bedtype_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_settings_dark.svg" : "plate_settings.svg");
    if (!m_plate_settings_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  {
        file_name = path + (m_is_dark ? "plate_set_filament_map_dark.svg" : "plate_set_filament_map.svg");
        if (!m_plate_set_filament_map_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
        }
    }
 
  {
        file_name = path + (m_is_dark ? "plate_set_filament_map_hover_dark.svg" : "plate_set_filament_map_hover.svg");
        if (!m_plate_set_filament_map_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
        }
    }
 
  //if (m_bedtype_changed_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_settings_changed_dark.svg" : "plate_settings_changed.svg");
    if (!m_plate_settings_changed_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_bedtype_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_settings_hover_dark.svg" : "plate_settings_hover.svg");
    if (!m_plate_settings_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  //if (m_bedtype_changed_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_settings_changed_hover_dark.svg" : "plate_settings_changed_hover.svg");
    if (!m_plate_settings_changed_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
  // if (m_plate_name_edit_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_name_edit_dark.svg" : "plate_name_edit.svg");
    if (!m_plate_name_edit_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
      BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
     }
  }
    // if (m_plate_name_edit_hovered_texture.get_id() == 0)
  {
    file_name = path + (m_is_dark ? "plate_name_edit_hover_dark.svg" : "plate_name_edit_hover.svg");
    if (!m_plate_name_edit_hovered_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
    }
  }
 
    // IMEX multi-material conflict warning badge
    {
        file_name = path + "obj_warning.svg";
        if (!m_imex_warn_texture.load_from_svg_file(file_name, true, false, false, icon_size)) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":load file %1% failed (IMEX warn badge)") % file_name;
        }
    }
 
    // IDEX/IQEX mode icon textures, one per ImexModeKind (fall back gracefully if an SVG is missing)
    {
        static const char* kind_names[] = { "normal", "copy", "mirror", "custom" }; // the Primary kind shows "normal"
        static_assert(std::size(kind_names) == kImexModeKindCount && std::tuple_size_v<decltype(m_imex_mode_textures)> == kImexModeKindCount);
        for (size_t kind = 0; kind < kImexModeKindCount; ++kind)
            for (const bool hovered : { false, true }) {
                file_name = path + "plate_imex_" + kind_names[kind] + "_mode" + (hovered ? "_hover" : "") + (m_is_dark ? "_dark.svg" : ".svg");
                GLTexture& texture = hovered ? m_imex_mode_hovered_textures[kind] : m_imex_mode_textures[kind];
                if (!texture.load_from_svg_file(file_name, true, false, false, icon_size))
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":load file %1% failed (IDEX/IQEX mode icon)") % file_name;
            }
    }
 
  std::string text_str = "01";
    // ORCA also scale font size to prevent low res texture
    int size = wxGetApp().em_unit() * PARTPLATE_ICON_SIZE;
    auto l = Label::sysFont(int(size), true);
    wxFont* font = &l;
 
  for (int i = 0; i < MAX_PLATE_COUNT; i++) {
    if (m_idx_textures[i].get_id() == 0) {
      //file_name = path + (boost::format("plate_%1%.svg") % (i + 1)).str();
      if ( i < 9 )
        file_name = std::string("0") + std::to_string(i+1);
      else
        file_name = std::to_string(i+1);
 
      wxColour foreground(0xf2, 0x75, 0x4e, 0xff);
      if (!m_idx_textures[i].generate_from_text_string(file_name, *font, *wxBLACK, foreground)) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":load file %1% failed") % file_name;
      }
    }
  }
}

Referenced by load_icon_textures().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

100{ return ObjectID(++ s_last_id); }

Slic3r::ObjectBase::s_last_id

static size_t s_last_id

Definition ObjectID.hpp:101

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

◆ get_bounding_box()

BoundingBoxf3 & Slic3r::GUI::PartPlateList::get_bounding_box ( )

inline

1067{ return m_bounding_box; }

References m_bounding_box.

Referenced by Slic3r::GUI::GLCanvas3D::scene_bounding_box(), and select_plate().

Here is the caller graph for this function:

◆ get_curr_plate() [1/2]

PartPlate * Slic3r::GUI::PartPlateList::get_curr_plate ( )

inline

962{ return m_plate_list[m_current_plate]; }

References m_current_plate, m_plate_list, and PartPlate.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_curr_plate() [2/2]

const PartPlate * Slic3r::GUI::PartPlateList::get_curr_plate ( ) const

inline

963{ return m_plate_list[m_current_plate]; }

References m_current_plate, m_plate_list, and PartPlate.

Here is the call graph for this function:

◆ get_curr_plate_index()

int Slic3r::GUI::PartPlateList::get_curr_plate_index ( ) const

inline

961{ return m_current_plate; }

References m_current_plate.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern_gen_gcode(), Slic3r::GUI::GLCanvas3D::_picking_pass_imex_ghosts(), Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::GLCanvas3D::_update_inactive_plates_visibility(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::Plater::calib_temp(), Slic3r::GUI::Plater::export_gcode_3mf(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::GCodeViewer::render_markers(), select_plate(), Slic3r::GUI::Plater::send_gcode_legacy(), Slic3r::GUI::Plater::set_print_job_plate_idx(), and Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance().

Here is the caller graph for this function:

◆ get_current_fff_print()

Print & Slic3r::GUI::PartPlateList::get_current_fff_print ( ) const

{
  PartPlate* current_plate;
  Print* print;
 
  current_plate = m_plate_list[m_current_plate];
  //BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":m_current_plate %1%, current_plate %2%") % m_current_plate % current_plate;
  assert(current_plate != NULL);
 
  current_plate->get_print((PrintBase **)&print, nullptr, nullptr);
 
  return *print;
}

References Slic3r::GUI::PartPlate::get_print(), m_current_plate, m_plate_list, PartPlate, and print().

Here is the call graph for this function:

◆ get_current_plate_origin()

Vec3d Slic3r::GUI::PartPlateList::get_current_plate_origin ( )

inline

974{ return compute_origin(m_current_plate, m_plate_cols); }

References compute_origin(), m_current_plate, and m_plate_cols.

Here is the call graph for this function:

◆ get_current_shape_position()

Vec2d Slic3r::GUI::PartPlateList::get_current_shape_position ( )

inline

975{ return compute_shape_position(m_current_plate, m_plate_cols); }

References compute_shape_position(), m_current_plate, and m_plate_cols.

Here is the call graph for this function:

◆ get_current_slice_result()

GCodeProcessorResult * Slic3r::GUI::PartPlateList::get_current_slice_result ( ) const

{
  PartPlate* current_plate;
 
  current_plate = m_plate_list[m_current_plate];
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":m_current_plate %1%, current_plate %2%") % m_current_plate % current_plate;
  assert(current_plate != NULL);
 
  return current_plate->get_slice_result();
}

References Slic3r::GUI::PartPlate::get_slice_result(), m_current_plate, m_plate_list, and PartPlate.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_exclude_area()

Pointfs Slic3r::GUI::PartPlateList::get_exclude_area ( )

inline

976{ return m_exclude_areas; }

References m_exclude_areas.

◆ get_extruders()

std::set< int > Slic3r::GUI::PartPlateList::get_extruders ( bool conside_custom_gcode = false ) const

{
    int plate_count = get_plate_count();
    std::set<int> extruder_ids;
 
    for (size_t i = 0; i < plate_count; i++) {
        auto plate_extruders = m_plate_list[i]->get_extruders(conside_custom_gcode);
        extruder_ids.insert(plate_extruders.begin(), plate_extruders.end());
    }
 
    return extruder_ids;
}

References get_plate_count(), and m_plate_list.

Referenced by Slic3r::GUI::ArrangeJob::prepare_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_height_limits()

void Slic3r::GUI::PartPlateList::get_height_limits	(	float &	height_to_lid,
		float &	height_to_rod )

inline

    {
        height_to_lid = m_height_to_lid;
        height_to_rod = m_height_to_rod;
    }

References m_height_to_lid, and m_height_to_rod.

◆ get_logo_texture_filename()

const std::string & Slic3r::GUI::PartPlateList::get_logo_texture_filename ( )

inline

1085{ return m_logo_texture_filename; }

References m_logo_texture_filename.

◆ get_nonempty_plate_list()

std::vector< PartPlate * > Slic3r::GUI::PartPlateList::get_nonempty_plate_list ( )

{
  std::vector<PartPlate*> nonempty_plate_list;
  for (auto plate : m_plate_list){
        //if (plate->get_extruders().size() != 0) {
    if (!plate->empty()) { // ORCA counts failed slices as non empty because they have model and should be calculated on total count
      nonempty_plate_list.push_back(plate);
    }
  }
  return nonempty_plate_list;
}

References m_plate_list.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_update_select_plate_toolbar_stats_item(), get_nonempty_plates_slice_results(), and Slic3r::GUI::GCodeViewer::render_all_plates_stats().

Here is the caller graph for this function:

◆ get_nonempty_plates_slice_results()

std::vector< const GCodeProcessorResult * > Slic3r::GUI::PartPlateList::get_nonempty_plates_slice_results ( )

                                                                                        {
  std::vector<const GCodeProcessorResult*> nonempty_plates_slice_result;
  for (auto plate : get_nonempty_plate_list()) {
    nonempty_plates_slice_result.push_back(plate->get_slice_result());
  }
  return nonempty_plates_slice_result;
}

References get_nonempty_plate_list().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_plate()

PartPlate * Slic3r::GUI::PartPlateList::get_plate ( int index )

{
  PartPlate* plate = NULL;
 
  if (index >= m_plate_list.size() || index < 0)
  {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":can not find index %1%, size %2%") % index % m_plate_list.size();
    return NULL;
  }
 
  plate = m_plate_list[index];
  assert(plate != NULL);
 
  return plate;
}

References m_plate_list, and PartPlate.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::GLCanvas3D::_update_imgui_select_plate_toolbar(), add_to_plate(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::GLCanvas3D::do_move(), duplicate_plate(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::estimate_wipe_tower_info(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), Slic3r::GUI::ObjectDataViewModel::Init(), Slic3r::GUI::Plater::invalid_all_plate_thumbnails(), Slic3r::GLVolumeCollection::load_real_wipe_tower_preview(), Slic3r::GLVolumeCollection::load_wipe_tower_preview(), lock_plate(), Slic3r::GUI::Plater::on_filament_count_change(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_imex_zones(), Slic3r::GUI::ArrangeJob::prepare_wipe_tower(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::ObjectList::reload_all_plates(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), Slic3r::GUI::Plater::priv::replace_all_with_stl(), Slic3r::CLI::run(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders_for_all_plates(), set_default_wipe_tower_pos_for_plate(), Slic3r::GUI::Plater::update_filament_volume_map(), Slic3r::GUI::Plater::update_obj_preview_thumbnail(), and Slic3r::GUI::Plater::update_plate_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_plate_cols()

int Slic3r::GUI::PartPlateList::get_plate_cols ( )

inline

998{ return m_plate_cols; }

References m_plate_cols.

Referenced by Slic3r::GUI::FillBedJob::finalize(), and Slic3r::GUI::FillBedJob::prepare().

Here is the caller graph for this function:

◆ get_plate_count()

int Slic3r::GUI::PartPlateList::get_plate_count ( ) const

{
  int ret = 0;
 
  ret = m_plate_list.size();
 
  return ret;
}

References m_plate_list.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::GLCanvas3D::_update_imgui_select_plate_toolbar(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::SyncAmsInfoDialog::check_empty_project(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::estimate_wipe_tower_info(), Slic3r::GUI::FillBedJob::finalize(), get_extruders(), Slic3r::GUI::ObjectDataViewModel::Init(), Slic3r::GUI::Plater::invalid_all_plate_thumbnails(), Slic3r::GUI::Plater::on_filament_count_change(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_imex_zones(), Slic3r::GUI::OrientJob::prepare_selection(), Slic3r::GUI::ArrangeJob::prepare_wipe_tower(), Slic3r::GUI::ObjectList::reload_all_plates(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::CLI::run(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders_for_all_plates(), Slic3r::GUI::Plater::update_all_plate_thumbnails(), and Slic3r::GUI::Plater::update_filament_volume_map().

Here is the caller graph for this function:

◆ get_plate_list()

std::vector< PartPlate * > & Slic3r::GUI::PartPlateList::get_plate_list ( )

inline

965{ return m_plate_list; };

References m_plate_list.

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

Here is the caller graph for this function:

◆ get_plate_size()

void Slic3r::GUI::PartPlateList::get_plate_size	(	int &	width,
		int &	depth,
		double &	height )

inline

                                                                {
        width = m_plate_width;
        depth = m_plate_depth;
        height = m_plate_height;
    }

References m_plate_depth, m_plate_height, and m_plate_width.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

◆ get_selected_plate()

PartPlate * Slic3r::GUI::PartPlateList::get_selected_plate ( )

{
  if (m_current_plate < 0 || m_current_plate >= m_plate_list.size()) {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":can not find m_current_plate  %1%, size %2%") % m_current_plate % m_plate_list.size();
    return NULL;
  }
  return m_plate_list[m_current_plate];
}

References m_current_plate, m_plate_list, and PartPlate.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_sliced_result()

void Slic3r::GUI::PartPlateList::get_sliced_result	(	std::vector< bool > &	sliced_result,
		std::vector< std::string > &	gcode_paths )

{
  sliced_result.resize(m_plate_list.size());
  gcode_paths.resize(m_plate_list.size());
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    sliced_result[i] = m_plate_list[i]->m_slice_result_valid;
    gcode_paths[i] = m_plate_list[i]->m_tmp_gcode_path;
  }
}

References m_plate_list.

Referenced by Slic3r::UndoRedo::StackImpl::load_snapshot().

Here is the caller graph for this function:

◆ get_wrapping_exclude_area()

Pointfs Slic3r::GUI::PartPlateList::get_wrapping_exclude_area ( ) const

inline

977{ return m_wrapping_exclude_areas; }

References m_wrapping_exclude_areas.

◆ icon_textures_loaded()

bool Slic3r::GUI::PartPlateList::icon_textures_loaded ( ) const

inline

1155{ return m_del_texture.get_id() != 0 && m_icon_textures_dark == m_is_dark; }

References m_del_texture, m_icon_textures_dark, and m_is_dark.

Referenced by load_icon_textures().

Here is the caller graph for this function:

◆ id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

69{ return m_id; }

References m_id.

◆ init()

void Slic3r::GUI::PartPlateList::init ( )

private

{
  m_intialized = false;
  PartPlate* first_plate = NULL;
  first_plate = new PartPlate(this, Vec3d(0.0, 0.0, 0.0), m_plate_width, m_plate_depth, m_plate_height, m_plater, m_model, true, printer_technology);
  assert(first_plate != NULL);
  m_plate_list.push_back(first_plate);
 
  m_print_index = 0;
  if (printer_technology == ptFFF)
  {
    Print* print = new Print();
    GCodeResult* gcode = new GCodeResult();
    m_print_list.emplace(m_print_index, print);
    m_gcode_result_list.emplace(m_print_index, gcode);
    first_plate->set_print(print, gcode, m_print_index);
    m_print_index++;
  }
  first_plate->set_index(0);
 
  m_plate_count = 1;
  m_plate_cols = 1;
  m_current_plate = 0;
 
  select_plate(0);
  unprintable_plate.set_index(1);
 
  m_intialized = true;
}

References Slic3r::GUI::gcode(), m_current_plate, m_gcode_result_list, m_intialized, m_model, m_plate_cols, m_plate_count, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_plater, m_print_index, m_print_list, PartPlate, print(), printer_technology, Slic3r::ptFFF, select_plate(), Slic3r::GUI::PartPlate::set_index(), Slic3r::GUI::PartPlate::set_print(), and unprintable_plate.

Referenced by PartPlateList(), PartPlateList(), reinit(), and reset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_bed_type_info()

void Slic3r::GUI::PartPlateList::init_bed_type_info ( )

{
  BedTextureInfo::TexturePart pct_part_left(10, 130,  10, 110, "orca_bed_pct_left.svg");
    BedTextureInfo::TexturePart st_part1(9, 70, 12.5, 170, "bbl_bed_st_left.svg");
    BedTextureInfo::TexturePart st_part2(74, -10, 148, 12, "bbl_bed_st_bottom.svg");
  BedTextureInfo::TexturePart pc_part1(10, 130, 10, 110, "bbl_bed_pc_left.svg");
  BedTextureInfo::TexturePart pc_part2(74, -10, 148, 12, "bbl_bed_pc_bottom.svg");
  BedTextureInfo::TexturePart ep_part1(7.5, 90, 12.5, 150, "bbl_bed_ep_left.svg");
  BedTextureInfo::TexturePart ep_part2(74, -10, 148, 12, "bbl_bed_ep_bottom.svg");
  BedTextureInfo::TexturePart pei_part1(7.5, 50, 12.5, 190, "bbl_bed_pei_left.svg");
  BedTextureInfo::TexturePart pei_part2(74, -10, 148, 12, "bbl_bed_pei_bottom.svg");
  BedTextureInfo::TexturePart pte_part1(10, 80, 10, 160, "bbl_bed_pte_left.svg");
  BedTextureInfo::TexturePart pte_part2(74, -10, 148,  12, "bbl_bed_pte_bottom.svg");
    auto bed_texture_maps        = wxGetApp().plater()->get_bed_texture_maps();
    std::string bottom_texture_end_name = bed_texture_maps.find("bottom_texture_end_name") != bed_texture_maps.end() ? bed_texture_maps["bottom_texture_end_name"] : "";
    std::string bottom_texture_rect_str = bed_texture_maps.find("bottom_texture_rect") != bed_texture_maps.end() ? bed_texture_maps["bottom_texture_rect"] : "";
    std::string bottom_texture_rect_longer_str = bed_texture_maps.find("bottom_texture_rect_longer") != bed_texture_maps.end() ? bed_texture_maps["bottom_texture_rect_longer"] : "";
    std::string middle_texture_rect_str = bed_texture_maps.find("middle_texture_rect") != bed_texture_maps.end() ? bed_texture_maps["middle_texture_rect"] : "";
    std::string use_double_extruder_default_texture = bed_texture_maps.find("use_double_extruder_default_texture") != bed_texture_maps.end() ? bed_texture_maps["use_double_extruder_default_texture"] : "";
    std::array<float, 4>        bottom_texture_rect = {0, 0, 0, 0}, bottom_texture_rect_longer = {0, 0, 0, 0}, middle_texture_rect = {0, 0, 0, 0};
    if (bottom_texture_rect_str.size() > 0) {
        std::vector<std::string> items;
        boost::algorithm::erase_all(bottom_texture_rect_str, " ");
        boost::split(items, bottom_texture_rect_str, boost::is_any_of(","));
        if (items.size() == 4) {
            for (int i = 0; i < items.size(); i++) {
                bottom_texture_rect[i] = std::atof(items[i].c_str());
            }
        }
    }
    if (bottom_texture_rect_longer_str.size() > 0) {
        std::vector<std::string> items;
        boost::algorithm::erase_all(bottom_texture_rect_longer_str, " ");
        boost::split(items, bottom_texture_rect_longer_str, boost::is_any_of(","));
        if (items.size() == 4) {
            for (int i = 0; i < items.size(); i++) {
                bottom_texture_rect_longer[i] = std::atof(items[i].c_str());
            }
        }
    }
    if (middle_texture_rect_str.size() > 0) {
        std::vector<std::string> items;
        boost::algorithm::erase_all(middle_texture_rect_str, " ");
        boost::split(items, middle_texture_rect_str, boost::is_any_of(","));
        if (items.size() == 4) {
            for (int i = 0; i < items.size(); i++) {
                middle_texture_rect[i] = std::atof(items[i].c_str());
            }
        }
    }
    auto is_single_extruder = wxGetApp().preset_bundle->get_printer_extruder_count() == 1;
    bool use_double_extruder_texture = !is_single_extruder || use_double_extruder_default_texture == "true";
    if (use_double_extruder_texture) {
        pte_part1 = BedTextureInfo::TexturePart(57, 300, 236.12f, 10.f, "bbl_bed_pte_middle.svg");
        auto &middle_rect = middle_texture_rect;
        if (middle_rect[2] > 0.f) {
            pte_part1 = BedTextureInfo::TexturePart(middle_rect[0], middle_rect[1], middle_rect[2], middle_rect[3], "bbl_bed_pte_middle.svg");
        }
        pte_part2 = BedTextureInfo::TexturePart(45, -14.5, 70, 8, "bbl_bed_pte_left_bottom.svg");
        auto &bottom_rect = bottom_texture_rect;
        auto &bottom_rect_longer = bottom_texture_rect_longer;
        if (bottom_texture_end_name.size() > 0 && bottom_rect[2] > 0.f) {
            std::string pte_part2_name = "bbl_bed_pte_bottom_" + bottom_texture_end_name + ".svg";
            pte_part2 = BedTextureInfo::TexturePart(bottom_rect[0], bottom_rect[1], bottom_rect[2], bottom_rect[3], pte_part2_name);
        }
 
        pei_part1  = BedTextureInfo::TexturePart(57, 300, 236.12f, 10.f, "bbl_bed_pei_middle.svg");
        if (middle_rect[2] > 0.f) {
            pei_part1 = BedTextureInfo::TexturePart(middle_rect[0], middle_rect[1], middle_rect[2], middle_rect[3], "bbl_bed_pei_middle.svg");
        }
        pei_part2  = BedTextureInfo::TexturePart(45, -14.5, 70, 8, "bbl_bed_pei_left_bottom.svg");
        if (bottom_texture_end_name.size() > 0 && bottom_rect[2] > 0.f) {
            std::string pei_part2_name = "bbl_bed_pei_bottom_" + bottom_texture_end_name + ".svg";
            pei_part2                  = BedTextureInfo::TexturePart(bottom_rect[0], bottom_rect[1], bottom_rect[2], bottom_rect[3], pei_part2_name);
        }
 
        st_part1 = BedTextureInfo::TexturePart(57, 300, 236.12f, 10.f, "bbl_bed_st_middle.svg");
        if (middle_rect[2] > 0.f) {
            st_part1 = BedTextureInfo::TexturePart(middle_rect[0], middle_rect[1], middle_rect[2], middle_rect[3], "bbl_bed_st_middle.svg");
        }
        st_part2 = BedTextureInfo::TexturePart(45, -14.5, 260, 8, "bbl_bed_st_left_bottom.svg");
        if (bottom_texture_end_name.size() > 0 && bottom_rect[2] > 0.f) {
            std::string st_part2_name = "bbl_bed_st_bottom_" + bottom_texture_end_name + ".svg";
            st_part2                   = BedTextureInfo::TexturePart(bottom_rect[0], bottom_rect[1], bottom_rect[2], bottom_rect[3], st_part2_name);
        } else if (bottom_rect_longer[2] > 0.f) {
            // SuperTack bottom strip uses the wider "longer" rect.
            st_part2.update_pos(bottom_rect_longer[0], bottom_rect_longer[1], bottom_rect_longer[2], bottom_rect_longer[3]);
        }
 
        ep_part1 = BedTextureInfo::TexturePart(57, 300, 236.12f, 10.f, "bbl_bed_ep_middle.svg");
        if (middle_rect[2] > 0.f) {
            ep_part1 = BedTextureInfo::TexturePart(middle_rect[0], middle_rect[1], middle_rect[2], middle_rect[3], "bbl_bed_ep_middle.svg");
        }
        ep_part2 = BedTextureInfo::TexturePart(45, -14.5, 260, 8, "bbl_bed_ep_left_bottom.svg");
        if (bottom_texture_end_name.size() > 0 && bottom_rect[2] > 0.f) {
            std::string ep_part2_name = "bbl_bed_ep_bottom_" + bottom_texture_end_name + ".svg";
            ep_part2                   = BedTextureInfo::TexturePart(bottom_rect[0], bottom_rect[1], bottom_rect[2], bottom_rect[3], ep_part2_name);
        } else if (bottom_rect_longer[2] > 0.f) {
            // Engineering-plate bottom strip uses the wider "longer" rect.
            ep_part2.update_pos(bottom_rect_longer[0], bottom_rect_longer[1], bottom_rect_longer[2], bottom_rect_longer[3]);
        }
 
        pc_part1 = BedTextureInfo::TexturePart(57, 300, 236.12f, 10.f, "bbl_bed_pc_middle.svg");
        if (middle_rect[2] > 0.f) {
            pc_part1 = BedTextureInfo::TexturePart(middle_rect[0], middle_rect[1], middle_rect[2], middle_rect[3], "bbl_bed_pc_middle.svg"); }
        pc_part2 = BedTextureInfo::TexturePart(45, -14.5, 70, 8, "bbl_bed_pc_left_bottom.svg");
        if (bottom_texture_end_name.size() > 0 && bottom_rect[2] > 0.f) {
            std::string pc_part2_name = "bbl_bed_pc_bottom_" + bottom_texture_end_name + ".svg";
            pc_part2                  = BedTextureInfo::TexturePart(bottom_rect[0], bottom_rect[1], bottom_rect[2], bottom_rect[3], pc_part2_name);
        }
 
        m_allow_bed_type_in_double_nozzle.clear();
        auto bed_types = wxGetApp().plater()->sidebar().get_cur_combox_bed_types();
        for (int i = 0; i < bed_types.size(); i++) {
            m_allow_bed_type_in_double_nozzle[bed_types[i]] = true;
        }
    } else {
        if (bottom_texture_end_name.size() > 0) {
            st_part2.update_file("bbl_bed_st_bottom_" + bottom_texture_end_name + ".svg");
            pc_part2.update_file("bbl_bed_pc_bottom_" + bottom_texture_end_name + ".svg");
            ep_part2.update_file("bbl_bed_ep_bottom_" + bottom_texture_end_name + ".svg");
            pei_part2.update_file("bbl_bed_pei_bottom_" + bottom_texture_end_name + ".svg");
            pte_part2.update_file("bbl_bed_pte_bottom_" + bottom_texture_end_name + ".svg");
        }
    }
 
  for (size_t i = 0; i < btCount; i++) {
    bed_texture_info[i].reset();
    bed_texture_info[i].parts.clear();
  }
    bed_texture_info[btSuperTack].parts.push_back(st_part1);
    bed_texture_info[btSuperTack].parts.push_back(st_part2);
  bed_texture_info[btPC].parts.push_back(pc_part1);
  bed_texture_info[btPC].parts.push_back(pc_part2);
  bed_texture_info[btPCT].parts.push_back(pct_part_left);
  bed_texture_info[btPCT].parts.push_back(pc_part2);
  bed_texture_info[btEP].parts.push_back(ep_part1);
  bed_texture_info[btEP].parts.push_back(ep_part2);
  bed_texture_info[btPEI].parts.push_back(pei_part1);
  bed_texture_info[btPEI].parts.push_back(pei_part2);
  bed_texture_info[btPTE].parts.push_back(pte_part1);
  bed_texture_info[btPTE].parts.push_back(pte_part2);
 
  auto  bed_ext     = get_extents(m_shape);
  int   bed_width   = bed_ext.size()(0);
  int   bed_height  = bed_ext.size()(1);
    float base_width  = 256;//standard 256*256 for single_extruder
    float base_height = 256;
    if (use_double_extruder_texture) { // standard 350*325 for double_extruder
        base_width  = bed_width;
        base_height = bed_height;
    }
    float x_rate      = bed_width / base_width;
    float y_rate      = bed_height / base_height;
    for (int i = 0; i < btCount; i++) {
    for (int j = 0; j < bed_texture_info[i].parts.size(); j++) {
      bed_texture_info[i].parts[j].x *= x_rate;
      bed_texture_info[i].parts[j].y *= y_rate;
            bed_texture_info[i].parts[j].w *= x_rate;
            bed_texture_info[i].parts[j].h *= y_rate;
            bed_texture_info[i].parts[j].update_buffer();
        }
    }
}

References bed_texture_info, Slic3r::btCount, Slic3r::btEP, Slic3r::btPC, Slic3r::btPCT, Slic3r::btPEI, Slic3r::btPTE, Slic3r::btSuperTack, Slic3r::get_extents(), m_allow_bed_type_in_double_nozzle, m_shape, Slic3r::GUI::PartPlateList::BedTextureInfo::TexturePart::update_file(), and Slic3r::GUI::PartPlateList::BedTextureInfo::TexturePart::update_pos().

Referenced by load_next_bedtype_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_cali_texture_info()

void Slic3r::GUI::PartPlateList::init_cali_texture_info ( )

{
  BedTextureInfo::TexturePart cali_line(18, 2, 224, 16, "bbl_cali_lines.svg");
  cali_texture_info.parts.push_back(cali_line);
 
  for (int j = 0; j < cali_texture_info.parts.size(); j++) {
    cali_texture_info.parts[j].update_buffer();
  }
}

References cali_texture_info.

Referenced by load_next_cali_texture().

Here is the caller graph for this function:

◆ init_extruder_only_area_info()

bool Slic3r::GUI::PartPlateList::init_extruder_only_area_info ( )

{
    Rect left_only_rect,  right_only_rect;
    auto ok = calc_extruder_only_area(left_only_rect, right_only_rect);
    if (!ok) { return false; }
    float  base_width  = 25.f;
    float  base_height = 320.f;
    float  left_x_rate = left_only_rect.w / base_width;
    float  left_y_rate = left_only_rect.h / base_height;
    bool   is_zh       = wxGetApp().app_config->get("language") == "zh_CN";
    Vec4f  base_left(-6.f, -75.f, 12.f, 150.f);
    if (is_zh) {
    base_left = Vec4f(-5.5f, -76.f, 12.f, 150.f);
    }
    base_left[0]   = base_left[0] * left_x_rate + left_only_rect.x + left_only_rect.w / 2.f;
    base_left[1]   = base_left[1] * left_y_rate + left_only_rect.y + left_only_rect.h / 2.f;
    base_left[2]   = base_left[2] * left_x_rate;
    base_left[3]   = base_left[3] * left_y_rate;
    Vec4f   base_right(-5.5f, -75.f, 12.f, 150.f);
    if (is_zh) {
        base_right = Vec4f(-4.5f, -76.f, 12.f, 150.f);
    }
    float right_x_rate = right_only_rect.w / base_width;
    float right_y_rate = right_only_rect.h / base_height;
    base_right[0]                   = base_right[0] * right_x_rate + right_only_rect.x + right_only_rect.w / 2.f;
    base_right[1]                   = base_right[1] * right_y_rate + right_only_rect.y + right_only_rect.h / 2.f;
    base_right[2]                   = base_right[2] * right_x_rate;
    base_right[3]                   = base_right[3] * right_y_rate;
    BedTextureInfo::TexturePart left_part(base_left[0], base_left[1], base_left[2], base_left[3], "left_extruder_only_area.svg");
    BedTextureInfo::TexturePart left_ch_part(base_left[0], base_left[1], base_left[2], base_left[3], "left_extruder_only_area_ch.svg");
    BedTextureInfo::TexturePart right_part(base_right[0], base_right[1], base_right[2], base_right[3], "right_extruder_only_area.svg");
    BedTextureInfo::TexturePart right_ch_part(base_right[0], base_right[1], base_right[2], base_right[3], "right_extruder_only_area_ch.svg");
 
    for (size_t i = 0; i < (unsigned char) ExtruderOnlyAreaType::btAreaCount; i++) {
        extruder_only_area_info[i].reset();
        extruder_only_area_info[i].parts.clear();
    }
    extruder_only_area_info[(unsigned char) ExtruderOnlyAreaType::Engilish].parts.push_back(left_part);
    if (base_right[2]>5) {//width should >5
        extruder_only_area_info[(unsigned char) ExtruderOnlyAreaType::Engilish].parts.push_back(right_part);
    }
    extruder_only_area_info[(unsigned char) ExtruderOnlyAreaType::Chinese].parts.push_back(left_ch_part);
    if (base_right[2] > 5) { // width should >5
        extruder_only_area_info[(unsigned char) ExtruderOnlyAreaType::Chinese].parts.push_back(right_ch_part);
    }
 
    for (int i = 0; i < (unsigned char) ExtruderOnlyAreaType::btAreaCount; i++) {
        for (int j = 0; j < extruder_only_area_info[i].parts.size(); j++) {
            extruder_only_area_info[i].parts[j].update_buffer();
        }
    }
    return true;
}

References Slic3r::btAreaCount, calc_extruder_only_area(), Slic3r::Chinese, Slic3r::Engilish, extruder_only_area_info, Slic3r::GUI::PartPlateList::Rect::h, Slic3r::GUI::PartPlateList::BedTextureInfo::parts, Slic3r::GUI::PartPlateList::Rect::w, Slic3r::GUI::PartPlateList::Rect::x, and Slic3r::GUI::PartPlateList::Rect::y.

Referenced by load_next_extruder_only_area_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ intersects()

bool Slic3r::GUI::PartPlateList::intersects ( const BoundingBoxf3 & bb )

{
  bool result = false;
  std::vector<PartPlate*>::iterator it = m_plate_list.begin();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    if ((*it)->intersects(bb)) {
      result = true;
    }
  }
  return result;
}

References m_plate_list.

◆ invalid_all_slice_result()

void Slic3r::GUI::PartPlateList::invalid_all_slice_result ( )

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plates count %1%") % m_plate_list.size();
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    m_plate_list[i]->update_slice_result_valid_state(false);
  }
 
  return;
}

References m_plate_list.

◆ invalidate_all_imex_ghosts()

void Slic3r::GUI::PartPlateList::invalidate_all_imex_ghosts ( )

{
    for (PartPlate* p : m_plate_list)
        if (p) p->invalidate_imex_ghosts();
}

References m_plate_list, and PartPlate.

Here is the call graph for this function:

◆ invalidate_exclusion_volume_previews()

void Slic3r::GUI::PartPlateList::invalidate_exclusion_volume_previews ( )

{
    for (PartPlate *plate : m_plate_list)
        if (plate != nullptr)
            plate->invalidate_exclusion_volume_preview();
}

References m_plate_list, and PartPlate.

Here is the call graph for this function:

◆ is_all_plates_ready_for_slice()

bool Slic3r::GUI::PartPlateList::is_all_plates_ready_for_slice ( ) const

{
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (m_plate_list[i]->can_slice())
      return true;
  }
  return false;
}

References m_plate_list.

◆ is_all_slice_result_ready_for_export()

bool Slic3r::GUI::PartPlateList::is_all_slice_result_ready_for_export ( ) const

{
  bool res = false;
 
    for (unsigned int i = 0; i < (unsigned int) m_plate_list.size(); ++i) {
        if (!m_plate_list[i]->empty()) {
            if (m_plate_list[i]->is_all_instances_unprintable()) {
        continue;
      }
            if (!m_plate_list[i]->is_slice_result_ready_for_print()) {
        return false;
      }
        }
        if (m_plate_list[i]->is_slice_result_ready_for_print()) {
      if (!m_plate_list[i]->has_printable_instances()) {
        return false;
      }
      res = true;
    }
    }
 
    return res;
}

References Slic3r::empty(), and m_plate_list.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_all_slice_results_ready_for_print()

bool Slic3r::GUI::PartPlateList::is_all_slice_results_ready_for_print ( ) const

{
    bool res = false;
 
    for (unsigned int i = 0; i < (unsigned int) m_plate_list.size(); ++i) {
        if (!m_plate_list[i]->empty()) {
            if (m_plate_list[i]->is_all_instances_unprintable()) {
        continue;
      }
            if (!m_plate_list[i]->is_slice_result_ready_for_print()) {
        return false;
      }
        }
        if (m_plate_list[i]->is_slice_result_ready_for_print()) {
      res = true;
    }
    }
 
    return res;
}

References Slic3r::empty(), and m_plate_list.

Referenced by Slic3r::GUI::MainFrame::can_export_all_gcode(), and Slic3r::GUI::MainFrame::get_enable_print_status().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_all_slice_results_valid()

bool Slic3r::GUI::PartPlateList::is_all_slice_results_valid ( ) const

{
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (!m_plate_list[i]->is_slice_result_valid())
      return false;
  }
  return true;
}

References m_plate_list.

◆ is_locked()

bool Slic3r::GUI::PartPlateList::is_locked ( int index )

inline

1007{ return m_plate_list[index]->is_locked();}

References m_plate_list.

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), postprocess_bed_index_for_selected(), postprocess_bed_index_for_unselected(), Slic3r::GUI::OrientJob::prepare_selection(), preprocess_arrange_polygon(), and rebuild_plates_after_arrangement().

Here is the caller graph for this function:

◆ load_and_construct()

template<class Archive>

void Slic3r::ObjectBase::load_and_construct	(	Archive &	ar,
		cereal::construct< ObjectBase > &	construct )

inlinestaticprivateinherited

109{ ObjectID id; ar(id); construct(id); }

Slic3r::ObjectBase::id

ObjectID id() const

Definition ObjectID.hpp:69

References id().

Here is the call graph for this function:

◆ load_bedtype_textures()

void Slic3r::GUI::PartPlateList::load_bedtype_textures ( )

{
  while (load_next_bedtype_texture()) {}
}

References load_next_bedtype_texture().

Here is the call graph for this function:

◆ load_cali_textures()

void Slic3r::GUI::PartPlateList::load_cali_textures ( )

{
  while (load_next_cali_texture()) {}
}

References load_next_cali_texture().

Here is the call graph for this function:

◆ load_extruder_only_area_textures()

void Slic3r::GUI::PartPlateList::load_extruder_only_area_textures ( )

{
    while (load_next_extruder_only_area_texture()) {}
}

References load_next_extruder_only_area_texture().

Here is the call graph for this function:

◆ load_from_3mf_structure()

int Slic3r::GUI::PartPlateList::load_from_3mf_structure	(	PlateDataPtrs &	plate_data_list,
		int	filament_count = 1 )

{
  int ret = 0;
 
  if (plate_data_list.size() <= 0)
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":no plates, should not happen!");
    return -1;
  }
  clear(true, true);
  set_filament_count(filament_count);
  for (unsigned int i = 0; i < (unsigned int)plate_data_list.size(); ++i)
  {
    int index = create_plate(false);
    m_plate_list[index]->m_locked = plate_data_list[i]->locked;
    m_plate_list[index]->config()->apply(plate_data_list[i]->config);
    m_plate_list[index]->set_plate_name(plate_data_list[i]->plate_name);
    if (plate_data_list[i]->plate_index != index)
    {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":plate index %1% seems invalid, skip it")% plate_data_list[i]->plate_index;
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1%, gcode_file %2%, is_sliced_valid %3%, toolpath_outside %4%, is_support_used %5% is_label_object_enabled %6%")
      %i %plate_data_list[i]->gcode_file %plate_data_list[i]->is_sliced_valid %plate_data_list[i]->toolpath_outside %plate_data_list[i]->is_support_used %plate_data_list[i]->is_label_object_enabled;
    //load object and instance from 3mf
    //just test for file correct or not, we will rebuild later
    /*for (std::vector<std::pair<int, int>>::iterator it = plate_data_list[i]->objects_and_instances.begin(); it != plate_data_list[i]->objects_and_instances.end(); ++it)
      m_plate_list[index]->obj_to_instance_set.insert(std::pair(it->first, it->second));*/
    if (!plate_data_list[i]->gcode_file.empty()) {
      m_plate_list[index]->m_gcode_path_from_3mf = plate_data_list[i]->gcode_file;
    }
    GCodeResult* gcode_result = nullptr;
    PrintBase* fff_print = nullptr;
    m_plate_list[index]->get_print(&fff_print, &gcode_result, nullptr);
    PrintStatistics& ps = (dynamic_cast<Print*>(fff_print))->print_statistics();
    gcode_result->print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time = atoi(plate_data_list[i]->gcode_prediction.c_str());
    ps.total_weight = atof(plate_data_list[i]->gcode_weight.c_str());
    ps.total_used_filament = 0.f;
    for (auto filament_item: plate_data_list[i]->slice_filaments_info)
    {
      ps.total_used_filament += filament_item.used_m;
    }
    ps.total_used_filament *= 1000; //koef
    gcode_result->toolpath_outside = plate_data_list[i]->toolpath_outside;
    gcode_result->label_object_enabled = plate_data_list[i]->is_label_object_enabled;
        gcode_result->timelapse_warning_code = plate_data_list[i]->timelapse_warning_code;
        m_plate_list[index]->set_timelapse_warning_code(plate_data_list[i]->timelapse_warning_code);
        gcode_result->filament_change_sequence = plate_data_list[i]->filament_change_sequence;
        gcode_result->nozzle_change_sequence = plate_data_list[i]->nozzle_change_sequence;
        gcode_result->optimal_assignment = plate_data_list[i]->optimal_assignment;
    m_plate_list[index]->slice_filaments_info = plate_data_list[i]->slice_filaments_info;
    gcode_result->warnings = plate_data_list[i]->warnings;
        gcode_result->filament_maps = plate_data_list[i]->filament_maps;
    gcode_result->used_mixed_filaments.clear();
    for (const auto &mixed_info : plate_data_list[i]->mixed_filaments_info) {
      if (mixed_info.id > 0)
        gcode_result->used_mixed_filaments.push_back(static_cast<unsigned int>(mixed_info.id - 1));
    }
    if (Print *print = dynamic_cast<Print*>(fff_print))
      print->set_slice_used_mixed_filaments(gcode_result->used_mixed_filaments);
 
        // Reconstruct the device-side nozzle grouping from the loaded 3mf so
        // the monitor/preview can map filaments to physical nozzles.
        // load_nozzle_infos_with_compatibility handles older single-nozzle 3mf (no <nozzle> tags) by
        // falling back to the per-filament group_id, then to the extruder volume types / nozzle diameters.
        {
            // nozzle_volume_types is space-separated ints; nozzle_diameters is comma/space-separated floats.
            auto parse_int_tokens = [](const std::string& str) -> std::vector<int> {
                std::vector<int> out;
                std::istringstream iss(str);
                std::string tok;
                while (iss >> tok) { try { out.push_back(std::stoi(tok)); } catch (...) {} }
                return out;
            };
            auto parse_double_tokens = [](const std::string& str) -> std::vector<double> {
                std::vector<double> out;
                std::string s = str;
                std::replace(s.begin(), s.end(), ',', ' ');
                std::istringstream iss(s);
                std::string tok;
                while (iss >> tok) { try { out.push_back(std::stod(tok)); } catch (...) {} }
                return out;
            };
 
            std::vector<int>    nozzle_volume_type_values = parse_int_tokens(plate_data_list[i]->nozzle_volume_types);
            std::vector<double> nozzle_diameter_values    = parse_double_tokens(plate_data_list[i]->nozzle_diameters);
 
            std::vector<NozzleVolumeType> extruder_volume_types(nozzle_volume_type_values.size(), NozzleVolumeType::nvtStandard);
            for (size_t idx = 0; idx < nozzle_volume_type_values.size(); ++idx)
                if (nozzle_volume_type_values[idx] >= 0 && nozzle_volume_type_values[idx] <= nvtMaxNozzleVolumeType)
                    extruder_volume_types[idx] = static_cast<NozzleVolumeType>(nozzle_volume_type_values[idx]);
 
            auto nozzle_infos = MultiNozzleUtils::load_nozzle_infos_with_compatibility(
                plate_data_list[i]->nozzles_info,
                plate_data_list[i]->slice_filaments_info,
                plate_data_list[i]->filament_maps,
                extruder_volume_types,
                nozzle_diameter_values);
 
            std::vector<int> fil_seq(plate_data_list[i]->filament_change_sequence.begin(), plate_data_list[i]->filament_change_sequence.end());
            std::vector<int> noz_seq(plate_data_list[i]->nozzle_change_sequence.begin(), plate_data_list[i]->nozzle_change_sequence.end());
            bool enable_filament_dynamic_map = false;
            if (plate_data_list[i]->config.has("enable_filament_dynamic_map"))
                enable_filament_dynamic_map = plate_data_list[i]->config.option<ConfigOptionBool>("enable_filament_dynamic_map")->value;
 
            auto group_result = MultiNozzleUtils::StaticNozzleGroupResult::create(
                plate_data_list[i]->slice_filaments_info, nozzle_infos, fil_seq, noz_seq, enable_filament_dynamic_map);
            if (group_result)
                gcode_result->nozzle_group_result = std::make_shared<MultiNozzleUtils::StaticNozzleGroupResult>(group_result.value());
            else
                gcode_result->nozzle_group_result = nullptr;
        }
    if (m_plater && !plate_data_list[i]->thumbnail_file.empty()) {
      BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1%, load thumbnail from %2%.")%(i+1) %plate_data_list[i]->thumbnail_file;
      if (boost::filesystem::exists(plate_data_list[i]->thumbnail_file)) {
        m_plate_list[index]->load_thumbnail_data(plate_data_list[i]->thumbnail_file, m_plate_list[index]->thumbnail_data);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ <<boost::format(": plate %1% after load, width %2%, height %3%, size %4%!")
          %(i+1) %m_plate_list[index]->thumbnail_data.width %m_plate_list[index]->thumbnail_data.height %m_plate_list[index]->thumbnail_data.pixels.size();
      }
    }
 
    if (m_plater && !plate_data_list[i]->no_light_thumbnail_file.empty()) {
      if (boost::filesystem::exists(plate_data_list[i]->no_light_thumbnail_file)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1%, load no_light_thumbnail_file from %2%.")%(i+1) %plate_data_list[i]->no_light_thumbnail_file;
        m_plate_list[index]->load_thumbnail_data(plate_data_list[i]->no_light_thumbnail_file, m_plate_list[index]->no_light_thumbnail_data);
      }
    }
 
    /*if (m_plater && !plate_data_list[i]->pattern_file.empty()) {
      if (boost::filesystem::exists(plate_data_list[i]->pattern_file)) {
        //no need to load pattern data currently
        //m_plate_list[index]->load_pattern_thumbnail_data(plate_data_list[i]->pattern_file);
      }
    }*/
    if (m_plater && !plate_data_list[i]->top_file.empty()) {
      if (boost::filesystem::exists(plate_data_list[i]->top_file)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1%, load top_thumbnail from %2%.")%(i+1) %plate_data_list[i]->top_file;
        m_plate_list[index]->load_thumbnail_data(plate_data_list[i]->top_file, m_plate_list[index]->top_thumbnail_data);
      }
    }
    if (m_plater && !plate_data_list[i]->pick_file.empty()) {
      if (boost::filesystem::exists(plate_data_list[i]->pick_file)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1%, load pick_thumbnail from %2%.")%(i+1) %plate_data_list[i]->pick_file;
        m_plate_list[index]->load_thumbnail_data(plate_data_list[i]->pick_file, m_plate_list[index]->pick_thumbnail_data);
      }
    }
    if (m_plater && !plate_data_list[i]->pattern_bbox_file.empty()) {
      if (boost::filesystem::exists(plate_data_list[i]->pattern_bbox_file)) {
        m_plate_list[index]->load_pattern_box_data(plate_data_list[i]->pattern_bbox_file);
      }
    }
 
  }
  print();
  ret = reload_all_objects();
  print();
 
  return ret;
}

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_gcode_files()

int Slic3r::GUI::PartPlateList::load_gcode_files ( )

{
  int ret = 0;
 
  //only do this while m_plater valid for gui mode
  if (!m_plater)
    return ret;
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (!m_plate_list[i]->m_gcode_path_from_3mf.empty()) {
      //the same as plater::priv::update_print_volume_state();
      //BoundingBoxf3   print_volume = m_plate_list[i]->get_bounding_box(false);
      //print_volume.max(2) = this->m_plate_height;
      //print_volume.min(2) = -1e10;
      m_model->update_print_volume_state({m_plate_list[i]->get_shape(), this->m_plate_height, m_plate_list[i]->get_extruder_areas(), m_plate_list[i]->get_extruder_heights() });
 
      if (!m_plate_list[i]->load_gcode_from_file(m_plate_list[i]->m_gcode_path_from_3mf))
        ret ++;
    }
  }
 
  BOOST_LOG_TRIVIAL(trace) << boost::format("totally got %1% gcode files") % ret;
 
  return ret;
}

References m_model, m_plate_height, m_plate_list, m_plater, and Slic3r::trace().

Here is the call graph for this function:

◆ load_icon_textures()

void Slic3r::GUI::PartPlateList::load_icon_textures ( )

{
  if (!icon_textures_loaded())
    generate_icon_textures();
}

References generate_icon_textures(), and icon_textures_loaded().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_logo_texture()

bool Slic3r::GUI::PartPlateList::load_logo_texture ( )

{
  if (m_logo_texture_filename.empty()) {
    m_logo_texture.reset();
    return false;
  }
 
  if (m_logo_texture.get_id() != 0 && m_logo_texture.get_source() == m_logo_texture_filename) {
    if (m_logo_texture.unsent_compressed_data_available())
      // sends to gpu the already available compressed levels of the main texture
      m_logo_texture.send_compressed_data_to_gpu();
    return true;
  }
 
  m_logo_texture.reset();
  // starts generating the main texture, compression will run asynchronously
  if (boost::algorithm::iends_with(m_logo_texture_filename, ".svg")) {
    if (!m_logo_texture.load_from_svg_file(m_logo_texture_filename, true, true, true, logo_texture_size())) {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": load logo texture from %1% failed!") % m_logo_texture_filename;
      return false;
    }
  }
  else if (boost::algorithm::iends_with(m_logo_texture_filename, ".png")) {
    if (!m_logo_texture.load_from_file(m_logo_texture_filename, true, GLTexture::MultiThreaded, true)) {
      BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": load logo texture from %1% failed!") % m_logo_texture_filename;
      return false;
    }
  }
  else {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": can not load logo texture from %1%, unsupported format") % m_logo_texture_filename;
    return false;
  }
  return true;
}

References Slic3r::GUI::logo_texture_size(), m_logo_texture, m_logo_texture_filename, and Slic3r::GUI::GLTexture::MultiThreaded.

Referenced by load_next_plate_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_next_bedtype_texture()

bool Slic3r::GUI::PartPlateList::load_next_bedtype_texture ( )

{
  if (PartPlateList::is_load_bedtype_textures)
    return false;
  if (m_next_bedtype_texture == 0)
    init_bed_type_info();
  if (load_next_part_texture(bed_texture_info, btCount, m_next_bedtype_texture, true))
    return true;
  PartPlateList::is_load_bedtype_textures = true;
  return false;
}

References bed_texture_info, Slic3r::btCount, init_bed_type_info(), is_load_bedtype_textures, Slic3r::GUI::load_next_part_texture(), and m_next_bedtype_texture.

Referenced by load_bedtype_textures(), and load_next_plate_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_next_cali_texture()

bool Slic3r::GUI::PartPlateList::load_next_cali_texture ( )

{
  if (PartPlateList::is_load_cali_texture)
    return false;
  if (m_next_cali_texture == 0)
    init_cali_texture_info();
  if (load_next_part_texture(&cali_texture_info, 1, m_next_cali_texture, true))
    return true;
  PartPlateList::is_load_cali_texture = true;
  return false;
}

References cali_texture_info, init_cali_texture_info(), is_load_cali_texture, Slic3r::GUI::load_next_part_texture(), and m_next_cali_texture.

Referenced by load_cali_textures(), and load_next_plate_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_next_extruder_only_area_texture()

bool Slic3r::GUI::PartPlateList::load_next_extruder_only_area_texture ( )

{
    if (PartPlateList::is_load_extruder_only_area_textures)
        return false;
    if (m_next_extruder_only_area_texture == 0 && !init_extruder_only_area_info()) {
        PartPlateList::is_load_extruder_only_area_textures = true;
        return false;
    }
    if (load_next_part_texture(extruder_only_area_info, (size_t) ExtruderOnlyAreaType::btAreaCount, m_next_extruder_only_area_texture, false))
        return true;
    PartPlateList::is_load_extruder_only_area_textures = true;
    return false;
}

References Slic3r::btAreaCount, extruder_only_area_info, init_extruder_only_area_info(), is_load_extruder_only_area_textures, Slic3r::GUI::load_next_part_texture(), and m_next_extruder_only_area_texture.

Referenced by load_extruder_only_area_textures(), and load_next_plate_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_next_plate_texture()

bool Slic3r::GUI::PartPlateList::load_next_plate_texture ( )

{
  if (!render_bedtype_logo) {
    load_logo_texture();
    return false;
  }
  return load_next_bedtype_texture() || load_next_cali_texture() || load_next_extruder_only_area_texture();
}

References load_logo_texture(), load_next_bedtype_texture(), load_next_cali_texture(), load_next_extruder_only_area_texture(), and render_bedtype_logo.

Here is the call graph for this function:

◆ lock_plate()

int Slic3r::GUI::PartPlateList::lock_plate	(	int	index,
		bool	state )

{
  int ret = 0;
  PartPlate* plate = NULL;
 
  plate = get_plate(index);
  if (!plate)
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":can not get plate for index %1%, size %2%") % index % m_plate_list.size();
    return -1;
  }
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":lock plate %1%, to state %2%") % index % state;
 
  plate->lock(state);
 
  return ret;
}

References get_plate(), Slic3r::GUI::PartPlate::lock(), m_plate_list, and PartPlate.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ move_plate_to_index()

int Slic3r::GUI::PartPlateList::move_plate_to_index	(	int	old_index,
		int	new_index )

{
  int ret = 0, delta;
  Vec3d origin;
 
 
  if (old_index == new_index)
  {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":should not happen, the same index %1%") % old_index;
    return -1;
  }
 
  // Orca: Rebuild plate membership before moving the plates.
  reload_all_objects();
 
  if (old_index < new_index)
  {
    delta = 1;
  }
  else
  {
    delta = -1;
  }
 
  PartPlate* plate = m_plate_list[old_index];
  //update the plates between old_index and new_index
  for (unsigned int i = (unsigned int)old_index; i != (unsigned int)new_index; i = i + delta)
  {
    m_plate_list[i] = m_plate_list[i + delta];
    m_plate_list[i]->set_index(i);
 
    origin = compute_origin(i, m_plate_cols);
    m_plate_list[i]->set_pos_and_size(origin, m_plate_width, m_plate_depth, m_plate_height, true);
  }
  origin = compute_origin(new_index, m_plate_cols);
  m_plate_list[new_index] = plate;
  plate->set_index(new_index);
  plate->set_pos_and_size(origin, m_plate_width, m_plate_depth, m_plate_height, true);
 
  //update the new plate index
  m_current_plate = new_index;
 
  return ret;
}

References compute_origin(), m_current_plate, m_plate_cols, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, PartPlate, reload_all_objects(), Slic3r::GUI::PartPlate::set_index(), and Slic3r::GUI::PartPlate::set_pos_and_size().

Here is the call graph for this function:

◆ notify_instance_removed()

int Slic3r::GUI::PartPlateList::notify_instance_removed	(	int	obj_id,
		int	instance_id )

{
  int ret = 0, index, instance_to_delete = instance_id;
  PartPlate* plate = NULL;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj_id %1%, instance_id %2%") % obj_id % instance_id;
  if (instance_id == -1) {
    instance_to_delete = 0;
  }
  index = find_instance(obj_id, instance_to_delete);
  if (index != -1)
  {
    //found it added before
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in plate %1%, remove it") % index;
    plate = m_plate_list[index];
    plate->remove_instance(obj_id, instance_to_delete);
    plate->update_slice_result_valid_state();
    plate->thumbnail_data.reset();
        plate->no_light_thumbnail_data.reset();
    plate->top_thumbnail_data.reset();
    plate->pick_thumbnail_data.reset();
  }
 
  if (unprintable_plate.contain_instance(obj_id, instance_to_delete))
  {
    //found in unprintable plate, add it to plate
    unprintable_plate.remove_instance(obj_id, instance_to_delete);
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in unprintable plate, remove it");
  }
 
  if (instance_id == -1) {
    //update all the obj_ids which is bigger
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
    {
      PartPlate* plate = m_plate_list[i];
      assert(plate != NULL);
 
      plate->update_object_index(obj_id, m_model->objects.size());
    }
    unprintable_plate.update_object_index(obj_id, m_model->objects.size());
  }
 
  if (m_plater)
    m_plater->mark_plate_toolbar_image_dirty();
 
  return 0;
}

References find_instance(), m_model, m_plate_list, m_plater, Slic3r::GUI::PartPlate::no_light_thumbnail_data, PartPlate, Slic3r::GUI::PartPlate::pick_thumbnail_data, Slic3r::GUI::PartPlate::remove_instance(), Slic3r::ThumbnailData::reset(), Slic3r::GUI::PartPlate::thumbnail_data, Slic3r::GUI::PartPlate::top_thumbnail_data, unprintable_plate, Slic3r::GUI::PartPlate::update_object_index(), and Slic3r::GUI::PartPlate::update_slice_result_valid_state().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_instance_update()

int Slic3r::GUI::PartPlateList::notify_instance_update	(	int	obj_id,
		int	instance_id,
		bool	is_new = false )

{
  int ret = 0, index;
  PartPlate* plate = NULL;
  ModelObject* object = NULL;
 
  if ((obj_id >= 0) && (obj_id < m_model->objects.size()))
  {
    object = m_model->objects[obj_id];
  }
  else if (obj_id >= 1000 && obj_id < 1000 + m_plate_count) {
    //wipe tower updates
    PartPlate* plate = m_plate_list[obj_id - 1000];
    plate->update_slice_result_valid_state( false );
    plate->thumbnail_data.reset();
        plate->no_light_thumbnail_data.reset();
    plate->top_thumbnail_data.reset();
    plate->pick_thumbnail_data.reset();
 
    return 0;
  }
    else
    return -1;
 
  BoundingBoxf3 boundingbox = object->instance_convex_hull_bounding_box(instance_id);
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj_id %1%, instance_id %2%") % obj_id % instance_id;
  index = find_instance(obj_id, instance_id);
  if (index != -1)
  {
    //found it added before
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in previous plate %1%") % index;
    plate = m_plate_list[index];
    if (!plate->intersect_instance(obj_id, instance_id, &boundingbox))
    {
      //not include anymore, remove it from original plate
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": not in plate %1% anymore, remove it") % index;
      plate->remove_instance(obj_id, instance_id);
    }
    else
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": still in original plate %1%, no need to be updated") % index;
      plate->update_instance_exclude_status(obj_id, instance_id, &boundingbox);
      plate->update_states();
      plate->update_slice_result_valid_state();
      plate->thumbnail_data.reset();
            plate->no_light_thumbnail_data.reset();
      plate->top_thumbnail_data.reset();
      plate->pick_thumbnail_data.reset();
      return 0;
    }
    plate->update_slice_result_valid_state();
    plate->thumbnail_data.reset();
        plate->no_light_thumbnail_data.reset();
    plate->top_thumbnail_data.reset();
    plate->pick_thumbnail_data.reset();
  }
  else if (unprintable_plate.contain_instance(obj_id, instance_id))
  {
    //found it in the unprintable plate
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in unprintable plate");
    if (!unprintable_plate.intersect_instance(obj_id, instance_id, &boundingbox))
    {
      //not include anymore, remove it from original plate
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": not in unprintable plate anymore, remove it");
      unprintable_plate.remove_instance(obj_id, instance_id);
    }
    else
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": still in unprintable plate, no need to be updated");
      return 0;
    }
  }
 
  auto is_object_config_compatible_with_spiral_vase = [](ModelObject* object) {
    const DynamicPrintConfig& config = object->config.get();
    if (config.has("wall_loops") && config.opt_int("wall_loops") == 1 &&
      config.has("top_shell_layers") && config.opt_int("top_shell_layers") == 0 &&
      config.has("sparse_infill_density") && config.option<ConfigOptionPercent>("sparse_infill_density")->value == 0 &&
      config.has("enable_support") && !config.opt_bool("enable_support") &&
      config.has("enforce_support_layers") && config.opt_int("enforce_support_layers") == 0 &&
      config.has("ensure_vertical_shell_thickness") && config.opt_bool("ensure_vertical_shell_thickness") &&
      config.has("detect_thin_wall") && !config.opt_bool("detect_thin_wall") &&
      config.has("timelapse_type") && config.opt_enum<TimelapseType>("timelapse_type") == TimelapseType::tlTraditional)
      return true;
    else
      return false;
  };
 
  //try to find a new plate
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    if (plate->intersect_instance(obj_id, instance_id, &boundingbox))
    {
      //found a new plate, add it to plate
      plate->add_instance(obj_id, instance_id, false, &boundingbox);
 
      // spiral mode, update object setting
      if (plate->config()->has("spiral_mode") && plate->config()->opt_bool("spiral_mode") && !is_object_config_compatible_with_spiral_vase(object)) {
        if (!is_new) {
          auto answer = static_cast<TabPrintPlate*>(wxGetApp().plate_tab)->show_spiral_mode_settings_dialog(true);
          if (answer == wxID_YES) {
            plate->set_vase_mode_related_object_config(obj_id);
          }
        }
        else {
          plate->set_vase_mode_related_object_config(obj_id);
        }
      }
 
      plate->update_slice_result_valid_state();
      plate->thumbnail_data.reset();
            plate->no_light_thumbnail_data.reset();
      plate->top_thumbnail_data.reset();
      plate->pick_thumbnail_data.reset();
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": add it to new plate %1%") % i;
      return 0;
    }
  }
 
  if (unprintable_plate.intersect_instance(obj_id, instance_id, &boundingbox))
  {
    //found in unprintable plate, add it to plate
    unprintable_plate.add_instance(obj_id, instance_id, false, &boundingbox);
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": add it to unprintable plate");
    return 0;
  }
 
  return 0;
}

Referenced by Slic3r::GUI::ObjectList::add_object_to_list(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::Selection::notify_instance_update(), and Slic3r::GUI::ObjectList::notify_instance_updated().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_change_color_mode()

void Slic3r::GUI::PartPlateList::on_change_color_mode ( bool is_dark )

inline

1056{ m_is_dark = is_dark; }

is_dark

static bool is_dark()

Definition TextureImportDialog.cpp:85

References is_dark(), and m_is_dark.

Here is the call graph for this function:

◆ on_extruder_count_changed()

void Slic3r::GUI::PartPlateList::on_extruder_count_changed ( int extruder_count )

{
    for (unsigned int i = 0; i < (unsigned int) m_plate_list.size(); ++i) {
        m_plate_list[i]->on_extruder_count_changed(extruder_count);
    }
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: extruder_count=%2%")% __FUNCTION__ %extruder_count;
}

References m_plate_list.

◆ on_filament_added()

void Slic3r::GUI::PartPlateList::on_filament_added ( int filament_count )

{
    m_filament_count++;
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
    {
        m_plate_list[i]->on_filament_added();
    }
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: filament_count=%2%")% __FUNCTION__ %filament_count;
}

References m_filament_count, and m_plate_list.

◆ on_filament_deleted()

void Slic3r::GUI::PartPlateList::on_filament_deleted	(	int	filament_count,
		int	filament_id )

{
    m_filament_count--;
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
    {
        m_plate_list[i]->on_filament_deleted(filament_count, filament_id);
    }
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: filament_count=%2%, filament_id=%3%")% __FUNCTION__ %filament_count %filament_id;
}

References m_filament_count, and m_plate_list.

◆ plate_stride_x()

double Slic3r::GUI::PartPlateList::plate_stride_x ( )

{
  //const auto plate_shape = Slic3r::Polygon::new_scale(m_shape);
  //double plate_width = plate_shape.bounding_box().size().x();
  //return unscaled<double>((1. + LOGICAL_PART_PLATE_GAP) * plate_width);
  return m_plate_width * (1. + LOGICAL_PART_PLATE_GAP);
}

References LOGICAL_PART_PLATE_GAP, and m_plate_width.

Referenced by compute_plate_index(), compute_shape_position(), postprocess_arrange_polygon(), preprocess_arrange_polygon(), preprocess_arrange_polygon_other_locked(), and set_shapes().

Here is the caller graph for this function:

◆ plate_stride_y()

double Slic3r::GUI::PartPlateList::plate_stride_y ( )

{
  //const auto plate_shape = Slic3r::Polygon::new_scale(m_shape);
  //double plate_depth = plate_shape.bounding_box().size().y();
  //return unscaled<double>((1. + LOGICAL_PART_PLATE_GAP) * plate_depth);
  return m_plate_depth * (1. + LOGICAL_PART_PLATE_GAP);
}

References LOGICAL_PART_PLATE_GAP, and m_plate_depth.

Referenced by compute_plate_index(), compute_shape_position(), postprocess_arrange_polygon(), preprocess_arrange_polygon(), preprocess_arrange_polygon_other_locked(), and set_shapes().

Here is the caller graph for this function:

◆ postprocess_arrange_polygon()

void Slic3r::GUI::PartPlateList::postprocess_arrange_polygon	(	arrangement::ArrangePolygon &	arrange_polygon,
		bool	selected )

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": bed_idx %1%, selected %2%, translation(x) %3%, (y) %4%") % arrange_polygon.bed_idx % selected % unscale<double>(arrange_polygon.translation(X)) % unscale<double>(arrange_polygon.translation(Y));
 
  // UNARRANGED means the item could not be placed, so it has no bed to map onto and
  // must be left where the user had it. Moving it to a virtual bed here would shift
  // it off the plate, because no such plate is created for it afterwards.
  if (arrange_polygon.bed_idx == arrangement::UNARRANGED)
    return;
 
  if ((selected) || (arrange_polygon.bed_idx != PartPlateList::MAX_PLATES_COUNT))
  {
    arrange_polygon.row = arrange_polygon.bed_idx / m_plate_cols;
    arrange_polygon.col = arrange_polygon.bed_idx % m_plate_cols;
    arrange_polygon.translation(X) += scaled<double>(plate_stride_x() * arrange_polygon.col);
    arrange_polygon.translation(Y) -= scaled<double>(plate_stride_y() * arrange_polygon.row);
  }
 
  return;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::arrangement::ArrangePolygon::col, m_plate_cols, MAX_PLATES_COUNT, plate_stride_x(), plate_stride_y(), Slic3r::arrangement::ArrangePolygon::row, Slic3r::scaled(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::arrangement::UNARRANGED, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::finalize(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postprocess_bed_index_for_current_plate()

void Slic3r::GUI::PartPlateList::postprocess_bed_index_for_current_plate ( arrangement::ArrangePolygon & arrange_polygon )

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": bed_idx %1%, locked_plate %2%, translation(x) %3%, (y) %4%") % arrange_polygon.bed_idx % arrange_polygon.locked_plate % unscale<double>(arrange_polygon.translation(X)) % unscale<double>(arrange_polygon.translation(Y));
 
  if (arrange_polygon.bed_idx == -1)
  {
    //outarea for large object
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": can not be arranged inside plate!");
  }
  else if (arrange_polygon.bed_idx == 0)
    arrange_polygon.bed_idx += m_current_plate;
  else
    arrange_polygon.bed_idx = m_plate_list.size();
 
  return;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::arrangement::ArrangePolygon::locked_plate, m_current_plate, m_plate_list, Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::finalize(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postprocess_bed_index_for_selected()

void Slic3r::GUI::PartPlateList::postprocess_bed_index_for_selected ( arrangement::ArrangePolygon & arrange_polygon )

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": bed_idx %1%, locked_plate %2%, translation(x) %3%, (y) %4%") % arrange_polygon.bed_idx % arrange_polygon.locked_plate % unscale<double>(arrange_polygon.translation(X)) % unscale<double>(arrange_polygon.translation(Y));
 
  if (arrange_polygon.bed_idx == -1)
  {
    //outarea for large object, can not process here for the plate number maybe increased later
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": can not be arranged inside plate!");
    return;
  }
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (m_plate_list[i]->is_locked())
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found locked_plate %1%, increate index by 1") % i;
      //arrange_polygon.translation(X) += scaled<double>(plate_stride_x());
      arrange_polygon.bed_idx += 1;
      //offset_x += scaled<double>(plate_stride_x());
    }
    else
    {
      //judge whether it is at the left side of the plate border
      if (arrange_polygon.bed_idx <= i)
      {
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":found in plate_index %1%, bed_idx %2%") % i % arrange_polygon.bed_idx;
        return;
      }
    }
  }
 
  //create a new plate which can hold this arrange_polygon
  int plate_index = create_plate(false);
 
  while (plate_index != -1)
  {
    if (arrange_polygon.bed_idx <= plate_index)
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":new plate_index %1%, matches bed_idx %2%") % plate_index % arrange_polygon.bed_idx;
      break;
    }
 
    plate_index = create_plate(false);
  }
 
  return;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, create_plate(), is_locked(), Slic3r::arrangement::ArrangePolygon::locked_plate, m_plate_list, Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::finalize(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postprocess_bed_index_for_unselected()

void Slic3r::GUI::PartPlateList::postprocess_bed_index_for_unselected ( arrangement::ArrangePolygon & arrange_polygon )

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": bed_idx %1%, locked_plate %2%, translation(x) %3%, (y) %4%") % arrange_polygon.bed_idx % arrange_polygon.locked_plate % unscale<double>(arrange_polygon.translation(X)) % unscale<double>(arrange_polygon.translation(Y));
 
  if (arrange_polygon.bed_idx == PartPlateList::MAX_PLATES_COUNT)
    return;
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (m_plate_list[i]->is_locked())
    {
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found locked_plate %1%, increate index by 1") % i;
      //arrange_polygon.translation(X) += scaled<double>(plate_stride_x());
      arrange_polygon.bed_idx += 1;
      //offset_x += scaled<double>(plate_stride_x());
    }
    else
    {
      //judge whether it is at the left side of the plate border
      if (arrange_polygon.bed_idx <= i)
      {
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":found in plate_index %1%, bed_idx %2%") % i % arrange_polygon.bed_idx;
        return;
      }
    }
  }
 
  return;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, is_locked(), Slic3r::arrangement::ArrangePolygon::locked_plate, m_plate_list, MAX_PLATES_COUNT, Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_arrange_polygon()

bool Slic3r::GUI::PartPlateList::preprocess_arrange_polygon	(	int	obj_index,
		int	instance_index,
		arrangement::ArrangePolygon &	arrange_polygon,
		bool	selected )

{
  bool locked = false;
  int lockplate_cnt = 0;
 
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    if (m_plate_list[i]->contain_instance(obj_index, instance_index))
    {
      if (m_plate_list[i]->is_locked())
      {
        locked = true;
        arrange_polygon.bed_idx = i;
        arrange_polygon.row = i / m_plate_cols;
        arrange_polygon.col = i % m_plate_cols;
        arrange_polygon.translation(X) -= scaled<double>(plate_stride_x() * arrange_polygon.col);
        arrange_polygon.translation(Y) += scaled<double>(plate_stride_y() * arrange_polygon.row);
      }
      else
      {
        if (!selected)
        {
          //will be treated as fixeditem later
          arrange_polygon.bed_idx = i - lockplate_cnt;
          arrange_polygon.row = i / m_plate_cols;
          arrange_polygon.col = i % m_plate_cols;
          arrange_polygon.translation(X) -= scaled<double>(plate_stride_x() * arrange_polygon.col);
          arrange_polygon.translation(Y) += scaled<double>(plate_stride_y() * arrange_polygon.row);
        }
      }
      BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj_id %1% instance_id %2% already in plate %3%, locked %4%, row %5%, col %6%\n") % obj_index % instance_index % i % locked % arrange_polygon.row % arrange_polygon.col;
      return locked;
    }
    if (m_plate_list[i]->is_locked())
      lockplate_cnt++;
  }
  //not be contained by any plates
  if (!selected)
    arrange_polygon.bed_idx = PartPlateList::MAX_PLATES_COUNT;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": not in any plates, bed_idx %1%, translation(x) %2%, (y) %3%") % arrange_polygon.bed_idx % unscale<double>(arrange_polygon.translation(X)) % unscale<double>(arrange_polygon.translation(Y));
 
  return locked;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::arrangement::ArrangePolygon::col, is_locked(), m_plate_cols, m_plate_list, MAX_PLATES_COUNT, plate_stride_x(), plate_stride_y(), Slic3r::arrangement::ArrangePolygon::row, Slic3r::scaled(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_selected(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_arrange_polygon_other_locked()

bool Slic3r::GUI::PartPlateList::preprocess_arrange_polygon_other_locked	(	int	obj_index,
		int	instance_index,
		arrangement::ArrangePolygon &	arrange_polygon,
		bool	selected )

{
  bool locked = false;
 
  if (selected)
  {
    //arrange_polygon.translation(X) -= scaled<double>(plate_stride_x() * m_current_plate);
  }
  else
  {
    locked = true;
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
    {
      if (m_plate_list[i]->contain_instance(obj_index, instance_index))
      {
        arrange_polygon.bed_idx = i;
        arrange_polygon.row = i / m_plate_cols;
        arrange_polygon.col = i % m_plate_cols;
        arrange_polygon.translation(X) -= scaled<double>(plate_stride_x() * arrange_polygon.col);
        arrange_polygon.translation(Y) += scaled<double>(plate_stride_y() * arrange_polygon.row);
        //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj_id %1% instance_id %2% in plate %3%, locked %4%, row %5%, col %6%\n") % obj_index % instance_index % i % locked % arrange_polygon.row % arrange_polygon.col;
        return locked;
      }
    }
    arrange_polygon.bed_idx = PartPlateList::MAX_PLATES_COUNT;
  }
  return locked;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::arrangement::ArrangePolygon::col, m_plate_cols, m_plate_list, MAX_PLATES_COUNT, plate_stride_x(), plate_stride_y(), Slic3r::arrangement::ArrangePolygon::row, Slic3r::scaled(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ArrangeJob::prepare_partplate(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_exclude_areas()

bool Slic3r::GUI::PartPlateList::preprocess_exclude_areas	(	arrangement::ArrangePolygons &	unselected,
		const DynamicPrintConfig &	config,
		bool	enable_wrapping_detect,
		int	num_plates = 16,
		float	inflation = 0 )

{
  bool added = false;
 
  // wrapping detection area
    if (enable_wrapping_detect)
  {
        if (!m_wrapping_exclude_areas.empty())
    {
      Polygon ap{};
            for (const Vec2d &p : m_wrapping_exclude_areas)
      {
                ap.append({scale_(p(0)), scale_(p(1))});
            }
 
      for(int j = 0; j < num_plates; j++)
      {
        arrangement::ArrangePolygon ret;
        ret.poly.contour = ap;
        ret.translation  = Vec2crd(0, 0);
        ret.rotation     = 0.0f;
        ret.is_virt_object = true;
        ret.bed_idx      = j;
        ret.height      = 1;
        ret.name = "WrappingRegion";
        ret.inflation = inflation;
 
        unselected.emplace_back(std::move(ret));
      }
    }
    added = true;
  }
    const BedExcludeVolumeMode mode = active_bed_exclude_volume_mode(config);
    const bool use_resolved_regions = has_bed_exclude_volumes(config);
 
    if (use_resolved_regions) {
        const std::vector<std::vector<BedExcludeRegion>> regions_by_extruder =
            get_bed_excluded_regions_by_extruder(config);
        const size_t extruder_count = mode == BedExcludeVolumeMode::Shared ?
            std::min<size_t>(1, regions_by_extruder.size()) : regions_by_extruder.size();
 
        for (size_t extruder_id = 0; extruder_id < extruder_count; ++extruder_id) {
            for (size_t region_id = 0; region_id < regions_by_extruder[extruder_id].size(); ++region_id) {
                const BedExcludeRegion &region = regions_by_extruder[extruder_id][region_id];
                if (!region.is_collision_volume() || region.polygon.points.size() < 3 ||
                    (region.has_z_range && region.z_max <= region.z_min + EPSILON))
                    continue;
 
                for (int plate_idx = 0; plate_idx < num_plates; ++plate_idx) {
                    arrangement::ArrangePolygon blocker;
                    blocker.poly.contour = bed_exclusion_arrange_polygon(region.polygon);
                    blocker.translation = Vec2crd::Zero();
                    blocker.rotation = 0.0;
                    blocker.is_virt_object = true;
                    blocker.is_bed_exclusion = true;
                    blocker.bed_exclusion_extruder_id = mode == BedExcludeVolumeMode::Shared ? -1 : int(extruder_id);
                    blocker.bed_idx = plate_idx;
                    blocker.height = std::max(0.0, region.z_max - region.z_min);
                    blocker.z_min = region.z_min;
                    blocker.z_max = region.z_max;
                    blocker.has_z_range = region.has_z_range;
                    blocker.name = "BedExclusionVolume" + std::to_string(extruder_id) + "_" + std::to_string(region_id);
                    blocker.inflation = inflation;
                    unselected.emplace_back(std::move(blocker));
                }
                added = true;
            }
        }
    }
 
    // Keep Orca's established legacy-area arrange obstacle alongside any
    // explicit collision-volume blockers. The two settings are additive.
    if (!m_exclude_areas.empty()) {
    //has exclude areas
    PartPlate *plate = m_plate_list[0];
 
    for (int index = 0; index < plate->m_exclude_bounding_box.size(); index ++)
    {
      Polygon ap({
        {scaled(plate->m_exclude_bounding_box[index].min.x()), scaled(plate->m_exclude_bounding_box[index].min.y())},
        {scaled(plate->m_exclude_bounding_box[index].max.x()), scaled(plate->m_exclude_bounding_box[index].min.y())},
        {scaled(plate->m_exclude_bounding_box[index].max.x()), scaled(plate->m_exclude_bounding_box[index].max.y())},
        {scaled(plate->m_exclude_bounding_box[index].min.x()), scaled(plate->m_exclude_bounding_box[index].max.y())}
        });
 
      for (int j = 0; j < num_plates; j++)
      {
        arrangement::ArrangePolygon ret;
        ret.poly.contour = ap;
        ret.translation  = Vec2crd(0, 0);
        ret.rotation     = 0.0f;
        ret.is_virt_object = true;
        ret.bed_idx      = j;
        ret.height      = 1;
        ret.name = "ExcludedRegion" + std::to_string(index);
        ret.inflation = inflation;
 
        unselected.emplace_back(std::move(ret));
      }
      added = true;
    }
  }
 
  return added;
}

Referenced by Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_nonprefered_areas()

bool Slic3r::GUI::PartPlateList::preprocess_nonprefered_areas	(	arrangement::ArrangePolygons &	regions,
		int	num_plates = 1,
		float	inflation = 0 )

{
  bool added = false;
 
  std::vector<BoundingBoxf> nonprefered_regions;
  nonprefered_regions.emplace_back(Vec2d{ 18,0 }, Vec2d{ 240,15 }); // new extrusion & hand-eye calibration region
 
  //has exclude areas
  PartPlate* plate = m_plate_list[0];
  for (int index = 0; index < nonprefered_regions.size(); index++)
  {
    Polygon ap = scaled(nonprefered_regions[index]).polygon();
    for (int j = 0; j < num_plates; j++)
    {
      arrangement::ArrangePolygon ret;
      ret.poly.contour = ap;
      ret.translation = Vec2crd(0, 0);
      ret.rotation = 0.0f;
      ret.is_virt_object = true;
            ret.is_extrusion_cali_object = true;
      ret.bed_idx = j;
      ret.height = 1;
      ret.name = "NonpreferedRegion" + std::to_string(index);
      ret.inflation = inflation;
 
      regions.emplace_back(std::move(ret));
    }
    added = true;
  }
  return added;
}

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print()

void Slic3r::GUI::PartPlateList::print ( ) const

{
  BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << boost::format("PartPlateList %1%, m_plate_count %2%, current_plate %3%, print_count %4%, current print index %5%, plate cols %6%") % this % m_plate_count % m_current_plate % m_print_list.size() % m_print_index % m_plate_cols;
  BOOST_LOG_TRIVIAL(trace) << boost::format("m_plate_width %1%, m_plate_depth %2%, m_plate_height %3%, plate count %4%\nplate list:") % m_plate_width % m_plate_depth % m_plate_height % m_plate_list.size();
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    BOOST_LOG_TRIVIAL(trace) << boost::format("the %1%th plate") % i;
    m_plate_list[i]->print();
  }
  BOOST_LOG_TRIVIAL(trace) << boost::format("the unprintable plate:");
  unprintable_plate.print();
 
  flush_logs();
  return;
}

References Slic3r::flush_logs(), m_current_plate, m_plate_cols, m_plate_count, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_print_index, m_print_list, Slic3r::trace(), and unprintable_plate.

Referenced by clear(), create_plate(), get_current_fff_print(), init(), load_from_3mf_structure(), Slic3r::UndoRedo::StackImpl::load_snapshot(), rebuild_plates_after_deserialize(), store_to_3mf_structure(), and Slic3r::UndoRedo::StackImpl::take_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rebuild_plates_after_arrangement()

int Slic3r::GUI::PartPlateList::rebuild_plates_after_arrangement	(	bool	recycle_plates = true,
		bool	except_locked = false,
		int	plate_index = -1 )

{
  int ret = 0;
 
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":before rebuild, plates count %1%, recycle_plates %2%") % m_plate_list.size() % recycle_plates;
 
  // sort by arrange_order
  std::sort(m_model->objects.begin(), m_model->objects.end(), [](auto a, auto b) {return a->instances[0]->arrange_order < b->instances[0]->arrange_order; });
  //for (auto object : m_model->objects)
  //  std::sort(object->instances.begin(), object->instances.end(), [](auto a, auto b) {return a->arrange_order < b->arrange_order; });
 
  ret = reload_all_objects(except_locked, plate_index);
 
  if (recycle_plates)
  {
    for (unsigned int i = (unsigned int)m_plate_list.size() - 1; i > 0; --i)
    {
      if (m_plate_list[i]->empty()
        || !m_plate_list[i]->has_printable_instances())
      {
        //delete it
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":delete plate %1% for empty") % i;
        delete_plate(i);
      }
      else if (m_plate_list[i]->is_locked()) {
        continue;
      }
      else
      {
        break;
      }
    }
  }
 
#if 0
  if (m_plater != nullptr) {
    // In GUI mode
    wxGetApp().obj_list()->reload_all_plates();
  }
#endif
 
  if (m_plater)
    m_plater->mark_plate_toolbar_image_dirty();
 
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":after rebuild, plates count %1%") % m_plate_list.size();
  return ret;
}

References delete_plate(), Slic3r::empty(), is_locked(), m_model, m_plate_list, m_plater, and reload_all_objects().

Referenced by Slic3r::GUI::ArrangeJob::finalize(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rebuild_plates_after_deserialize()

int Slic3r::GUI::PartPlateList::rebuild_plates_after_deserialize	(	std::vector< bool > &	previous_sliced_result,
		std::vector< std::string > &	previous_gcode_paths )

{
  int ret = 0;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plates count %1%") % m_plate_list.size();
  // SoftFever: assign plater info first
    for (auto partplate : m_plate_list) {
        partplate->m_plater = this->m_plater;
        partplate->m_partplate_list = this;
        partplate->m_model = this->m_model;
        partplate->printer_technology = this->printer_technology;
    }
  update_plate_cols();
  update_all_plates_pos_and_size(false, false, false, false);
  set_shapes(m_shape, m_exclude_areas, m_wrapping_exclude_areas, m_extruder_areas, m_extruder_heights, m_logo_texture_filename, m_height_to_lid, m_height_to_rod);
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    bool need_reset_print = false;
    //check the previous sliced result
    if (m_plate_list[i]->m_slice_result_valid) {
      if ((i >= previous_sliced_result.size()) || !previous_sliced_result[i])
        m_plate_list[i]->update_slice_result_valid_state(false);
    }
    if ((i < previous_gcode_paths.size())
      && !previous_gcode_paths[i].empty()
      && (m_plate_list[i]->m_tmp_gcode_path != previous_gcode_paths[i])) {
      if (boost::filesystem::exists(previous_gcode_paths[i])) {
        boost::nowide::remove(previous_gcode_paths[i].c_str());
        need_reset_print = true;
      }
    }
 
    std::map<int, PrintBase*>::iterator it = m_print_list.find(m_plate_list[i]->m_print_index);
    std::map<int, GCodeResult*>::iterator it2 = m_gcode_result_list.find(m_plate_list[i]->m_print_index);
    if (it != m_print_list.end())
    {
      //find it
      if (it2 == m_gcode_result_list.end())
      {
        //should not happen
        assert(0);
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":can not find gcode result for plate %1%, print index %2%") % i % m_plate_list[i]->m_print_index;
        delete it->second;
        m_print_list.erase(it);
      }
      else
      {
        m_plate_list[i]->set_print(it->second, it2->second, m_plate_list[i]->m_print_index);
        it->second->set_plate_index(i);
        if (need_reset_print) {
          Print *print = dynamic_cast<Print*>(it->second);
          it2->second->reset();
          print->set_gcode_file_invalidated();
          if ((i == m_current_plate)&&m_plater)
            m_plater->reset_gcode_toolpaths();
        }
        continue;
      }
    }
 
    //can not find, create a new one
    Print* print = new Print();
    GCodeResult* gcode = new GCodeResult();
    m_print_list.emplace(m_print_index, print);
    m_gcode_result_list.emplace(m_print_index, gcode);
    m_plate_list[i]->set_print(print, gcode, m_print_index);
    print->set_plate_index(i);
    m_print_index++;
  }
 
  //go through the print list, and delete the one not used by plate
  std::map<int, PrintBase*>::iterator it = m_print_list.begin();
  int print_index;
  std::vector<int> delete_list;
  while (it != m_print_list.end())
  {
    print_index = it->first;
 
    int plate_index = find_plate_by_print_index(print_index);
    if (plate_index < 0)
    {
      delete_list.push_back(print_index);
    }
    it++;
  }
 
  for (unsigned int index = 0; index < delete_list.size(); index++)
  {
    destroy_print(delete_list[index]);
  }
 
  //update the bed's position
  Vec2d pos = compute_shape_position(m_current_plate, m_plate_cols);
  m_plater->set_bed_position(pos);
 
  //not used
  /*if (m_plate_width == 0)
  {
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": jump to the first init state, need to re-set size!");
    Vec3d max = m_plater->get_bed().get_bounding_box(false).max;
    Vec3d min = m_plater->get_bed().get_bounding_box(false).min;
    double z = m_plater->config()->opt_float("printable_height");
    reset_size(max.x() - min.x(), max.y() - min.y(), z);
  }*/
  return ret;
}

References compute_shape_position(), destroy_print(), find_plate_by_print_index(), Slic3r::GUI::gcode(), m_current_plate, m_exclude_areas, m_extruder_areas, m_extruder_heights, m_gcode_result_list, m_height_to_lid, m_height_to_rod, m_logo_texture_filename, m_model, m_plate_cols, m_plate_list, m_plater, m_print_index, m_print_list, m_shape, m_wrapping_exclude_areas, print(), printer_technology, set_shapes(), update_all_plates_pos_and_size(), and update_plate_cols().

Referenced by Slic3r::UndoRedo::StackImpl::load_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refresh_imex_icons()

void Slic3r::GUI::PartPlateList::refresh_imex_icons ( )

{
    const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
    for (PartPlate* plate : m_plate_list)
        plate->refresh_imex_icon();
}

References m_plate_list, m_plates_mutex, and PartPlate.

Here is the call graph for this function:

◆ register_raycasters_for_picking()

void Slic3r::GUI::PartPlateList::register_raycasters_for_picking ( GLCanvas3D & canvas )

inline

    {
        for (auto plate : m_plate_list)
            plate->register_raycasters_for_picking(canvas);
    }

References m_plate_list.

◆ reinit()

void Slic3r::GUI::PartPlateList::reinit ( )

{
  clear(true, true);
 
  init();
 
  m_plate_list[0]->set_filament_count(m_filament_count);
 
  //reset plate 0's position
  Vec2d pos = compute_shape_position(0, m_plate_cols);
  m_plate_list[0]->set_shape(m_shape, m_exclude_areas, m_extruder_areas, m_extruder_heights, pos, m_height_to_lid, m_height_to_rod);
  //reset unprintable plate's position
  Vec3d origin2 = compute_origin_for_unprintable();
  unprintable_plate.set_pos_and_size(origin2, m_plate_width, m_plate_depth, m_plate_height, false);
  //re-calc the bounding boxes
  calc_bounding_boxes();
 
  if (m_plater) {
        // In GUI mode
        set_default_wipe_tower_pos_for_plate(0, true);
    }
 
  return;
}

References calc_bounding_boxes(), clear(), compute_origin_for_unprintable(), compute_shape_position(), init(), m_exclude_areas, m_extruder_areas, m_extruder_heights, m_filament_count, m_height_to_lid, m_height_to_rod, m_plate_cols, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_plater, m_shape, set_default_wipe_tower_pos_for_plate(), and unprintable_plate.

Here is the call graph for this function:

◆ release_icon_textures()

void Slic3r::GUI::PartPlateList::release_icon_textures ( )

private

{
  m_logo_texture.reset();
  m_del_texture.reset();
  m_del_hovered_texture.reset();
    m_move_front_hovered_texture.reset();
    m_move_front_texture.reset();
  m_arrange_texture.reset();
  m_arrange_hovered_texture.reset();
  m_orient_texture.reset();
  m_orient_hovered_texture.reset();
  m_locked_texture.reset();
  m_locked_hovered_texture.reset();
  m_lockopen_texture.reset();
  m_lockopen_hovered_texture.reset();
  m_plate_settings_texture.reset();
  m_plate_settings_hovered_texture.reset();
    m_plate_set_filament_map_texture.reset();
    m_plate_set_filament_map_hovered_texture.reset();
  m_plate_name_edit_texture.reset();
  m_plate_name_edit_hovered_texture.reset();
    for (GLTexture& texture : m_imex_mode_textures)
        texture.reset();
    for (GLTexture& texture : m_imex_mode_hovered_textures)
        texture.reset();
    m_imex_warn_texture.reset();
  for (int i = 0;i < MAX_PLATE_COUNT; i++) {
    m_idx_textures[i].reset();
  }
  //reset
  PartPlateList::is_load_bedtype_textures = false;
    PartPlateList::is_load_extruder_only_area_textures = false;
  PartPlateList::is_load_cali_texture = false;
  m_next_bedtype_texture = 0;
  m_next_extruder_only_area_texture = 0;
  m_next_cali_texture = 0;
  for (int i = 0; i < btCount; i++) {
    for (auto& part: bed_texture_info[i].parts) {
      if (part.texture) {
        part.texture->reset();
        delete part.texture;
      }
      if (part.buffer) {
        delete part.buffer;
      }
    }
  }
    for (int i = 0; i < (unsigned char)ExtruderOnlyAreaType::btAreaCount; i++) {
        for (auto &part : extruder_only_area_info[i].parts) {
            if (part.texture) {
                part.texture->reset();
                delete part.texture;
            }
            if (part.buffer) { delete part.buffer; }
        }
    }
}

Referenced by ~PartPlateList().

Here is the caller graph for this function:

◆ reload_all_objects()

int Slic3r::GUI::PartPlateList::reload_all_objects	(	bool	except_locked = false,
		int	plate_index = -1 )

{
  int ret = 0;
  unsigned int i, j, k;
 
  clear(false, false, except_locked, plate_index);
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": m_model->objects.size() is %1%") % m_model->objects.size();
  //try to find a new plate
  for (i = 0; i < (unsigned int)m_model->objects.size(); ++i)
  {
    ModelObject* object = m_model->objects[i];
    for (j = 0; j < (unsigned int)object->instances.size(); ++j)
    {
      ModelInstance* instance = object->instances[j];
      BoundingBoxf3 boundingbox = object->instance_convex_hull_bounding_box(j);
      for (k = 0; k < (unsigned int)m_plate_list.size(); ++k)
      {
        PartPlate* plate = m_plate_list[k];
        assert(plate != NULL);
 
        if (plate->intersect_instance(i, j, &boundingbox))
        {
          //found a new plate, add it to plate
          plate->add_instance(i, j, false, &boundingbox);
          BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found plate_id %1%, for obj_id %2%, instance_id %3%") % k % i % j;
 
          //need to judge whether this instance has an outer part
          /*if (plate->check_outside(i, j))
          {
            plate->m_ready_for_slice = false;
          }*/
          break;
        }
      }
 
      if ((k == m_plate_list.size()) && (unprintable_plate.intersect_instance(i, j, &boundingbox)))
      {
        //found in unprintable plate, add it to plate
        unprintable_plate.add_instance(i, j, false, &boundingbox);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found in unprintable plate, obj_id %1%, instance_id %2%") % i % j;
      }
    }
 
  }
 
  return ret;
}

References Slic3r::GUI::PartPlate::add_instance(), clear(), Slic3r::GUI::PartPlate::intersect_instance(), m_model, m_plate_list, PartPlate, and unprintable_plate.

Referenced by create_plate(), load_from_3mf_structure(), move_plate_to_index(), Slic3r::GUI::ObjectList::OnDrop(), rebuild_plates_after_arrangement(), reset_size(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render()

void Slic3r::GUI::PartPlateList::render	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		bool	bottom,
		bool	only_current = false,
		bool	only_body = false,
		int	hover_id = -1,
		bool	render_cali = false,
		bool	show_grid = true,
		bool	hide_chrome = false,
		bool	hide_inactive = false )

{
  const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
  std::vector<PartPlate*>::iterator it = m_plate_list.begin();
 
  int plate_hover_index = -1;
  int plate_hover_action = -1;
  if (hover_id != -1) {
    plate_hover_index = hover_id / PartPlate::GRABBER_COUNT;
    plate_hover_action = hover_id % PartPlate::GRABBER_COUNT;
  }
 
  load_icon_textures();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    int current_index = (*it)->get_index();
    if ((only_current || hide_inactive) && (current_index != m_current_plate))
      continue;
    if (current_index == m_current_plate) {
      PartPlate::HeightLimitMode height_mode = (only_current)?PartPlate::HEIGHT_LIMIT_NONE:m_height_limit_mode;
      if (plate_hover_index == current_index)
                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, plate_hover_action, render_cali, show_grid, hide_chrome);
      else
                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, -1, render_cali, show_grid, hide_chrome);
    }
    else {
      if (plate_hover_index == current_index)
        (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, plate_hover_action, render_cali, show_grid, hide_chrome);
      else
                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, -1, render_cali, show_grid, hide_chrome);
    }
  }
}

References Slic3r::GUI::PartPlate::GRABBER_COUNT, Slic3r::GUI::PartPlate::HEIGHT_LIMIT_NONE, load_icon_textures(), m_current_plate, m_height_limit_mode, m_plate_list, and m_plates_mutex.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_exclusion_volume_intersections()

void Slic3r::GUI::PartPlateList::render_exclusion_volume_intersections	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix )

{
    GLShaderProgram *shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    shader->start_using();
    shader->set_uniform("view_model_matrix", view_matrix);
    shader->set_uniform("projection_matrix", projection_matrix);
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    glsafe(::glDepthMask(GL_FALSE));
 
    for (PartPlate *plate : m_plate_list)
        if (plate != nullptr)
            plate->render_exclusion_volume_intersections();
 
    glsafe(::glDepthMask(GL_TRUE));
    glsafe(::glDisable(GL_BLEND));
    shader->stop_using();
}

References GL_BLEND, GL_DEPTH_TEST, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, m_plate_list, PartPlate, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

◆ render_hover_tooltip()

void Slic3r::GUI::PartPlateList::render_hover_tooltip ( ) const

{
    if (m_hover_tooltip.empty())
        return;
 
    const auto scale = m_plater->get_current_canvas3D()->get_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {6 * scale, 3 * scale});
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3 * scale);
    ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BACKGROUND);
    ImGui::PushStyleColor(ImGuiCol_Border, {0, 0, 0, 0});
    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));
    ImGui::BeginTooltip();
    ImGui::TextUnformatted(m_hover_tooltip.c_str());
    ImGui::EndTooltip();
    ImGui::PopStyleColor(3);
    ImGui::PopStyleVar(2);
}

References Slic3r::GUI::ImGuiWrapper::COL_WINDOW_BACKGROUND, m_hover_tooltip, m_plater, and scale().

Here is the call graph for this function:

◆ reset()

void Slic3r::GUI::PartPlateList::reset ( bool do_init )

{
  clear(true, false);
 
  //m_plate_list.clear();
 
  if (do_init) {
    init();
    m_plate_list[0]->set_filament_count(m_filament_count);
  }
 
  return;
}

References clear(), init(), m_filament_count, and m_plate_list.

Referenced by Slic3r::UndoRedo::StackImpl::load_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_hover_id()

void Slic3r::GUI::PartPlateList::reset_hover_id ( )

{
  const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
  std::vector<PartPlate*>::iterator it = m_plate_list.begin();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    (*it)->set_hover_id(-1);
  }
}

References m_plate_list, and m_plates_mutex.

◆ reset_size()

void Slic3r::GUI::PartPlateList::reset_size	(	int	width,
		int	depth,
		double	height,
		bool	reload_objects = true,
		bool	update_shapes = false )

{
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":before size: plate_width %1%, plate_depth %2%, plate_height %3%") % m_plate_width % m_plate_depth % m_plate_height;
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":after size: plate_width %1%, plate_depth %2%, plate_height %3%") % width % depth % height;
  if ((m_plate_width != width) || (m_plate_depth != depth) || (m_plate_height != height))
  {
    m_plate_width = width;
    m_plate_depth = depth;
    m_plate_height = height;
    update_all_plates_pos_and_size(false, false, true);
    if (update_shapes) {
      set_shapes(m_shape, m_exclude_areas, m_wrapping_exclude_areas, m_extruder_areas, m_extruder_heights, m_logo_texture_filename, m_height_to_lid, m_height_to_rod);
    }
    if (reload_objects)
      reload_all_objects();
    else
      clear(false, false, false, -1);
  }
 
  return;
}

References clear(), m_exclude_areas, m_extruder_areas, m_extruder_heights, m_height_to_lid, m_height_to_rod, m_logo_texture_filename, m_plate_depth, m_plate_height, m_plate_width, m_shape, m_wrapping_exclude_areas, reload_all_objects(), set_shapes(), and update_all_plates_pos_and_size().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_plate()

int Slic3r::GUI::PartPlateList::select_plate ( int index )

{
  const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
  if (m_plate_list.empty() || index >= m_plate_list.size()) {
    return -1;
  }
  const int previous_index = m_current_plate;
 
  // BBS: erase unnecessary snapshot
  if (get_curr_plate_index() != index && m_intialized) {
    if (m_plater)
      m_plater->take_snapshot("select partplate!");
  }
 
  std::vector<PartPlate *>::iterator it = m_plate_list.begin();
  for (it = m_plate_list.begin(); it != m_plate_list.end(); it++) {
    (*it)->set_unselected();
  }
 
  m_current_plate = index;
  m_plate_list[m_current_plate]->set_selected();
 
  //BBS
  if(m_model)
    m_model->curr_plate_index = index;
 
  //BBS update bed origin
  if (m_intialized && m_plater) {
    Vec2d pos = compute_shape_position(index, m_plate_cols);
        m_plater->set_bed_position(pos);
    //wxQueueEvent(m_plater, new SimpleEvent(EVT_GLCANVAS_PLATE_SELECT));
  }
 
  // With the other plates hidden, the view follows the selected plate.
  if (previous_index != index && m_intialized && m_plater != nullptr && m_plater->is_view3D_shown() && wxGetApp().focus_mode()) {
    Camera& camera = m_plater->get_camera();
    Vec3d   target = camera.get_target();
    target.head<2>() = m_plate_list[index]->get_bounding_box().center().head<2>();
    camera.set_target(target);
  }
 
    if (previous_index != index && m_intialized && m_plater != nullptr && !m_plater->is_loading_project()) {
        LifecycleEventContext ctx;
        ctx.name = m_plate_list[index]->get_plate_name();
        ctx.index = index;
        fire_lifecycle_event(LifecycleEvent::PlateSelected, ctx);
    }
 
  return 0;
}

References Slic3r::BoundingBox3Base< PointType >::center(), compute_shape_position(), Slic3r::fire_lifecycle_event(), get_bounding_box(), get_curr_plate_index(), Slic3r::GUI::Camera::get_target(), Slic3r::LifecycleEventContext::index, m_current_plate, m_intialized, m_model, m_plate_cols, m_plate_list, m_plater, m_plates_mutex, Slic3r::LifecycleEventContext::name, Slic3r::PlateSelected, and Slic3r::GUI::Camera::set_target().

Referenced by delete_plate(), init(), Slic3r::GUI::Plater::new_project(), Slic3r::CLI::run(), select_plate_by_obj(), and Slic3r::GUI::Plater::priv::set_current_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_plate_by_obj()

int Slic3r::GUI::PartPlateList::select_plate_by_obj	(	int	obj_index,
		int	instance_index )

{
  int ret = 0, index;
  PartPlate* plate = NULL;
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": obj_id %1%, instance_id %2%") % obj_index % instance_index;
  index = find_instance(obj_index, instance_index);
  if (index != -1)
  {
    //found it in plate
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": found it in plate %1%") % index;
    select_plate(index);
    return 0;
  }
  return -1;
}

References find_instance(), PartPlate, and select_plate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_plate_view()

void Slic3r::GUI::PartPlateList::select_plate_view ( )

{
  if (m_current_plate < 0 || m_current_plate >= m_plate_list.size()) return;
 
  Vec3d target = m_plate_list[m_current_plate]->get_bounding_box(false).center();
  Vec3d position(target.x(), target.y(), m_plater->get_camera().get_distance());
  m_plater->get_camera().look_at(position, target, Vec3d::UnitY());
  m_plater->get_camera().select_view("topfront");
}

References m_current_plate, m_plate_list, and m_plater.

◆ serialize()

template<class Archive>

void Slic3r::GUI::PartPlateList::serialize ( Archive & ar )

inline

    {
        //ar(cereal::base_class<ObjectBase>(this));
        //Cancel undo/redo for m_shape ,Because the printing area of different models is different, currently if the grid changes, it cannot correspond to the model on the left ui
        ar(m_plate_width, m_plate_depth, m_plate_height, m_height_to_lid, m_height_to_rod, m_height_limit_mode, m_plate_count, m_current_plate, m_plate_list, unprintable_plate);
        //ar(m_plate_width, m_plate_depth, m_plate_height, m_plate_count, m_current_plate);
    }

References m_current_plate, m_height_limit_mode, m_height_to_lid, m_height_to_rod, m_plate_count, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, and unprintable_plate.

◆ set_default_wipe_tower_pos_for_plate()

void Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate	(	int	plate_idx,
		bool	init_pos = false )

{
    DynamicConfig &     proj_cfg     = wxGetApp().preset_bundle->project_config;
    ConfigOptionFloats *wipe_tower_x = proj_cfg.opt<ConfigOptionFloats>("wipe_tower_x");
    ConfigOptionFloats *wipe_tower_y = proj_cfg.opt<ConfigOptionFloats>("wipe_tower_y");
    wipe_tower_x->values.resize(m_plate_list.size(), wipe_tower_x->values.front());
    wipe_tower_y->values.resize(m_plate_list.size(), wipe_tower_y->values.front());
 
    auto printer_structure_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
    // set the default position, the same with print config(left top)
    float x = WIPE_TOWER_DEFAULT_X_POS;
    float y = WIPE_TOWER_DEFAULT_Y_POS;
    if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
        x = I3_WIPE_TOWER_DEFAULT_X_POS;
        y = I3_WIPE_TOWER_DEFAULT_Y_POS;
    }
 
    std::string printer_type = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
    // Note: printer_type == "N9" and printer_structure_opt->value == PrinterStructure::psI3 can both be true
    if (printer_type == "N9") {
        y = N9_WIPE_TOWER_DEFAULT_Y_POS;
    }
 
    PartPlate *part_plate = get_plate(plate_idx);
    Vec3d plate_origin = part_plate->get_origin();
    BoundingBoxf3 plate_bbox = part_plate->get_bounding_box();
    BoundingBoxf plate_bbox_2d(Vec2d(plate_bbox.min(0), plate_bbox.min(1)), Vec2d(plate_bbox.max(0), plate_bbox.max(1)));
    const std::vector<Pointfs> &extruder_areas = part_plate->get_extruder_areas();
    for (const Pointfs &points : extruder_areas) {
        BoundingBoxf bboxf(points);
        plate_bbox_2d.min = plate_bbox_2d.min(0) >= bboxf.min(0) ? plate_bbox_2d.min : bboxf.min;
        plate_bbox_2d.max = plate_bbox_2d.max(0) <= bboxf.max(0) ? plate_bbox_2d.max : bboxf.max;
    }
 
    coordf_t plate_bbox_x_min_local_coord = plate_bbox_2d.min(0) - plate_origin(0);
    coordf_t plate_bbox_x_max_local_coord = plate_bbox_2d.max(0) - plate_origin(0);
    coordf_t plate_bbox_y_max_local_coord = plate_bbox_2d.max(1) - plate_origin(1);
 
    std::vector<int> filament_maps = part_plate->get_real_filament_maps(proj_cfg);
    // Keep this composition consistent with the apply-time injection (plate volume map, else
    // per-extruder defaults); the config below currently only feeds scalar reads, but a
    // divergent volume map would silently mis-resolve any future per-filament read here.
    std::vector<int> f_volume_maps = part_plate->get_filament_volume_maps();
    if (f_volume_maps.empty()) {
        f_volume_maps = wxGetApp().preset_bundle->get_default_nozzle_volume_types_for_filaments(filament_maps);
    }
    DynamicPrintConfig full_config = wxGetApp().preset_bundle->full_config(false, filament_maps, f_volume_maps);
    WipeTowerFootprint footprint = part_plate->estimate_wipe_tower_footprint(full_config, init_pos ? 2 : 0);
 
    if (!init_pos && (is_approx(footprint.width, 0.0) || is_approx(footprint.depth, 0.0))) {
        footprint = part_plate->estimate_wipe_tower_footprint(full_config, 2);
    }
    Vec3d wipe_tower_size(footprint.width, footprint.depth, footprint.height);
 
    // Brim-aware margin: the brim extends outward from the tower position.
    const float brim_width = float(footprint.brim_width);
    const float margin     = WIPE_TOWER_AUTO_MARGIN + brim_width;
 
    // clamp wipe tower position within plate boundaries
    {
        if (x + margin + wipe_tower_size(0) > plate_bbox_x_max_local_coord) {
            x = plate_bbox_x_max_local_coord - wipe_tower_size(0) - margin;
        } else if (x < margin + plate_bbox_x_min_local_coord) {
            x = margin + plate_bbox_x_min_local_coord;
        }
 
        if (y + margin + wipe_tower_size(1) > plate_bbox_y_max_local_coord) {
            y = plate_bbox_y_max_local_coord - wipe_tower_size(1) - margin;
        } else if (y < margin) {
            y = margin;
        }
    }
 
    // The bounding box above still allows a corner a delta or hexagonal bed does not have, and the
    // prime tower is validated against the real outline — pull it onto the bed before storing.
    {
        Polygons bed{part_plate->get_shared_printable_polygon()};
        bed.front().translate(Point(-scaled(plate_origin.x()), -scaled(plate_origin.y()))); // into the frame x/y live in
        const BoundingBox tower(Point::new_scale(x, y),
                                Point::new_scale(x + wipe_tower_size(0), y + wipe_tower_size(1)));
        const Vec2f move = WipeTower::move_box_inside_polygon(tower, bed, scaled<coord_t>(margin));
        x += move.x();
        y += move.y();
    }
 
    ConfigOptionFloat wt_x_opt(x);
    ConfigOptionFloat wt_y_opt(y);
    dynamic_cast<ConfigOptionFloats *>(proj_cfg.option("wipe_tower_x"))->set_at(&wt_x_opt, plate_idx, 0);
    dynamic_cast<ConfigOptionFloats *>(proj_cfg.option("wipe_tower_y"))->set_at(&wt_y_opt, plate_idx, 0);
}

References Slic3r::WipeTowerFootprint::brim_width, Slic3r::WipeTowerFootprint::depth, Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), Slic3r::GUI::PartPlate::get_bounding_box(), Slic3r::GUI::PartPlate::get_extruder_areas(), Slic3r::GUI::PartPlate::get_filament_volume_maps(), Slic3r::GUI::PartPlate::get_origin(), get_plate(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::get_shared_printable_polygon(), Slic3r::WipeTowerFootprint::height, I3_WIPE_TOWER_DEFAULT_X_POS, I3_WIPE_TOWER_DEFAULT_Y_POS, Slic3r::is_approx(), m_plate_list, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::WipeTower::move_box_inside_polygon(), N9_WIPE_TOWER_DEFAULT_Y_POS, Slic3r::Point::new_scale(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), PartPlate, Slic3r::psI3, Slic3r::scaled(), Slic3r::ConfigOptionVector< double >::values, Slic3r::WipeTowerFootprint::width, WIPE_TOWER_AUTO_MARGIN, WIPE_TOWER_DEFAULT_X_POS, WIPE_TOWER_DEFAULT_Y_POS, and Slic3r::wipe_tower_y().

Referenced by create_plate(), reinit(), update_all_plates_pos_and_size(), 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:

◆ set_filament_count()

void Slic3r::GUI::PartPlateList::set_filament_count ( int filament_count )

{
    m_filament_count = filament_count;
    for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
    {
        m_plate_list[i]->set_filament_count(filament_count);
    }
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: filament_count=%2%")% __FUNCTION__ %filament_count;
}

References m_filament_count, and m_plate_list.

Referenced by load_from_3mf_structure(), and Slic3r::GUI::Plater::on_filament_count_change().

Here is the caller graph for this function:

◆ set_height_limits_mode()

void Slic3r::GUI::PartPlateList::set_height_limits_mode ( PartPlate::HeightLimitMode mode )

inline

    {
        m_height_limit_mode = mode;
    }

References m_height_limit_mode.

◆ set_hover_id()

void Slic3r::GUI::PartPlateList::set_hover_id ( int id )

{
  int index = id / PartPlate::GRABBER_COUNT;
  int sub_hover_id = id % PartPlate::GRABBER_COUNT;
  m_plate_list[index]->set_hover_id(sub_hover_id);
}

References Slic3r::GUI::PartPlate::GRABBER_COUNT, and m_plate_list.

◆ set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

90{ m_id = 0; }

References m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

◆ set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

89{ m_id = generate_new_id(); }

Slic3r::ObjectBase::generate_new_id

static ObjectID generate_new_id()

Definition ObjectID.hpp:100

References generate_new_id(), and m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_render_cali()

void Slic3r::GUI::PartPlateList::set_render_cali ( bool value = true )

inline

1059{ render_cali_logo = value; }

Slic3r::GUI::PartPlateList::render_cali_logo

bool render_cali_logo

Definition PartPlate.hpp:828

References render_cali_logo.

◆ set_render_option()

void Slic3r::GUI::PartPlateList::set_render_option	(	bool	bedtype_texture,
		bool	plate_settings )

{
    render_bedtype_logo = bedtype_texture;
    render_plate_settings = plate_settings;
}

References render_bedtype_logo, and render_plate_settings.

◆ set_shapes()

bool Slic3r::GUI::PartPlateList::set_shapes	(	const Pointfs &	shape,
		const Pointfs &	exclude_areas,
		const Pointfs &	wrapping_exclude_areas,
		const std::vector< Pointfs > &	extruder_areas,
		const std::vector< double > &	extruder_heights,
		const std::string &	custom_texture,
		float	height_to_lid,
		float	height_to_rod )

{
  const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
  m_shape = shape;
  m_exclude_areas = exclude_areas;
    m_wrapping_exclude_areas = wrapping_exclude_areas;
  m_extruder_areas = extruder_areas;
  m_extruder_heights = extruder_heights;
  m_height_to_lid = height_to_lid;
  m_height_to_rod = height_to_rod;
 
  double stride_x = plate_stride_x();
  double stride_y = plate_stride_y();
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    Vec2d pos;
 
    pos = compute_shape_position(i, m_plate_cols);
    plate->set_shape(shape, exclude_areas, extruder_areas, extruder_heights, pos, height_to_lid, height_to_rod);
  }
  is_load_bedtype_textures = false; //reload textures
    is_load_extruder_only_area_textures = false; // reload textures
  m_next_bedtype_texture = 0;
  m_next_extruder_only_area_texture = 0;
  calc_bounding_boxes();
 
  update_logo_texture_filename(texture_filename);
 
  return true;
}

References calc_bounding_boxes(), compute_shape_position(), is_load_bedtype_textures, is_load_extruder_only_area_textures, m_exclude_areas, m_extruder_areas, m_extruder_heights, m_height_to_lid, m_height_to_rod, m_next_bedtype_texture, m_next_extruder_only_area_texture, m_plate_cols, m_plate_list, m_plates_mutex, m_shape, m_wrapping_exclude_areas, PartPlate, plate_stride_x(), plate_stride_y(), Slic3r::GUI::PartPlate::set_shape(), and update_logo_texture_filename().

Referenced by create_plate(), delete_plate(), rebuild_plates_after_deserialize(), reset_size(), Slic3r::CLI::run(), and update_plates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_cali_texture()

void Slic3r::GUI::PartPlateList::show_cali_texture ( bool show = true )

◆ store_to_3mf_structure()

int Slic3r::GUI::PartPlateList::store_to_3mf_structure	(	PlateDataPtrs &	plate_data_list,
		bool	with_slice_info = true,
		int	plate_idx = -1,
		bool	with_statistics = false )

{
  int ret = 0;
 
  plate_data_list.clear();
  plate_data_list.reserve(m_plate_list.size());
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PlateData* plate_data_item = new PlateData();
    // TODO: write if needed
    plate_data_item->filament_maps = m_plate_list[i]->get_filament_maps();
    plate_data_item->locked = m_plate_list[i]->m_locked;
    plate_data_item->plate_index = m_plate_list[i]->m_plate_index;
    plate_data_item->plate_name  = m_plate_list[i]->get_plate_name();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% before load, width %2%, height %3%, size %4%!")
      %(i+1) %m_plate_list[i]->thumbnail_data.width %m_plate_list[i]->thumbnail_data.height %m_plate_list[i]->thumbnail_data.pixels.size();
    plate_data_item->plate_thumbnail.load_from(m_plate_list[i]->thumbnail_data);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% after load, width %2%, height %3%, size %4%!")
      %(i+1) %plate_data_item->plate_thumbnail.width %plate_data_item->plate_thumbnail.height %plate_data_item->plate_thumbnail.pixels.size();
    plate_data_item->config.apply(*m_plate_list[i]->config());
 
    if (m_plate_list[i]->no_light_thumbnail_data.is_valid())
      plate_data_item->no_light_thumbnail_file = "valid_no_light";
    if (m_plate_list[i]->top_thumbnail_data.is_valid())
      plate_data_item->top_file = "valid_top";
    if (m_plate_list[i]->pick_thumbnail_data.is_valid())
      plate_data_item->pick_file = "valid_pick";
 
    if (m_plate_list[i]->obj_to_instance_set.size() > 0)
    {
      for (std::set<std::pair<int, int>>::iterator it = m_plate_list[i]->obj_to_instance_set.begin(); it != m_plate_list[i]->obj_to_instance_set.end(); ++it)
        plate_data_item->objects_and_instances.emplace_back(it->first, it->second);
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ <<boost::format(": plate %1%, gcode_filename=%2%, with_slice_info=%3%, slice_valid %4%, object item count %5%.")
      %i %m_plate_list[i]->m_gcode_result->filename % with_slice_info %m_plate_list[i]->is_slice_result_valid()%plate_data_item->objects_and_instances.size();
 
    if (with_slice_info) {
      if (m_plate_list[i]->get_slice_result() && m_plate_list[i]->is_slice_result_valid()) {
        // BBS only include current palte_idx
        if (plate_idx == i || plate_idx == PLATE_CURRENT_IDX || plate_idx == PLATE_ALL_IDX) {
          //load calibration thumbnail
          //if (m_plate_list[i]->cali_thumbnail_data.is_valid())
          //  plate_data_item->pattern_file = "valid_pattern";
          if (m_plate_list[i]->cali_bboxes_data.is_valid())
            plate_data_item->pattern_bbox_file = "valid_pattern_bbox";
          plate_data_item->gcode_file       = m_plate_list[i]->m_gcode_result->filename;
          plate_data_item->is_sliced_valid  = true;
          plate_data_item->gcode_prediction = std::to_string(
            (int) m_plate_list[i]->get_slice_result()->print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time);
          plate_data_item->toolpath_outside = m_plate_list[i]->m_gcode_result->toolpath_outside;
                    plate_data_item->timelapse_warning_code = m_plate_list[i]->m_gcode_result->timelapse_warning_code;
                    m_plate_list[i]->set_timelapse_warning_code(plate_data_item->timelapse_warning_code);
          plate_data_item->is_label_object_enabled = m_plate_list[i]->m_gcode_result->label_object_enabled;
                    plate_data_item->limit_filament_maps = m_plate_list[i]->m_gcode_result->limit_filament_maps;
                    plate_data_item->layer_filaments  = m_plate_list[i]->m_gcode_result->layer_filaments;
                    plate_data_item->filament_change_sequence = m_plate_list[i]->m_gcode_result->filament_change_sequence;
                    plate_data_item->nozzle_change_sequence = m_plate_list[i]->m_gcode_result->nozzle_change_sequence;
                    plate_data_item->optimal_assignment = m_plate_list[i]->m_gcode_result->optimal_assignment;
                    plate_data_item->first_layer_time = std::to_string(m_plate_list[i]->get_slice_result()->initial_layer_time);
          Print *print                      = nullptr;
          m_plate_list[i]->get_print((PrintBase **) &print, nullptr, nullptr);
          if (print) {
            const PrintStatistics &ps = print->print_statistics();
            if (ps.total_weight != 0.0) {
              CNumericLocalesSetter locales_setter;
              plate_data_item->gcode_weight =wxString::Format("%.2f", ps.total_weight).ToStdString();
            }
            plate_data_item->is_support_used = print->is_support_used();
          } else {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("print is null!");
          }
          //parse filament info
          plate_data_item->parse_filament_info(m_plate_list[i]->get_slice_result());
          if (with_statistics)
            plate_data_item->statistics = gcode_statistics_json(*m_plate_list[i]->get_slice_result());
 
          // Record mixed (virtual) filaments actually used on this plate.
          // Source is ToolOrdering::used_mixed_filaments (slots that appeared in
          // layer tools before resolve), persisted on GCodeProcessorResult / Print —
          // not print->extruders() which only reflects assignment.
          {
            std::vector<unsigned int> used_mixed;
            if (auto *slice_result = m_plate_list[i]->get_slice_result())
              used_mixed = slice_result->used_mixed_filaments;
            if (used_mixed.empty() && print)
              used_mixed = print->get_slice_used_mixed_filaments();
            if (!used_mixed.empty() && print) {
              const auto &fila_types  = print->config().filament_type.values;
              const auto &fila_colors = print->config().filament_colour.values;
              const auto &fila_comps  = print->config().filament_mixed_components.values;
              for (unsigned int fid : used_mixed) {
                PlateMixedFilamentInfo mixed_info;
                mixed_info.id = (int) fid + 1;
                if (fid < fila_types.size())  mixed_info.type       = fila_types[fid];
                if (fid < fila_colors.size()) mixed_info.color      = fila_colors[fid];
                if (fid < fila_comps.size())  mixed_info.components = fila_comps[fid];
                plate_data_item->mixed_filaments_info.push_back(mixed_info);
              }
            }
          }
        } else {
          BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "slice result = " << m_plate_list[i]->get_slice_result()
                    << ", result valid = " << m_plate_list[i]->is_slice_result_valid();
        }
      }
    }
 
    plate_data_list.push_back(plate_data_item);
  }
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":stored %1% plates!") % m_plate_list.size();
 
  return ret;
}

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

74{ return 0; }

◆ update_all_plates_pos_and_size()

void Slic3r::GUI::PartPlateList::update_all_plates_pos_and_size	(	bool	adjust_position = true,
		bool	with_unprintable_move = true,
		bool	switch_plate_type = false,
		bool	do_clear = true )

{
  Vec3d origin1, origin2;
  for (unsigned int i = 0; i < (unsigned int)m_plate_list.size(); ++i)
  {
    PartPlate* plate = m_plate_list[i];
    assert(plate != NULL);
 
    //compute origin1 for PartPlate
    origin1 = compute_origin(i, m_plate_cols);
    plate->set_pos_and_size(origin1, m_plate_width, m_plate_depth, m_plate_height, adjust_position, do_clear);
 
    // set default wipe pos when switch plate
        if (switch_plate_type && m_plater/* && plate->get_used_extruders().size() <= 0*/) {
      set_default_wipe_tower_pos_for_plate(i);
    }
  }
 
  origin2 = compute_origin_for_unprintable();
  unprintable_plate.set_pos_and_size(origin2, m_plate_width, m_plate_depth, m_plate_height, with_unprintable_move);
}

References compute_origin(), compute_origin_for_unprintable(), m_plate_cols, m_plate_depth, m_plate_height, m_plate_list, m_plate_width, m_plater, PartPlate, set_default_wipe_tower_pos_for_plate(), Slic3r::GUI::PartPlate::set_pos_and_size(), and unprintable_plate.

Referenced by create_plate(), delete_plate(), rebuild_plates_after_deserialize(), reset_size(), and update_plates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_current_slice_result_state()

void Slic3r::GUI::PartPlateList::update_current_slice_result_state ( bool valid )

inline

1100{ m_plate_list[m_current_plate]->update_slice_result_valid_state(valid); }

References m_current_plate, and m_plate_list.

◆ update_logo_texture_filename()

void Slic3r::GUI::PartPlateList::update_logo_texture_filename ( const std::string & texture_filename )

{
    auto check_texture = [](const std::string &texture) {
        boost::system::error_code ec; // so the exists call does not throw (e.g. after a permission problem)
        return !texture.empty() && (boost::algorithm::iends_with(texture, ".png") || boost::algorithm::iends_with(texture, ".svg")) && boost::filesystem::exists(texture, ec);
    };
    if (!texture_filename.empty() && !check_texture(texture_filename)) {
    m_logo_texture_filename = "";
        BOOST_LOG_TRIVIAL(error) << "Unable to load bed texture: " << texture_filename;
    } else {
        m_logo_texture_filename = texture_filename;
        Utils::slash_to_back_slash(m_logo_texture_filename);
    }
}

References m_logo_texture_filename, and Slic3r::Utils::slash_to_back_slash().

Referenced by set_shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_plate_cols()

void Slic3r::GUI::PartPlateList::update_plate_cols ( )

{
  m_plate_count = m_plate_list.size();
 
  m_plate_cols = compute_colum_count(m_plate_count);
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":m_plate_count %1%, m_plate_cols change to %2%") % m_plate_count % m_plate_cols;
  return;
}

References compute_colum_count(), m_plate_cols, m_plate_count, and m_plate_list.

Referenced by create_plate(), delete_plate(), and rebuild_plates_after_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_plates()

void Slic3r::GUI::PartPlateList::update_plates ( )

{
    update_all_plates_pos_and_size(true, false);
    set_shapes(m_shape, m_exclude_areas, m_wrapping_exclude_areas, m_extruder_areas, m_extruder_heights, m_logo_texture_filename, m_height_to_lid, m_height_to_rod);
}

References m_exclude_areas, m_extruder_areas, m_extruder_heights, m_height_to_lid, m_height_to_rod, m_logo_texture_filename, m_shape, m_wrapping_exclude_areas, set_shapes(), and update_all_plates_pos_and_size().

Here is the call graph for this function:

◆ update_slice_context_to_current_plate()

void Slic3r::GUI::PartPlateList::update_slice_context_to_current_plate ( BackgroundSlicingProcess & process )

{
  PartPlate* current_plate;
 
  current_plate = m_plate_list[m_current_plate];
  assert(current_plate != NULL);
 
  current_plate->update_slice_context(process);
 
  return;
}

References m_current_plate, m_plate_list, PartPlate, and Slic3r::GUI::PartPlate::update_slice_context().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cereal::access

friend class cereal::access

friend

References cereal::access.

Referenced by cereal::access.

◆ PartPlate

friend class PartPlate

friend

References PartPlate.

Referenced by add_to_plate(), check_all_plate_local_bed_type(), clear(), construct_objects_list_for_new_plate(), create_plate(), delete_plate(), duplicate_plate(), find_instance(), find_instance(), find_instance_belongs(), find_plate_by_print_index(), get_curr_plate(), get_curr_plate(), get_current_fff_print(), get_current_slice_result(), get_plate(), get_selected_plate(), init(), invalidate_all_imex_ghosts(), invalidate_exclusion_volume_previews(), lock_plate(), move_plate_to_index(), notify_instance_removed(), notify_instance_update(), PartPlate, preprocess_exclude_areas(), preprocess_nonprefered_areas(), refresh_imex_icons(), reload_all_objects(), render_exclusion_volume_intersections(), select_plate_by_obj(), set_default_wipe_tower_pos_for_plate(), set_shapes(), update_all_plates_pos_and_size(), and update_slice_context_to_current_plate().

◆ UndoRedo::StackImpl

friend class UndoRedo::StackImpl

friend

Member Data Documentation

◆ bed_texture_info

BedTextureInfo Slic3r::GUI::PartPlateList::bed_texture_info[btCount]

Referenced by init_bed_type_info(), load_next_bedtype_texture(), and release_icon_textures().

◆ bed_textures

GLTexture Slic3r::GUI::PartPlateList::bed_textures[(unsigned int) btCount]

static

◆ cali_texture_info

BedTextureInfo Slic3r::GUI::PartPlateList::cali_texture_info

Referenced by init_cali_texture_info(), and load_next_cali_texture().

◆ extruder_only_area_info

BedTextureInfo Slic3r::GUI::PartPlateList::extruder_only_area_info[(unsigned char) Slic3r::ExtruderOnlyAreaType::btAreaCount]

Referenced by init_extruder_only_area_info(), load_next_extruder_only_area_texture(), and release_icon_textures().

◆ is_load_bedtype_textures

bool Slic3r::GUI::PartPlateList::is_load_bedtype_textures = false

static

Referenced by load_next_bedtype_texture(), release_icon_textures(), and set_shapes().

◆ is_load_cali_texture

bool Slic3r::GUI::PartPlateList::is_load_cali_texture = false

static

Referenced by load_next_cali_texture(), and release_icon_textures().

◆ is_load_extruder_only_area_textures

bool Slic3r::GUI::PartPlateList::is_load_extruder_only_area_textures = false

static

Referenced by load_next_extruder_only_area_texture(), release_icon_textures(), and set_shapes().

◆ m_allow_bed_type_in_double_nozzle

std::map<int, bool> Slic3r::GUI::PartPlateList::m_allow_bed_type_in_double_nozzle

Referenced by init_bed_type_info().

◆ m_arrange_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_arrange_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_arrange_texture

GLTexture Slic3r::GUI::PartPlateList::m_arrange_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_bounding_box

BoundingBoxf3 Slic3r::GUI::PartPlateList::m_bounding_box

private

Referenced by calc_bounding_boxes(), and get_bounding_box().

◆ m_current_plate

int Slic3r::GUI::PartPlateList::m_current_plate

private

◆ m_del_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_del_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_del_texture

GLTexture Slic3r::GUI::PartPlateList::m_del_texture

private

Referenced by generate_icon_textures(), icon_textures_loaded(), and release_icon_textures().

◆ m_exclude_areas

Pointfs Slic3r::GUI::PartPlateList::m_exclude_areas

private

Referenced by create_plate(), delete_plate(), get_exclude_area(), preprocess_exclude_areas(), rebuild_plates_after_deserialize(), reinit(), reset_size(), set_shapes(), and update_plates().

◆ m_extruder_areas

std::vector<Pointfs> Slic3r::GUI::PartPlateList::m_extruder_areas

private

Referenced by calc_extruder_only_area(), create_plate(), delete_plate(), rebuild_plates_after_deserialize(), reinit(), reset_size(), set_shapes(), and update_plates().

◆ m_extruder_heights

std::vector<double> Slic3r::GUI::PartPlateList::m_extruder_heights

private

Referenced by create_plate(), delete_plate(), rebuild_plates_after_deserialize(), reinit(), reset_size(), set_shapes(), and update_plates().

◆ m_filament_count

int Slic3r::GUI::PartPlateList::m_filament_count = 1

private

Referenced by create_plate(), on_filament_added(), on_filament_deleted(), reinit(), reset(), and set_filament_count().

◆ m_gcode_result_list

std::map<int, GCodeResult*> Slic3r::GUI::PartPlateList::m_gcode_result_list

private

Referenced by clear(), create_plate(), destroy_print(), init(), and rebuild_plates_after_deserialize().

◆ m_height_limit_mode

PartPlate::HeightLimitMode Slic3r::GUI::PartPlateList::m_height_limit_mode {PartPlate::HEIGHT_LIMIT_BOTH}

private

789{PartPlate::HEIGHT_LIMIT_BOTH};

Slic3r::GUI::PartPlate::HEIGHT_LIMIT_BOTH

@ HEIGHT_LIMIT_BOTH

Definition PartPlate.hpp:114

Referenced by render(), serialize(), and set_height_limits_mode().

◆ m_height_to_lid

float Slic3r::GUI::PartPlateList::m_height_to_lid

private

Referenced by create_plate(), delete_plate(), get_height_limits(), rebuild_plates_after_deserialize(), reinit(), reset_size(), serialize(), set_shapes(), and update_plates().

◆ m_height_to_rod

float Slic3r::GUI::PartPlateList::m_height_to_rod

private

Referenced by create_plate(), delete_plate(), get_height_limits(), rebuild_plates_after_deserialize(), reinit(), reset_size(), serialize(), set_shapes(), and update_plates().

◆ m_hover_tooltip

std::string Slic3r::GUI::PartPlateList::m_hover_tooltip

private

Referenced by clear_hover_tooltip(), and render_hover_tooltip().

◆ m_icon_textures_dark

bool Slic3r::GUI::PartPlateList::m_icon_textures_dark = false

private

Referenced by generate_icon_textures(), and icon_textures_loaded().

◆ m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by ObjectBase(), ObjectBase(), ObjectBase(), copy_id(), id(), serialize(), set_invalid_id(), and set_new_unique_id().

◆ m_idx_textures

GLTexture Slic3r::GUI::PartPlateList::m_idx_textures[MAX_PLATE_COUNT]

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_imex_mode_hovered_textures

std::array<GLTexture, 4> Slic3r::GUI::PartPlateList::m_imex_mode_hovered_textures

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_imex_mode_textures

std::array<GLTexture, 4> Slic3r::GUI::PartPlateList::m_imex_mode_textures

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_imex_warn_texture

GLTexture Slic3r::GUI::PartPlateList::m_imex_warn_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_intialized

bool Slic3r::GUI::PartPlateList::m_intialized

private

Referenced by create_plate(), delete_plate(), init(), and select_plate().

◆ m_is_dark

bool Slic3r::GUI::PartPlateList::m_is_dark = false

private

Referenced by generate_icon_textures(), icon_textures_loaded(), and on_change_color_mode().

◆ m_locked_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_locked_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_locked_texture

GLTexture Slic3r::GUI::PartPlateList::m_locked_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_lockopen_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_lockopen_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_lockopen_texture

GLTexture Slic3r::GUI::PartPlateList::m_lockopen_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_logo_texture

GLTexture Slic3r::GUI::PartPlateList::m_logo_texture

private

Referenced by load_logo_texture(), and release_icon_textures().

◆ m_logo_texture_filename

std::string Slic3r::GUI::PartPlateList::m_logo_texture_filename

private

Referenced by create_plate(), delete_plate(), get_logo_texture_filename(), load_logo_texture(), rebuild_plates_after_deserialize(), reset_size(), update_logo_texture_filename(), and update_plates().

◆ m_model

Model* Slic3r::GUI::PartPlateList::m_model

private

Referenced by PartPlateList(), PartPlateList(), construct_objects_list_for_new_plate(), create_plate(), duplicate_plate(), init(), load_gcode_files(), notify_instance_removed(), notify_instance_update(), rebuild_plates_after_arrangement(), rebuild_plates_after_deserialize(), reload_all_objects(), and select_plate().

◆ m_move_front_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_move_front_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_move_front_texture

GLTexture Slic3r::GUI::PartPlateList::m_move_front_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_next_bedtype_texture

size_t Slic3r::GUI::PartPlateList::m_next_bedtype_texture { 0 }

private

1177{ 0 };

Referenced by load_next_bedtype_texture(), release_icon_textures(), and set_shapes().

◆ m_next_cali_texture

size_t Slic3r::GUI::PartPlateList::m_next_cali_texture { 0 }

private

1178{ 0 };

Referenced by load_next_cali_texture(), and release_icon_textures().

◆ m_next_extruder_only_area_texture

size_t Slic3r::GUI::PartPlateList::m_next_extruder_only_area_texture { 0 }

private

1179{ 0 };

Referenced by load_next_extruder_only_area_texture(), release_icon_textures(), and set_shapes().

◆ m_orient_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_orient_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_orient_texture

GLTexture Slic3r::GUI::PartPlateList::m_orient_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_cols

int Slic3r::GUI::PartPlateList::m_plate_cols

private

Referenced by compute_origin_for_unprintable(), compute_origin_using_new_size(), compute_plate_index(), delete_plate(), get_current_plate_origin(), get_current_shape_position(), get_plate_cols(), init(), move_plate_to_index(), postprocess_arrange_polygon(), preprocess_arrange_polygon(), preprocess_arrange_polygon_other_locked(), print(), rebuild_plates_after_deserialize(), reinit(), select_plate(), set_shapes(), update_all_plates_pos_and_size(), and update_plate_cols().

◆ m_plate_count

int Slic3r::GUI::PartPlateList::m_plate_count

private

Referenced by compute_origin_for_unprintable(), init(), notify_instance_update(), print(), serialize(), and update_plate_cols().

◆ m_plate_depth

int Slic3r::GUI::PartPlateList::m_plate_depth

private

Referenced by PartPlateList(), PartPlateList(), create_plate(), delete_plate(), get_plate_size(), init(), move_plate_to_index(), plate_stride_y(), print(), reinit(), reset_size(), serialize(), and update_all_plates_pos_and_size().

◆ m_plate_height

double Slic3r::GUI::PartPlateList::m_plate_height

private

Referenced by PartPlateList(), PartPlateList(), create_plate(), delete_plate(), get_plate_size(), init(), load_gcode_files(), move_plate_to_index(), print(), reinit(), reset_size(), serialize(), and update_all_plates_pos_and_size().

◆ m_plate_list

std::vector<PartPlate*> Slic3r::GUI::PartPlateList::m_plate_list

private

Referenced by add_to_plate(), calc_bounding_boxes(), check_all_plate_local_bed_type(), clear(), construct_objects_list_for_new_plate(), contains(), create_plate(), delete_plate(), find_instance(), find_instance(), find_instance_belongs(), find_plate_by_print_index(), get_curr_plate(), get_curr_plate(), get_current_fff_print(), get_current_slice_result(), get_extruders(), get_nonempty_plate_list(), get_plate(), get_plate_count(), get_plate_list(), get_selected_plate(), get_sliced_result(), init(), intersects(), invalid_all_slice_result(), invalidate_all_imex_ghosts(), invalidate_exclusion_volume_previews(), is_all_plates_ready_for_slice(), is_all_slice_result_ready_for_export(), is_all_slice_results_ready_for_print(), is_all_slice_results_valid(), is_locked(), load_from_3mf_structure(), load_gcode_files(), lock_plate(), move_plate_to_index(), notify_instance_removed(), notify_instance_update(), on_extruder_count_changed(), on_filament_added(), on_filament_deleted(), postprocess_bed_index_for_current_plate(), postprocess_bed_index_for_selected(), postprocess_bed_index_for_unselected(), preprocess_arrange_polygon(), preprocess_arrange_polygon_other_locked(), preprocess_exclude_areas(), preprocess_nonprefered_areas(), print(), rebuild_plates_after_arrangement(), rebuild_plates_after_deserialize(), refresh_imex_icons(), register_raycasters_for_picking(), reinit(), reload_all_objects(), render(), render_exclusion_volume_intersections(), reset(), reset_hover_id(), select_plate(), select_plate_view(), serialize(), set_default_wipe_tower_pos_for_plate(), set_filament_count(), set_hover_id(), set_shapes(), store_to_3mf_structure(), update_all_plates_pos_and_size(), update_current_slice_result_state(), update_plate_cols(), and update_slice_context_to_current_plate().

◆ m_plate_name_edit_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_name_edit_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_name_edit_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_name_edit_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_set_filament_map_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_set_filament_map_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_set_filament_map_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_set_filament_map_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_settings_changed_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_settings_changed_hovered_texture

private

Referenced by generate_icon_textures().

◆ m_plate_settings_changed_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_settings_changed_texture

private

Referenced by generate_icon_textures().

◆ m_plate_settings_hovered_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_settings_hovered_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_settings_texture

GLTexture Slic3r::GUI::PartPlateList::m_plate_settings_texture

private

Referenced by generate_icon_textures(), and release_icon_textures().

◆ m_plate_width

int Slic3r::GUI::PartPlateList::m_plate_width

private

Referenced by PartPlateList(), PartPlateList(), create_plate(), delete_plate(), get_plate_size(), init(), move_plate_to_index(), plate_stride_x(), print(), reinit(), reset_size(), serialize(), and update_all_plates_pos_and_size().

◆ m_plater

Plater* Slic3r::GUI::PartPlateList::m_plater

private

Referenced by PartPlateList(), PartPlateList(), create_plate(), delete_plate(), init(), load_from_3mf_structure(), load_gcode_files(), notify_instance_removed(), rebuild_plates_after_arrangement(), rebuild_plates_after_deserialize(), reinit(), render_hover_tooltip(), select_plate(), select_plate_view(), and update_all_plates_pos_and_size().

◆ m_plates_mutex

std::mutex Slic3r::GUI::PartPlateList::m_plates_mutex

private

Referenced by refresh_imex_icons(), render(), reset_hover_id(), select_plate(), and set_shapes().

◆ m_print_index

int Slic3r::GUI::PartPlateList::m_print_index

private

Referenced by create_plate(), init(), print(), and rebuild_plates_after_deserialize().

◆ m_print_list

std::map<int, PrintBase*> Slic3r::GUI::PartPlateList::m_print_list

private

Referenced by clear(), create_plate(), destroy_print(), init(), print(), and rebuild_plates_after_deserialize().

◆ m_shape

Pointfs Slic3r::GUI::PartPlateList::m_shape

private

Referenced by calc_extruder_only_area(), create_plate(), delete_plate(), init_bed_type_info(), rebuild_plates_after_deserialize(), reinit(), reset_size(), set_shapes(), and update_plates().

◆ m_wrapping_exclude_areas

Pointfs Slic3r::GUI::PartPlateList::m_wrapping_exclude_areas

private

Referenced by create_plate(), delete_plate(), get_wrapping_exclude_area(), preprocess_exclude_areas(), rebuild_plates_after_deserialize(), reset_size(), set_shapes(), and update_plates().

◆ MAX_PLATES_COUNT

unsigned int Slic3r::GUI::PartPlateList::MAX_PLATES_COUNT = MAX_PLATE_COUNT

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::Plater::priv::can_add_plate(), create_plate(), postprocess_arrange_polygon(), postprocess_bed_index_for_unselected(), Slic3r::GUI::FillBedJob::prepare(), preprocess_arrange_polygon(), and preprocess_arrange_polygon_other_locked().

◆ printer_technology

PrinterTechnology Slic3r::GUI::PartPlateList::printer_technology

private

Referenced by PartPlateList(), PartPlateList(), create_plate(), init(), and rebuild_plates_after_deserialize().

◆ render_bedtype_logo

bool Slic3r::GUI::PartPlateList::render_bedtype_logo = true

private

Referenced by load_next_plate_texture(), and set_render_option().

◆ render_cali_logo

bool Slic3r::GUI::PartPlateList::render_cali_logo = true

private

Referenced by set_render_cali().

◆ render_plate_settings

bool Slic3r::GUI::PartPlateList::render_plate_settings = true

private

Referenced by set_render_option().

◆ s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

◆ unprintable_plate

PartPlate Slic3r::GUI::PartPlateList::unprintable_plate

private

Referenced by PartPlateList(), PartPlateList(), clear(), construct_objects_list_for_new_plate(), create_plate(), delete_plate(), init(), notify_instance_removed(), notify_instance_update(), print(), reinit(), reload_all_objects(), serialize(), and update_all_plates_pos_and_size().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PartPlate.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PartPlate.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Class Documentation

◆ Slic3r::GUI::PartPlateList::Rect

Member Typedef Documentation

◆ Timestamp

Constructor & Destructor Documentation

◆ PartPlateList() [1/2]

◆ PartPlateList() [2/2]

◆ ~PartPlateList()

Member Function Documentation

◆ add_to_plate()

◆ assign_new_unique_ids_recursive()

◆ calc_bounding_boxes()

◆ calc_extruder_only_area()

◆ check_all_plate_local_bed_type()

◆ clear()

◆ clear_hover_tooltip()

◆ compute_origin()

◆ compute_origin_for_unprintable()

◆ compute_origin_using_new_size()

◆ compute_plate_index()

◆ compute_shape_position()

◆ construct_objects_list_for_new_plate()

◆ contains()

◆ copy_id()

◆ create_plate()

◆ create_plate_from_gcode_file()

◆ delete_plate()

◆ delete_selected_plate()

◆ destroy_print()

◆ duplicate_plate()

◆ find_instance() [1/2]

◆ find_instance() [2/2]

◆ find_instance_belongs()

◆ find_plate_by_print_index()

◆ generate_icon_textures()

◆ generate_new_id()

◆ get_bounding_box()

◆ get_curr_plate() [1/2]

◆ get_curr_plate() [2/2]

◆ get_curr_plate_index()

◆ get_current_fff_print()

◆ get_current_plate_origin()

◆ get_current_shape_position()

◆ get_current_slice_result()

◆ get_exclude_area()

◆ get_extruders()

◆ get_height_limits()

◆ get_logo_texture_filename()

◆ get_nonempty_plate_list()

◆ get_nonempty_plates_slice_results()

◆ get_plate()

◆ get_plate_cols()

◆ get_plate_count()

◆ get_plate_list()

◆ get_plate_size()

◆ get_selected_plate()

◆ get_sliced_result()

◆ get_wrapping_exclude_area()

◆ icon_textures_loaded()

◆ id()

◆ init()

◆ init_bed_type_info()

◆ init_cali_texture_info()

◆ init_extruder_only_area_info()

◆ intersects()

◆ invalid_all_slice_result()

◆ invalidate_all_imex_ghosts()

◆ invalidate_exclusion_volume_previews()