WIP Refactoring of exceptions:

1) All slicer's exceptions are now derived from Slic3r::Exception.
2) New exceptions are defined for slicing errors.
3) Exceptions are propagated to the Plater to show.
It remains to modify the slicing back-end to throw the new SlicingError
exceptions instead of std::runtime_error and to show the other exceptions
by a message dialog instead of a notification.

src/slic3r/Config/Snapshot.cpp

@@ -315,7 +315,7 @@ size_t SnapshotDB::load_db()
     // Sort the snapshots by their date/time.
     std::sort(m_snapshots.begin(), m_snapshots.end(), [](const Snapshot &s1, const Snapshot &s2) { return s1.time_captured < s2.time_captured; });
     if (! errors_cummulative.empty())
-        throw std::runtime_error(errors_cummulative);
+        throw Slic3r::RuntimeError(errors_cummulative);
     return m_snapshots.size();
 }
 
@@ -339,7 +339,7 @@ static void copy_config_dir_single_level(const boost::filesystem::path &path_src
 {
     if (! boost::filesystem::is_directory(path_dst) && 
         ! boost::filesystem::create_directory(path_dst))
-        throw std::runtime_error(std::string("Slic3r was unable to create a directory at ") + path_dst.string());
+        throw Slic3r::RuntimeError(std::string("Slic3r was unable to create a directory at ") + path_dst.string());
 
     for (auto &dir_entry : boost::filesystem::directory_iterator(path_src))
         if (Slic3r::is_ini_file(dir_entry))
@@ -429,7 +429,7 @@ const Snapshot& SnapshotDB::restore_snapshot(const std::string &id, AppConfig &a
 			this->restore_snapshot(snapshot, app_config);
 			return snapshot;
 		}
-	throw std::runtime_error(std::string("Snapshot with id " + id + " was not found."));
+	throw Slic3r::RuntimeError(std::string("Snapshot with id " + id + " was not found."));
 }
 
 void SnapshotDB::restore_snapshot(const Snapshot &snapshot, AppConfig &app_config)
@@ -501,7 +501,7 @@ boost::filesystem::path SnapshotDB::create_db_dir()
         subdir.make_preferred();
         if (! boost::filesystem::is_directory(subdir) && 
             ! boost::filesystem::create_directory(subdir))
-            throw std::runtime_error(std::string("Slic3r was unable to create a directory at ") + subdir.string());
+            throw Slic3r::RuntimeError(std::string("Slic3r was unable to create a directory at ") + subdir.string());
     }
     return snapshots_dir;
 }

src/slic3r/Config/Version.cpp

@@ -324,7 +324,7 @@ std::vector<Index> Index::load_db()
         }
 
     if (! errors_cummulative.empty())
-        throw std::runtime_error(errors_cummulative);
+        throw Slic3r::RuntimeError(errors_cummulative);
     return index_db;
 }
 

src/slic3r/GUI/3DScene.cpp

@@ -1926,7 +1926,7 @@ void _3DScene::extrusionentity_to_verts(const ExtrusionEntity *extrusion_entity,
                     if (extrusion_entity_collection != nullptr)
                         extrusionentity_to_verts(*extrusion_entity_collection, print_z, copy, volume);
                     else {
-                        throw std::runtime_error("Unexpected extrusion_entity type in to_verts()");
+                        throw Slic3r::RuntimeError("Unexpected extrusion_entity type in to_verts()");
                     }
                 }
             }

src/slic3r/GUI/BackgroundSlicingProcess.cpp

