smw/deskflow
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: make APP:m_events private access via exsisting getEvents method

Browse source
This commit is contained in:
sithlord48 2025-08-02 08:44:18 -04:00 committed by Nick Bolton
parent 92ae41852d
commit 4e01e3f337
3 changed files with 76 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/lib/deskflow/App.h
View file

@ -114,9 +114,8 @@ public:
protected: protected:
void runEventsLoop(void *); void runEventsLoop(void *);
IEventQueue *m_events = nullptr;
private: private:
IEventQueue *m_events = nullptr;
deskflow::ArgsBase *m_args; deskflow::ArgsBase *m_args;
static App *s_instance; static App *s_instance;
FileLogOutputter *m_fileLog = nullptr; FileLogOutputter *m_fileLog = nullptr;

53
src/lib/deskflow/ClientApp.cpp
View file

@ -156,8 +156,10 @@ deskflow::Screen *ClientApp::createScreen()
{ {
#if WINAPI_MSWINDOWS #if WINAPI_MSWINDOWS
return new deskflow::Screen( return new deskflow::Screen(
new MSWindowsScreen(false, args().m_noHooks, m_events, args().m_enableLangSync, args().m_clientScrollDirection), new MSWindowsScreen(
m_events false, args().m_noHooks, getEvents(), args().m_enableLangSync, args().m_clientScrollDirection
),
getEvents()
); );
#endif #endif
@ -165,7 +167,7 @@ deskflow::Screen *ClientApp::createScreen()
if (deskflow::platform::isWayland()) { if (deskflow::platform::isWayland()) {
#if WINAPI_LIBEI #if WINAPI_LIBEI
LOG((CLOG_INFO "using ei screen for wayland")); LOG((CLOG_INFO "using ei screen for wayland"));
return new deskflow::Screen(new deskflow::EiScreen(false, m_events, true), m_events); return new deskflow::Screen(new deskflow::EiScreen(false, getEvents(), true), getEvents());
#else #else
throw XNoEiSupport(); throw XNoEiSupport();
#endif #endif
@ -175,14 +177,15 @@ deskflow::Screen *ClientApp::createScreen()
#if WINAPI_XWINDOWS #if WINAPI_XWINDOWS
LOG((CLOG_INFO "using legacy x windows screen")); LOG((CLOG_INFO "using legacy x windows screen"));
return new deskflow::Screen( return new deskflow::Screen(
new XWindowsScreen(args().m_display, false, args().m_yscroll, m_events, args().m_clientScrollDirection), m_events new XWindowsScreen(args().m_display, false, args().m_yscroll, getEvents(), args().m_clientScrollDirection),
getEvents()
); );
#endif #endif
#if WINAPI_CARBON #if WINAPI_CARBON
return new deskflow::Screen( return new deskflow::Screen(
new OSXScreen(m_events, false, args().m_enableLangSync, args().m_clientScrollDirection), m_events new OSXScreen(getEvents(), false, args().m_enableLangSync, args().m_clientScrollDirection), getEvents()
); );
#endif #endif
} }
@ -200,13 +203,13 @@ void ClientApp::updateStatus(const std::string_view &) const
void ClientApp::handleScreenError() void ClientApp::handleScreenError()
{ {
LOG((CLOG_CRIT "error on screen")); LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} }
deskflow::Screen *ClientApp::openClientScreen() deskflow::Screen *ClientApp::openClientScreen()
{ {
deskflow::Screen *screen = createScreen(); deskflow::Screen *screen = createScreen();
m_events->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
handleScreenError(); handleScreenError();
}); });
return screen; return screen;
@ -215,7 +218,7 @@ deskflow::Screen *ClientApp::openClientScreen()
void ClientApp::closeClientScreen(deskflow::Screen *screen) void ClientApp::closeClientScreen(deskflow::Screen *screen)
{ {
if (screen != nullptr) { if (screen != nullptr) {
m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget()); getEvents()->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
delete screen; delete screen;
} }
} }
@ -223,8 +226,8 @@ void ClientApp::closeClientScreen(deskflow::Screen *screen)
void ClientApp::handleClientRestart(const Event &, EventQueueTimer *timer) void ClientApp::handleClientRestart(const Event &, EventQueueTimer *timer)
{ {
// discard old timer // discard old timer
m_events->deleteTimer(timer); getEvents()->deleteTimer(timer);
m_events->removeHandler(EventTypes::Timer, timer); getEvents()->removeHandler(EventTypes::Timer, timer);
// reconnect // reconnect
startClient(); startClient();
@ -234,8 +237,8 @@ void ClientApp::scheduleClientRestart(double retryTime)
{ {
// install a timer and handler to retry later // install a timer and handler to retry later
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime)); LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
EventQueueTimer *timer = m_events->newOneShotTimer(retryTime, nullptr); EventQueueTimer *timer = getEvents()->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, timer, [this, timer](const auto &e) { handleClientRestart(e, timer); }); getEvents()->addHandler(EventTypes::Timer, timer, [this, timer](const auto &e) { handleClientRestart(e, timer); });
} }
void ClientApp::handleClientConnected() const void ClientApp::handleClientConnected() const
@ -267,7 +270,7 @@ void ClientApp::handleClientRefused(const Event &e)
updateStatus(std::string("Failed to connect to server: ") + info->m_what); updateStatus(std::string("Failed to connect to server: ") + info->m_what);
if (!args().m_restartable || !info->m_retry) { if (!args().m_restartable || !info->m_retry) {
LOG((CLOG_ERR "failed to connect to server: %s", info->m_what.c_str())); LOG((CLOG_ERR "failed to connect to server: %s", info->m_what.c_str()));
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} else { } else {
LOG((CLOG_WARN "failed to connect to server: %s", info->m_what.c_str())); LOG((CLOG_WARN "failed to connect to server: %s", info->m_what.c_str()));
if (!m_suspended) { if (!m_suspended) {
@ -280,7 +283,7 @@ void ClientApp::handleClientDisconnected()
{ {
LOG((CLOG_NOTE "disconnected from server")); LOG((CLOG_NOTE "disconnected from server"));
if (!args().m_restartable) { if (!args().m_restartable) {
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} else if (!m_suspended) { } else if (!m_suspended) {
scheduleClientRestart(s_retryTime); scheduleClientRestart(s_retryTime);
} }
@ -289,19 +292,19 @@ void ClientApp::handleClientDisconnected()
Client *ClientApp::openClient(const std::string &name, const NetworkAddress &address, deskflow::Screen *screen) Client *ClientApp::openClient(const std::string &name, const NetworkAddress &address, deskflow::Screen *screen)
{ {
auto *client = new Client(m_events, name, address, getSocketFactory(), screen, args()); auto *client = new Client(getEvents(), name, address, getSocketFactory(), screen, args());
try { try {
m_events->addHandler(EventTypes::ClientConnected, client->getEventTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ClientConnected, client->getEventTarget(), [this](const auto &) {
handleClientConnected(); handleClientConnected();
}); });
m_events->addHandler(EventTypes::ClientConnectionFailed, client->getEventTarget(), [this](const auto &e) { getEvents()->addHandler(EventTypes::ClientConnectionFailed, client->getEventTarget(), [this](const auto &e) {
handleClientFailed(e); handleClientFailed(e);
}); });
m_events->addHandler(EventTypes::ClientConnectionRefused, client->getEventTarget(), [this](const auto &e) { getEvents()->addHandler(EventTypes::ClientConnectionRefused, client->getEventTarget(), [this](const auto &e) {
handleClientRefused(e); handleClientRefused(e);
}); });
m_events->addHandler(EventTypes::ClientDisconnected, client->getEventTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ClientDisconnected, client->getEventTarget(), [this](const auto &) {
handleClientDisconnected(); handleClientDisconnected();
}); });
@ -319,10 +322,10 @@ void ClientApp::closeClient(Client *client)
return; return;
} }
using enum EventTypes; using enum EventTypes;
m_events->removeHandler(ClientConnected, client); getEvents()->removeHandler(ClientConnected, client);
m_events->removeHandler(ClientConnectionFailed, client); getEvents()->removeHandler(ClientConnectionFailed, client);
m_events->removeHandler(ClientConnectionRefused, client); getEvents()->removeHandler(ClientConnectionRefused, client);
m_events->removeHandler(ClientDisconnected, client); getEvents()->removeHandler(ClientDisconnected, client);
delete client; delete client;
} }
@ -406,7 +409,7 @@ int ClientApp::mainLoop()
runCocoaApp(); runCocoaApp();
#else #else
m_events->loop(); getEvents()->loop();
#endif #endif
DAEMON_RUNNING(false); DAEMON_RUNNING(false);
@ -468,5 +471,5 @@ void ClientApp::startNode()
ISocketFactory *ClientApp::getSocketFactory() const ISocketFactory *ClientApp::getSocketFactory() const
{ {
return new TCPSocketFactory(m_events, getSocketMultiplexer()); return new TCPSocketFactory(getEvents(), getSocketMultiplexer());
} }

90
src/lib/deskflow/ServerApp.cpp
View file

@ -218,17 +218,19 @@ void ServerApp::closeServer(Server *server)
// wait for clients to disconnect for up to timeout seconds // wait for clients to disconnect for up to timeout seconds
double timeout = 3.0; double timeout = 3.0;
EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr); EventQueueTimer *timer = getEvents()->newOneShotTimer(timeout, nullptr);
m_events->addHandler(EventTypes::Timer, timer, [this](const auto &) { m_events->addEvent(Event(EventTypes::Quit)); }); getEvents()->addHandler(EventTypes::Timer, timer, [this](const auto &) {
m_events->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) { getEvents()->addEvent(Event(EventTypes::Quit));
m_events->addEvent(Event(EventTypes::Quit)); });
getEvents()->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) {
getEvents()->addEvent(Event(EventTypes::Quit));
}); });
m_events->loop(); getEvents()->loop();
m_events->removeHandler(EventTypes::Timer, timer); getEvents()->removeHandler(EventTypes::Timer, timer);
m_events->deleteTimer(timer); getEvents()->deleteTimer(timer);
m_events->removeHandler(EventTypes::ServerDisconnected, server); getEvents()->removeHandler(EventTypes::ServerDisconnected, server);
// done with server // done with server
delete server; delete server;
@ -237,8 +239,8 @@ void ServerApp::closeServer(Server *server)
void ServerApp::stopRetryTimer() void ServerApp::stopRetryTimer()
{ {
if (m_timer != nullptr) { if (m_timer != nullptr) {
m_events->removeHandler(EventTypes::Timer, m_timer); getEvents()->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer); getEvents()->deleteTimer(m_timer);
m_timer = nullptr; m_timer = nullptr;
} }
} }
@ -256,7 +258,7 @@ void ServerApp::updateStatus(const std::string_view &msg) const
void ServerApp::closeClientListener(ClientListener *listen) void ServerApp::closeClientListener(ClientListener *listen)
{ {
if (listen != nullptr) { if (listen != nullptr) {
m_events->removeHandler(EventTypes::ClientListenerAccepted, listen); getEvents()->removeHandler(EventTypes::ClientListenerAccepted, listen);
delete listen; delete listen;
} }
} }
@ -287,9 +289,9 @@ void ServerApp::closeServerScreen(deskflow::Screen *screen)
{ {
if (screen != nullptr) { if (screen != nullptr) {
using enum EventTypes; using enum EventTypes;
m_events->removeHandler(ScreenError, screen->getEventTarget()); getEvents()->removeHandler(ScreenError, screen->getEventTarget());
m_events->removeHandler(ScreenSuspend, screen->getEventTarget()); getEvents()->removeHandler(ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(ScreenResume, screen->getEventTarget()); getEvents()->removeHandler(ScreenResume, screen->getEventTarget());
delete screen; delete screen;
} }
} }
@ -332,7 +334,7 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = Uninitialized; m_serverState = Uninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} }
break; break;
@ -340,11 +342,11 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = Uninitialized; m_serverState = Uninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} else if (m_serverState == Initialized) { } else if (m_serverState == Initialized) {
LOG((CLOG_DEBUG1 "starting server")); LOG((CLOG_DEBUG1 "starting server"));
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} }
} }
break; break;
@ -353,7 +355,7 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry starting server")); LOG((CLOG_DEBUG1 "retry starting server"));
m_serverState = Initialized; m_serverState = Initialized;
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} }
break; break;
} }
@ -401,8 +403,8 @@ bool ServerApp::initServer()
// install a timer and handler to retry later // install a timer and handler to retry later
assert(m_timer == nullptr); assert(m_timer == nullptr);
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime)); LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr); m_timer = getEvents()->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); }); getEvents()->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = Initializing; m_serverState = Initializing;
return true; return true;
} else { } else {
@ -414,11 +416,13 @@ bool ServerApp::initServer()
deskflow::Screen *ServerApp::openServerScreen() deskflow::Screen *ServerApp::openServerScreen()
{ {
deskflow::Screen *screen = createScreen(); deskflow::Screen *screen = createScreen();
m_events->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
handleScreenError(); handleScreenError();
}); });
m_events->addHandler(EventTypes::ScreenSuspend, screen->getEventTarget(), [this](const auto &) { handleSuspend(); }); getEvents()->addHandler(EventTypes::ScreenSuspend, screen->getEventTarget(), [this](const auto &) {
m_events->addHandler(EventTypes::ScreenResume, screen->getEventTarget(), [this](const auto &) { handleResume(); }); handleSuspend();
});
getEvents()->addHandler(EventTypes::ScreenResume, screen->getEventTarget(), [this](const auto &) { handleResume(); });
return screen; return screen;
} }
@ -474,8 +478,8 @@ bool ServerApp::startServer()
assert(m_timer == nullptr); assert(m_timer == nullptr);
const auto retryTime = 10.0; const auto retryTime = 10.0;
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime)); LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr); m_timer = getEvents()->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); }); getEvents()->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = Starting; m_serverState = Starting;
return true; return true;
} else { } else {
@ -487,14 +491,14 @@ bool ServerApp::startServer()
deskflow::Screen *ServerApp::createScreen() deskflow::Screen *ServerApp::createScreen()
{ {
#if WINAPI_MSWINDOWS #if WINAPI_MSWINDOWS
return new deskflow::Screen(new MSWindowsScreen(true, args().m_noHooks, m_events), m_events); return new deskflow::Screen(new MSWindowsScreen(true, args().m_noHooks, getEvents()), getEvents());
#endif #endif
#if defined(WINAPI_XWINDOWS) or defined(WINAPI_LIBEI) #if defined(WINAPI_XWINDOWS) or defined(WINAPI_LIBEI)
if (deskflow::platform::isWayland()) { if (deskflow::platform::isWayland()) {
#if WINAPI_LIBEI #if WINAPI_LIBEI
LOG((CLOG_INFO "using ei screen for wayland")); LOG((CLOG_INFO "using ei screen for wayland"));
return new deskflow::Screen(new deskflow::EiScreen(true, m_events, true), m_events); return new deskflow::Screen(new deskflow::EiScreen(true, getEvents(), true), getEvents());
#else #else
throw XNoEiSupport(); throw XNoEiSupport();
#endif #endif
@ -503,9 +507,9 @@ deskflow::Screen *ServerApp::createScreen()
#if WINAPI_XWINDOWS #if WINAPI_XWINDOWS
LOG((CLOG_INFO "using legacy x windows screen")); LOG((CLOG_INFO "using legacy x windows screen"));
return new deskflow::Screen(new XWindowsScreen(args().m_display, true, 0, m_events), m_events); return new deskflow::Screen(new XWindowsScreen(args().m_display, true, 0, getEvents()), getEvents());
#elif WINAPI_CARBON #elif WINAPI_CARBON
return new deskflow::Screen(new OSXScreen(m_events, true), m_events); return new deskflow::Screen(new OSXScreen(getEvents(), true), getEvents());
#endif #endif
} }
@ -518,7 +522,7 @@ PrimaryClient *ServerApp::openPrimaryClient(const std::string &name, deskflow::S
void ServerApp::handleScreenError() void ServerApp::handleScreenError()
{ {
LOG((CLOG_CRIT "error on screen")); LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(EventTypes::Quit)); getEvents()->addEvent(Event(EventTypes::Quit));
} }
void ServerApp::handleSuspend() void ServerApp::handleSuspend()
@ -551,9 +555,9 @@ ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
} }
} }
auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel); auto *listen = new ClientListener(getAddress(address), getSocketFactory(), getEvents(), securityLevel);
m_events->addHandler(EventTypes::ClientListenerAccepted, listen, [this, listen](const auto &e) { getEvents()->addHandler(EventTypes::ClientListenerAccepted, listen, [this, listen](const auto &e) {
handleClientConnected(e, listen); handleClientConnected(e, listen);
}); });
@ -562,10 +566,10 @@ ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
Server *ServerApp::openServer(ServerConfig &config, PrimaryClient *primaryClient) Server *ServerApp::openServer(ServerConfig &config, PrimaryClient *primaryClient)
{ {
auto *server = new Server(config, primaryClient, m_serverScreen, m_events, args()); auto *server = new Server(config, primaryClient, m_serverScreen, getEvents(), args());
try { try {
m_events->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) { updateStatus(); }); getEvents()->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) { updateStatus(); });
m_events->addHandler(EventTypes::ServerScreenSwitched, server, [this](const auto &) { handleScreenSwitched(); }); getEvents()->addHandler(EventTypes::ServerScreenSwitched, server, [this](const auto &) { handleScreenSwitched(); });
} catch (std::bad_alloc &ba) { } catch (std::bad_alloc &ba) {
delete server; delete server;
@ -582,7 +586,7 @@ void ServerApp::handleScreenSwitched() const
std::unique_ptr<ISocketFactory> ServerApp::getSocketFactory() const std::unique_ptr<ISocketFactory> ServerApp::getSocketFactory() const
{ {
return std::make_unique<TCPSocketFactory>(m_events, getSocketMultiplexer()); return std::make_unique<TCPSocketFactory>(getEvents(), getSocketMultiplexer());
} }
NetworkAddress ServerApp::getAddress(const NetworkAddress &address) const NetworkAddress ServerApp::getAddress(const NetworkAddress &address) const
@ -622,19 +626,19 @@ int ServerApp::mainLoop()
// handle hangup signal by reloading the server's configuration // handle hangup signal by reloading the server's configuration
ARCH->setSignalHandler(Arch::ThreadSignal::Hangup, &reloadSignalHandler, nullptr); ARCH->setSignalHandler(Arch::ThreadSignal::Hangup, &reloadSignalHandler, nullptr);
m_events->addHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ServerAppReloadConfig, getEvents()->getSystemTarget(), [this](const auto &) {
reloadConfig(); reloadConfig();
}); });
// handle force reconnect event by disconnecting clients. they'll // handle force reconnect event by disconnecting clients. they'll
// reconnect automatically. // reconnect automatically.
m_events->addHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ServerAppForceReconnect, getEvents()->getSystemTarget(), [this](const auto &) {
forceReconnect(); forceReconnect();
}); });
// to work around the sticky meta keys problem, we'll give users // to work around the sticky meta keys problem, we'll give users
// the option to reset the state of the server. // the option to reset the state of the server.
m_events->addHandler(EventTypes::ServerAppResetServer, m_events->getSystemTarget(), [this](const auto &) { getEvents()->addHandler(EventTypes::ServerAppResetServer, getEvents()->getSystemTarget(), [this](const auto &) {
resetServer(); resetServer();
}); });
@ -653,15 +657,15 @@ int ServerApp::mainLoop()
runCocoaApp(); runCocoaApp();
#else #else
m_events->loop(); getEvents()->loop();
#endif #endif
DAEMON_RUNNING(false); DAEMON_RUNNING(false);
// close down // close down
LOG((CLOG_DEBUG1 "stopping server")); LOG((CLOG_DEBUG1 "stopping server"));
m_events->removeHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget()); getEvents()->removeHandler(EventTypes::ServerAppForceReconnect, getEvents()->getSystemTarget());
m_events->removeHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget()); getEvents()->removeHandler(EventTypes::ServerAppReloadConfig, getEvents()->getSystemTarget());
cleanupServer(); cleanupServer();
updateStatus(); updateStatus();
LOG((CLOG_NOTE "stopped server")); LOG((CLOG_NOTE "stopped server"));
@ -681,7 +685,7 @@ int ServerApp::runInner(int argc, char **argv, StartupFunc startup)
{ {
// general initialization // general initialization
m_deskflowAddress = new NetworkAddress; m_deskflowAddress = new NetworkAddress;
args().m_config = std::make_shared<Config>(m_events); args().m_config = std::make_shared<Config>(getEvents());
args().m_pname = QFileInfo(argv[0]).fileName().toLocal8Bit().constData(); args().m_pname = QFileInfo(argv[0]).fileName().toLocal8Bit().constData();
// run // run