Slic3r::BackgroundSlicingProcess Class Reference

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

Collaboration diagram for Slic3r::BackgroundSlicingProcess:

Classes
struct	UITask

Public Types
enum	State {   STATE_INITIAL = 0 , STATE_IDLE , STATE_STARTED , STATE_RUNNING ,   STATE_FINISHED , STATE_CANCELED , STATE_EXIT , STATE_EXITED }

Public Member Functions
	BackgroundSlicingProcess ()
	~BackgroundSlicingProcess ()
void	set_fff_print (Print *print)
void	set_sla_print (SLAPrint *print)
void	set_thumbnail_cb (ThumbnailsGeneratorCallback cb)
void	set_gcode_result (GCodeProcessorResult *result)
bool	switch_print_preprocess ()
bool	can_switch_print ()
void	set_current_plate (GUI::PartPlate *plate)
GUI::PartPlate *	get_current_plate ()
GCodeProcessorResult *	get_current_gcode_result ()
void	set_slicing_completed_event (int event_id)
void	set_finished_event (int event_id)
void	set_export_began_event (int event_id)
void	set_export_finished_event (int event_id)
bool	select_technology (PrinterTechnology tech)
PrinterTechnology	current_printer_technology () const
const PrintBase *	current_print () const
const Print *	fff_print () const
Print *	fff_print ()
const SLAPrint *	sla_print () const
std::string	output_filepath_for_project (const boost::filesystem::path &project_path)
bool	start ()
bool	stop ()
bool	reset ()
PrintBase::ApplyStatus	apply (const Model &model, const DynamicPrintConfig &config)
void	set_task (const PrintBase::TaskParams &params)
bool	empty () const
StringObjectException	validate (std::vector< StringObjectException > *warnings=nullptr, Polygons *collison_polygons=nullptr, std::vector< std::pair< Polygon, float > > *height_polygons=nullptr)
void	schedule_export (const std::string &path, bool export_path_on_removable_media)
void	schedule_upload (Slic3r::PrintHostJob upload_job)
void	reset_export ()
bool	is_export_scheduled () const
bool	is_upload_scheduled () const
State	state () const
bool	idle () const
bool	running () const
bool	finished () const
bool	is_internal_cancelled ()

Private Member Functions
void	thread_proc ()
void	thread_proc_safe () throw ()
void	join_background_thread ()
void	stop_internal ()
void	process_fff ()
void	process_sla ()
void	call_process (std::exception_ptr &ex) throw ()
bool	set_step_started (BackgroundSlicingProcessStep step)
void	set_step_done (BackgroundSlicingProcessStep step)
bool	is_step_done (BackgroundSlicingProcessStep step) const
bool	invalidate_step (BackgroundSlicingProcessStep step)
bool	invalidate_all_steps ()
void	throw_if_canceled () const
void	finalize_gcode ()
void	export_gcode ()
void	prepare_upload ()
ThumbnailsList	render_thumbnails (const ThumbnailsParams &params)
bool	execute_ui_task (std::function< void()> task)

Static Private Member Functions
static void	cancel_ui_task (std::shared_ptr< BackgroundSlicingProcess::UITask > task)

Private Attributes
PrintBase *	m_print = nullptr
Print *	m_fff_print = nullptr
SLAPrint *	m_sla_print = nullptr
GCodeProcessorResult *	m_gcode_result = nullptr
ThumbnailsGeneratorCallback	m_thumbnail_cb = nullptr
SL1Archive	m_sla_archive
std::string	m_temp_output_path
std::string	m_export_path
bool	m_export_path_on_removable_media = false
bool	m_export_statistics = false
PrintHostJob	m_upload_job
boost::thread	m_thread
std::mutex	m_mutex
std::condition_variable	m_condition
State	m_state = STATE_INITIAL
std::shared_ptr< UITask >	m_ui_task
GUI::PartPlate *	m_current_plate
PrinterTechnology	m_printer_tech = ptUnknown
bool	m_internal_cancelled = false
PrintState< BackgroundSlicingProcessStep, bspsCount >	m_step_state
int	m_event_slicing_completed_id = 0
int	m_event_finished_id = 0
int	m_event_export_began_id = 0
int	m_event_export_finished_id = 0

Friends
class	GUI::Plater

Detailed Description

Member Enumeration Documentation

State

enum Slic3r::BackgroundSlicingProcess::State

Enumerator
STATE_INITIAL
STATE_IDLE
STATE_STARTED
STATE_RUNNING
STATE_FINISHED
STATE_CANCELED
STATE_EXIT
STATE_EXITED

             {
    // m_thread  is not running yet, or it did not reach the STATE_IDLE yet (it does not wait on the condition yet).
    STATE_INITIAL = 0,
    // m_thread is waiting for the task to execute.
    STATE_IDLE,
    STATE_STARTED,
    // m_thread is executing a task.
    STATE_RUNNING,
    // m_thread finished executing a task, and it is waiting until the UI thread picks up the results.
    STATE_FINISHED,
    // m_thread finished executing a task, the task has been canceled by the UI thread, therefore the UI thread will not be notified.
    STATE_CANCELED,
    // m_thread exited the loop and it is going to finish. The UI thread should join on m_thread.
    STATE_EXIT,
    STATE_EXITED,
  };

Constructor & Destructor Documentation

BackgroundSlicingProcess()

Slic3r::BackgroundSlicingProcess::BackgroundSlicingProcess

(

)

{
    // BBS: move this logic to part plate
#if 0
    boost::filesystem::path temp_path(wxStandardPaths::Get().GetTempDir().utf8_str().data());
    temp_path /= (boost::format(".%1%.gcode") % get_current_pid()).str();
  m_temp_output_path = temp_path.string();
#endif
}

References Slic3r::get_current_pid(), and m_temp_output_path.

Here is the call graph for this function:

~BackgroundSlicingProcess()

Slic3r::BackgroundSlicingProcess::~BackgroundSlicingProcess

(

)

{
    this->stop();
    this->join_background_thread();
    // BBS: move this logic to part plate
    // boost::nowide::remove(m_temp_output_path.c_str());
}

References join_background_thread(), and stop().

Here is the call graph for this function:

Member Function Documentation

apply()

Print::ApplyStatus Slic3r::BackgroundSlicingProcess::apply	(	const Model &	model,
		const DynamicPrintConfig &	config )

{
    assert(m_print != nullptr);
    assert(config.opt_enum<PrinterTechnology>("printer_technology") == m_print->technology());
    // TODO: add partplate config
    DynamicPrintConfig new_config = config;
    new_config.apply(*m_current_plate->config());
    Print::ApplyStatus invalidated = m_print->apply(model, new_config);
 
    // Orca: prevent resetting under gcode viewer mode
    if (invalidated != PrintBase::APPLY_STATUS_UNCHANGED) {
        // Use the app’s plater accessor instead of going through mainframe, otherwise anything during startup that reaches apply() 
        // (loading presets, config or input files, e.g. from the CLI) therefore dereferences a null `mainframe` and crashes.
        const auto plater = GUI::wxGetApp().plater();
        if (plater && plater->only_gcode_mode()) {
            invalidated = PrintBase::APPLY_STATUS_UNCHANGED;
        }
    }
 
    if ((invalidated & PrintBase::APPLY_STATUS_INVALIDATED) != 0 && m_print->technology() == ptFFF &&
        !m_fff_print->is_step_done(psGCodeExport)) {
        // Some FFF status was invalidated, and the G-code was not exported yet.
        // Let the G-code preview UI know that the final G-code preview is not valid.
        // In addition, this early memory deallocation reduces memory footprint.
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": invalide gcode result %1%, will reset soon") % m_gcode_result;
        if (m_gcode_result != nullptr)
            m_gcode_result->reset();
    }
    return invalidated;
}

