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

refactor: use using enum EventTypes when possible to reduce verbosity

Browse source
This commit is contained in:
sithlord48 2025-06-30 23:23:18 -04:00 committed by Chris Rizzitello
parent 8f6f014bcd
commit ab4fbd1c85
14 changed files with 122 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/lib/base/Event.cpp
View file

@ -55,10 +55,11 @@ Event::Flags Event::getFlags() const
void Event::deleteData(const Event &event)
{
switch (event.getType()) {
case EventTypes::Unknown:
case EventTypes::Quit:
case EventTypes::System:
case EventTypes::Timer:
using enum EventTypes;
case Unknown:
case Quit:
case System:
case Timer:
break;
default:

13
src/lib/client/Client.cpp
View file

@ -468,12 +468,13 @@ void Client::cleanupConnecting()
void Client::cleanupConnection()
{
if (m_stream != nullptr) {
m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::SocketDisconnected, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::SocketStopRetry, m_stream->getEventTarget());
using enum EventTypes;
m_events->removeHandler(StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(StreamOutputShutdown, m_stream->getEventTarget());
m_events->removeHandler(SocketDisconnected, m_stream->getEventTarget());
m_events->removeHandler(SocketStopRetry, m_stream->getEventTarget());
cleanupStream();
}
}

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

@ -318,11 +318,11 @@ void ClientApp::closeClient(Client *client)
if (client == nullptr) {
return;
}
m_events->removeHandler(EventTypes::ClientConnected, client);
m_events->removeHandler(EventTypes::ClientConnectionFailed, client);
m_events->removeHandler(EventTypes::ClientConnectionRefused, client);
m_events->removeHandler(EventTypes::ClientDisconnected, client);
using enum EventTypes;
m_events->removeHandler(ClientConnected, client);
m_events->removeHandler(ClientConnectionFailed, client);
m_events->removeHandler(ClientConnectionRefused, client);
m_events->removeHandler(ClientDisconnected, client);
delete client;
}

11
src/lib/deskflow/KeyState.cpp
View file

@ -708,20 +708,21 @@ void KeyState::sendKeyEvent(
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, int32_t count, KeyButton button
)
{
using enum EventTypes;
if (m_keyMap.isHalfDuplex(key, button)) {
if (isAutoRepeat) {
// ignore auto-repeat on half-duplex keys
} else {
m_events->addEvent(Event(EventTypes::KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(EventTypes::KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
}
} else {
if (isAutoRepeat) {
m_events->addEvent(Event(EventTypes::KeyStateKeyRepeat, target, KeyInfo::alloc(key, mask, button, count)));
m_events->addEvent(Event(KeyStateKeyRepeat, target, KeyInfo::alloc(key, mask, button, count)));
} else if (press) {
m_events->addEvent(Event(EventTypes::KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
} else {
m_events->addEvent(Event(EventTypes::KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
}
}
}

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

@ -285,9 +285,10 @@ void ServerApp::closePrimaryClient(PrimaryClient *primaryClient)
void ServerApp::closeServerScreen(deskflow::Screen *screen)
{
if (screen != nullptr) {
m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenResume, screen->getEventTarget());
using enum EventTypes;
m_events->removeHandler(ScreenError, screen->getEventTarget());
m_events->removeHandler(ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(ScreenResume, screen->getEventTarget());
delete screen;
}
}
@ -535,8 +536,8 @@ void ServerApp::handleResume()
ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
{
auto securityLevel = args().m_enableCrypto ? args().m_chkPeerCert ? SecurityLevel::PeerAuth : SecurityLevel::Encrypted
: SecurityLevel::PlainText;
using enum SecurityLevel;
auto securityLevel = args().m_enableCrypto ? args().m_chkPeerCert ? PeerAuth : Encrypted : PlainText;
auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel);

14
src/lib/net/Fingerprint.cpp
View file

@ -12,11 +12,12 @@
bool Fingerprint::isValid() const
{
switch (type) {
case Fingerprint::Type::Invalid:
using enum Type;
case Invalid:
return false;
case Fingerprint::Type::SHA1:
case SHA1:
return data.length() == 20;
case Fingerprint::Type::SHA256:
case SHA256:
return data.length() == 32;
default:
return false;
@ -68,12 +69,13 @@ Fingerprint Fingerprint::fromDbLine(const QString &line)
Fingerprint::Type Fingerprint::typeFromString(const QString &type)
{
using enum Type;
const auto t = type.toLower();
if (t == m_type_sha1)
return Type::SHA1;
return SHA1;
if (t == m_type_sha256)
return Type::SHA256;
return Type::Invalid;
return SHA256;
return Invalid;
}
QString Fingerprint::typeToString(Fingerprint::Type type)

7
src/lib/net/SecureSocket.cpp
View file

@ -626,9 +626,10 @@ void SecureSocket::checkResult(int status, int &retry)
void SecureSocket::disconnect()
{
sendEvent(EventTypes::SocketStopRetry);
sendEvent(EventTypes::SocketDisconnected);
sendEvent(EventTypes::StreamInputShutdown);
using enum EventTypes;
sendEvent(SocketStopRetry);
sendEvent(SocketDisconnected);
sendEvent(StreamInputShutdown);
}
bool SecureSocket::verifyCertFingerprint(const QString &FingerprintDatabasePath) const

16
src/lib/net/TCPSocket.cpp
View file

@ -485,16 +485,18 @@ ISocketMultiplexerJob *TCPSocket::serviceConnecting(ISocketMultiplexerJob *job,
ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, bool read, bool write, bool error)
{
using enum EventTypes;
Lock lock(&m_mutex);
if (error) {
sendEvent(EventTypes::SocketDisconnected);
sendEvent(SocketDisconnected);
onDisconnected();
return newJob();
}
EJobResult readResult = kRetry;
EJobResult writeResult = kRetry;
if (write) {
try {
writeResult = doWrite();
@ -502,23 +504,23 @@ ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, b
// remote read end of stream hungup. our output side
// has therefore shutdown.
onOutputShutdown();
sendEvent(EventTypes::StreamOutputShutdown);
sendEvent(StreamOutputShutdown);
if (!m_readable && m_inputBuffer.getSize() == 0) {
sendEvent(EventTypes::SocketDisconnected);
sendEvent(SocketDisconnected);
m_connected = false;
}
writeResult = kNew;
} catch (XArchNetworkDisconnected &) {
// stream hungup
onDisconnected();
sendEvent(EventTypes::SocketDisconnected);
sendEvent(SocketDisconnected);
writeResult = kNew;
} catch (XArchNetwork &e) {
// other write error
LOG((CLOG_WARN "error writing socket: %s", e.what()));
onDisconnected();
sendEvent(EventTypes::StreamOutputError);
sendEvent(EventTypes::SocketDisconnected);
sendEvent(StreamOutputError);
sendEvent(SocketDisconnected);
writeResult = kNew;
}
}
@ -528,7 +530,7 @@ ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, b
readResult = doRead();
} catch (XArchNetworkDisconnected &) {
// stream hungup
sendEvent(EventTypes::SocketDisconnected);
sendEvent(SocketDisconnected);
onDisconnected();
readResult = kNew;
} catch (XArchNetwork &e) {

7
src/lib/platform/XWindowsScreen.cpp
View file

@ -1477,17 +1477,18 @@ void XWindowsScreen::onMousePress(const XButtonEvent &xbutton)
void XWindowsScreen::onMouseRelease(const XButtonEvent &xbutton)
{
using enum EventTypes;
LOG((CLOG_DEBUG1 "event: ButtonRelease button=%d", xbutton.button));
ButtonID button = mapButtonFromX(&xbutton);
KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state);
if (button != kButtonNone) {
sendEvent(EventTypes::PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
sendEvent(PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
} else if (xbutton.button == 4) {
// wheel forward (away from user)
sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(0, 120));
sendEvent(PrimaryScreenWheel, WheelInfo::alloc(0, 120));
} else if (xbutton.button == 5) {
// wheel backward (toward user)
sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(0, -120));
sendEvent(PrimaryScreenWheel, WheelInfo::alloc(0, -120));
}
// XXX -- support x-axis scrolling
}

9
src/lib/server/ClientListener.cpp
View file

@ -87,14 +87,15 @@ void ClientListener::start()
void ClientListener::stop()
{
using enum EventTypes;
LOG((CLOG_DEBUG1 "stop listening for clients"));
// discard already connected clients
for (auto index = m_newClients.begin(); index != m_newClients.end(); ++index) {
ClientProxyUnknown *client = *index;
m_events->removeHandler(EventTypes::ClientProxyUnknownSuccess, client);
m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, client);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
m_events->removeHandler(ClientProxyUnknownSuccess, client);
m_events->removeHandler(ClientProxyUnknownFailure, client);
m_events->removeHandler(ClientProxyDisconnected, client);
delete client;
}
@ -105,7 +106,7 @@ void ClientListener::stop()
client = getNextClient();
}
m_events->removeHandler(EventTypes::ListenSocketConnecting, m_listen);
m_events->removeHandler(ListenSocketConnecting, m_listen);
cleanupListenSocket();
cleanupClientSockets();
}

13
src/lib/server/ClientProxy1_0.cpp
View file

@ -61,13 +61,14 @@ void ClientProxy1_0::disconnect()
void ClientProxy1_0::removeHandlers()
{
using enum EventTypes;
// uninstall event handlers
m_events->removeHandler(EventTypes::StreamInputReady, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputFormatError, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::Timer, this);
m_events->removeHandler(StreamInputReady, getStream()->getEventTarget());
m_events->removeHandler(StreamOutputError, getStream()->getEventTarget());
m_events->removeHandler(StreamInputShutdown, getStream()->getEventTarget());
m_events->removeHandler(StreamOutputShutdown, getStream()->getEventTarget());
m_events->removeHandler(StreamInputFormatError, getStream()->getEventTarget());
m_events->removeHandler(Timer, this);
// remove timer
removeHeartbeatTimer();

15
src/lib/server/ClientProxyUnknown.cpp
View file

@ -119,16 +119,17 @@ void ClientProxyUnknown::addProxyHandlers()
void ClientProxyUnknown::removeHandlers()
{
using enum EventTypes;
if (m_stream != nullptr) {
m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputFormatError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
m_events->removeHandler(StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(StreamInputFormatError, m_stream->getEventTarget());
m_events->removeHandler(StreamOutputShutdown, m_stream->getEventTarget());
}
if (m_proxy != nullptr) {
m_events->removeHandler(EventTypes::ClientProxyReady, m_proxy);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, m_proxy);
m_events->removeHandler(ClientProxyReady, m_proxy);
m_events->removeHandler(ClientProxyDisconnected, m_proxy);
}
}

55
src/lib/server/InputFilter.cpp
View file

@ -444,15 +444,12 @@ std::string InputFilter::KeystrokeAction::format() const
void InputFilter::KeystrokeAction::perform(const Event &event)
{
EventTypes type = m_press ? EventTypes::KeyStateKeyDown : EventTypes::KeyStateKeyUp;
using enum EventTypes;
EventTypes type = m_press ? KeyStateKeyDown : KeyStateKeyUp;
m_events->addEvent(
Event(EventTypes::PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Event::kDeliverImmediately)
);
m_events->addEvent(Event(PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Event::kDeliverImmediately));
m_events->addEvent(Event(type, event.getTarget(), m_keyInfo, Event::kDeliverImmediately | Event::kDontFreeData));
m_events->addEvent(
Event(EventTypes::PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Event::kDeliverImmediately)
);
m_events->addEvent(Event(PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Event::kDeliverImmediately));
}
const char *InputFilter::KeystrokeAction::formatName() const
@ -501,15 +498,16 @@ void InputFilter::MouseButtonAction::perform(const Event &event)
{
// send modifiers
using enum EventTypes;
IPlatformScreen::KeyInfo *modifierInfo = nullptr;
if (m_buttonInfo->m_mask != 0) {
KeyID key = m_press ? kKeySetModifiers : kKeyClearModifiers;
modifierInfo = IKeyState::KeyInfo::alloc(key, m_buttonInfo->m_mask, 0, 1);
m_events->addEvent(Event(EventTypes::KeyStateKeyDown, event.getTarget(), modifierInfo, Event::kDeliverImmediately));
m_events->addEvent(Event(KeyStateKeyDown, event.getTarget(), modifierInfo, Event::kDeliverImmediately));
}
// send button
EventTypes type = m_press ? EventTypes::PrimaryScreenButtonDown : EventTypes::PrimaryScreenButtonUp;
EventTypes type = m_press ? PrimaryScreenButtonDown : PrimaryScreenButtonUp;
m_events->addEvent(Event(type, event.getTarget(), m_buttonInfo, Event::kDeliverImmediately | Event::kDontFreeData));
}
@ -778,48 +776,43 @@ void InputFilter::setPrimaryClient(PrimaryClient *client)
return;
}
using enum EventTypes;
if (m_primaryClient != nullptr) {
for (auto rule = m_ruleList.begin(); rule != m_ruleList.end(); ++rule) {
rule->disable(m_primaryClient);
}
m_events->removeHandler(EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::ServerConnected, m_primaryClient->getEventTarget());
m_events->removeHandler(KeyStateKeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(KeyStateKeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(KeyStateKeyRepeat, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(ServerConnected, m_primaryClient->getEventTarget());
}
m_primaryClient = client;
if (m_primaryClient != nullptr) {
m_events->addHandler(EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget(), [this](const auto &e) {
m_events->addHandler(KeyStateKeyDown, m_primaryClient->getEventTarget(), [this](const auto &e) { handleEvent(e); });
m_events->addHandler(KeyStateKeyUp, m_primaryClient->getEventTarget(), [this](const auto &e) { handleEvent(e); });
m_events->addHandler(KeyStateKeyRepeat, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget(), [this](const auto &e) {
m_events->addHandler(PrimaryScreenButtonDown, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget(), [this](const auto &e) {
m_events->addHandler(PrimaryScreenButtonUp, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget(), [this](const auto &e) {
m_events->addHandler(PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(EventTypes::ServerConnected, m_primaryClient->getEventTarget(), [this](const auto &e) {
m_events->addHandler(PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget(), [this](const auto &e) {
handleEvent(e);
});
m_events->addHandler(ServerConnected, m_primaryClient->getEventTarget(), [this](const auto &e) { handleEvent(e); });
for (auto rule = m_ruleList.begin(); rule != m_ruleList.end(); ++rule) {
rule->enable(m_primaryClient);

45
src/lib/server/Server.cpp
View file

@ -142,19 +142,20 @@ Server::Server(
Server::~Server()
{
// remove event handlers and timers
m_events->removeHandler(EventTypes::KeyStateKeyDown, m_inputFilter);
m_events->removeHandler(EventTypes::KeyStateKeyUp, m_inputFilter);
m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_inputFilter);
m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_inputFilter);
m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_inputFilter);
m_events->removeHandler(EventTypes::PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenWheel, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenSaverActivated, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenFakeInputBegin, m_inputFilter);
m_events->removeHandler(EventTypes::PrimaryScreenFakeInputEnd, m_inputFilter);
m_events->removeHandler(EventTypes::Timer, this);
using enum EventTypes;
m_events->removeHandler(KeyStateKeyDown, m_inputFilter);
m_events->removeHandler(KeyStateKeyUp, m_inputFilter);
m_events->removeHandler(KeyStateKeyRepeat, m_inputFilter);
m_events->removeHandler(PrimaryScreenButtonDown, m_inputFilter);
m_events->removeHandler(PrimaryScreenButtonUp, m_inputFilter);
m_events->removeHandler(PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenWheel, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenSaverActivated, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget());
m_events->removeHandler(PrimaryScreenFakeInputBegin, m_inputFilter);
m_events->removeHandler(PrimaryScreenFakeInputEnd, m_inputFilter);
m_events->removeHandler(Timer, this);
stopSwitch();
try {
@ -167,8 +168,8 @@ Server::~Server()
for (auto index = m_oldClients.begin(); index != m_oldClients.end(); ++index) {
BaseClientProxy *client = index->first;
m_events->deleteTimer(index->second);
m_events->removeHandler(EventTypes::Timer, client);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
m_events->removeHandler(Timer, client);
m_events->removeHandler(ClientProxyDisconnected, client);
delete client;
}
@ -1873,6 +1874,7 @@ bool Server::addClient(BaseClientProxy *client)
bool Server::removeClient(BaseClientProxy *client)
{
using enum EventTypes;
// return false if not in list
ClientSet::iterator i = m_clientSet.find(client);
if (i == m_clientSet.end()) {
@ -1880,9 +1882,9 @@ bool Server::removeClient(BaseClientProxy *client)
}
// remove event handlers
m_events->removeHandler(EventTypes::ScreenShapeChanged, client->getEventTarget());
m_events->removeHandler(EventTypes::ClipboardGrabbed, client->getEventTarget());
m_events->removeHandler(EventTypes::ClipboardChanged, client->getEventTarget());
m_events->removeHandler(ScreenShapeChanged, client->getEventTarget());
m_events->removeHandler(ClipboardGrabbed, client->getEventTarget());
m_events->removeHandler(ClipboardChanged, client->getEventTarget());
// remove from list
m_clients.erase(getName(client));
@ -1961,14 +1963,15 @@ void Server::removeActiveClient(BaseClientProxy *client)
void Server::removeOldClient(BaseClientProxy *client)
{
using enum EventTypes;
OldClients::iterator i = m_oldClients.find(client);
if (i != m_oldClients.end()) {
m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
m_events->removeHandler(EventTypes::Timer, i->second);
m_events->removeHandler(ClientProxyDisconnected, client);
m_events->removeHandler(Timer, i->second);
m_events->deleteTimer(i->second);
m_oldClients.erase(i);
if (m_clients.size() == 1 && m_oldClients.empty()) {
m_events->addEvent(Event(EventTypes::ServerDisconnected, this));
m_events->addEvent(Event(ServerDisconnected, this));
}
}
}