@@ -41,6 +41,36 @@
 
 namespace Slic3r {
 
+bool SlicingProcessCompletedEvent::critical_error() const
+{
+	try {
+		this->rethrow_exception();
+	} catch (const Slic3r::SlicingError &ex) {
+		// Exception derived from SlicingError is non-critical.
+		return false;
+	} catch (...) {
+		return true;
+	}
+}
+
+std::string SlicingProcessCompletedEvent::format_error_message() const
+{
+	std::string error;
+	try {
+		this->rethrow_exception();
+    } catch (const std::bad_alloc& ex) {
+        wxString errmsg = GUI::from_u8((boost::format(_utf8(L("%s has encountered an error. It was likely caused by running out of memory. "
+                              "If you are sure you have enough RAM on your system, this may also be a bug and we would "
+                              "be glad if you reported it."))) % SLIC3R_APP_NAME).str());
+        error = std::string(errmsg.ToUTF8()) + "\n\n" + std::string(ex.what());
+    } catch (std::exception &ex) {
+		error = ex.what();
+	} catch (...) {
+		error = "Unknown C++ exception.";
+	}
+	return error;
+}
+
 BackgroundSlicingProcess::BackgroundSlicingProcess()
 {
     boost::filesystem::path temp_path(wxStandardPaths::Get().GetTempDir().utf8_str().data());
@@ -109,19 +139,19 @@ void BackgroundSlicingProcess::process_fff()
 			switch (copy_ret_val) {
 			case SUCCESS: break; // no error
 			case FAIL_COPY_FILE:
-				throw std::runtime_error(_utf8(L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?")));
+				throw Slic3r::RuntimeError(_utf8(L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?")));
 				break;
 			case FAIL_FILES_DIFFERENT: 
-				throw std::runtime_error((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());
+				throw Slic3r::RuntimeError((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 FAIL_RENAMING: 
-				throw std::runtime_error((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()); 
+				throw Slic3r::RuntimeError((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 FAIL_CHECK_ORIGIN_NOT_OPENED: 
-				throw std::runtime_error((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."))) % m_temp_output_path % export_path).str());
+				throw Slic3r::RuntimeError((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."))) % m_temp_output_path % export_path).str());
 				break;
 			case FAIL_CHECK_TARGET_NOT_OPENED: 
-				throw std::runtime_error((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()); 
+				throw Slic3r::RuntimeError((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(warning) << "Unexpected fail code(" << (int)copy_ret_val << ") durring copy_file() to " << export_path << ".";
@@ -210,7 +240,7 @@ void BackgroundSlicingProcess::thread_proc()
 		// Process the background slicing task.
 		m_state = STATE_RUNNING;
 		lck.unlock();
-		std::string error;
+		std::exception_ptr exception;
 		try {
 			assert(m_print != nullptr);
 			switch(m_print->technology()) {
@@ -221,15 +251,8 @@ void BackgroundSlicingProcess::thread_proc()
 		} catch (CanceledException & /* ex */) {
 			// Canceled, this is all right.
 			assert(m_print->canceled());
-        } catch (const std::bad_alloc& ex) {
-            wxString errmsg = GUI::from_u8((boost::format(_utf8(L("%s has encountered an error. It was likely caused by running out of memory. "
-                                  "If you are sure you have enough RAM on your system, this may also be a bug and we would "
-                                  "be glad if you reported it."))) % SLIC3R_APP_NAME).str());
-            error = std::string(errmsg.ToUTF8()) + "\n\n" + std::string(ex.what());
-        } catch (std::exception &ex) {
-			error = ex.what();
 		} catch (...) {
-			error = "Unknown C++ exception.";
+			exception = std::current_exception();
 		}
 		m_print->finalize();
 		lck.lock();
@@ -237,9 +260,9 @@ void BackgroundSlicingProcess::thread_proc()
 		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().
-			wxCommandEvent evt(m_event_finished_id);
-            evt.SetString(GUI::from_u8(error));
-			evt.SetInt(m_print->canceled() ? -1 : (error.empty() ? 1 : 0));
+			SlicingProcessCompletedEvent evt(m_event_finished_id, 0, 
+				(m_state == STATE_CANCELED) ? SlicingProcessCompletedEvent::Cancelled :
+				exception ? SlicingProcessCompletedEvent::Error : SlicingProcessCompletedEvent::Finished, exception);
         	wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
         }
 	    m_print->restart();
@@ -299,7 +322,7 @@ bool BackgroundSlicingProcess::start()
 		// The background processing thread is already running.
 		return false;
 	if (! this->idle())
-		throw std::runtime_error("Cannot start a background task, the worker thread is not 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();
@@ -494,7 +517,7 @@ void BackgroundSlicingProcess::prepare_upload()
 	if (m_print == m_fff_print) {
 		m_print->set_status(95, _utf8(L("Running post-processing scripts")));
 		if (copy_file(m_temp_output_path, source_path.string()) != SUCCESS) {
-			throw std::runtime_error(_utf8(L("Copying of the temporary G-code to the output G-code failed")));
+			throw Slic3r::RuntimeError(_utf8(L("Copying of the temporary G-code to the output G-code failed")));
 		}
 		run_post_process_scripts(source_path.string(), m_fff_print->config());
         m_upload_job.upload_data.upload_path = m_fff_print->print_statistics().finalize_output_path(m_upload_job.upload_data.upload_path.string());

src/slic3r/GUI/BackgroundSlicingProcess.hpp

@@ -37,6 +37,36 @@ public:
 	PrintBase::SlicingStatus status;
 };
 
+class SlicingProcessCompletedEvent : public wxEvent
+{
+public:
+	enum StatusType {
+		Finished,
+		Cancelled,
+		Error
+	};
+
+	SlicingProcessCompletedEvent(wxEventType eventType, int winid, StatusType status, std::exception_ptr exception) :
+		wxEvent(winid, eventType), m_status(status), m_exception(exception) {}
+	virtual wxEvent* Clone() const { return new SlicingProcessCompletedEvent(*this); }
+
+	StatusType 	status()    const { return m_status; }
+	bool 		finished()  const { return m_status == Finished; }
+	bool 		success()   const { return m_status == Finished; }
+	bool 		cancelled() const { return m_status == Cancelled; }
+	bool		error() 	const { return m_status == Error; }
+	// Unhandled error produced by stdlib or a Win32 structured exception, or unhandled Slic3r's own critical exception.
+	bool 		critical_error() const;
+	// Only valid if error()
+	void 		rethrow_exception() const { assert(this->error()); assert(m_exception); std::rethrow_exception(m_exception); }
+	// Produce a human readable message to be displayed by a notification or a message box.
+	std::string format_error_message() const;
+
+private:
+	StatusType 			m_status;
+	std::exception_ptr 	m_exception;
+};
+
 wxDEFINE_EVENT(EVT_SLICING_UPDATE, SlicingStatusEvent);
 
 // Print step IDs for keeping track of the print state.

src/slic3r/GUI/ConfigExceptions.hpp

@@ -1,15 +1,15 @@
 #include <exception> 
 namespace Slic3r {
 
-class ConfigError : public std::runtime_error { 
-using std::runtime_error::runtime_error;
+class ConfigError : public Slic3r::RuntimeError { 
+	using Slic3r::RuntimeError::RuntimeError;
 };
 
 namespace GUI {
 
 class ConfigGUITypeError : public ConfigError { 
-using ConfigError::ConfigError;
+	using ConfigError::ConfigError;
 };
-}
 
-}
+} // namespace GUI
+} // namespace Slic3r

src/slic3r/GUI/ConfigWizard.cpp

@@ -123,7 +123,7 @@ Bundle& BundleMap::prusa_bundle()
 {
     auto it = find(PresetBundle::PRUSA_BUNDLE);
     if (it == end()) {
-        throw std::runtime_error("ConfigWizard: Internal error in BundleMap: PRUSA_BUNDLE not loaded");
+        throw Slic3r::RuntimeError("ConfigWizard: Internal error in BundleMap: PRUSA_BUNDLE not loaded");
     }
 
     return it->second;

src/slic3r/GUI/FirmwareDialog.cpp

@@ -766,7 +766,7 @@ const char* FirmwareDialog::priv::avr109_dev_name(Avr109Pid usb_pid) {
 			return "Original Prusa CW1";
 		break;
 
-		default: throw std::runtime_error((boost::format("Invalid avr109 device USB PID: %1%") % usb_pid.boot).str());
+		default: throw Slic3r::RuntimeError((boost::format("Invalid avr109 device USB PID: %1%") % usb_pid.boot).str());
 	}
 }
 

src/slic3r/GUI/GUI_App.cpp

@@ -571,7 +571,7 @@ void GUI_App::init_app_config()
         std::string error = app_config->load();
         if (!error.empty())
             // Error while parsing config file. We'll customize the error message and rethrow to be displayed.
-            throw std::runtime_error(
+            throw Slic3r::RuntimeError(
                 _u8L("Error parsing PrusaSlicer config file, it is probably corrupted. "
                     "Try to manually delete the file to recover from the error. Your user profiles will not be affected.") +
                 "\n\n" + AppConfig::config_path() + "\n\n" + error);

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -927,7 +927,7 @@ void ImGuiWrapper::init_font(bool compress)
     if (font == nullptr) {
         font = io.Fonts->AddFontDefault();
         if (font == nullptr) {
-            throw std::runtime_error("ImGui: Could not load deafult font");
+            throw Slic3r::RuntimeError("ImGui: Could not load deafult font");
         }
     }
 

src/slic3r/GUI/OptionsGroup.cpp

@@ -7,6 +7,7 @@
 #include <wx/numformatter.h>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
+#include "libslic3r/Exception.hpp"
 #include "libslic3r/Utils.hpp"
 #include "I18N.hpp"
 
@@ -64,7 +65,7 @@ const t_field& OptionsGroup::build_field(const t_config_option_key& id, const Co
 				break;
             case coNone:   break;
             default:
-				throw /*//!ConfigGUITypeError("")*/std::logic_error("This control doesn't exist till now"); break;
+				throw Slic3r::LogicError("This control doesn't exist till now"); break;
         }
     }
     // Grab a reference to fields for convenience
@@ -620,7 +621,7 @@ boost::any ConfigOptionsGroup::config_value(const std::string& opt_key, int opt_
 		// Aggregate the strings the old way.
 		// Currently used for the post_process config value only.
 		if (opt_index != -1)
-			throw std::out_of_range("Can't deserialize option indexed value");
+			throw Slic3r::OutOfRange("Can't deserialize option indexed value");
 // 		return join(';', m_config->get(opt_key)});
 		return get_config_value(*m_config, opt_key);
 	}

src/slic3r/GUI/Plater.cpp

@@ -107,7 +107,7 @@ namespace GUI {
 wxDEFINE_EVENT(EVT_SCHEDULE_BACKGROUND_PROCESS,     SimpleEvent);
 wxDEFINE_EVENT(EVT_SLICING_UPDATE,                  SlicingStatusEvent);
 wxDEFINE_EVENT(EVT_SLICING_COMPLETED,               wxCommandEvent);
-wxDEFINE_EVENT(EVT_PROCESS_COMPLETED,               wxCommandEvent);
+wxDEFINE_EVENT(EVT_PROCESS_COMPLETED,               SlicingProcessCompletedEvent);
 wxDEFINE_EVENT(EVT_EXPORT_BEGAN,                    wxCommandEvent);
 
 // Sidebar widgets
@@ -1682,7 +1682,7 @@ struct Plater::priv
     void on_select_preset(wxCommandEvent&);
     void on_slicing_update(SlicingStatusEvent&);
     void on_slicing_completed(wxCommandEvent&);
-    void on_process_completed(wxCommandEvent&);
+    void on_process_completed(SlicingProcessCompletedEvent&);
 	void on_export_began(wxCommandEvent&);
     void on_layer_editing_toggled(bool enable);
 	void on_slicing_began();
@@ -3510,7 +3510,7 @@ bool Plater::priv::warnings_dialog()
 	return res == wxID_OK;
 
 }
-void Plater::priv::on_process_completed(wxCommandEvent &evt)
+void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
 {
     // Stop the background task, wait until the thread goes into the "Idle" state.
     // At this point of time the thread should be either finished or canceled,
@@ -3519,27 +3519,23 @@ void Plater::priv::on_process_completed(wxCommandEvent &evt)
     this->statusbar()->reset_cancel_callback();
     this->statusbar()->stop_busy();
 
-    const bool canceled = evt.GetInt() < 0;
-    const bool error = evt.GetInt() == 0;
-    const bool success  = evt.GetInt() > 0;
     // Reset the "export G-code path" name, so that the automatic background processing will be enabled again.
     this->background_process.reset_export();
 
-    if (error) {
-        wxString message = evt.GetString();
-        if (message.IsEmpty())
-            message = _L("Export failed.");
-		notification_manager->push_slicing_error_notification(boost::nowide::narrow(message), *q->get_current_canvas3D());
-        this->statusbar()->set_status_text(message);
+    if (evt.error()) {
+        std::string message = evt.format_error_message();
+        //FIXME show a messagebox if evt.critical_error().
+		notification_manager->push_slicing_error_notification(message, *q->get_current_canvas3D());
+        this->statusbar()->set_status_text(from_u8(message));
 		const wxString invalid_str = _L("Invalid data");
 		for (auto btn : { ActionButtonType::abReslice, ActionButtonType::abSendGCode, ActionButtonType::abExport })
 			sidebar->set_btn_label(btn, invalid_str);
 		process_completed_with_error = true;
     }
-    if (canceled)
+    if (evt.cancelled())
         this->statusbar()->set_status_text(_L("Cancelled"));
 
-    this->sidebar->show_sliced_info_sizer(success);
+    this->sidebar->show_sliced_info_sizer(evt.success());
 
     // This updates the "Slice now", "Export G-code", "Arrange" buttons status.
     // Namely, it refreshes the "Out of print bed" property of all the ModelObjects, and it enables
@@ -3560,7 +3556,7 @@ void Plater::priv::on_process_completed(wxCommandEvent &evt)
     default: break;
     }
 	
-    if (canceled) {
+    if (evt.cancelled()) {
         if (wxGetApp().get_mode() == comSimple)
             sidebar->set_btn_label(ActionButtonType::abReslice, "Slice now");
         show_action_buttons(true);

src/slic3r/GUI/wxExtensions.cpp

@@ -436,7 +436,7 @@ wxBitmap create_scaled_bitmap(  const std::string& bmp_name_in,
 
     if (bmp == nullptr) {
         // Neither SVG nor PNG has been found, raise error
-        throw std::runtime_error("Could not load bitmap: " + bmp_name);
+        throw Slic3r::RuntimeError("Could not load bitmap: " + bmp_name);
     }
 
     return *bmp;

src/slic3r/Utils/FixModelByWin10.cpp

@@ -209,10 +209,10 @@ typedef std::function<void (const char * /* message */, unsigned /* progress */)
 void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path_dst, ProgressFn on_progress, ThrowOnCancelFn throw_on_cancel)
 {
 	if (! is_windows10())
-		throw std::runtime_error("fix_model_by_win10_sdk called on non Windows 10 system");
+		throw Slic3r::RuntimeError("fix_model_by_win10_sdk called on non Windows 10 system");
 
 	if (! winrt_load_runtime_object_library())
-		throw std::runtime_error("Failed to initialize the WinRT library.");
+		throw Slic3r::RuntimeError("Failed to initialize the WinRT library.");
 
 	HRESULT hr = (*s_RoInitialize)(RO_INIT_MULTITHREADED);
 	{
@@ -232,7 +232,7 @@ void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path
 		if (status == AsyncStatus::Completed)
 			hr = modelAsync->GetResults(model.GetAddressOf());
 		else
-			throw std::runtime_error(L("Failed loading the input model."));
+			throw Slic3r::RuntimeError(L("Failed loading the input model."));
 
 		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::Collections::IVector<ABI::Windows::Graphics::Printing3D::Printing3DMesh*>> meshes;
 		hr = model->get_Meshes(meshes.GetAddressOf());
@@ -245,7 +245,7 @@ void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path
 		hr = model->RepairAsync(repairAsync.GetAddressOf());
 		status = winrt_async_await(repairAsync, throw_on_cancel);
 		if (status != AsyncStatus::Completed)
-			throw std::runtime_error(L("Mesh repair failed."));
+			throw Slic3r::RuntimeError(L("Mesh repair failed."));
 		repairAsync->GetResults();
 
 		on_progress(L("Loading repaired model"), 60);
@@ -260,14 +260,14 @@ void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path
 		hr = printing3d3mfpackage->SaveModelToPackageAsync(model.Get(), saveToPackageAsync.GetAddressOf());
 		status = winrt_async_await(saveToPackageAsync, throw_on_cancel);
 		if (status != AsyncStatus::Completed)
-			throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+			throw Slic3r::RuntimeError(L("Saving mesh into the 3MF container failed."));
 		hr = saveToPackageAsync->GetResults();
 
 		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperation<ABI::Windows::Storage::Streams::IRandomAccessStream*>> generatorStreamAsync;
 		hr = printing3d3mfpackage->SaveAsync(generatorStreamAsync.GetAddressOf());
 		status = winrt_async_await(generatorStreamAsync, throw_on_cancel);
 		if (status != AsyncStatus::Completed)
-			throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+			throw Slic3r::RuntimeError(L("Saving mesh into the 3MF container failed."));
 		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IRandomAccessStream> generatorStream;
 		hr = generatorStreamAsync->GetResults(generatorStream.GetAddressOf());
 
@@ -299,7 +299,7 @@ void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path
 			hr = inputStream->ReadAsync(buffer.Get(), 65536 * 2048, ABI::Windows::Storage::Streams::InputStreamOptions_ReadAhead, asyncRead.GetAddressOf());
 			status = winrt_async_await(asyncRead, throw_on_cancel);
 			if (status != AsyncStatus::Completed)
-				throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+				throw Slic3r::RuntimeError(L("Saving mesh into the 3MF container failed."));
 			hr = buffer->get_Length(&length);
 			if (length == 0)
 				break;
@@ -365,7 +365,7 @@ void fix_model_by_win10_sdk_gui(ModelObject &model_object, int volume_idx)
 				model_object->add_instance();
 				if (!Slic3r::store_3mf(path_src.string().c_str(), &model, nullptr, false)) {
 					boost::filesystem::remove(path_src);
-					throw std::runtime_error(L("Export of a temporary 3mf file failed"));
+					throw Slic3r::RuntimeError(L("Export of a temporary 3mf file failed"));
 				}
 				model.clear_objects();
 				model.clear_materials();
@@ -380,15 +380,15 @@ void fix_model_by_win10_sdk_gui(ModelObject &model_object, int volume_idx)
 				bool loaded = Slic3r::load_3mf(path_dst.string().c_str(), &config, &model, false);
 			    boost::filesystem::remove(path_dst);
 				if (! loaded)
-	 				throw std::runtime_error(L("Import of the repaired 3mf file failed"));
+	 				throw Slic3r::RuntimeError(L("Import of the repaired 3mf file failed"));
 	 			if (model.objects.size() == 0)
-	 				throw std::runtime_error(L("Repaired 3MF file does not contain any object"));
+	 				throw Slic3r::RuntimeError(L("Repaired 3MF file does not contain any object"));
 	 			if (model.objects.size() > 1)
-	 				throw std::runtime_error(L("Repaired 3MF file contains more than one object"));
+	 				throw Slic3r::RuntimeError(L("Repaired 3MF file contains more than one object"));
 	 			if (model.objects.front()->volumes.size() == 0)
-	 				throw std::runtime_error(L("Repaired 3MF file does not contain any volume"));
+	 				throw Slic3r::RuntimeError(L("Repaired 3MF file does not contain any volume"));
 				if (model.objects.front()->volumes.size() > 1)
-	 				throw std::runtime_error(L("Repaired 3MF file contains more than one volume"));
+	 				throw Slic3r::RuntimeError(L("Repaired 3MF file contains more than one volume"));
 	 			meshes_repaired.emplace_back(std::move(model.objects.front()->volumes.front()->mesh()));
 			}
 			for (size_t i = 0; i < volumes.size(); ++ i) {

src/slic3r/Utils/Http.cpp

@@ -156,7 +156,7 @@ Http::priv::priv(const std::string &url)
     Http::tls_global_init();
     
 	if (curl == nullptr) {
-		throw std::runtime_error(std::string("Could not construct Curl object"));
+		throw Slic3r::RuntimeError(std::string("Could not construct Curl object"));
 	}
 
 	set_timeout_connect(DEFAULT_TIMEOUT_CONNECT);

src/slic3r/Utils/Serial.cpp

@@ -298,7 +298,7 @@ void Serial::set_baud_rate(unsigned baud_rate)
 
 		auto handle_errno = [](int retval) {
 			if (retval != 0) {
-				throw std::runtime_error(
+				throw Slic3r::RuntimeError(
 					(boost::format("Could not set baud rate: %1%") % strerror(errno)).str()
 				);
 			}
@@ -346,7 +346,7 @@ void Serial::set_baud_rate(unsigned baud_rate)
 		handle_errno(::cfsetspeed(&ios, baud_rate));
 		handle_errno(::tcsetattr(handle, TCSAFLUSH, &ios));
 #else
-		throw std::runtime_error("Custom baud rates are not currently supported on this OS");
+		throw Slic3r::RuntimeError("Custom baud rates are not currently supported on this OS");
 #endif
 	}
 }
@@ -358,7 +358,7 @@ void Serial::set_DTR(bool on)
 	auto handle = native_handle();
 #if defined(_WIN32) && !defined(__SYMBIAN32__)
 	if (! EscapeCommFunction(handle, on ? SETDTR : CLRDTR)) {
-		throw std::runtime_error("Could not set serial port DTR");
+		throw Slic3r::RuntimeError("Could not set serial port DTR");
 	}
 #else
 	int status;
@@ -369,7 +369,7 @@ void Serial::set_DTR(bool on)
 		}
 	}
 
-	throw std::runtime_error(
+	throw Slic3r::RuntimeError(
 		(boost::format("Could not set serial port DTR: %1%") % strerror(errno)).str()
 	);
 #endif

src/slic3r/Utils/UndoRedo.cpp

@@ -847,7 +847,7 @@ void StackImpl::load_snapshot(size_t timestamp, Slic3r::Model& model, Slic3r::GU
 	// Find the snapshot by time. It must exist.
 	const auto it_snapshot = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(timestamp));
 	if (it_snapshot == m_snapshots.end() || it_snapshot->timestamp != timestamp)
-		throw std::runtime_error((boost::format("Snapshot with timestamp %1% does not exist") % timestamp).str());
+		throw Slic3r::RuntimeError((boost::format("Snapshot with timestamp %1% does not exist") % timestamp).str());
 
 	m_active_snapshot_time = timestamp;
 	model.clear_objects();