Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT > Class Template Reference

#include <src/libslic3r/PrintBase.hpp>

Inheritance diagram for Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >:

Collaboration diagram for Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >:

Public Types
using	PrintStepEnum = PrintStepEnumType
enum	ApplyStatus { APPLY_STATUS_UNCHANGED , APPLY_STATUS_CHANGED , APPLY_STATUS_INVALIDATED }
enum	CancelStatus { NOT_CANCELED = 0 , CANCELED_BY_USER = 1 , CANCELED_INTERNAL = 2 }
typedef std::function< void(const SlicingStatus &)>	status_callback_type
typedef std::function< void()>	cancel_callback_type
using	Timestamp = uint64_t

Public Member Functions
	PrintBaseWithState ()=default
bool	is_step_done (PrintStepEnum step) const
PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (PrintStepEnum step) const
PrintStateBase::StateWithWarnings	step_state_with_warnings (PrintStepEnum step) const
virtual PrinterTechnology	technology () const noexcept=0
virtual void	clear ()=0
virtual bool	empty () const =0
virtual std::vector< ObjectID >	print_object_ids () const =0
virtual std::string	validate (std::vector< std::string > *warnings=nullptr) const
virtual ApplyStatus	apply (const Model &model, DynamicPrintConfig config)=0
const Model &	model () const
virtual void	set_task (const TaskParams &params)=0
virtual void	process ()=0
virtual void	finalize ()=0
virtual void	cleanup ()=0
void	set_status_default ()
void	set_status_silent ()
void	set_status_callback (status_callback_type cb)
void	set_status (int percent, const std::string &message, unsigned int flags=SlicingStatus::DEFAULT)
void	set_cancel_callback (cancel_callback_type cancel_callback)
CancelStatus	cancel_status () const
bool	canceled () const
void	cancel ()
void	cancel_internal ()
void	restart ()
virtual bool	finished () const =0
const PlaceholderParser &	placeholder_parser () const
const DynamicPrintConfig &	full_print_config () const
virtual std::string	output_filename (const std::string &filename_base=std::string()) const =0
std::string	output_filepath (const std::string &path, const std::string &filename_base=std::string()) const
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Attributes
static constexpr const size_t	PrintStepEnumSize = COUNT

Protected Member Functions
bool	set_started (PrintStepEnum step)
PrintStateBase::TimeStamp	set_done (PrintStepEnum step)
bool	invalidate_step (PrintStepEnum step)
template<typename StepTypeIterator >
bool	invalidate_steps (StepTypeIterator step_begin, StepTypeIterator step_end)
bool	invalidate_steps (std::initializer_list< PrintStepEnum > il)
bool	invalidate_all_steps ()
bool	is_step_started_unguarded (PrintStepEnum step) const
bool	is_step_done_unguarded (PrintStepEnum step) const
void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id=0)
template<typename PrintObject >
void	set_task_impl (const TaskParams &params, std::vector< PrintObject * > &print_objects)
template<typename PrintObject >
void	finalize_impl (std::vector< PrintObject * > &print_objects)
std::string	output_filename (const std::string &format, const std::string &default_ext, const std::string &filename_base, const DynamicConfig *config_override=nullptr) const
std::mutex &	state_mutex () const
std::function< void()>	cancel_callback ()
void	call_cancel_callback ()
void	status_update_warnings (int step, PrintStateBase::WarningLevel warning_level, const std::string &message, const PrintObjectBase *print_object=nullptr)
void	throw_if_canceled () const
PrintTryCancel	make_try_cancel () const
void	update_object_placeholders (DynamicConfig &config, const std::string &default_ext) const
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Protected Attributes
Model	m_model
DynamicPrintConfig	m_full_print_config
PlaceholderParser	m_placeholder_parser
status_callback_type	m_status_callback

Private Member Functions
template<class Archive >
void	serialize (Archive &ar)

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
PrintState< PrintStepEnum, COUNT >	m_state
std::atomic< CancelStatus >	m_cancel_status
cancel_callback_type	m_cancel_callback = [](){}
std::mutex	m_state_mutex
friend	PrintTryCancel
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Detailed Description

template<typename PrintStepEnumType, const size_t COUNT>
class Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >

Member Typedef Documentation

cancel_callback_type

typedef std::function<void()> Slic3r::PrintBase::cancel_callback_type

inherited

PrintStepEnum

template<typename PrintStepEnumType , const size_t COUNT>

using Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::PrintStepEnum = PrintStepEnumType

status_callback_type

typedef std::function<void(const SlicingStatus&)> Slic3r::PrintBase::status_callback_type

inherited

Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Member Enumeration Documentation

ApplyStatus

enum Slic3r::PrintBase::ApplyStatus