References Slic3r::ConfigBase::apply(), Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, Slic3r::PrintBase::APPLY_STATUS_UNCHANGED, m_current_plate, m_fff_print, m_gcode_result, m_print, Slic3r::DynamicConfig::opt_enum(), Slic3r::psGCodeExport, and Slic3r::ptFFF.

Here is the call graph for this function:

call_process()

void Slic3r::BackgroundSlicingProcess::call_process ( std::exception_ptr & ex ) throw (  )

private

{
    try {
        assert(m_print != nullptr);
        switch (m_print->technology()) {
        case ptFFF: this->process_fff(); break;
        case ptSLA: this->process_sla(); break;
        default: m_print->process(); break;
        }
    } catch (CanceledException& /* ex */) {
        // Canceled, this is all right.
        assert(m_print->canceled());
        ex = std::current_exception();
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":got cancelled exception" << std::endl;
    } catch (...) {
        ex = std::current_exception();
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":got other exception" << std::endl;
    }
}

References m_print, process_fff(), process_sla(), Slic3r::ptFFF, and Slic3r::ptSLA.

Referenced by thread_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

can_switch_print()

bool Slic3r::BackgroundSlicingProcess::can_switch_print

(

)

{
    bool result = true;
 
    if (m_state == STATE_RUNNING) {
        // currently it is on slicing, judge whether the slice result is valid or not
        // if (m_current_plate->is_slice_result_valid())
        {
            result = false;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format(": slicing plate's plate_id %1%, on slicing, can not switch print") %
                                           m_current_plate->get_index();
        }
    }
 
    return result;
}

References m_current_plate, m_state, and STATE_RUNNING.

cancel_ui_task()

void Slic3r::BackgroundSlicingProcess::cancel_ui_task ( std::shared_ptr< BackgroundSlicingProcess::UITask > task )

staticprivate

{
    if (task) {
        std::unique_lock<std::mutex> lck(task->mutex);
        task->state = UITask::Canceled;
        lck.unlock();
        task->condition.notify_all();
    }
}

References Slic3r::BackgroundSlicingProcess::UITask::Canceled.

Referenced by stop(), and stop_internal().

Here is the caller graph for this function:

current_print()

const PrintBase * Slic3r::BackgroundSlicingProcess::current_print ( ) const

inline

{ return m_print; }

References m_print.

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

Here is the caller graph for this function:

current_printer_technology()

PrinterTechnology Slic3r::BackgroundSlicingProcess::current_printer_technology

(

)

const

{
    // BBS: as the m_printer is changed frequently when switch plates, use m_printer_tech directly
    return m_printer_tech;
    // return m_print->technology();
}

References m_printer_tech.

empty()

bool Slic3r::BackgroundSlicingProcess::empty

(

)

const

{
    assert(m_print != nullptr);
    return m_print->empty();
}

References m_print.

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

Here is the caller graph for this function:

execute_ui_task()

bool Slic3r::BackgroundSlicingProcess::execute_ui_task ( std::function< void()> task )

private

{
    bool running = false;
    if (m_mutex.try_lock()) {
        // Cancellation is either not in process, or already canceled and waiting for us to finish.
        // There must be no UI task planned.
        assert(!m_ui_task);
        if (!m_print->canceled()) {
            running   = true;
            m_ui_task = std::make_shared<UITask>();
        }
        m_mutex.unlock();
    } else {
        // Cancellation is in process.
    }
 
    bool result = false;
    if (running) {
        std::shared_ptr<UITask> ctx = m_ui_task;
        GUI::wxGetApp().mainframe->m_plater->CallAfter([task, ctx]() {
            // Running on the UI thread, thus ctx->state does not need to be guarded with mutex against ::cancel_ui_task().
            assert(ctx->state == UITask::Planned || ctx->state == UITask::Canceled);
            if (ctx->state == UITask::Planned) {
                task();
                std::unique_lock<std::mutex> lck(ctx->mutex);
                ctx->state = UITask::Finished;
            }
            // Wake up the worker thread from the UI thread.
            ctx->condition.notify_all();
        });
 
        {
            std::unique_lock<std::mutex> lock(ctx->mutex);
            ctx->condition.wait(lock, [&ctx] { return ctx->state == UITask::Finished || ctx->state == UITask::Canceled; });
        }
        result = ctx->state == UITask::Finished;
        m_ui_task.reset();
    }
 
    return result;
}

References Slic3r::BackgroundSlicingProcess::UITask::Canceled, Slic3r::BackgroundSlicingProcess::UITask::Finished, m_mutex, m_print, m_ui_task, Slic3r::BackgroundSlicingProcess::UITask::Planned, and running().

Referenced by render_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

export_gcode()

void Slic3r::BackgroundSlicingProcess::export_gcode ( )

private

{
    // Perform the final post-processing of the export path by applying the print statistics over the file name.
    std::string export_path = m_fff_print->print_statistics().finalize_output_path(m_export_path);
    std::string output_path = m_temp_output_path;
 
    // FIXME localize the messages
    std::string error_message;
    int copy_ret_val = CopyFileResult::SUCCESS;
    try {
        copy_ret_val = copy_file(output_path, export_path, error_message, m_export_path_on_removable_media);
    } catch (...) {
        throw Slic3r::ExportError(_utf8(L("Unknown error with G-code export")));
    }
    switch (copy_ret_val) {
    case CopyFileResult::SUCCESS: break; // no error
    case CopyFileResult::FAIL_COPY_FILE:
        // throw Slic3r::ExportError((boost::format(_utf8(L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card
        // is write locked?\nError message: %1%"))) % error_message).str()); break;
    case CopyFileResult::FAIL_FILES_DIFFERENT:
        // throw Slic3r::ExportError((boost::format(_utf8(L("Copying of the temporary G-code to the output G-code failed. There might be
        // problem with target device, please try exporting again or using different device. The corrupted output G-code is at %1%.tmp.")))
        // % export_path).str()); break;
    case CopyFileResult::FAIL_RENAMING:
        // throw Slic3r::ExportError((boost::format(_utf8(L("Renaming of the G-code after copying to the selected destination folder has
        // failed. Current path is %1%.tmp. Please try exporting again."))) % export_path).str()); break;
    case CopyFileResult::FAIL_CHECK_ORIGIN_NOT_OPENED:
        // throw Slic3r::ExportError((boost::format(_utf8(L("Copying of the temporary G-code has finished but the original code at %1%
        // couldn't be opened during copy check. The output G-code is at %2%.tmp."))) % output_path % export_path).str()); break;
    case CopyFileResult::FAIL_CHECK_TARGET_NOT_OPENED:
        // throw Slic3r::ExportError((boost::format(_utf8(L("Copying of the temporary G-code has finished but the exported code couldn't be
        // opened during copy check. The output G-code is at %1%.tmp."))) % export_path).str()); break;
    default:
        BOOST_LOG_TRIVIAL(error) << "Fail code(" << (int) copy_ret_val << ") when copy " << output_path << " to " << export_path << ".";
        throw Slic3r::ExportError(
            (boost::format(_utf8(L("Failed to save G-code file.\nError message: %1%.\nSource file %2%."))) % error_message % output_path)
                .str());
        // throw Slic3r::ExportError(_utf8(L("Unknown error when exporting G-code.")));
        break;
    }
    if (m_export_statistics)
        export_gcode_statistics(*m_gcode_result, gcode_statistics_path(export_path));
 
    // BBS
    auto evt                  = new wxCommandEvent(m_event_export_finished_id, GUI::wxGetApp().mainframe->m_plater->GetId());
    wxString output_gcode_str = wxString::FromUTF8(export_path.c_str(), export_path.length());
    evt->SetString(output_gcode_str);
    wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt);
 
    // BBS: to be checked. Whether use export_path or output_path.
    gcode_add_line_number(export_path, m_fff_print->full_print_config());
}

