110 lines
3.1 KiB
C++
110 lines
3.1 KiB
C++
#ifndef JOB_HPP
|
|
#define JOB_HPP
|
|
|
|
#include <atomic>
|
|
|
|
#include <slic3r/Utils/Thread.hpp>
|
|
#include <slic3r/GUI/I18N.hpp>
|
|
#include <slic3r/GUI/ProgressIndicator.hpp>
|
|
|
|
#include <wx/event.h>
|
|
|
|
#include <boost/thread.hpp>
|
|
|
|
namespace Slic3r { namespace GUI {
|
|
|
|
// A class to handle UI jobs like arranging and optimizing rotation.
|
|
// These are not instant jobs, the user has to be informed about their
|
|
// state in the status progress indicator. On the other hand they are
|
|
// separated from the background slicing process. Ideally, these jobs should
|
|
// run when the background process is not running.
|
|
//
|
|
// TODO: A mechanism would be useful for blocking the plater interactions:
|
|
// objects would be frozen for the user. In case of arrange, an animation
|
|
// could be shown, or with the optimize orientations, partial results
|
|
// could be displayed.
|
|
class Job : public wxEvtHandler
|
|
{
|
|
int m_range = 100;
|
|
boost::thread m_thread;
|
|
std::atomic<bool> m_running{false}, m_canceled{false};
|
|
bool m_finalized = false;
|
|
std::shared_ptr<ProgressIndicator> m_progress;
|
|
|
|
void run();
|
|
|
|
protected:
|
|
// status range for a particular job
|
|
virtual int status_range() const { return 100; }
|
|
|
|
// status update, to be used from the work thread (process() method)
|
|
void update_status(int st, const wxString &msg = "");
|
|
|
|
bool was_canceled() const { return m_canceled.load(); }
|
|
|
|
// Launched just before start(), a job can use it to prepare internals
|
|
virtual void prepare() {}
|
|
|
|
// Launched when the job is finished. It refreshes the 3Dscene by def.
|
|
virtual void finalize() { m_finalized = true; }
|
|
|
|
public:
|
|
Job(std::shared_ptr<ProgressIndicator> pri);
|
|
|
|
bool is_finalized() const { return m_finalized; }
|
|
|
|
Job(const Job &) = delete;
|
|
Job(Job &&) = delete;
|
|
Job &operator=(const Job &) = delete;
|
|
Job &operator=(Job &&) = delete;
|
|
|
|
virtual void process() = 0;
|
|
|
|
void start();
|
|
|
|
// To wait for the running job and join the threads. False is
|
|
// returned if the timeout has been reached and the job is still
|
|
// running. Call cancel() before this fn if you want to explicitly
|
|
// end the job.
|
|
bool join(int timeout_ms = 0);
|
|
|
|
bool is_running() const { return m_running.load(); }
|
|
void cancel() { m_canceled.store(true); }
|
|
};
|
|
|
|
// Jobs defined inside the group class will be managed so that only one can
|
|
// run at a time. Also, the background process will be stopped if a job is
|
|
// started.
|
|
class ExclusiveJobGroup
|
|
{
|
|
static const int ABORT_WAIT_MAX_MS = 10000;
|
|
|
|
std::vector<std::unique_ptr<GUI::Job>> m_jobs;
|
|
|
|
protected:
|
|
virtual void before_start() {}
|
|
|
|
public:
|
|
virtual ~ExclusiveJobGroup() = default;
|
|
|
|
size_t add_job(std::unique_ptr<GUI::Job> &&job)
|
|
{
|
|
m_jobs.emplace_back(std::move(job));
|
|
return m_jobs.size() - 1;
|
|
}
|
|
|
|
void start(size_t jid);
|
|
|
|
void cancel_all() { for (auto& j : m_jobs) j->cancel(); }
|
|
|
|
void join_all(int wait_ms = 0);
|
|
|
|
void stop_all() { cancel_all(); join_all(ABORT_WAIT_MAX_MS); }
|
|
|
|
bool is_any_running() const;
|
|
};
|
|
|
|
}} // namespace Slic3r::GUI
|
|
|
|
#endif // JOB_HPP
|