inherited

Enumerator
APPLY_STATUS_UNCHANGED
APPLY_STATUS_CHANGED
APPLY_STATUS_INVALIDATED

                     {
        // No change after the Print::apply() call.
        APPLY_STATUS_UNCHANGED,
        // Some of the Print / PrintObject / PrintObjectInstance data was changed,
        // but no result was invalidated (only data influencing not yet calculated results were changed).
        APPLY_STATUS_CHANGED,
        // Some data was changed, which in turn invalidated already calculated steps.
        APPLY_STATUS_INVALIDATED,
    };

CancelStatus

enum Slic3r::PrintBase::CancelStatus

inherited

Enumerator
NOT_CANCELED
CANCELED_BY_USER
CANCELED_INTERNAL

                    {
    // No cancelation, background processing should run.
    NOT_CANCELED = 0,
    // Canceled by user from the user interface (user pressed the "Cancel" button or user closed the application).
    CANCELED_BY_USER = 1,
    // Canceled internally from Print::apply() through the Print/PrintObject::invalidate_step() or ::invalidate_all_steps().
    CANCELED_INTERNAL = 2
  };

Constructor & Destructor Documentation

PrintBaseWithState()

template<typename PrintStepEnumType , const size_t COUNT>

Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::PrintBaseWithState ( )

default

Member Function Documentation

active_step_add_warning()

template<typename PrintStepEnumType , const size_t COUNT>

void Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning ( PrintStateBase::WarningLevel  warning_level, const std::string &  message, int  message_id = 0  )

inlineprotected

                                                                                                                                    {
      std::pair<PrintStepEnum, bool> active_step = m_state.active_step_add_warning(warning_level, message, message_id, this->state_mutex());
      if (active_step.second)
        // Update UI.
            this->status_update_warnings(static_cast<int>(active_step.first), warning_level, message);
    }