References _utf8, Slic3r::copy_file(), Slic3r::export_gcode_statistics(), Slic3r::FAIL_CHECK_ORIGIN_NOT_OPENED, Slic3r::FAIL_CHECK_TARGET_NOT_OPENED, Slic3r::FAIL_COPY_FILE, Slic3r::FAIL_FILES_DIFFERENT, Slic3r::FAIL_RENAMING, Slic3r::gcode_add_line_number(), Slic3r::gcode_statistics_path(), L, m_event_export_finished_id, m_export_path, m_export_path_on_removable_media, m_export_statistics, m_fff_print, m_gcode_result, m_temp_output_path, and Slic3r::SUCCESS.

Referenced by process_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

fff_print() [1/2]

Print * Slic3r::BackgroundSlicingProcess::fff_print ( )

inline

{ return m_fff_print; }

References m_fff_print.

fff_print() [2/2]

const Print * Slic3r::BackgroundSlicingProcess::fff_print ( ) const

inline

{ return m_fff_print; }

References m_fff_print.

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

Here is the caller graph for this function:

finalize_gcode()

void Slic3r::BackgroundSlicingProcess::finalize_gcode ( )

private

{
    m_print->set_status(95, _u8L("Running post-processing scripts"));
 
    // Perform the final post-processing of the export path by applying the print statistics over the file name.
    std::string export_path = m_fff_print->print_statistics().finalize_output_path(m_export_path);
    std::string output_path = m_temp_output_path;
    // Both output_path and export_path ar in-out parameters.
    // If post processed, output_path will differ from m_temp_output_path as run_post_process_scripts() will make a copy of the G-code to not
    // collide with the G-code viewer memory mapping of the unprocessed G-code. G-code viewer maps unprocessed G-code, because m_gcode_result
    // is calculated for the unprocessed G-code and it references lines in the memory mapped G-code file by line numbers.
    // export_path may be changed by the post-processing script as well if the post processing script decides so, see GH #6042.
    // Runs both post-processing scripts and plugins on a single .pp copy of the G-code (make_copy = true),
    // so neither touches the original file the G-code viewer keeps memory-mapped.
    bool post_processed = run_post_process_scripts(output_path, true, "File", export_path, m_fff_print->full_print_config());
 
    auto remove_post_processed_temp_file = [post_processed, &output_path]() {
        if (post_processed)
            try {
                boost::filesystem::remove(output_path);
            } catch (const std::exception& ex) {
                BOOST_LOG_TRIVIAL(error) << "Failed to remove temp file " << output_path << ": " << ex.what();
            }
    };
    m_print->set_status(99, _utf8(L("Successfully executed post-processing script")));
 
    // FIXME localize the messages
    std::string error_message;
    int copy_ret_val = CopyFileResult::SUCCESS;
    try {
        copy_ret_val = copy_file(output_path, export_path, error_message, m_export_path_on_removable_media);
        remove_post_processed_temp_file();
    } catch (...) {
        remove_post_processed_temp_file();
        throw Slic3r::ExportError(_u8L("Unknown error occurred during exporting G-code."));
    }
    switch (copy_ret_val) {
    case CopyFileResult::SUCCESS: break; // no error
    case CopyFileResult::FAIL_COPY_FILE:
        throw Slic3r::ExportError(GUI::format(
            m_export_path_on_removable_media ?
                _L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?\nError message: %1%") :
                _L("Copying of the temporary G-code to the output G-code failed.\nError message: %1%"),
            error_message));
        break;
    case CopyFileResult::FAIL_FILES_DIFFERENT:
        throw Slic3r::ExportError(
            GUI::format(_L("Copying of the temporary G-code to the output G-code failed. There might be problem with target device, please "
                           "try exporting again or using different device. The corrupted output G-code is at %1%.tmp."),
                        export_path));
        break;
    case CopyFileResult::FAIL_RENAMING:
        throw Slic3r::ExportError(GUI::format(_L("Renaming of the G-code after copying to the selected destination folder has failed. "
                                                 "Current path is %1%.tmp. Please try exporting again."),
                                              export_path));
        break;
    case CopyFileResult::FAIL_CHECK_ORIGIN_NOT_OPENED:
        throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code has finished but the original code at %1% couldn't be "
                                                 "opened during copy check. The output G-code is at %2%.tmp."),
                                              output_path, export_path));
        break;
    case CopyFileResult::FAIL_CHECK_TARGET_NOT_OPENED:
        throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code has finished but the exported code couldn't be opened "
                                                 "during copy check. The output G-code is at %1%.tmp."),
                                              export_path));
        break;
    default:
        throw Slic3r::ExportError(_u8L("Unknown error occurred during exporting G-code."));
        BOOST_LOG_TRIVIAL(error) << "Unexpected fail code(" << (int) copy_ret_val << ") durring copy_file() to " << export_path << ".";
        break;
    }
    if (m_export_statistics)
        export_gcode_statistics(*m_gcode_result, gcode_statistics_path(export_path));
 
    m_print->set_status(100, GUI::format(_L("G-code file exported to %1%"), export_path));
}

References _L, _u8L, _utf8, Slic3r::copy_file(), Slic3r::export_gcode_statistics(), Slic3r::FAIL_CHECK_ORIGIN_NOT_OPENED, Slic3r::FAIL_CHECK_TARGET_NOT_OPENED, Slic3r::FAIL_COPY_FILE, Slic3r::FAIL_FILES_DIFFERENT, Slic3r::FAIL_RENAMING, Slic3r::GUI::format(), Slic3r::gcode_statistics_path(), L, m_export_path, m_export_path_on_removable_media, m_export_statistics, m_fff_print, m_gcode_result, m_print, m_temp_output_path, Slic3r::run_post_process_scripts(), and Slic3r::SUCCESS.

Referenced by process_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

finished()

bool Slic3r::BackgroundSlicingProcess::finished ( ) const

inline

{ return m_print->finished() && !m_gcode_result->moves.empty(); }

References m_gcode_result, and m_print.

get_current_gcode_result()

GCodeProcessorResult * Slic3r::BackgroundSlicingProcess::get_current_gcode_result ( )

inline

{ return m_gcode_result;}

References m_gcode_result.

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

Here is the caller graph for this function:

get_current_plate()

