3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-10-26 18:21:18 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Add dedicated subclass NotificationProgressIndicator

Browse source 
to replace ProgressStatusBar and revert changes from b9dab754, keep UI jobs untouched
This commit is contained in:
tamasmeszaros 2021-09-21 12:34:40 +02:00
parent 7e3306c68f
commit 63647f594e
16 changed files with 161 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/slic3r/GUI/Jobs/ArrangeJob.hpp
View file

@ -9,7 +9,6 @@ namespace Slic3r {
class ModelInstance;
namespace GUI {
class NotificationManager;
class ArrangeJob : public PlaterJob
{
@ -18,21 +17,21 @@ class ArrangeJob : public PlaterJob
ArrangePolygons m_selected, m_unselected, m_unprintable;
std::vector<ModelInstance*> m_unarranged;
// clear m_selected and m_unselected, reserve space for next usage
void clear_input();
// Prepare all objects on the bed regardless of the selection
void prepare_all();
// Prepare the selected and unselected items separately. If nothing is
// selected, behaves as if everything would be selected.
void prepare_selected();
ArrangePolygon get_arrange_poly_(ModelInstance *mi);
protected:
void prepare() override;
void on_exception(const std::exception_ptr &) override;
@ -40,15 +39,15 @@ protected:
void process() override;
public:
ArrangeJob(std::shared_ptr<NotificationManager> nm, Plater *plater)
: PlaterJob{nm, plater}
ArrangeJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater)
: PlaterJob{std::move(pri), plater}
{}
int status_range() const override
{
return int(m_selected.size() + m_unprintable.size());
}
void finalize() override;
};

5
src/slic3r/GUI/Jobs/FillBedJob.hpp
View file

@ -6,7 +6,6 @@
namespace Slic3r { namespace GUI {
class Plater;
class NotificationManager;
class FillBedJob : public PlaterJob
{
@ -28,8 +27,8 @@ protected:
void process() override;
public:
FillBedJob(std::shared_ptr<NotificationManager> nm, Plater *plater)
: PlaterJob{nm, plater}
FillBedJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater)
: PlaterJob{std::move(pri), plater}
{}
int status_range() const override

48
src/slic3r/GUI/Jobs/Job.cpp
View file

@ -2,11 +2,9 @@
#include <exception>
#include "Job.hpp"
#include "../NotificationManager.hpp"
#include <libslic3r/Thread.hpp>
#include <boost/log/trivial.hpp>
namespace Slic3r {
void GUI::Job::run(std::exception_ptr &eptr)
@ -19,7 +17,7 @@ void GUI::Job::run(std::exception_ptr &eptr)
}
m_running.store(false);
// ensure to call the last status to finalize the job
update_status(status_range(), "");
}
@ -32,8 +30,8 @@ void GUI::Job::update_status(int st, const wxString &msg)
wxQueueEvent(this, evt);
}
GUI::Job::Job(std::shared_ptr<NotificationManager> nm)
: m_notifications(nm)
GUI::Job::Job(std::shared_ptr<ProgressIndicator> pri)
: m_progress(std::move(pri))
{
m_thread_evt_id = wxNewId();
@ -42,21 +40,21 @@ GUI::Job::Job(std::shared_ptr<NotificationManager> nm)
auto msg = evt.GetString();
if (!msg.empty() && !m_worker_error)
m_notifications->progress_indicator_set_status_text(msg.ToUTF8().data());
m_progress->set_status_text(msg.ToUTF8().data());
if (m_finalized) return;
m_notifications->progress_indicator_set_progress(evt.GetInt());
m_progress->set_progress(evt.GetInt());
if (evt.GetInt() == status_range() || m_worker_error) {
// set back the original range and cancel callback
m_notifications->progress_indicator_set_range(m_range);
m_notifications->progress_indicator_set_cancel_callback();
m_progress->set_range(m_range);
m_progress->set_cancel_callback();
wxEndBusyCursor();
if (m_worker_error) {
m_finalized = true;
m_notifications->progress_indicator_set_status_text("");
m_notifications->progress_indicator_set_progress(m_range);
m_progress->set_status_text("");
m_progress->set_progress(m_range);
on_exception(m_worker_error);
}
else {
@ -86,22 +84,22 @@ void GUI::Job::start()
{ // Start the job. No effect if the job is already running
if (!m_running.load()) {
prepare();
// Save the current status indicatior range and push the new one
m_range = m_notifications->progress_indicator_get_range();
m_notifications->progress_indicator_set_range(status_range());
m_range = m_progress->get_range();
m_progress->set_range(status_range());
// init cancellation flag and set the cancel callback
m_canceled.store(false);
m_notifications->progress_indicator_set_cancel_callback(
m_progress->set_cancel_callback(
[this]() { m_canceled.store(true); });
m_finalized = false;
m_finalizing = false;
// Changing cursor to busy
wxBeginBusyCursor();
try { // Execute the job
m_worker_error = nullptr;
m_thread = create_thread([this] { this->run(m_worker_error); });
@ -110,7 +108,7 @@ void GUI::Job::start()
_(L("ERROR: not enough resources to "
"execute a new job.")));
}
// The state changes will be undone when the process hits the
// last status value, in the status update handler (see ctor)
}
@ -119,12 +117,12 @@ void GUI::Job::start()
bool GUI::Job::join(int timeout_ms)
{
if (!m_thread.joinable()) return true;
if (timeout_ms <= 0)
m_thread.join();
else if (!m_thread.try_join_for(boost::chrono::milliseconds(timeout_ms)))
return false;
return true;
}
@ -137,10 +135,10 @@ void GUI::ExclusiveJobGroup::start(size_t jid) {
void GUI::ExclusiveJobGroup::join_all(int wait_ms)
{
std::vector<bool> aborted(m_jobs.size(), false);
for (size_t jid = 0; jid < m_jobs.size(); ++jid)
aborted[jid] = m_jobs[jid]->join(wait_ms);
if (!std::all_of(aborted.begin(), aborted.end(), [](bool t) { return t; }))
BOOST_LOG_TRIVIAL(error) << "Could not abort a job!";
}

7
src/slic3r/GUI/Jobs/Job.hpp
View file

@ -8,13 +8,14 @@
#include <slic3r/GUI/I18N.hpp>
#include "ProgressIndicator.hpp"
#include <wx/event.h>
#include <boost/thread.hpp>
namespace Slic3r { namespace GUI {
class NotificationManager;
// 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
@ -32,7 +33,7 @@ class Job : public wxEvtHandler
boost::thread m_thread;
std::atomic<bool> m_running{false}, m_canceled{false};
bool m_finalized = false, m_finalizing = false;
std::shared_ptr<NotificationManager> m_notifications;
std::shared_ptr<ProgressIndicator> m_progress;
std::exception_ptr m_worker_error = nullptr;
void run(std::exception_ptr &);
@ -64,7 +65,7 @@ protected:
}
public:
Job(std::shared_ptr<NotificationManager> nm);
Job(std::shared_ptr<ProgressIndicator> pri);
bool is_finalized() const { return m_finalized; }

33
src/slic3r/GUI/Jobs/NotificationProgressIndicator.cpp Normal file
View file

@ -0,0 +1,33 @@
#include "NotificationProgressIndicator.hpp"
#include "slic3r/GUI/NotificationManager.hpp"
namespace Slic3r { namespace GUI {
NotificationProgressIndicator::NotificationProgressIndicator(NotificationManager *nm): m_nm{nm} {}
void NotificationProgressIndicator::set_range(int range)
{
m_nm->progress_indicator_set_range(range);
}
void NotificationProgressIndicator::set_cancel_callback(CancelFn fn)
{
m_nm->progress_indicator_set_cancel_callback(std::move(fn));
}
void NotificationProgressIndicator::set_progress(int pr)
{
m_nm->progress_indicator_set_progress(pr);
}
void NotificationProgressIndicator::set_status_text(const char *msg)
{
m_nm->progress_indicator_set_status_text(msg);
}
int NotificationProgressIndicator::get_range() const
{
return m_nm->progress_indicator_get_range();
}
}} // namespace Slic3r::GUI

26
src/slic3r/GUI/Jobs/NotificationProgressIndicator.hpp Normal file
View file

@ -0,0 +1,26 @@
#ifndef NOTIFICATIONPROGRESSINDICATOR_HPP
#define NOTIFICATIONPROGRESSINDICATOR_HPP
#include "ProgressIndicator.hpp"
namespace Slic3r { namespace GUI {
class NotificationManager;
class NotificationProgressIndicator: public ProgressIndicator {
NotificationManager *m_nm = nullptr;
public:
explicit NotificationProgressIndicator(NotificationManager *nm);
void set_range(int range) override;
void set_cancel_callback(CancelFn = CancelFn()) override;
void set_progress(int pr) override;
void set_status_text(const char *) override; // utf8 char array
int get_range() const override;
};
}} // namespace Slic3r::GUI
#endif // NOTIFICATIONPROGRESSINDICATOR_HPP

5
src/slic3r/GUI/Jobs/PlaterJob.hpp
View file

@ -6,7 +6,6 @@
namespace Slic3r { namespace GUI {
class Plater;
class NotificationManager;
class PlaterJob : public Job {
protected:
@ -16,8 +15,8 @@ protected:
public:
PlaterJob(std::shared_ptr<NotificationManager> nm, Plater *plater):
Job{nm}, m_plater{plater} {}
PlaterJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater):
Job{std::move(pri)}, m_plater{plater} {}
};
}} // namespace Slic3r::GUI

6
src/slic3r/GUI/Jobs/RotoptimizeJob.hpp
View file

@ -10,8 +10,6 @@ namespace Slic3r {
namespace GUI {
class NotificationManager;
class RotoptimizeJob : public PlaterJob
{
using FindFn = std::function<Vec2d(const ModelObject & mo,
@ -54,8 +52,8 @@ protected:
public:
RotoptimizeJob(std::shared_ptr<NotificationManager> nm, Plater *plater)
: PlaterJob{nm, plater}
RotoptimizeJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater)
: PlaterJob{std::move(pri), plater}
{}
void finalize() override;

65
src/slic3r/GUI/Jobs/SLAImportJob.cpp
View file

@ -6,7 +6,6 @@
#include "slic3r/GUI/GUI_App.hpp"
#include "slic3r/GUI/Plater.hpp"
#include "slic3r/GUI/GUI_ObjectList.hpp"
#include "slic3r/GUI/NotificationManager.hpp"
#include "libslic3r/Model.hpp"
#include "libslic3r/PresetBundle.hpp"
@ -20,79 +19,79 @@
namespace Slic3r { namespace GUI {
enum class Sel { modelAndProfile, profileOnly, modelOnly};
class ImportDlg: public wxDialog {
wxFilePickerCtrl *m_filepicker;
wxComboBox *m_import_dropdown, *m_quality_dropdown;
public:
ImportDlg(Plater *plater)
: wxDialog{plater, wxID_ANY, "Import SLA archive"}
{
auto szvert = new wxBoxSizer{wxVERTICAL};
auto szfilepck = new wxBoxSizer{wxHORIZONTAL};
m_filepicker = new wxFilePickerCtrl(this, wxID_ANY,
from_u8(wxGetApp().app_config->get_last_dir()), _(L("Choose SLA archive:")),
"SL1 / SL1S archive files (*.sl1, *.sl1s, *.zip)|*.sl1;*.SL1;*.sl1s;*.SL1S;*.zip;*.ZIP",
wxDefaultPosition, wxDefaultSize, wxFLP_DEFAULT_STYLE | wxFD_OPEN | wxFD_FILE_MUST_EXIST);
szfilepck->Add(new wxStaticText(this, wxID_ANY, _L("Import file") + ": "), 0, wxALIGN_CENTER);
szfilepck->Add(m_filepicker, 1);
szvert->Add(szfilepck, 0, wxALL | wxEXPAND, 5);
auto szchoices = new wxBoxSizer{wxHORIZONTAL};
static const std::vector<wxString> inp_choices = {
_(L("Import model and profile")),
_(L("Import profile only")),
_(L("Import model only"))
};
m_import_dropdown = new wxComboBox(
this, wxID_ANY, inp_choices[0], wxDefaultPosition, wxDefaultSize,
inp_choices.size(), inp_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
szchoices->Add(m_import_dropdown);
szchoices->Add(new wxStaticText(this, wxID_ANY, _L("Quality") + ": "), 0, wxALIGN_CENTER | wxALL, 5);
static const std::vector<wxString> qual_choices = {
_(L("Accurate")),
_(L("Balanced")),
_(L("Quick"))
};
m_quality_dropdown = new wxComboBox(
this, wxID_ANY, qual_choices[0], wxDefaultPosition, wxDefaultSize,
qual_choices.size(), qual_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
szchoices->Add(m_quality_dropdown);
m_import_dropdown->Bind(wxEVT_COMBOBOX, [this](wxCommandEvent &) {
if (get_selection() == Sel::profileOnly)
m_quality_dropdown->Disable();
else m_quality_dropdown->Enable();
});
szvert->Add(szchoices, 0, wxALL, 5);
szvert->AddStretchSpacer(1);
auto szbtn = new wxBoxSizer(wxHORIZONTAL);
szbtn->Add(new wxButton{this, wxID_CANCEL});
szbtn->Add(new wxButton{this, wxID_OK});
szvert->Add(szbtn, 0, wxALIGN_RIGHT | wxALL, 5);
SetSizerAndFit(szvert);
}
Sel get_selection() const
{
int sel = m_import_dropdown->GetSelection();
return Sel(std::min(int(Sel::modelOnly), std::max(0, sel)));
}
Vec2i get_marchsq_windowsize() const
{
enum { Accurate, Balanced, Fast};
switch(m_quality_dropdown->GetSelection())
{
case Fast: return {8, 8};
@ -102,7 +101,7 @@ public:
return {2, 2};
}
}
wxString get_path() const
{
return m_filepicker->GetPath();
@ -112,7 +111,7 @@ public:
class SLAImportJob::priv {
public:
Plater *plater;
Sel sel = Sel::modelAndProfile;
indexed_triangle_set mesh;
@ -125,8 +124,8 @@ public:
priv(Plater *plt) : plater{plt} {}
};
SLAImportJob::SLAImportJob(std::shared_ptr<NotificationManager> nm, Plater *plater)
: PlaterJob{nm, plater}, p{std::make_unique<priv>(plater)}
SLAImportJob::SLAImportJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater)
: PlaterJob{std::move(pri), plater}, p{std::make_unique<priv>(plater)}
{}
SLAImportJob::~SLAImportJob() = default;
@ -138,9 +137,9 @@ void SLAImportJob::process()
update_status(int(s), _(L("Importing SLA archive")));
return !was_canceled();
};
if (p->path.empty()) return;
std::string path = p->path.ToUTF8().data();
try {
switch (p->sel) {
@ -154,11 +153,11 @@ void SLAImportJob::process()
p->config_substitutions = import_sla_archive(path, p->profile);
break;
}
} catch (std::exception &ex) {
p->err = ex.what();
}
update_status(100, was_canceled() ? _(L("Importing canceled.")) :
_(L("Importing done.")));
}
@ -175,9 +174,9 @@ void SLAImportJob::reset()
void SLAImportJob::prepare()
{
reset();
ImportDlg dlg{p->plater};
if (dlg.ShowModal() == wxID_OK) {
auto path = dlg.get_path();
auto nm = wxFileName(path);
@ -194,15 +193,15 @@ void SLAImportJob::finalize()
{
// Ignore the arrange result if aborted.
if (was_canceled()) return;
if (!p->err.empty()) {
show_error(p->plater, p->err);
p->err = "";
return;
}
std::string name = wxFileName(p->path).GetName().ToUTF8().data();
if (!p->profile.empty()) {
const ModelObjectPtrs& objects = p->plater->model().objects;
for (auto object : objects)
@ -214,15 +213,15 @@ void SLAImportJob::finalize()
_(L("Attention!")) );
return;
}
DynamicPrintConfig config = {};
config.apply(SLAFullPrintConfig::defaults());
config += std::move(p->profile);
wxGetApp().preset_bundle->load_config_model(name, std::move(config));
wxGetApp().load_current_presets();
}
if (!p->mesh.empty()) {
bool is_centered = false;
p->plater->sidebar().obj_list()->load_mesh_object(TriangleMesh{p->mesh},

8
src/slic3r/GUI/Jobs/SLAImportJob.hpp
View file

@ -5,20 +5,18 @@
namespace Slic3r { namespace GUI {
class NotificationManager;
class SLAImportJob : public PlaterJob {
class priv;
std::unique_ptr<priv> p;
protected:
void prepare() override;
void process() override;
void finalize() override;
public:
SLAImportJob(std::shared_ptr<NotificationManager> nm, Plater *plater);
SLAImportJob(std::shared_ptr<ProgressIndicator> pri, Plater *plater);
~SLAImportJob();
void reset();