|
|
@@ -0,0 +1,495 @@
|
|
|
+#include "GUI_App.hpp"
|
|
|
+#include "InstanceCheck.hpp"
|
|
|
+
|
|
|
+#include "boost/nowide/convert.hpp"
|
|
|
+#include <boost/log/trivial.hpp>
|
|
|
+#include <iostream>
|
|
|
+
|
|
|
+#include <fcntl.h>
|
|
|
+#include <errno.h>
|
|
|
+
|
|
|
+#if __linux__
|
|
|
+#include <dbus/dbus.h> /* Pull in all of D-Bus headers. */
|
|
|
+#endif //__linux__
|
|
|
+
|
|
|
+namespace Slic3r {
|
|
|
+namespace instance_check_internal
|
|
|
+{
|
|
|
+ struct CommandLineAnalysis
|
|
|
+ {
|
|
|
+ bool should_send;
|
|
|
+ std::string cl_string;
|
|
|
+ };
|
|
|
+ static CommandLineAnalysis process_command_line(int argc, char** argv) //d:\3dmodels\Klapka\Klapka.3mf
|
|
|
+ {
|
|
|
+ CommandLineAnalysis ret { false };
|
|
|
+ if (argc < 2)
|
|
|
+ return ret;
|
|
|
+ ret.cl_string = argv[0];
|
|
|
+ for (size_t i = 1; i < argc; i++) {
|
|
|
+ std::string token = argv[i];
|
|
|
+ if (token == "--single-instance") {
|
|
|
+ ret.should_send = true;
|
|
|
+ } else {
|
|
|
+ ret.cl_string += " ";
|
|
|
+ ret.cl_string += token;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "single instance: "<< ret.should_send << ". other params: " << ret.cl_string;
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+} //namespace instance_check_internal
|
|
|
+
|
|
|
+#if _WIN32
|
|
|
+
|
|
|
+namespace instance_check_internal
|
|
|
+{
|
|
|
+ static HWND l_prusa_slicer_hwnd;
|
|
|
+ static BOOL CALLBACK EnumWindowsProc(_In_ HWND hwnd, _In_ LPARAM lParam)
|
|
|
+ {
|
|
|
+ //checks for other instances of prusaslicer, if found brings it to front and return false to stop enumeration and quit this instance
|
|
|
+ //search is done by classname(wxWindowNR is wxwidgets thing, so probably not unique) and name in window upper panel
|
|
|
+ //other option would be do a mutex and check for its existence
|
|
|
+ TCHAR wndText[1000];
|
|
|
+ TCHAR className[1000];
|
|
|
+ GetClassName(hwnd, className, 1000);
|
|
|
+ GetWindowText(hwnd, wndText, 1000);
|
|
|
+ std::wstring classNameString(className);
|
|
|
+ std::wstring wndTextString(wndText);
|
|
|
+ if (wndTextString.find(L"PrusaSlicer") != std::wstring::npos && classNameString == L"wxWindowNR") {
|
|
|
+ l_prusa_slicer_hwnd = hwnd;
|
|
|
+ ShowWindow(hwnd, SW_SHOWMAXIMIZED);
|
|
|
+ SetForegroundWindow(hwnd);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ static void send_message(const HWND hwnd)
|
|
|
+ {
|
|
|
+ LPWSTR command_line_args = GetCommandLine();
|
|
|
+ //Create a COPYDATASTRUCT to send the information
|
|
|
+ //cbData represents the size of the information we want to send.
|
|
|
+ //lpData represents the information we want to send.
|
|
|
+ //dwData is an ID defined by us(this is a type of ID different than WM_COPYDATA).
|
|
|
+ COPYDATASTRUCT data_to_send = { 0 };
|
|
|
+ data_to_send.dwData = 1;
|
|
|
+ data_to_send.cbData = sizeof(TCHAR) * (wcslen(command_line_args) + 1);
|
|
|
+ data_to_send.lpData = command_line_args;
|
|
|
+
|
|
|
+ SendMessage(hwnd, WM_COPYDATA, 0, (LPARAM)&data_to_send);
|
|
|
+ }
|
|
|
+} //namespace instance_check_internal
|
|
|
+
|
|
|
+bool instance_check(int argc, char** argv, bool app_config_single_instance)
|
|
|
+{
|
|
|
+ instance_check_internal::CommandLineAnalysis cla = instance_check_internal::process_command_line(argc, argv);
|
|
|
+ if (cla.should_send || app_config_single_instance) {
|
|
|
+ // Call EnumWidnows with own callback. cons: Based on text in the name of the window and class name which is generic.
|
|
|
+ if (!EnumWindows(instance_check_internal::EnumWindowsProc, 0)) {
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance found. This instance will terminate.";
|
|
|
+ instance_check_internal::send_message(instance_check_internal::l_prusa_slicer_hwnd);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance not found or single-instance not set.";
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+#elif defined(__APPLE__)
|
|
|
+
|
|
|
+namespace instance_check_internal
|
|
|
+{
|
|
|
+ static int get_lock()
|
|
|
+ {
|
|
|
+ struct flock fl;
|
|
|
+ int fdlock;
|
|
|
+ fl.l_type = F_WRLCK;
|
|
|
+ fl.l_whence = SEEK_SET;
|
|
|
+ fl.l_start = 0;
|
|
|
+ fl.l_len = 1;
|
|
|
+
|
|
|
+ if ((fdlock = open("/tmp/prusaslicer.lock", O_WRONLY | O_CREAT, 0666)) == -1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (fcntl(fdlock, F_SETLK, &fl) == -1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+} //namespace instance_check_internal
|
|
|
+
|
|
|
+bool instance_check(int argc, char** argv, bool app_config_single_instance)
|
|
|
+{
|
|
|
+ instance_check_internal::CommandLineAnalysis cla = instance_check_internal::process_command_line(argc, argv);
|
|
|
+ if (!instance_check_internal::get_lock() && (cla.should_send || app_config_single_instance)) {
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance found. This instance will terminate.";
|
|
|
+ send_message_mac(cla.cl_string);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance not found or single-instance not set.";
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+#elif defined(__linux__)
|
|
|
+
|
|
|
+namespace instance_check_internal
|
|
|
+{
|
|
|
+ static int get_lock()
|
|
|
+ {
|
|
|
+ struct flock fl;
|
|
|
+ int fdlock;
|
|
|
+ fl.l_type = F_WRLCK;
|
|
|
+ fl.l_whence = SEEK_SET;
|
|
|
+ fl.l_start = 0;
|
|
|
+ fl.l_len = 1;
|
|
|
+
|
|
|
+ if ((fdlock = open("/tmp/prusaslicer.lock", O_WRONLY | O_CREAT, 0666)) == -1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (fcntl(fdlock, F_SETLK, &fl) == -1)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ static void send_message(std::string message_text)
|
|
|
+ {
|
|
|
+ DBusMessage* msg;
|
|
|
+ DBusMessageIter args;
|
|
|
+ DBusConnection* conn;
|
|
|
+ DBusError err;
|
|
|
+ dbus_uint32_t serial = 0;
|
|
|
+ const char* sigval = message_text.c_str();
|
|
|
+ std::string interface_name = "com.prusa3d.prusaslicer.InstanceCheck";
|
|
|
+ std::string method_name = "AnotherInstace";
|
|
|
+ std::string object_name = "/com/prusa3d/prusaslicer/InstanceCheck";
|
|
|
+
|
|
|
+
|
|
|
+ // initialise the error value
|
|
|
+ dbus_error_init(&err);
|
|
|
+
|
|
|
+ // connect to bus, and check for errors (use SESSION bus everywhere!)
|
|
|
+ conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
|
|
|
+ if (dbus_error_is_set(&err)) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Connection Error. Message to another instance wont be send.";
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Connection Error: "<< err.message;
|
|
|
+ dbus_error_free(&err);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (NULL == conn) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Connection is NULL. Message to another instance wont be send.";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //some sources do request interface ownership before constructing msg but i think its wrong.
|
|
|
+
|
|
|
+ //create new method call message
|
|
|
+ msg = dbus_message_new_method_call(interface_name.c_str(), object_name.c_str(), interface_name.c_str(), method_name.c_str());
|
|
|
+ if (NULL == msg) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Message is NULL. Message to another instance wont be send.";
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ //the AnotherInstace method is not sending reply.
|
|
|
+ dbus_message_set_no_reply(msg, TRUE);
|
|
|
+
|
|
|
+ //append arguments to message
|
|
|
+ if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &sigval, DBUS_TYPE_INVALID)) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Ran out of memory while constructing args for DBus message. Message to another instance wont be send.";
|
|
|
+ dbus_message_unref(msg);
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // send the message and flush the connection
|
|
|
+ if (!dbus_connection_send(conn, msg, &serial)) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Ran out of memory while sending DBus message.";
|
|
|
+ dbus_message_unref(msg);
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ dbus_connection_flush(conn);
|
|
|
+
|
|
|
+ BOOST_LOG_TRIVIAL(trace) << "DBus message sent.";
|
|
|
+
|
|
|
+ // free the message and close the connection
|
|
|
+ dbus_message_unref(msg);
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ }
|
|
|
+} //namespace instance_check_internal
|
|
|
+
|
|
|
+bool instance_check(int argc, char** argv, bool app_config_single_instance)
|
|
|
+{
|
|
|
+ instance_check_internal::CommandLineAnalysis cla = instance_check_internal::process_command_line(argc, argv);
|
|
|
+ if (!instance_check_internal::get_lock() && (cla.should_send || app_config_single_instance)) {
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance found. This instance will terminate.";
|
|
|
+ instance_check_internal::send_message(cla.cl_string);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "instance check: Another instance not found or single-instance not set.";
|
|
|
+ return false;
|
|
|
+}
|
|
|
+#endif //_WIN32/__APPLE__/__linux__
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+namespace GUI {
|
|
|
+
|
|
|
+wxDEFINE_EVENT(EVT_LOAD_MODEL_OTHER_INSTANCE, LoadFromOtherInstanceEvent);
|
|
|
+wxDEFINE_EVENT(EVT_INSTANCE_GO_TO_FRONT, InstanceGoToFrontEvent);
|
|
|
+
|
|
|
+void OtherInstanceMessageHandler::init(wxEvtHandler* callback_evt_handler)
|
|
|
+{
|
|
|
+ assert(!m_initialized);
|
|
|
+ assert(m_callback_evt_handler == nullptr);
|
|
|
+ if (m_initialized)
|
|
|
+ return;
|
|
|
+
|
|
|
+ m_initialized = true;
|
|
|
+ m_callback_evt_handler = callback_evt_handler;
|
|
|
+
|
|
|
+#if _WIN32
|
|
|
+ //create_listener_window();
|
|
|
+#endif //_WIN32
|
|
|
+
|
|
|
+#if defined(__APPLE__)
|
|
|
+ this->register_for_messages();
|
|
|
+#endif //__APPLE__
|
|
|
+
|
|
|
+#ifdef BACKGROUND_MESSAGE_LISTENER
|
|
|
+ m_thread = boost::thread((boost::bind(&OtherInstanceMessageHandler::listen, this)));
|
|
|
+#endif //BACKGROUND_MESSAGE_LISTENER
|
|
|
+}
|
|
|
+void OtherInstanceMessageHandler::shutdown()
|
|
|
+{
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "message handler shutdown().";
|
|
|
+ assert(m_initialized);
|
|
|
+ if (m_initialized) {
|
|
|
+#if __APPLE__
|
|
|
+ //delete macos implementation
|
|
|
+ this->unregister_for_messages();
|
|
|
+#endif //__APPLE__
|
|
|
+#ifdef BACKGROUND_MESSAGE_LISTENER
|
|
|
+ if (m_thread.joinable()) {
|
|
|
+ // Stop the worker thread, if running.
|
|
|
+ {
|
|
|
+ // Notify the worker thread to cancel wait on detection polling.
|
|
|
+ std::lock_guard<std::mutex> lck(m_thread_stop_mutex);
|
|
|
+ m_stop = true;
|
|
|
+ }
|
|
|
+ m_thread_stop_condition.notify_all();
|
|
|
+ // Wait for the worker thread to stop.
|
|
|
+ m_thread.join();
|
|
|
+ m_stop = false;
|
|
|
+ }
|
|
|
+#endif //BACKGROUND_MESSAGE_LISTENER
|
|
|
+ m_initialized = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+namespace MessageHandlerInternal
|
|
|
+{
|
|
|
+ // returns ::path to possible model or empty ::path if input string is not existing path
|
|
|
+ static boost::filesystem::path get_path(const std::string possible_path)
|
|
|
+ {
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "message part: " << possible_path;
|
|
|
+
|
|
|
+ if (possible_path.empty() || possible_path.size() < 3) {
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "empty";
|
|
|
+ return boost::filesystem::path();
|
|
|
+ }
|
|
|
+ if (boost::filesystem::exists(possible_path)) {
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "is path";
|
|
|
+ return boost::filesystem::path(possible_path);
|
|
|
+ } else if (possible_path[0] == '\"') {
|
|
|
+ if(boost::filesystem::exists(possible_path.substr(1, possible_path.size() - 2))) {
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "is path in quotes";
|
|
|
+ return boost::filesystem::path(possible_path.substr(1, possible_path.size() - 2));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BOOST_LOG_TRIVIAL(debug) << "is NOT path";
|
|
|
+ return boost::filesystem::path();
|
|
|
+ }
|
|
|
+} //namespace MessageHandlerInternal
|
|
|
+
|
|
|
+void OtherInstanceMessageHandler::handle_message(const std::string message) {
|
|
|
+ std::vector<boost::filesystem::path> paths;
|
|
|
+ auto next_space = message.find(' ');
|
|
|
+ size_t last_space = 0;
|
|
|
+ int counter = 0;
|
|
|
+
|
|
|
+ BOOST_LOG_TRIVIAL(info) << "message from other instance: " << message;
|
|
|
+
|
|
|
+ while (next_space != std::string::npos)
|
|
|
+ {
|
|
|
+ if (counter != 0) {
|
|
|
+ const std::string possible_path = message.substr(last_space, next_space - last_space);
|
|
|
+ boost::filesystem::path p = MessageHandlerInternal::get_path(possible_path);
|
|
|
+ if(!p.string().empty())
|
|
|
+ paths.emplace_back(p);
|
|
|
+ }
|
|
|
+ last_space = next_space;
|
|
|
+ next_space = message.find(' ', last_space + 1);
|
|
|
+ counter++;
|
|
|
+ }
|
|
|
+ if (counter != 0 ) {
|
|
|
+ boost::filesystem::path p = MessageHandlerInternal::get_path(message.substr(last_space + 1));
|
|
|
+ if (!p.string().empty())
|
|
|
+ paths.emplace_back(p);
|
|
|
+ }
|
|
|
+ if (!paths.empty()) {
|
|
|
+ //wxEvtHandler* evt_handler = wxGetApp().plater(); //assert here?
|
|
|
+ //if (evt_handler) {
|
|
|
+ wxPostEvent(m_callback_evt_handler, LoadFromOtherInstanceEvent(GUI::EVT_LOAD_MODEL_OTHER_INSTANCE, std::vector<boost::filesystem::path>(std::move(paths))));
|
|
|
+ //}
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef BACKGROUND_MESSAGE_LISTENER
|
|
|
+
|
|
|
+namespace MessageHandlerDBusInternal
|
|
|
+{
|
|
|
+ //reply to introspect makes our DBus object visible for other programs like D-Feet
|
|
|
+ static void respond_to_introspect(DBusConnection *connection, DBusMessage *request)
|
|
|
+ {
|
|
|
+ DBusMessage *reply;
|
|
|
+ const char *introspection_data =
|
|
|
+ " <!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
|
|
|
+ "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">"
|
|
|
+ " <!-- dbus-sharp 0.8.1 -->"
|
|
|
+ " <node>"
|
|
|
+ " <interface name=\"org.freedesktop.DBus.Introspectable\">"
|
|
|
+ " <method name=\"Introspect\">"
|
|
|
+ " <arg name=\"data\" direction=\"out\" type=\"s\" />"
|
|
|
+ " </method>"
|
|
|
+ " </interface>"
|
|
|
+ " <interface name=\"com.prusa3d.prusaslicer.InstanceCheck\">"
|
|
|
+ " <method name=\"AnotherInstace\">"
|
|
|
+ " <arg name=\"data\" direction=\"in\" type=\"s\" />"
|
|
|
+ " </method>"
|
|
|
+ " </interface>"
|
|
|
+ " </node>";
|
|
|
+
|
|
|
+ reply = dbus_message_new_method_return(request);
|
|
|
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_data, DBUS_TYPE_INVALID);
|
|
|
+ dbus_connection_send(connection, reply, NULL);
|
|
|
+ dbus_message_unref(reply);
|
|
|
+ }
|
|
|
+ //method AnotherInstance receives message from another PrusaSlicer instance
|
|
|
+ static void handle_method_another_instance(DBusConnection *connection, DBusMessage *request)
|
|
|
+ {
|
|
|
+ DBusError err;
|
|
|
+ char* text= "";
|
|
|
+ wxEvtHandler* evt_handler;
|
|
|
+
|
|
|
+ dbus_error_init(&err);
|
|
|
+ dbus_message_get_args(request, &err, DBUS_TYPE_STRING, &text, DBUS_TYPE_INVALID);
|
|
|
+ if (dbus_error_is_set(&err)) {
|
|
|
+ BOOST_LOG_TRIVIAL(trace) << "Dbus method AnotherInstance received with wrong arguments.";
|
|
|
+ dbus_error_free(&err);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ wxGetApp().other_instance_message_handler()->handle_message(text);
|
|
|
+
|
|
|
+ evt_handler = wxGetApp().plater();
|
|
|
+ if (evt_handler) {
|
|
|
+ wxPostEvent(evt_handler, InstanceGoToFrontEvent(EVT_INSTANCE_GO_TO_FRONT));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //every dbus message received comes here
|
|
|
+ static DBusHandlerResult handle_dbus_object_message(DBusConnection *connection, DBusMessage *message, void *user_data)
|
|
|
+ {
|
|
|
+ const char* interface_name = dbus_message_get_interface(message);
|
|
|
+ const char* member_name = dbus_message_get_member(message);
|
|
|
+
|
|
|
+ BOOST_LOG_TRIVIAL(trace) << "DBus message received: interface: " << interface_name << ", member: " << member_name;
|
|
|
+
|
|
|
+ if (0 == strcmp("org.freedesktop.DBus.Introspectable", interface_name) && 0 == strcmp("Introspect", member_name)) {
|
|
|
+ respond_to_introspect(connection, message);
|
|
|
+ return DBUS_HANDLER_RESULT_HANDLED;
|
|
|
+ } else if (0 == strcmp("com.prusa3d.prusaslicer.InstanceCheck", interface_name) && 0 == strcmp("AnotherInstace", member_name)) {
|
|
|
+ handle_method_another_instance(connection, message);
|
|
|
+ return DBUS_HANDLER_RESULT_HANDLED;
|
|
|
+ }
|
|
|
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
|
+ }
|
|
|
+} //namespace MessageHandlerDBusInternal
|
|
|
+
|
|
|
+void OtherInstanceMessageHandler::listen()
|
|
|
+{
|
|
|
+ DBusConnection* conn;
|
|
|
+ DBusError err;
|
|
|
+ int name_req_val;
|
|
|
+ DBusObjectPathVTable vtable;
|
|
|
+ std::string interface_name = "com.prusa3d.prusaslicer.InstanceCheck";
|
|
|
+ std::string object_name = "/com/prusa3d/prusaslicer/InstanceCheck";
|
|
|
+
|
|
|
+ dbus_error_init(&err);
|
|
|
+
|
|
|
+ // connect to the bus and check for errors (use SESSION bus everywhere!)
|
|
|
+ conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
|
|
|
+ if (dbus_error_is_set(&err)) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Connection Error: "<< err.message;
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Dbus Messages listening terminating.";
|
|
|
+ dbus_error_free(&err);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (NULL == conn) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Connection is NULL. Dbus Messages listening terminating.";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // request our name on the bus and check for errors
|
|
|
+ name_req_val = dbus_bus_request_name(conn, interface_name.c_str(), DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
|
|
|
+ if (dbus_error_is_set(&err)) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Request name Error: "<< err.message;
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Dbus Messages listening terminating.";
|
|
|
+ dbus_error_free(&err);
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != name_req_val) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Not primary owner of DBus name - probably another PrusaSlicer instance is running.";
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Dbus Messages listening terminating.";
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Set callbacks. Unregister function should not be nessary.
|
|
|
+ vtable.message_function = MessageHandlerDBusInternal::handle_dbus_object_message;
|
|
|
+ vtable.unregister_function = NULL;
|
|
|
+
|
|
|
+ // register new object - this is our access to DBus
|
|
|
+ dbus_connection_try_register_object_path(conn, object_name.c_str(), &vtable, NULL, &err);
|
|
|
+ if ( dbus_error_is_set(&err) ) {
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "DBus Register object Error: "<< err.message;
|
|
|
+ BOOST_LOG_TRIVIAL(error) << "Dbus Messages listening terminating.";
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+ dbus_error_free(&err);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ BOOST_LOG_TRIVIAL(trace) << "Dbus object registered. Starting listening for messages.";
|
|
|
+
|
|
|
+ for (;;) {
|
|
|
+ // Wait for 1 second
|
|
|
+ // Cancellable.
|
|
|
+ {
|
|
|
+ std::unique_lock<std::mutex> lck(m_thread_stop_mutex);
|
|
|
+ m_thread_stop_condition.wait_for(lck, std::chrono::seconds(1), [this] { return m_stop; });
|
|
|
+ }
|
|
|
+ if (m_stop)
|
|
|
+ // Stop the worker thread.
|
|
|
+
|
|
|
+ break;
|
|
|
+ //dispatch should do all the work with incoming messages
|
|
|
+ //second parameter is blocking time that funciton waits for new messages
|
|
|
+ //that is handled here with our own event loop above
|
|
|
+ dbus_connection_read_write_dispatch(conn, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ dbus_connection_unref(conn);
|
|
|
+}
|
|
|
+#endif //BACKGROUND_MESSAGE_LISTENER
|
|
|
+} // namespace GUI
|
|
|
+} // namespace Slic3r
|
David Kocik