GUI::PartPlate * Slic3r::BackgroundSlicingProcess::get_current_plate ( )

inline

{ return m_current_plate; }

References m_current_plate.

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

Here is the caller graph for this function:

idle()

bool Slic3r::BackgroundSlicingProcess::idle ( ) const

inline

{ return m_state == STATE_IDLE; }

References m_state, and STATE_IDLE.

Referenced by Slic3r::GUI::Plater::priv::init_notification_manager(), and start().

Here is the caller graph for this function:

invalidate_all_steps()

bool Slic3r::BackgroundSlicingProcess::invalidate_all_steps ( )

private

{
    return m_step_state.invalidate_all([this]() { this->stop_internal(); });
}

References m_step_state, and stop_internal().

Referenced by reset().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_step()

bool Slic3r::BackgroundSlicingProcess::invalidate_step ( BackgroundSlicingProcessStep step )

private

{
    bool invalidated = m_step_state.invalidate(step, [this]() { this->stop_internal(); });
    return invalidated;
}

References m_step_state, and stop_internal().

Referenced by reset_export(), schedule_export(), and schedule_upload().

Here is the call graph for this function:

Here is the caller graph for this function:

is_export_scheduled()

bool Slic3r::BackgroundSlicingProcess::is_export_scheduled ( ) const

inline

{ return ! m_export_path.empty(); }

References m_export_path.

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

Here is the caller graph for this function:

is_internal_cancelled()

bool Slic3r::BackgroundSlicingProcess::is_internal_cancelled ( )

inline

{ return m_internal_cancelled; }

References m_internal_cancelled.

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

Here is the caller graph for this function:

is_step_done()

bool Slic3r::BackgroundSlicingProcess::is_step_done ( BackgroundSlicingProcessStep step ) const

private

{ return m_step_state.is_done(step, m_print->state_mutex()); }

References m_print, and m_step_state.

is_upload_scheduled()

bool Slic3r::BackgroundSlicingProcess::is_upload_scheduled ( ) const

inline

{ return ! m_upload_job.empty(); }

References m_upload_job.

join_background_thread()

void Slic3r::BackgroundSlicingProcess::join_background_thread ( )

private

{
    std::unique_lock<std::mutex> lck(m_mutex);
    if (m_state == STATE_INITIAL) {
        // Worker thread has not been started yet.
        assert(!m_thread.joinable());
    } else {
        assert(m_state == STATE_IDLE);
        assert(m_thread.joinable());
        // Notify the worker thread to exit.
        m_state = STATE_EXIT;
        lck.unlock();
        m_condition.notify_one();
        // Wait until the worker thread exits.
        m_thread.join();
    }
}

References m_condition, m_mutex, m_state, m_thread, STATE_EXIT, STATE_IDLE, and STATE_INITIAL.

Referenced by ~BackgroundSlicingProcess().

Here is the caller graph for this function:

output_filepath_for_project()

std::string Slic3r::BackgroundSlicingProcess::output_filepath_for_project

(

const boost::filesystem::path &

project_path

)

{
    assert(m_print != nullptr);
    if (project_path.empty())
        return m_print->output_filepath("");
    return m_print->output_filepath(project_path.parent_path().string(), project_path.stem().string());
}

References m_print.

prepare_upload()

void Slic3r::BackgroundSlicingProcess::prepare_upload ( )

private

{
    // Generate a unique temp path to which the gcode/zip file is copied/exported
    boost::filesystem::path source_path = boost::filesystem::temp_directory_path() /
                                          boost::filesystem::unique_path("." SLIC3R_APP_KEY ".upload.%%%%-%%%%-%%%%-%%%%");
 
    if (m_print == m_fff_print) {
        if (m_upload_job.upload_data.use_3mf) {
            source_path = m_upload_job.upload_data.source_path;
        } else {
            m_print->set_status(95, _utf8(L("Running post-processing scripts")));
            std::string error_message;
            if (copy_file(m_temp_output_path, source_path.string(), error_message) != SUCCESS)
                throw Slic3r::RuntimeError(_utf8(L("Copying of the temporary G-code to the output G-code failed.")));
            m_upload_job.upload_data.upload_path = m_fff_print->print_statistics().finalize_output_path(
                m_upload_job.upload_data.upload_path.string());
            // Orca: skip post-processing scripts for BBL printers as we have run them already in finalize_gcode()
            // todo: do we need to copy the file?
 
            // Make a copy of the source path, as run_post_process_scripts() is allowed to change it when making a copy of the source file
            // (not here, but when the final target is a file).
            if (!m_fff_print->is_BBL_printer()) {
                std::string source_path_str = source_path.string();
                std::string output_name_str = m_upload_job.upload_data.upload_path.string();
                // source_path_str is already a dedicated copy of the temp G-code (see copy_file above), not the
                // memory-mapped original, so scripts and plugins can modify it in place (make_copy = false).
                bool post_process = run_post_process_scripts(source_path_str, false, m_upload_job.printhost->get_name(), output_name_str,
                                             m_fff_print->full_print_config());
                if (post_process)
                    m_upload_job.upload_data.upload_path = output_name_str;
            }
        }
    } else {
        m_upload_job.upload_data.upload_path = m_sla_print->print_statistics().finalize_output_path(
            m_upload_job.upload_data.upload_path.string());
 
        ThumbnailsList thumbnails = this->render_thumbnails(
            ThumbnailsParams{current_print()->full_print_config().option<ConfigOptionPoints>("thumbnails")->values, true, true, true, true});
        // true, false, true, true); // renders also supports and pad
        Zipper zipper{source_path.string()};
        m_sla_archive.export_print(zipper, *m_sla_print, m_upload_job.upload_data.upload_path.string());
        for (const ThumbnailData& data : thumbnails)
            if (data.is_valid())
                write_thumbnail(zipper, data);
        zipper.finalize();
    }
 
    m_print->set_status(100, (boost::format(_utf8(L("Scheduling upload to `%1%`. See Window -> Print Host Upload Queue"))) %
                              m_upload_job.printhost->get_host())
                                 .str());
 
    m_upload_job.upload_data.source_path = std::move(source_path);
 
    GUI::wxGetApp().printhost_job_queue().enqueue(std::move(m_upload_job));
}

References _utf8, Slic3r::copy_file(), current_print(), Slic3r::PrintBase::full_print_config(), L, m_fff_print, m_print, m_sla_archive, m_sla_print, m_temp_output_path, m_upload_job, Slic3r::ConfigBase::option(), Slic3r::post_process(), render_thumbnails(), Slic3r::run_post_process_scripts(), Slic3r::SUCCESS, and Slic3r::write_thumbnail().

Referenced by process_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

process_fff()

void Slic3r::BackgroundSlicingProcess::process_fff ( )

private