References Slic3r::PrintState< StepType, COUNT >::active_step_add_warning(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintBase::state_mutex(), and Slic3r::PrintBase::status_update_warnings().

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::do_export(), and Slic3r::GCodeProcessor::post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

apply()

virtual ApplyStatus Slic3r::PrintBase::apply ( const Model &  model, DynamicPrintConfig  config  )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::apply(), and Slic3r::CLI::run().

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.

{ this->set_new_unique_id(); }

References Slic3r::ObjectBase::set_new_unique_id().

Here is the call graph for this function:

call_cancel_callback()

void Slic3r::PrintBase::call_cancel_callback ( )

inlineprotectedinherited

{ m_cancel_callback(); }

References Slic3r::PrintBase::m_cancel_callback.

Referenced by Slic3r::SLAPrint::apply(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the caller graph for this function:

cancel()

void Slic3r::PrintBase::cancel ( )

inlineinherited

{ m_cancel_status = CANCELED_BY_USER; }

References Slic3r::PrintBase::CANCELED_BY_USER, and Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::stop().

Here is the caller graph for this function:

cancel_callback()

std::function< void()> Slic3r::PrintBase::cancel_callback ( )

inlineprotectedinherited

{ return m_cancel_callback; }

References Slic3r::PrintBase::m_cancel_callback.

Referenced by Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), and Slic3r::PrintBase::set_cancel_callback().

Here is the caller graph for this function:

cancel_internal()

void Slic3r::PrintBase::cancel_internal ( )

inlineinherited

{ m_cancel_status = CANCELED_INTERNAL; }

References Slic3r::PrintBase::CANCELED_INTERNAL, and Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::stop_internal().

Here is the caller graph for this function:

cancel_status()

CancelStatus Slic3r::PrintBase::cancel_status ( ) const

inlineinherited

{ return m_cancel_status.load(std::memory_order_acquire); }

References Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

canceled()

bool Slic3r::PrintBase::canceled ( ) const

inlineinherited

{ return m_cancel_status.load(std::memory_order_acquire) != NOT_CANCELED; }

References Slic3r::PrintBase::m_cancel_status, and Slic3r::PrintBase::NOT_CANCELED.

Referenced by Slic3r::SLAPrint::Steps::canceled(), Slic3r::BackgroundSlicingProcess::execute_ui_task(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrint::Steps::rasterize(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::SLAPrint::Steps::support_tree(), Slic3r::BackgroundSlicingProcess::thread_proc(), and Slic3r::BackgroundSlicingProcess::throw_if_canceled().

Here is the caller graph for this function:

cleanup()

virtual void Slic3r::PrintBase::cleanup ( )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

clear()

virtual void Slic3r::PrintBase::clear ( )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::reset().

Here is the caller graph for this function:

copy_id()

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

inlineprotectedinherited

{ m_id = rhs.id(); }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

virtual bool Slic3r::PrintBase::empty ( ) const

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::empty(), Slic3r::CLI::run(), and Slic3r::BackgroundSlicingProcess::start().

Here is the caller graph for this function:

finalize()

virtual void Slic3r::PrintBase::finalize ( )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

finalize_impl()

template<typename PrintStepEnumType , const size_t COUNT>

template<typename PrintObject >

void Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl ( std::vector< PrintObject * > &  print_objects )

inlineprotected

    {
        // Grab the lock for the Print / PrintObject milestones.
        std::scoped_lock<std::mutex> lock(this->state_mutex());
        for (auto *po : print_objects)
            po->finalize_impl();
        m_state.enable_all_unguarded(true);
        m_state.mark_canceled_unguarded();
    }

References Slic3r::PrintState< StepType, COUNT >::enable_all_unguarded(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::mark_canceled_unguarded(), and Slic3r::PrintBase::state_mutex().

Referenced by Slic3r::Print::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

finished()

virtual bool Slic3r::PrintBase::finished ( ) const

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::finished().

Here is the caller graph for this function:

full_print_config()

const DynamicPrintConfig & Slic3r::PrintBase::full_print_config ( ) const

inlineinherited

{ return m_full_print_config; }

References Slic3r::PrintBase::m_full_print_config.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::anonymous_namespace{SL1.cpp}::fill_slicerconf(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::BackgroundSlicingProcess::process_sla(), and Slic3r::CLI::run().

Here is the caller graph for this function:

generate_new_id()

static ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References Slic3r::ObjectBase::s_last_id.

Referenced by Slic3r::ObjectBase::set_new_unique_id().

Here is the caller graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References Slic3r::ObjectBase::m_id.

Referenced by Slic3r::Model::Model(), Slic3r::ModelInstance::ModelInstance(), Slic3r::ModelMaterial::ModelMaterial(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::Plater::priv::actualize_slicing_warnings(), Slic3r::ModelObjectStatusDB::add(), Slic3r::ModelObjectStatusDB::add_if_new(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GUI::GLGizmoFdmSupports::apply_data_from_backend(), Slic3r::ModelVolume::check(), Slic3r::check_model_ids_equal(), Slic3r::ModelObject::convert_units(), Slic3r::ObjectBase::copy_id(), Slic3r::PrintObjectStatusDB::count(), anonymous_namespace{RaycastManager.cpp}::create_key(), priv::create_volume(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoHollow::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoSlaSupports::data_changed(), Slic3r::Model::delete_object(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::ModelObjectStatusDB::get(), Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::GLGizmoSlaSupports::get_data_from_backend(), Slic3r::PrintObjectStatusDB::get_range(), Slic3r::GUI::GLGizmoFdmSupports::has_backend_supports(), Slic3r::GUI::GLGizmoSlaSupports::has_backend_supports(), Slic3r::CutObjectBase::has_same_id(), Slic3r::UndoRedo::StackImpl::immutable_object_id_impl(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::inner_brim_area(), Slic3r::ModelObject::is_cut(), Slic3r::CutObjectBase::is_equal(), Slic3r::ObjectBase::load_and_construct(), Slic3r::UndoRedo::StackImpl::load_snapshot(), Slic3r::GUI::ObjectList::merge(), Slic3r::model_property_changed(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::ModelConfigObject::object_id_and_timestamp_match(), Slic3r::ObjectWithTimestamp::object_id_and_timestamp_match(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::CutObjectBase::operator<(), Slic3r::Model::operator=(), Slic3r::ModelObject::operator=(), Slic3r::ModelObject::operator=(), Slic3r::CutObjectBase::operator==(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), Slic3r::GUI::processed_objects_idxs(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::ModelMaterial::serialize(), Slic3r::SLAPrintObject::SliceRecord::set_model_slice_idx(), Slic3r::SLAPrintObject::SliceRecord::set_support_slice_idx(), Slic3r::slices_to_regions(), Slic3r::ModelObject::split(), Slic3r::UndoRedo::StackImpl::take_snapshot(), Slic3r::top_level_outer_brim_area(), Slic3r::GUI::update_object_cut_id(), and anonymous_namespace{EmbossJob.cpp}::update_volume_name().

invalidate_all_steps()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_all_steps ( )

inlineprotected

        { return m_state.invalidate_all(this->cancel_callback()); }

References Slic3r::PrintBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate_all(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

invalidate_step()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_step ( PrintStepEnum  step )

inlineprotected

    { return m_state.invalidate(step, this->cancel_callback()); }

References Slic3r::PrintBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

invalidate_steps() [1/2]

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps ( std::initializer_list< PrintStepEnum >  il )

inlineprotected

        { return m_state.invalidate_multiple(il.begin(), il.end(), this->cancel_callback()); }

References Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

invalidate_steps() [2/2]

template<typename PrintStepEnumType , const size_t COUNT>

template<typename StepTypeIterator >

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps ( StepTypeIterator  step_begin, StepTypeIterator  step_end  )

inlineprotected

        { return m_state.invalidate_multiple(step_begin, step_end, this->cancel_callback()); }

References Slic3r::PrintBase::cancel_callback(), Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Referenced by Slic3r::PrintObject::set_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

is_step_done()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done ( PrintStepEnum  step ) const

inline

{ return m_state.is_done(step, this->state_mutex()); }

References Slic3r::PrintState< StepType, COUNT >::is_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

is_step_done_unguarded()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done_unguarded ( PrintStepEnum  step ) const

inlineprotected

{ return m_state.is_done_unguarded(step); }

References Slic3r::PrintState< StepType, COUNT >::is_done_unguarded(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

is_step_started_unguarded()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_started_unguarded ( PrintStepEnum  step ) const

inlineprotected

{ return m_state.is_started_unguarded(step); }

References Slic3r::PrintState< StepType, COUNT >::is_started_unguarded(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state.

Here is the call graph for this function:

load_and_construct()

template<class Archive >

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

inlinestaticprivateinherited

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

References Slic3r::ObjectBase::id().

Here is the call graph for this function:

make_try_cancel()

PrintTryCancel Slic3r::PrintBase::make_try_cancel ( ) const

inlineprotectedinherited

{ return PrintTryCancel(this); }

References Slic3r::PrintBase::PrintTryCancel.

Referenced by Slic3r::Print::process().

Here is the caller graph for this function:

model()

const Model & Slic3r::PrintBase::model ( ) const

inlineinherited

{ return m_model; }

References Slic3r::PrintBase::m_model.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GUI::Plater::priv::actualize_object_warnings(), Slic3r::SLAPrint::apply(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::sort_object_instances_by_model_order(), and Slic3r::DoExport::validate_custom_gcode().

Here is the caller graph for this function:

output_filename() [1/2]

virtual std::string Slic3r::PrintBase::output_filename ( const std::string &  filename_base = std::string() ) const

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::Print::output_filename(), Slic3r::SLAPrint::output_filename(), and Slic3r::PrintBase::output_filepath().

Here is the caller graph for this function:

output_filename() [2/2]

std::string Slic3r::PrintBase::output_filename ( const std::string &  format, const std::string &  default_ext, const std::string &  filename_base, const DynamicConfig *  config_override = nullptr  ) const

protectedinherited

{
    DynamicConfig cfg;
    if (config_override != nullptr)
      cfg = *config_override;
    cfg.set_key_value("version", new ConfigOptionString(std::string(SLIC3R_VERSION)));
    PlaceholderParser::update_timestamp(cfg);
    this->update_object_placeholders(cfg, default_ext);
    if (! filename_base.empty()) {
    cfg.set_key_value("input_filename", new ConfigOptionString(filename_base + default_ext));
    cfg.set_key_value("input_filename_base", new ConfigOptionString(filename_base));
    }
    try {
    boost::filesystem::path filename = format.empty() ?
      cfg.opt_string("input_filename_base") + default_ext :
      this->placeholder_parser().process(format, 0, &cfg);
        if (filename.extension().empty())
            filename = boost::filesystem::change_extension(filename, default_ext);
        return filename.string();
    } catch (std::runtime_error &err) {
        throw Slic3r::PlaceholderParserError(_u8L("Failed processing of the output_filename_format template.") + "\n" + err.what());
    }
}

References _u8L, Slic3r::format(), Slic3r::ConfigBase::opt_string(), Slic3r::PrintBase::placeholder_parser(), Slic3r::PlaceholderParser::process(), Slic3r::DynamicConfig::set_key_value(), Slic3r::PrintBase::update_object_placeholders(), and Slic3r::PlaceholderParser::update_timestamp().

Here is the call graph for this function:

output_filepath()

std::string Slic3r::PrintBase::output_filepath ( const std::string &  path, const std::string &  filename_base = std::string()  ) const

inherited

{
    // if we were supplied no path, generate an automatic one based on our first object's input file
    if (path.empty())
        // get the first input file name
        return (boost::filesystem::path(m_model.propose_export_file_name_and_path()).parent_path() / this->output_filename(filename_base)).make_preferred().string();
    
    // if we were supplied a directory, use it and append our automatically generated filename
    boost::filesystem::path p(path);
    if (boost::filesystem::is_directory(p))
        return (p / this->output_filename(filename_base)).make_preferred().string();
    
    // if we were supplied a file which is not a directory, use it
    return path;
}

References Slic3r::PrintBase::m_model, Slic3r::PrintBase::output_filename(), and Slic3r::Model::propose_export_file_name_and_path().

Referenced by Slic3r::Print::export_gcode(), Slic3r::BackgroundSlicingProcess::output_filepath_for_project(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

placeholder_parser()

const PlaceholderParser & Slic3r::PrintBase::placeholder_parser ( ) const

inlineinherited

{ return m_placeholder_parser; }

References Slic3r::PrintBase::m_placeholder_parser.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::PrintBase::output_filename().

Here is the caller graph for this function:

print_object_ids()

virtual std::vector< ObjectID > Slic3r::PrintBase::print_object_ids ( ) const

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

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

Here is the caller graph for this function:

process()

virtual void Slic3r::PrintBase::process ( )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::process_fff(), Slic3r::BackgroundSlicingProcess::process_sla(), and Slic3r::CLI::run().

Here is the caller graph for this function:

restart()

void Slic3r::PrintBase::restart ( )

inlineinherited

{ m_cancel_status = NOT_CANCELED; }

References Slic3r::PrintBase::m_cancel_status, and Slic3r::PrintBase::NOT_CANCELED.

Referenced by Slic3r::PrintBase::PrintBase(), and Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

serialize()

template<class Archive >

void Slic3r::ObjectBase::serialize ( Archive &  ar )

inlineprivateinherited

{ ar(m_id); }

References Slic3r::ObjectBase::m_id.

set_cancel_callback()

void Slic3r::PrintBase::set_cancel_callback ( cancel_callback_type  cancel_callback )

inlineinherited

{ m_cancel_callback = cancel_callback; }

References Slic3r::PrintBase::cancel_callback(), and Slic3r::PrintBase::m_cancel_callback.

Referenced by Slic3r::BackgroundSlicingProcess::start(), Slic3r::BackgroundSlicingProcess::stop(), and Slic3r::BackgroundSlicingProcess::stop_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

set_done()

template<typename PrintStepEnumType , const size_t COUNT>

PrintStateBase::TimeStamp Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done ( PrintStepEnum  step )

inlineprotected

                                                       { 
    std::pair<PrintStateBase::TimeStamp, bool> status = m_state.set_done(step, this->state_mutex(), [this](){ this->throw_if_canceled(); });
        if (status.second)
            this->status_update_warnings(static_cast<int>(step), PrintStateBase::WarningLevel::NON_CRITICAL, std::string());
        return status.first;
  }

References Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::PrintState< StepType, COUNT >::set_done(), Slic3r::PrintBase::state_mutex(), Slic3r::PrintBase::status_update_warnings(), and Slic3r::PrintBase::throw_if_canceled().

Referenced by Slic3r::GCode::do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References Slic3r::ObjectBase::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

{ m_id = generate_new_id(); }

References Slic3r::ObjectBase::generate_new_id(), and Slic3r::ObjectBase::m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ObjectBase::assign_new_unique_ids_recursive(), Slic3r::ModelObject::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_started()

template<typename PrintStepEnumType , const size_t COUNT>

bool Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started ( PrintStepEnum  step )

inlineprotected

{ return m_state.set_started(step, this->state_mutex(), [this](){ this->throw_if_canceled(); }); }

References Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::set_started(), Slic3r::PrintBase::state_mutex(), and Slic3r::PrintBase::throw_if_canceled().

Referenced by Slic3r::GCode::do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

set_status()

void Slic3r::PrintBase::set_status ( int  percent, const std::string &  message, unsigned int  flags = SlicingStatus::DEFAULT  )

inlineinherited

                                                                                                                         {
    if (m_status_callback) m_status_callback(SlicingStatus(percent, message, flags));
        else printf("%d => %s\n", percent, message.c_str());
    }

References Slic3r::PrintBase::m_status_callback.

Referenced by Slic3r::Print::alert_when_supports_needed(), Slic3r::Print::export_gcode(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::PrintObject::make_perimeters(), Slic3r::SLAPrint::StatusReporter::operator()(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::Print::process(), Slic3r::BackgroundSlicingProcess::process_fff(), and Slic3r::BackgroundSlicingProcess::process_sla().

Here is the caller graph for this function:

set_status_callback()

void Slic3r::PrintBase::set_status_callback ( status_callback_type  cb )

inlineinherited

{ m_status_callback = cb; }

References Slic3r::PrintBase::m_status_callback.

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

Here is the caller graph for this function:

set_status_default()

void Slic3r::PrintBase::set_status_default ( )

inlineinherited

{ m_status_callback = nullptr; }

References Slic3r::PrintBase::m_status_callback.

set_status_silent()

void Slic3r::PrintBase::set_status_silent ( )

inlineinherited

{ m_status_callback = [](const SlicingStatus&){}; }

References Slic3r::PrintBase::m_status_callback.

set_task()

virtual void Slic3r::PrintBase::set_task ( const TaskParams &  params )

pure virtualinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::set_task().

Here is the caller graph for this function:

set_task_impl()

template<typename PrintStepEnumType , const size_t COUNT>

template<typename PrintObject >

void Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl ( const TaskParams &  params, std::vector< PrintObject * > &  print_objects  )

inlineprotected

    {
        static constexpr const auto PrintObjectStepEnumSize = int(PrintObject::PrintObjectStepEnumSize);
        using                       PrintObjectStepEnum     = typename PrintObject::PrintObjectStepEnum;
        // Grab the lock for the Print / PrintObject milestones.
        std::scoped_lock<std::mutex> lock(this->state_mutex());
 
        int n_object_steps = int(params.to_object_step) + 1;
        if (n_object_steps == 0)
            n_object_steps = PrintObjectStepEnumSize;
 
        if (params.single_model_object.valid()) {
            // Find the print object to be processed with priority.
            PrintObject *print_object = nullptr;
            size_t       idx_print_object = 0;
            for (; idx_print_object < print_objects.size(); ++ idx_print_object)
                if (print_objects[idx_print_object]->model_object()->id() == params.single_model_object) {
                    print_object = print_objects[idx_print_object];
                    break;
                }
            assert(print_object != nullptr);
            // Find out whether the priority print object is being currently processed.
            bool running = false;
            for (int istep = 0; istep < n_object_steps; ++ istep) {
                if (! print_object->is_step_enabled_unguarded(PrintObjectStepEnum(istep)))
                    // Step was skipped, cancel.
                    break;
                if (print_object->is_step_started_unguarded(PrintObjectStepEnum(istep))) {
                    // No step was skipped, and a wanted step is being processed. Don't cancel.
                    running = true;
                    break;
                }
            }
            if (! running)
                this->call_cancel_callback();
 
            // Now the background process is either stopped, or it is inside one of the print object steps to be calculated anyway.
            if (params.single_model_instance_only) {
                // Suppress all the steps of other instances.
                for (PrintObject *po : print_objects)
                    for (size_t istep = 0; istep < PrintObjectStepEnumSize; ++ istep)
                        po->enable_step_unguarded(PrintObjectStepEnum(istep), false);
            } else if (! running) {
                // Swap the print objects, so that the selected print_object is first in the row.
                // At this point the background processing must be stopped, so it is safe to shuffle print objects.
                if (idx_print_object != 0)
                    std::swap(print_objects.front(), print_objects[idx_print_object]);
            }
            // and set the steps for the current object.
            for (int istep = 0; istep < n_object_steps; ++ istep)
                print_object->enable_step_unguarded(PrintObjectStepEnum(istep), true);
            for (int istep = n_object_steps; istep < PrintObjectStepEnumSize; ++ istep)
                print_object->enable_step_unguarded(PrintObjectStepEnum(istep), false);
        } else {
            // Slicing all objects.
            bool running = false;
            for (PrintObject *print_object : print_objects)
                for (int istep = 0; istep < n_object_steps; ++ istep) {
                    if (! print_object->is_step_enabled_unguarded(PrintObjectStepEnum(istep))) {
                        // Step may have been skipped. Restart.
                        goto loop_end;
                    }
                    if (print_object->is_step_started_unguarded(PrintObjectStepEnum(istep))) {
                        // This step is running, and the state cannot be changed due to the this->state_mutex() being locked.
                        // It is safe to manipulate m_stepmask of other PrintObjects and Print now.
                        running = true;
                        goto loop_end;
                    }
                }
        loop_end:
            if (! running)
                this->call_cancel_callback();
            for (PrintObject *po : print_objects) {
                for (int istep = 0; istep < n_object_steps; ++ istep)
                    po->enable_step_unguarded(PrintObjectStepEnum(istep), true);
                for (int istep = n_object_steps; istep < PrintObjectStepEnumSize; ++ istep)
                    po->enable_step_unguarded(PrintObjectStepEnum(istep), false);
            }
        }
 
        if (params.to_object_step != -1 || params.to_print_step != -1) {
            // Limit the print steps.
            size_t istep = (params.to_object_step != -1) ? 0 : size_t(params.to_print_step) + 1;
            for (; istep < PrintStepEnumSize; ++ istep)
                m_state.enable_unguarded(PrintStepEnum(istep), false);
        }
    }

References Slic3r::PrintBase::call_cancel_callback(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_step_unguarded(), Slic3r::PrintState< StepType, COUNT >::enable_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_enabled_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_started_unguarded(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintObjectBaseWithState< Print, PrintObjectStep, posCount >::PrintObjectStepEnumSize, Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::PrintStepEnumSize, Slic3r::PrintBase::TaskParams::single_model_instance_only, Slic3r::PrintBase::TaskParams::single_model_object, Slic3r::PrintBase::state_mutex(), Slic3r::PrintBase::TaskParams::to_object_step, Slic3r::PrintBase::TaskParams::to_print_step, and Slic3r::ObjectID::valid().

Referenced by Slic3r::Print::set_task().

Here is the call graph for this function:

Here is the caller graph for this function:

state_mutex()

std::mutex & Slic3r::PrintBase::state_mutex ( ) const

inlineprotectedinherited

{ return m_state_mutex; }

References Slic3r::PrintBase::m_state_mutex.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::SLAPrint::apply(), Slic3r::Print::clear(), Slic3r::SLAPrint::clear(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl(), Slic3r::BackgroundSlicingProcess::is_step_done(), Slic3r::Print::is_step_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done(), Slic3r::SLAPrint::is_step_done(), Slic3r::BackgroundSlicingProcess::reset_export(), Slic3r::BackgroundSlicingProcess::schedule_export(), Slic3r::BackgroundSlicingProcess::schedule_upload(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), Slic3r::BackgroundSlicingProcess::set_step_done(), Slic3r::BackgroundSlicingProcess::set_step_started(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl(), Slic3r::PrintObjectBase::state_mutex(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_warnings(), and Slic3r::BackgroundSlicingProcess::stop_internal().

Here is the caller graph for this function:

status_update_warnings()

void Slic3r::PrintBase::status_update_warnings ( int  step, PrintStateBase::WarningLevel  warning_level, const std::string &  message, const PrintObjectBase *  print_object = nullptr  )

protectedinherited

{
    if (m_status_callback) {
        auto status = print_object ? SlicingStatus(*print_object, step) : SlicingStatus(*this, step);
        m_status_callback(status);
    }
    else if (! message.empty())
        printf("%s warning: %s\n",  print_object ? "print_object" : "print", message.c_str());
}

References Slic3r::PrintBase::m_status_callback.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), and Slic3r::PrintObjectBase::status_update_warnings().

Here is the caller graph for this function:

step_state_with_timestamp()

template<typename PrintStepEnumType , const size_t COUNT>

PrintStateBase::StateWithTimeStamp Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp ( PrintStepEnum  step ) const

inline

{ return m_state.state_with_timestamp(step, this->state_mutex()); }

References Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintBase::state_mutex(), and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp().

Referenced by Slic3r::GCode::do_export(), and Slic3r::BackgroundSlicingProcess::process_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

step_state_with_warnings()

template<typename PrintStepEnumType , const size_t COUNT>

PrintStateBase::StateWithWarnings Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_warnings ( PrintStepEnum  step ) const

inline

{ return m_state.state_with_warnings(step, this->state_mutex()); }

References Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state, Slic3r::PrintBase::state_mutex(), and Slic3r::PrintState< StepType, COUNT >::state_with_warnings().

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

Here is the call graph for this function:

Here is the caller graph for this function:

technology()

virtual PrinterTechnology Slic3r::PrintBase::technology ( ) const

pure virtualnoexceptinherited

Implemented in Slic3r::Print, and Slic3r::SLAPrint.

Referenced by Slic3r::BackgroundSlicingProcess::apply(), Slic3r::BackgroundSlicingProcess::current_printer_technology(), and Slic3r::BackgroundSlicingProcess::select_technology().

Here is the caller graph for this function:

throw_if_canceled()

void Slic3r::PrintBase::throw_if_canceled ( ) const

inlineprotectedinherited

{ if (m_cancel_status.load(std::memory_order_acquire)) throw CanceledException(); }

References Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::GCode::_do_export(), Slic3r::Print::_make_skirt(), Slic3r::Print::_make_wipe_tower(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::PrintObject::make_perimeters(), Slic3r::PrintTryCancel::operator()(), Slic3r::SLAPrint::process(), Slic3r::GCode::process_layers(), Slic3r::GCode::process_layers(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), Slic3r::PrintObject::slice_support_volumes(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::PrintObject::slice_volumes(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::SLAPrint::Steps::support_tree(), and Slic3r::SLAPrint::Steps::throw_if_canceled().

Here is the caller graph for this function:

timestamp()

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

inlinevirtualinherited

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

{ return 0; }

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

Here is the caller graph for this function:

update_object_placeholders()

void Slic3r::PrintBase::update_object_placeholders ( DynamicConfig &  config, const std::string &  default_ext  ) const

protectedinherited

{
    // get the first input file name
    std::string input_file;
    std::vector<std::string> v_scale;
    int num_objects = 0;
    int num_instances = 0;
  for (const ModelObject *model_object : m_model.objects) {
    ModelInstance *printable = nullptr;
    for (ModelInstance *model_instance : model_object->instances)
      if (model_instance->is_printable()) {
        printable = model_instance;
        ++ num_instances;
      }
    if (printable) {
            ++ num_objects;
          // CHECK_ME -> Is the following correct ?
      v_scale.push_back("x:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(X) * 100) +
        "% y:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(Y) * 100) +
        "% z:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(Z) * 100) + "%");
          if (input_file.empty())
              input_file = model_object->name.empty() ? model_object->input_file : model_object->name;
      }
    }
    
    config.set_key_value("num_objects", new ConfigOptionInt(num_objects));
    config.set_key_value("num_instances", new ConfigOptionInt(num_instances));
 
    config.set_key_value("scale", new ConfigOptionStrings(v_scale));
    if (! input_file.empty()) {
        // get basename with and without suffix
        const std::string input_filename = boost::filesystem::path(input_file).filename().string();
        const std::string input_filename_base = input_filename.substr(0, input_filename.find_last_of("."));
        config.set_key_value("input_filename", new ConfigOptionString(input_filename_base + default_ext));
        config.set_key_value("input_filename_base", new ConfigOptionString(input_filename_base));
    }
}

References Slic3r::ModelInstance::get_scaling_factor(), Slic3r::PrintBase::m_model, Slic3r::Model::objects, Slic3r::DynamicConfig::set_key_value(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::PrintBase::output_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

validate()

virtual std::string Slic3r::PrintBase::validate ( std::vector< std::string > *  warnings = nullptr ) const

inlinevirtualinherited

Reimplemented in Slic3r::Print, and Slic3r::SLAPrint.

{ return std::string(); }

Referenced by Slic3r::CLI::run(), and Slic3r::BackgroundSlicingProcess::validate().

Here is the caller graph for this function:

Member Data Documentation

m_cancel_callback

cancel_callback_type Slic3r::PrintBase::m_cancel_callback = [](){}

privateinherited

Referenced by Slic3r::PrintBase::call_cancel_callback(), Slic3r::PrintBase::cancel_callback(), and Slic3r::PrintBase::set_cancel_callback().

m_cancel_status

std::atomic<CancelStatus> Slic3r::PrintBase::m_cancel_status

privateinherited

Referenced by Slic3r::PrintBase::cancel(), Slic3r::PrintBase::cancel_internal(), Slic3r::PrintBase::cancel_status(), Slic3r::PrintBase::canceled(), Slic3r::PrintBase::restart(), and Slic3r::PrintBase::throw_if_canceled().

m_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_full_print_config

protectedinherited

Referenced by Slic3r::SLAPrint::apply(), and Slic3r::PrintBase::full_print_config().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

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

m_model

Model Slic3r::PrintBase::m_model

protectedinherited

Referenced by Slic3r::SLAPrint::apply(), Slic3r::Print::clear(), Slic3r::SLAPrint::clear(), Slic3r::PrintBase::model(), Slic3r::PrintBase::output_filepath(), and Slic3r::PrintBase::update_object_placeholders().

m_placeholder_parser

PlaceholderParser Slic3r::PrintBase::m_placeholder_parser

protectedinherited

Referenced by Slic3r::SLAPrint::apply(), and Slic3r::PrintBase::placeholder_parser().

m_state

template<typename PrintStepEnumType , const size_t COUNT>

PrintState<PrintStepEnum, COUNT> Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::m_state

private

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done_unguarded(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_started_unguarded(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_warnings().

m_state_mutex

std::mutex Slic3r::PrintBase::m_state_mutex

mutableprivateinherited

Referenced by Slic3r::PrintBase::state_mutex().

m_status_callback

status_callback_type Slic3r::PrintBase::m_status_callback

protectedinherited

Referenced by Slic3r::PrintBase::set_status(), Slic3r::PrintBase::set_status_callback(), Slic3r::PrintBase::set_status_default(), Slic3r::PrintBase::set_status_silent(), and Slic3r::PrintBase::status_update_warnings().

PrintStepEnumSize

template<typename PrintStepEnumType , const size_t COUNT>

constexpr const size_t Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::PrintStepEnumSize = COUNT

staticconstexpr

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

PrintTryCancel

friend Slic3r::PrintBase::PrintTryCancel

privateinherited

Referenced by Slic3r::PrintBase::make_try_cancel().

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by Slic3r::ObjectBase::generate_new_id().

---

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

• src/libslic3r/PrintBase.hpp