refactor: use using enum EventTypes when possible to reduce verbosity

src/lib/base/Event.cpp

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

src/lib/client/Client.cpp

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

src/lib/deskflow/ClientApp.cpp

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

src/lib/deskflow/KeyState.cpp

@@ -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(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(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)));
     }
   }
 }

src/lib/deskflow/ServerApp.cpp

@@ -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());
+    using enum EventTypes;
-    m_events->removeHandler(EventTypes::ScreenSuspend, screen->getEventTarget());
+    m_events->removeHandler(ScreenError, screen->getEventTarget());
-    m_events->removeHandler(EventTypes::ScreenResume, 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
+  using enum SecurityLevel;
-                                             : SecurityLevel::PlainText;
+  auto securityLevel = args().m_enableCrypto ? args().m_chkPeerCert ? PeerAuth : Encrypted : PlainText;
 
   auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel);
 

src/lib/net/Fingerprint.cpp

@@ -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 SHA256;
-  return Type::Invalid;
+  return Invalid;
 }
 
 QString Fingerprint::typeToString(Fingerprint::Type type)

src/lib/net/SecureSocket.cpp

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

src/lib/net/TCPSocket.cpp

@@ -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(StreamOutputError);
-      sendEvent(EventTypes::SocketDisconnected);
+      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) {

src/lib/platform/XWindowsScreen.cpp

@@ -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
 }

src/lib/server/ClientListener.cpp

@@ -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(ClientProxyUnknownSuccess, client);
-    m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, client);
+    m_events->removeHandler(ClientProxyUnknownFailure, client);
-    m_events->removeHandler(EventTypes::ClientProxyDisconnected, 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();
 }

src/lib/server/ClientProxy1_0.cpp

@@ -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(StreamInputReady, getStream()->getEventTarget());
-  m_events->removeHandler(EventTypes::StreamOutputError, getStream()->getEventTarget());
+  m_events->removeHandler(StreamOutputError, getStream()->getEventTarget());
-  m_events->removeHandler(EventTypes::StreamInputShutdown, getStream()->getEventTarget());
+  m_events->removeHandler(StreamInputShutdown, getStream()->getEventTarget());
-  m_events->removeHandler(EventTypes::StreamOutputShutdown, getStream()->getEventTarget());
+  m_events->removeHandler(StreamOutputShutdown, getStream()->getEventTarget());
-  m_events->removeHandler(EventTypes::StreamInputFormatError, getStream()->getEventTarget());
+  m_events->removeHandler(StreamInputFormatError, getStream()->getEventTarget());
-  m_events->removeHandler(EventTypes::Timer, this);
+  m_events->removeHandler(Timer, this);
 
   // remove timer
   removeHeartbeatTimer();

src/lib/server/ClientProxyUnknown.cpp

@@ -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(StreamInputReady, m_stream->getEventTarget());
-    m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
+    m_events->removeHandler(StreamOutputError, m_stream->getEventTarget());
-    m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
+    m_events->removeHandler(StreamInputShutdown, m_stream->getEventTarget());
-    m_events->removeHandler(EventTypes::StreamInputFormatError, m_stream->getEventTarget());
+    m_events->removeHandler(StreamInputFormatError, m_stream->getEventTarget());
-    m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
+    m_events->removeHandler(StreamOutputShutdown, m_stream->getEventTarget());
   }
   if (m_proxy != nullptr) {
-    m_events->removeHandler(EventTypes::ClientProxyReady, m_proxy);
+    m_events->removeHandler(ClientProxyReady, m_proxy);
-    m_events->removeHandler(EventTypes::ClientProxyDisconnected, m_proxy);
+    m_events->removeHandler(ClientProxyDisconnected, m_proxy);
   }
 }
 

src/lib/server/InputFilter.cpp

@@ -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(
+  m_events->addEvent(Event(PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Event::kDeliverImmediately));
-      Event(EventTypes::PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Event::kDeliverImmediately)
-  );
   m_events->addEvent(Event(type, event.getTarget(), m_keyInfo, Event::kDeliverImmediately | Event::kDontFreeData));
-  m_events->addEvent(
+  m_events->addEvent(Event(PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Event::kDeliverImmediately));
-      Event(EventTypes::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(KeyStateKeyDown, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget());
+    m_events->removeHandler(KeyStateKeyUp, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget());
+    m_events->removeHandler(KeyStateKeyRepeat, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
+    m_events->removeHandler(PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
+    m_events->removeHandler(PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
+    m_events->removeHandler(PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
+    m_events->removeHandler(PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
-    m_events->removeHandler(EventTypes::ServerConnected, 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) {
+    m_events->addHandler(PrimaryScreenHotkeyUp, 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) {
       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);

src/lib/server/Server.cpp

@@ -142,19 +142,20 @@ Server::Server(
 Server::~Server()
 {
   // remove event handlers and timers
-  m_events->removeHandler(EventTypes::KeyStateKeyDown, m_inputFilter);
+  using enum EventTypes;
-  m_events->removeHandler(EventTypes::KeyStateKeyUp, m_inputFilter);
+  m_events->removeHandler(KeyStateKeyDown, m_inputFilter);
-  m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_inputFilter);
+  m_events->removeHandler(KeyStateKeyUp, m_inputFilter);
-  m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_inputFilter);
+  m_events->removeHandler(KeyStateKeyRepeat, m_inputFilter);
-  m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_inputFilter);
+  m_events->removeHandler(PrimaryScreenButtonDown, m_inputFilter);
-  m_events->removeHandler(EventTypes::PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget());
+  m_events->removeHandler(PrimaryScreenButtonUp, m_inputFilter);
-  m_events->removeHandler(EventTypes::PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget());
+  m_events->removeHandler(PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget());
-  m_events->removeHandler(EventTypes::PrimaryScreenWheel, m_primaryClient->getEventTarget());
+  m_events->removeHandler(PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget());
-  m_events->removeHandler(EventTypes::PrimaryScreenSaverActivated, m_primaryClient->getEventTarget());
+  m_events->removeHandler(PrimaryScreenWheel, m_primaryClient->getEventTarget());
-  m_events->removeHandler(EventTypes::PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget());
+  m_events->removeHandler(PrimaryScreenSaverActivated, m_primaryClient->getEventTarget());
-  m_events->removeHandler(EventTypes::PrimaryScreenFakeInputBegin, m_inputFilter);
+  m_events->removeHandler(PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget());
-  m_events->removeHandler(EventTypes::PrimaryScreenFakeInputEnd, m_inputFilter);
+  m_events->removeHandler(PrimaryScreenFakeInputBegin, m_inputFilter);
-  m_events->removeHandler(EventTypes::Timer, this);
+  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(Timer, client);
-    m_events->removeHandler(EventTypes::ClientProxyDisconnected, 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(ScreenShapeChanged, client->getEventTarget());
-  m_events->removeHandler(EventTypes::ClipboardGrabbed, client->getEventTarget());
+  m_events->removeHandler(ClipboardGrabbed, client->getEventTarget());
-  m_events->removeHandler(EventTypes::ClipboardChanged, 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(ClientProxyDisconnected, client);
-    m_events->removeHandler(EventTypes::Timer, i->second);
+    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));
     }
   }
 }