{
    assert(m_print == m_fff_print);
    PresetBundle& preset_bundle   = *GUI::wxGetApp().preset_bundle;
    m_fff_print->is_BBL_printer() = preset_bundle.is_bbl_vendor();
    // BBS: add the logic to process from an existed gcode file
    if (m_print->finished()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: skip slicing, to process previous gcode file") % __LINE__;
        m_fff_print->set_status(80, _utf8(L("Processing G-code from previous file\u2026" /* \u2026 -> ... */)));
        wxCommandEvent evt(m_event_slicing_completed_id);
        // Post the Slicing Finished message for the G-code viewer to update.
        // Passing the timestamp
        evt.SetInt((int) (m_fff_print->step_state_with_timestamp(PrintStep::psSlicingFinished).timestamp));
        wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
 
        m_temp_output_path = this->get_current_plate()->get_tmp_gcode_path();
        if (!m_export_path.empty()) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format(" %1%: export gcode from %2% directly to %3%") % __LINE__ % m_temp_output_path %
                                           m_export_path;
        } else {
            if (m_upload_job.empty()) {
                m_fff_print->export_gcode_from_previous_file(m_temp_output_path, m_gcode_result, [this](const ThumbnailsParams& params) {
                    return this->render_thumbnails(params);
                });
            }
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format(" %1%: export_gcode_from_previous_file from %2% finished") % __LINE__ %
                                           m_temp_output_path;
        }
    } else {
        // BBS: reset the gcode before reload_print in slicing_completed event processing
        // FIX the gcode rename failed issue
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                << boost::format(" %1%: will start slicing, reset gcode_result %2% firstly") % __LINE__ % m_gcode_result;
        m_gcode_result->reset();
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: gcode_result reseted, will start print::process") % __LINE__;
        m_print->process();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                << boost::format(" %1%: after print::process, send slicing complete event to gui...") % __LINE__;
        if (m_current_plate->get_real_filament_map_mode(preset_bundle.project_config) < FilamentMapMode::fmmManual) {
            std::vector<int> f_maps = m_fff_print->get_filament_maps();
            m_current_plate->set_filament_maps(f_maps);
            // The engine's concrete per-filament volume assignment is merged into the print
            // config by the ToolOrdering write-back; reading it back keeps the plate config the
            // next apply overlays equal to the written-back state (no diff, no re-invalidation)
            // and persists the auto result (always concrete Std/HF, never the Hybrid seed).
            std::vector<int> f_volume_maps = m_fff_print->get_filament_volume_maps();
            m_current_plate->set_filament_volume_maps(f_volume_maps);
        }
        if (m_current_plate->get_real_filament_map_mode(preset_bundle.project_config) != FilamentMapMode::fmmNozzleManual) {
            // The engine-resolved nozzle map is read back for every non-nozzle-manual mode so the
            // plate config the next apply overlays matches the engine's written-back state
            // (otherwise the full-config diff would invalidate the g-code on every apply).
            std::vector<int> f_nozzle_maps = m_fff_print->get_filament_nozzle_maps();
            m_current_plate->set_filament_nozzle_maps(f_nozzle_maps);
        }
        wxCommandEvent evt(m_event_slicing_completed_id);
        // Post the Slicing Finished message for the G-code viewer to update.
        // Passing the timestamp
        evt.SetInt((int) (m_fff_print->step_state_with_timestamp(PrintStep::psSlicingFinished).timestamp));
        wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
 
        // BBS: add plate index into render params
        m_temp_output_path = this->get_current_plate()->get_tmp_gcode_path();
        m_fff_print->export_gcode(m_temp_output_path, m_gcode_result,
                                  [this](const ThumbnailsParams& params) { return this->render_thumbnails(params); });
        // Orca: BBL printers post-process the g-code in place here, in the file the G-code viewer maps, so
        // the preview re-reads its moves and line offsets from the edited file. The rest of m_gcode_result,
        // including nozzle_group_result (consumed by the H2C print-dispatch nozzle mapping), is kept.
        if (m_fff_print->is_BBL_printer()) {
            if (run_post_process_scripts(m_temp_output_path, false, "File", m_temp_output_path, m_fff_print->full_print_config()))
                m_fff_print->reload_gcode_moves(m_gcode_result);
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": export gcode finished");
    }
    if (this->set_step_started(bspsGCodeFinalize)) {
        if (!m_export_path.empty()) {
            wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
            if (!m_fff_print->is_BBL_printer())
                finalize_gcode();
            else
                export_gcode();
        } else if (!m_upload_job.empty()) {
            wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
            prepare_upload();
        } else {
            m_print->set_status(100, _utf8(L("Slicing complete")));
        }
        this->set_step_done(bspsGCodeFinalize);
    }
}

References _utf8, Slic3r::bspsGCodeFinalize, export_gcode(), finalize_gcode(), Slic3r::fmmManual, Slic3r::fmmNozzleManual, get_current_plate(), Slic3r::GUI::PartPlate::get_tmp_gcode_path(), Slic3r::PresetBundle::is_bbl_vendor(), L, m_current_plate, m_event_export_began_id, m_event_slicing_completed_id, m_export_path, m_fff_print, m_gcode_result, m_print, m_temp_output_path, m_upload_job, prepare_upload(), Slic3r::PresetBundle::project_config, Slic3r::psSlicingFinished, render_thumbnails(), Slic3r::run_post_process_scripts(), set_step_done(), and set_step_started().

Referenced by call_process().

Here is the call graph for this function:

Here is the caller graph for this function:

process_sla()

void Slic3r::BackgroundSlicingProcess::process_sla ( )

private

{
    assert(m_print == m_sla_print);
    m_print->process();
    if (this->set_step_started(bspsGCodeFinalize)) {
        if (!m_export_path.empty()) {
            wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
 
            const std::string export_path = m_sla_print->print_statistics().finalize_output_path(m_export_path);
 
            // BBS: add plate id for thumbnail generation
            ThumbnailsList thumbnails = this->render_thumbnails(
                ThumbnailsParams{current_print()->full_print_config().option<ConfigOptionPoints>("thumbnails")->values, true, true, true,
                                 true, 0});
 
            Zipper zipper(export_path);
            m_sla_archive.export_print(zipper, *m_sla_print); // true, false, true, true); // renders also supports and pad
            for (const ThumbnailData& data : thumbnails)
                if (data.is_valid())
                    write_thumbnail(zipper, data);
            zipper.finalize();
 
            // m_print->set_status(100, (boost::format(_utf8(L("Masked SLA file exported to %1%"))) % export_path).str());
            m_print->set_status(100, (boost::format(_utf8("Masked SLA file exported to %1%")) % export_path).str());
        } else {
            // m_print->set_status(100, _utf8(L("Slicing complete")));
            m_print->set_status(100, _utf8("Slicing complete"));
        }
        this->set_step_done(bspsGCodeFinalize);
    }
}

References _utf8, Slic3r::bspsGCodeFinalize, current_print(), Slic3r::PrintBase::full_print_config(), m_event_export_began_id, m_export_path, m_print, m_sla_archive, m_sla_print, Slic3r::ConfigBase::option(), render_thumbnails(), set_step_done(), set_step_started(), and Slic3r::write_thumbnail().

Referenced by call_process().

Here is the call graph for this function:

Here is the caller graph for this function:

render_thumbnails()

ThumbnailsList Slic3r::BackgroundSlicingProcess::render_thumbnails ( const ThumbnailsParams & params )

private

{
    ThumbnailsList thumbnails;
    if (m_thumbnail_cb)
        this->execute_ui_task([this, &params, &thumbnails]() { thumbnails = m_thumbnail_cb(params); });
    return thumbnails;
}

References execute_ui_task(), and m_thumbnail_cb.

Referenced by prepare_upload(), process_fff(), and process_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

bool Slic3r::BackgroundSlicingProcess::reset

(

)

{
    bool stopped = this->stop();
    this->reset_export();
    // BBS: don't clear print for print is not owned by background slicing process anymore
    // do it in the part_plate
    // m_print->clear();
    this->invalidate_all_steps();
    return stopped;
}

References invalidate_all_steps(), reset_export(), and stop().

Referenced by Slic3r::GUI::Plater::priv::reset(), and select_technology().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_export()

void Slic3r::BackgroundSlicingProcess::reset_export

(

)

{
    assert(!this->running());
    if (!this->running()) {
        m_export_path.clear();
        m_export_path_on_removable_media = false;
        // invalidate_step expects the mutex to be locked.
        std::scoped_lock<std::mutex> lock(m_print->state_mutex());
        this->invalidate_step(bspsGCodeFinalize);
    }
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_export_path_on_removable_media, m_print, and running().

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

Here is the call graph for this function:

Here is the caller graph for this function:

running()

bool Slic3r::BackgroundSlicingProcess::running ( ) const

inline

{ return m_state == STATE_STARTED || m_state == STATE_RUNNING || m_state == STATE_FINISHED || m_state == STATE_CANCELED; }

References m_state, STATE_CANCELED, STATE_FINISHED, STATE_RUNNING, and STATE_STARTED.

Referenced by execute_ui_task(), reset_export(), Slic3r::GUI::Plater::priv::set_current_panel(), start(), Slic3r::GUI::Plater::priv::trigger_auto_reslice_now(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

schedule_export()

void Slic3r::BackgroundSlicingProcess::schedule_export	(	const std::string &	path,
		bool	export_path_on_removable_media )

{
    assert(m_export_path.empty());
    if (!m_export_path.empty())
        return;
 
    // Guard against entering the export step before changing the export path.
    std::scoped_lock<std::mutex> lock(m_print->state_mutex());
    this->invalidate_step(bspsGCodeFinalize);
    m_export_path                    = path;
    m_export_path_on_removable_media = export_path_on_removable_media;
    m_export_statistics              = GUI::wxGetApp().app_config->get_bool("export_statistics");
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_export_path_on_removable_media, m_export_statistics, and m_print.

Here is the call graph for this function:

schedule_upload()

void Slic3r::BackgroundSlicingProcess::schedule_upload

(

Slic3r::PrintHostJob

upload_job

)

{
    assert(m_export_path.empty());
    if (!m_export_path.empty())
        return;
 
    // Guard against entering the export step before changing the export path.
    std::scoped_lock<std::mutex> lock(m_print->state_mutex());
    this->invalidate_step(bspsGCodeFinalize);
    m_export_path.clear();
    m_upload_job = std::move(upload_job);
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_print, and m_upload_job.

Here is the call graph for this function:

select_technology()

bool Slic3r::BackgroundSlicingProcess::select_technology

(

PrinterTechnology

tech

)

{
    bool changed = false;
    if (m_printer_tech != tech) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": change the printer technology from %1% to %2%") % m_printer_tech % tech;
        m_printer_tech = tech;
        if (m_print != nullptr)
            this->reset();
        changed = true;
    }
 
    switch (tech) {
    case ptFFF: m_print = m_fff_print; break;
    case ptSLA: m_print = m_sla_print; break;
    default: assert(false); break;
    }
    assert(m_print != nullptr);
    return changed;
}

References m_fff_print, m_print, m_printer_tech, m_sla_print, Slic3r::ptFFF, Slic3r::ptSLA, and reset().

Here is the call graph for this function:

set_current_plate()

void Slic3r::BackgroundSlicingProcess::set_current_plate ( GUI::PartPlate * plate )

inline

{ m_current_plate = plate; }

References m_current_plate.

set_export_began_event()

void Slic3r::BackgroundSlicingProcess::set_export_began_event ( int event_id )

inline

{ m_event_export_began_id = event_id; }

References m_event_export_began_id.

set_export_finished_event()

void Slic3r::BackgroundSlicingProcess::set_export_finished_event ( int event_id )

inline

{ m_event_export_finished_id = event_id; }

References m_event_export_finished_id.

set_fff_print()

void Slic3r::BackgroundSlicingProcess::set_fff_print ( Print * print )

inline

{ m_fff_print = print; }

References m_fff_print.

set_finished_event()

void Slic3r::BackgroundSlicingProcess::set_finished_event ( int event_id )

inline

{ m_event_finished_id = event_id; }

References m_event_finished_id.

set_gcode_result()

void Slic3r::BackgroundSlicingProcess::set_gcode_result ( GCodeProcessorResult * result )

inline

{ m_gcode_result = result; }

References m_gcode_result.

set_sla_print()

void Slic3r::BackgroundSlicingProcess::set_sla_print ( SLAPrint * print )

inline

{ m_sla_print = print; m_sla_print->set_printer(&m_sla_archive); }

References m_sla_archive, and m_sla_print.

set_slicing_completed_event()

void Slic3r::BackgroundSlicingProcess::set_slicing_completed_event ( int event_id )

inline

{ m_event_slicing_completed_id = event_id; }

References m_event_slicing_completed_id.

set_step_done()

void Slic3r::BackgroundSlicingProcess::set_step_done ( BackgroundSlicingProcessStep step )

private

{
    m_step_state.set_done(step, m_print->state_mutex(), [this]() { this->throw_if_canceled(); });
}

References m_print, and m_step_state.

Referenced by process_fff(), and process_sla().

Here is the caller graph for this function:

set_step_started()

bool Slic3r::BackgroundSlicingProcess::set_step_started ( BackgroundSlicingProcessStep step )

private

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

References m_print, and m_step_state.

Referenced by process_fff(), and process_sla().

Here is the caller graph for this function:

set_task()

void Slic3r::BackgroundSlicingProcess::set_task

(

const PrintBase::TaskParams &

params

)

{
    assert(m_print != nullptr);
    m_print->set_task(params);
}

References m_print.

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

Here is the caller graph for this function:

set_thumbnail_cb()

void Slic3r::BackgroundSlicingProcess::set_thumbnail_cb ( ThumbnailsGeneratorCallback cb )

inline

{ m_thumbnail_cb = cb; }

References m_thumbnail_cb.

sla_print()

const SLAPrint * Slic3r::BackgroundSlicingProcess::sla_print ( ) const

inline

{ return m_sla_print; }

References m_sla_print.

start()

bool Slic3r::BackgroundSlicingProcess::start

(

)

{
    if (m_print->empty()) {
        if (!m_current_plate || !m_current_plate->is_slice_result_valid())
            // The print is empty (no object in Model, or all objects are out of the print bed).
            return false;
    }
 
    std::unique_lock<std::mutex> lck(m_mutex);
    if (m_state == STATE_INITIAL) {
        // The worker thread is not running yet. Start it.
        assert(!m_thread.joinable());
        m_thread = create_thread([this] {
#ifdef _WIN32
            this->thread_proc_safe_seh_throw();
#else  // _WIN32
            this->thread_proc_safe();
#endif // _WIN32
        });
        // Wait until the worker thread is ready to execute the background processing task.
        m_condition.wait(lck, [this]() { return m_state == STATE_IDLE; });
    }
    assert(m_state == STATE_IDLE || this->running());
    if (this->running())
        // The background processing thread is already running.
        return false;
    if (!this->idle())
        throw Slic3r::RuntimeError("Cannot start a background task, the worker thread is not idle.");
    m_state = STATE_STARTED;
    m_print->set_cancel_callback([this]() { this->stop_internal(); });
    lck.unlock();
    m_condition.notify_one();
    return true;
}

References Slic3r::create_thread(), idle(), m_condition, m_current_plate, m_mutex, m_print, m_state, m_thread, running(), STATE_IDLE, STATE_INITIAL, STATE_STARTED, stop_internal(), and thread_proc_safe().

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

Here is the call graph for this function:

Here is the caller graph for this function:

state()

State Slic3r::BackgroundSlicingProcess::state ( ) const

inline

{ return m_state; }

References m_state.

stop()

bool Slic3r::BackgroundSlicingProcess::stop

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", enter" << std::endl;
    // m_print->state_mutex() shall NOT be held. Unfortunately there is no interface to test for it.
    std::unique_lock<std::mutex> lck(m_mutex);
    if (m_state == STATE_INITIAL) {
        //    m_export_path.clear();
        return false;
    }
    //  assert(this->running());
    if (m_state == STATE_STARTED || m_state == STATE_RUNNING) {
        // Cancel any task planned by the background thread on UI thread.
        cancel_ui_task(m_ui_task);
        m_print->cancel();
        // Wait until the background processing stops by being canceled.
        m_condition.wait(lck, [this]() { return m_state == STATE_CANCELED; });
        // In the "Canceled" state. Reset the state to "Idle".
        m_state = STATE_IDLE;
        m_print->set_cancel_callback([]() {});
    } else if (m_state == STATE_FINISHED || m_state == STATE_CANCELED) {
        // In the "Finished" or "Canceled" state. Reset the state to "Idle".
        m_state = STATE_IDLE;
        m_print->set_cancel_callback([]() {});
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", exit" << std::endl;
    //  m_export_path.clear();
    return true;
}

References cancel_ui_task(), m_condition, m_mutex, m_print, m_state, m_ui_task, STATE_CANCELED, STATE_FINISHED, STATE_IDLE, STATE_INITIAL, STATE_RUNNING, and STATE_STARTED.

Referenced by ~BackgroundSlicingProcess(), Slic3r::GUI::Plater::priv::init_notification_manager(), Slic3r::GUI::Plater::priv::on_process_completed(), reset(), and Slic3r::GUI::Plater::priv::reset().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_internal()

void Slic3r::BackgroundSlicingProcess::stop_internal ( )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", enter" << std::endl;
    // m_print->state_mutex() shall be held. Unfortunately there is no interface to test for it.
    if (m_state == STATE_IDLE)
        // The worker thread is waiting on m_mutex/m_condition for wake up. The following lock of the mutex would block.
        return;
    std::unique_lock<std::mutex> lck(m_mutex);
    assert(m_state == STATE_STARTED || m_state == STATE_RUNNING || m_state == STATE_FINISHED || m_state == STATE_CANCELED);
    if (m_state == STATE_STARTED || m_state == STATE_RUNNING) {
        // Cancel any task planned by the background thread on UI thread.
        cancel_ui_task(m_ui_task);
        // At this point of time the worker thread may be blocking on m_print->state_mutex().
        // Set the print state to canceled before unlocking the state_mutex(), so when the worker thread wakes up,
        // it throws the CanceledException().
        m_print->cancel_internal();
        // Allow the worker thread to wake up if blocking on a milestone.
        m_print->state_mutex().unlock();
        // Wait until the background processing stops by being canceled.
        m_condition.wait(lck, [this]() { return m_state == STATE_CANCELED; });
        // Lock it back to be in a consistent state.
        m_print->state_mutex().lock();
    }
    // In the "Canceled" state. Reset the state to "Idle".
    m_state = STATE_IDLE;
    m_print->set_cancel_callback([]() {});
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", exit" << std::endl;
}

References cancel_ui_task(), m_condition, m_mutex, m_print, m_state, m_ui_task, STATE_CANCELED, STATE_FINISHED, STATE_IDLE, STATE_RUNNING, and STATE_STARTED.

Referenced by invalidate_all_steps(), invalidate_step(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_print_preprocess()

bool Slic3r::BackgroundSlicingProcess::switch_print_preprocess

(

)

{
    bool result = true;
 
    /*switch (m_printer_tech) {
    case ptFFF: m_print = m_fff_print; break;
    case ptSLA: m_print = m_sla_print; break;
    default: assert(false); break;
    }*/
    return result;
}

thread_proc()

void Slic3r::BackgroundSlicingProcess::thread_proc ( )

private

{
    // BBS: thread name
    set_current_thread_name("bbl_BgSlcPcs");
    name_tbb_thread_pool_threads_set_locale();
 
    assert(m_print != nullptr);
    assert(m_print == m_fff_print || m_print == m_sla_print);
    std::unique_lock<std::mutex> lck(m_mutex);
    // Let the caller know we are ready to run the background processing task.
    m_state = STATE_IDLE;
    lck.unlock();
    m_condition.notify_one();
    for (;;) {
        // BBS: sometimes the state has already been set in the start function
        // assert(m_state == STATE_IDLE || m_state == STATE_CANCELED || m_state == STATE_FINISHED || m_state == STATE_STARTED);
        //  Wait until a new task is ready to be executed, or this thread should be finished.
        lck.lock();
        m_condition.wait(lck, [this]() { return m_state == STATE_STARTED || m_state == STATE_EXIT; });
        if (m_state == STATE_EXIT)
            // Exiting this thread.
            break;
        // Process the background slicing task.
        m_state = STATE_RUNNING;
        // BBS: internal cancel
        m_internal_cancelled = false;
        lck.unlock();
        std::exception_ptr exception;
#ifdef _WIN32
        this->call_process_seh_throw(exception);
#else
        this->call_process(exception);
#endif
        m_print->finalize();
        lck.lock();
        m_state = m_print->canceled() ? STATE_CANCELED : STATE_FINISHED;
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__
                                 << boost::format(": process finished, state %1%, print cancel_status %2%") % m_state %
                                        m_print->cancel_status();
        if (m_print->cancel_status() != Print::CANCELED_INTERNAL) {
            // Only post the canceled event, if canceled by user.
            // Don't post the canceled event, if canceled from Print::apply().
            SlicingProcessCompletedEvent evt(m_event_finished_id, 0,
                                             (m_state == STATE_CANCELED) ? SlicingProcessCompletedEvent::Cancelled :
                                             exception                   ? SlicingProcessCompletedEvent::Error :
                                                                           SlicingProcessCompletedEvent::Finished,
                                             exception);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format(": send SlicingProcessCompletedEvent to main, status %1%") % evt.status();
            wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
        } else {
            // BBS: internal cancel
            m_internal_cancelled = true;
        }
        m_print->restart();
        lck.unlock();
        // Let the UI thread wake up if it is waiting for the background task to finish.
        m_condition.notify_one();
        // Let the UI thread see the result.
    }
    m_state = STATE_EXITED;
    lck.unlock();
    // End of the background processing thread. The UI thread should join m_thread now.
}

References call_process(), Slic3r::PrintBase::CANCELED_INTERNAL, Slic3r::SlicingProcessCompletedEvent::Cancelled, Slic3r::SlicingProcessCompletedEvent::Clone(), Slic3r::SlicingProcessCompletedEvent::Error, Slic3r::SlicingProcessCompletedEvent::Finished, m_condition, m_event_finished_id, m_fff_print, m_internal_cancelled, m_mutex, m_print, m_sla_print, m_state, Slic3r::name_tbb_thread_pool_threads_set_locale(), Slic3r::set_current_thread_name(), STATE_CANCELED, STATE_EXIT, STATE_EXITED, STATE_FINISHED, STATE_IDLE, STATE_RUNNING, STATE_STARTED, and Slic3r::SlicingProcessCompletedEvent::status().

Referenced by thread_proc_safe().

Here is the call graph for this function:

Here is the caller graph for this function:

thread_proc_safe()

void Slic3r::BackgroundSlicingProcess::thread_proc_safe ( ) throw (  )

private

{
    try {
        this->thread_proc();
    } catch (...) {
        wxTheApp->OnUnhandledException();
    }
}

References thread_proc().

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_canceled()

void Slic3r::BackgroundSlicingProcess::throw_if_canceled ( ) const

inlineprivate

{ if (m_print->canceled()) throw CanceledException(); }

References m_print.

validate()

StringObjectException Slic3r::BackgroundSlicingProcess::validate	(	std::vector< StringObjectException > *	warnings = nullptr,
		Polygons *	collison_polygons = nullptr,
		std::vector< std::pair< Polygon, float > > *	height_polygons = nullptr )

{
    assert(m_print != nullptr);
    assert(m_print == m_fff_print);
 
    m_fff_print->is_BBL_printer() = GUI::wxGetApp().preset_bundle->is_bbl_vendor();
    return m_print->validate(warnings, collison_polygons, height_polygons);
}

References m_fff_print, and m_print.

Friends And Related Symbol Documentation

GUI::Plater

friend class GUI::Plater

friend

Member Data Documentation

m_condition

std::condition_variable Slic3r::BackgroundSlicingProcess::m_condition

private

Referenced by join_background_thread(), start(), stop(), stop_internal(), and thread_proc().

m_current_plate

GUI::PartPlate* Slic3r::BackgroundSlicingProcess::m_current_plate

private

Referenced by apply(), can_switch_print(), get_current_plate(), process_fff(), set_current_plate(), and start().

m_event_export_began_id

int Slic3r::BackgroundSlicingProcess::m_event_export_began_id = 0

private

Referenced by process_fff(), process_sla(), and set_export_began_event().

m_event_export_finished_id

int Slic3r::BackgroundSlicingProcess::m_event_export_finished_id = 0

private

Referenced by export_gcode(), and set_export_finished_event().

m_event_finished_id

int Slic3r::BackgroundSlicingProcess::m_event_finished_id = 0

private

Referenced by set_finished_event(), and thread_proc().

m_event_slicing_completed_id

int Slic3r::BackgroundSlicingProcess::m_event_slicing_completed_id = 0

private

Referenced by process_fff(), and set_slicing_completed_event().

m_export_path

std::string Slic3r::BackgroundSlicingProcess::m_export_path

private

Referenced by export_gcode(), finalize_gcode(), is_export_scheduled(), process_fff(), process_sla(), reset_export(), schedule_export(), and schedule_upload().

m_export_path_on_removable_media

bool Slic3r::BackgroundSlicingProcess::m_export_path_on_removable_media = false

private

Referenced by export_gcode(), finalize_gcode(), reset_export(), and schedule_export().

m_export_statistics

bool Slic3r::BackgroundSlicingProcess::m_export_statistics = false

private

Referenced by export_gcode(), finalize_gcode(), and schedule_export().

m_fff_print

Print* Slic3r::BackgroundSlicingProcess::m_fff_print = nullptr

private

Referenced by apply(), export_gcode(), fff_print(), fff_print(), finalize_gcode(), Slic3r::GUI::Plater::priv::generate_first_layer_bbox(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Plater::priv::on_slicing_update(), prepare_upload(), process_fff(), select_technology(), set_fff_print(), thread_proc(), and validate().

m_gcode_result

GCodeProcessorResult* Slic3r::BackgroundSlicingProcess::m_gcode_result = nullptr

private

Referenced by apply(), export_gcode(), finalize_gcode(), finished(), get_current_gcode_result(), process_fff(), and set_gcode_result().

m_internal_cancelled

bool Slic3r::BackgroundSlicingProcess::m_internal_cancelled = false

private

Referenced by is_internal_cancelled(), and thread_proc().

m_mutex

std::mutex Slic3r::BackgroundSlicingProcess::m_mutex

private

Referenced by execute_ui_task(), join_background_thread(), start(), stop(), stop_internal(), and thread_proc().

m_print

PrintBase* Slic3r::BackgroundSlicingProcess::m_print = nullptr

private

Referenced by apply(), call_process(), current_print(), empty(), execute_ui_task(), finalize_gcode(), finished(), is_step_done(), output_filepath_for_project(), prepare_upload(), process_fff(), process_sla(), reset_export(), schedule_export(), schedule_upload(), select_technology(), set_step_done(), set_step_started(), set_task(), start(), stop(), stop_internal(), thread_proc(), throw_if_canceled(), and validate().

m_printer_tech

PrinterTechnology Slic3r::BackgroundSlicingProcess::m_printer_tech = ptUnknown

private

Referenced by current_printer_technology(), and select_technology().

m_sla_archive

SL1Archive Slic3r::BackgroundSlicingProcess::m_sla_archive

private

Referenced by prepare_upload(), process_sla(), and set_sla_print().

m_sla_print

SLAPrint* Slic3r::BackgroundSlicingProcess::m_sla_print = nullptr

private

Referenced by Slic3r::GUI::Plater::priv::on_slicing_update(), prepare_upload(), process_sla(), select_technology(), set_sla_print(), sla_print(), and thread_proc().

m_state

State Slic3r::BackgroundSlicingProcess::m_state = STATE_INITIAL

private

Referenced by can_switch_print(), idle(), join_background_thread(), running(), start(), state(), stop(), stop_internal(), and thread_proc().

m_step_state

PrintState<BackgroundSlicingProcessStep, bspsCount> Slic3r::BackgroundSlicingProcess::m_step_state

private

Referenced by invalidate_all_steps(), invalidate_step(), is_step_done(), set_step_done(), and set_step_started().

m_temp_output_path

std::string Slic3r::BackgroundSlicingProcess::m_temp_output_path

private

Referenced by BackgroundSlicingProcess(), export_gcode(), finalize_gcode(), prepare_upload(), and process_fff().

m_thread

boost::thread Slic3r::BackgroundSlicingProcess::m_thread

private

Referenced by join_background_thread(), and start().

m_thumbnail_cb

ThumbnailsGeneratorCallback Slic3r::BackgroundSlicingProcess::m_thumbnail_cb = nullptr

private

Referenced by render_thumbnails(), and set_thumbnail_cb().

m_ui_task

std::shared_ptr<UITask> Slic3r::BackgroundSlicingProcess::m_ui_task

private

Referenced by execute_ui_task(), stop(), and stop_internal().

m_upload_job

PrintHostJob Slic3r::BackgroundSlicingProcess::m_upload_job

private

Referenced by is_upload_scheduled(), prepare_upload(), process_fff(), and schedule_upload().

---

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

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