refactor: Event anon enum => EventFlags struct

src/lib/base/Event.cpp

@@ -63,7 +63,7 @@ void Event::deleteData(const Event &event)
     break;
 
   default:
-    if ((event.getFlags() & kDontFreeData) == 0) {
+    if ((event.getFlags() & EventFlags::DontFreeData) == 0) {
       free(event.getData());
       delete event.getDataObject();
     }

src/lib/base/Event.h

@@ -27,11 +27,11 @@ class Event
 {
 public:
   using Flags = uint32_t;
-  enum
+  struct EventFlags
   {
-    kNone = 0x00,               //!< No flags
+    inline static const Flags NoFlags = 0x00;            //!< No flags
-    kDeliverImmediately = 0x01, //!< Dispatch and free event immediately
+    inline static const Flags DeliverImmediately = 0x01; //!< Dispatch and free event immediately
-    kDontFreeData = 0x02        //!< Don't free data in deleteData
+    inline static const Flags DontFreeData = 0x02;       //!< Don't free data in deleteData
   };
 
   Event() = default;
@@ -45,7 +45,7 @@ public:
   \p target is the intended recipient of the event.
   \p flags is any combination of \c Flags.
   */
-  Event(EventTypes type, void *target = nullptr, void *data = nullptr, Flags flags = kNone);
+  Event(EventTypes type, void *target = nullptr, void *data = nullptr, Flags flags = EventFlags::NoFlags);
 
   //! Create \c Event with non-POD data
   /*!
@@ -113,6 +113,6 @@ private:
   EventTypes m_type = EventTypes::Unknown;
   void *m_target = nullptr;
   void *m_data = nullptr;
-  Flags m_flags = kNone;
+  Flags m_flags = EventFlags::NoFlags;
   EventData *m_dataObject = nullptr;
 };

src/lib/base/EventQueue.cpp

@@ -184,7 +184,7 @@ void EventQueue::addEvent(const Event &event)
     break;
   }
 
-  if ((event.getFlags() & Event::kDeliverImmediately) != 0) {
+  if ((event.getFlags() & Event::EventFlags::DeliverImmediately) != 0) {
     dispatchEvent(event);
     Event::deleteData(event);
   } else if (!(*m_readyCondVar)) {

src/lib/client/Client.cpp

@@ -157,7 +157,7 @@ void Client::refuseConnection(const char *msg)
   if (msg) {
     auto info = new FailInfo(msg);
     info->m_retry = true;
-    Event event(EventTypes::ClientConnectionRefused, getEventTarget(), info, Event::kDontFreeData);
+    Event event(EventTypes::ClientConnectionRefused, getEventTarget(), info, Event::EventFlags::DontFreeData);
     m_events->addEvent(event);
   }
 }
@@ -381,7 +381,7 @@ void Client::sendConnectionFailedEvent(const char *msg)
 {
   auto *info = new FailInfo(msg);
   info->m_retry = true;
-  Event event(EventTypes::ClientConnectionFailed, getEventTarget(), info, Event::kDontFreeData);
+  Event event(EventTypes::ClientConnectionFailed, getEventTarget(), info, Event::EventFlags::DontFreeData);
   m_events->addEvent(event);
 }
 

src/lib/net/TCPSocket.cpp

@@ -393,7 +393,9 @@ ISocketMultiplexerJob *TCPSocket::newJob()
 void TCPSocket::sendConnectionFailedEvent(const char *msg)
 {
   auto *info = new ConnectionFailedInfo(msg);
-  m_events->addEvent(Event(EventTypes::DataSocketConnectionFailed, getEventTarget(), info, Event::kDontFreeData));
+  m_events->addEvent(
+      Event(EventTypes::DataSocketConnectionFailed, getEventTarget(), info, Event::EventFlags::DontFreeData)
+  );
 }
 
 void TCPSocket::sendEvent(EventTypes type)

src/lib/platform/MSWindowsScreen.cpp

@@ -951,7 +951,8 @@ bool MSWindowsScreen::onEvent(HWND, UINT msg, WPARAM wParam, LPARAM lParam, LRES
   /* On windows 10 we don't receive WM_POWERBROADCAST after sleep.
    We receive only WM_TIMECHANGE hence this message is used to resume.*/
   case WM_TIMECHANGE:
-    m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::kDeliverImmediately));
+    m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::EventFlags::DeliverImmediately)
+    );
     break;
 
   case WM_POWERBROADCAST:
@@ -959,11 +960,15 @@ bool MSWindowsScreen::onEvent(HWND, UINT msg, WPARAM wParam, LPARAM lParam, LRES
     case PBT_APMRESUMEAUTOMATIC:
     case PBT_APMRESUMECRITICAL:
     case PBT_APMRESUMESUSPEND:
-      m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::kDeliverImmediately));
+      m_events->addEvent(
+          Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::EventFlags::DeliverImmediately)
+      );
       break;
 
     case PBT_APMSUSPEND:
-      m_events->addEvent(Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::kDeliverImmediately));
+      m_events->addEvent(
+          Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::EventFlags::DeliverImmediately)
+      );
       break;
     }
     *result = TRUE;

src/lib/platform/OSXScreen.mm

@@ -1421,7 +1421,9 @@ void OSXScreen::handlePowerChangeRequest(natural_t messageType, void *messageArg
     // OSXScreen has to handle this in the main thread so we have to
     // queue a confirm sleep event here.  we actually don't allow the
     // system to sleep until the event is handled.
-    m_events->addEvent(Event(EventTypes::OsxScreenConfirmSleep, getEventTarget(), messageArg, Event::kDontFreeData));
+    m_events->addEvent(
+        Event(EventTypes::OsxScreenConfirmSleep, getEventTarget(), messageArg, Event::EventFlags::DontFreeData)
+    );
     return;
 
   case kIOMessageSystemHasPoweredOn:
@@ -1446,7 +1448,9 @@ void OSXScreen::handleConfirmSleep(const Event &event)
     Lock lock(m_pmMutex);
     if (m_pmRootPort != 0) {
       // deliver suspend event immediately.
-      m_events->addEvent(Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::kDeliverImmediately));
+      m_events->addEvent(
+          Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::EventFlags::DeliverImmediately)
+      );
 
       LOG((CLOG_DEBUG "system will sleep"));
       IOAllowPowerChange(m_pmRootPort, messageArg);

src/lib/server/InputFilter.cpp

@@ -229,7 +229,9 @@ void InputFilter::LockCursorToScreenAction::perform(const Event &event)
 
   // send event
   Server::LockCursorToScreenInfo *info = Server::LockCursorToScreenInfo::alloc(s_state[m_mode]);
-  m_events->addEvent(Event(EventTypes::ServerLockCursorToScreen, event.getTarget(), info, Event::kDeliverImmediately));
+  m_events->addEvent(
+      Event(EventTypes::ServerLockCursorToScreen, event.getTarget(), info, Event::EventFlags::DeliverImmediately)
+  );
 }
 
 InputFilter::RestartServer::RestartServer(IEventQueue *events, Mode mode) : m_mode(mode), m_events(events)
@@ -294,7 +296,9 @@ void InputFilter::SwitchToScreenAction::perform(const Event &event)
 
   // send event
   Server::SwitchToScreenInfo *info = Server::SwitchToScreenInfo::alloc(screen);
-  m_events->addEvent(Event(EventTypes::ServerSwitchToScreen, event.getTarget(), info, Event::kDeliverImmediately));
+  m_events->addEvent(
+      Event(EventTypes::ServerSwitchToScreen, event.getTarget(), info, Event::EventFlags::DeliverImmediately)
+  );
 }
 
 InputFilter::SwitchInDirectionAction::SwitchInDirectionAction(IEventQueue *events, Direction direction)
@@ -324,7 +328,9 @@ std::string InputFilter::SwitchInDirectionAction::format() const
 void InputFilter::SwitchInDirectionAction::perform(const Event &event)
 {
   Server::SwitchInDirectionInfo *info = Server::SwitchInDirectionInfo::alloc(m_direction);
-  m_events->addEvent(Event(EventTypes::ServerSwitchInDirection, event.getTarget(), info, Event::kDeliverImmediately));
+  m_events->addEvent(
+      Event(EventTypes::ServerSwitchInDirection, event.getTarget(), info, Event::EventFlags::DeliverImmediately)
+  );
 }
 
 InputFilter::KeyboardBroadcastAction::KeyboardBroadcastAction(IEventQueue *events, Mode mode)
@@ -384,7 +390,9 @@ void InputFilter::KeyboardBroadcastAction::perform(const Event &event)
 
   // send event
   Server::KeyboardBroadcastInfo *info = Server::KeyboardBroadcastInfo::alloc(s_state[m_mode], m_screens);
-  m_events->addEvent(Event(EventTypes::ServerKeyboardBroadcast, event.getTarget(), info, Event::kDeliverImmediately));
+  m_events->addEvent(
+      Event(EventTypes::ServerKeyboardBroadcast, event.getTarget(), info, Event::EventFlags::DeliverImmediately)
+  );
 }
 
 InputFilter::KeystrokeAction::KeystrokeAction(IEventQueue *events, IPlatformScreen::KeyInfo *info, bool press)
@@ -445,11 +453,13 @@ std::string InputFilter::KeystrokeAction::format() const
 void InputFilter::KeystrokeAction::perform(const Event &event)
 {
   using enum EventTypes;
+  using Flags = Event::EventFlags;
+
   EventTypes type = m_press ? KeyStateKeyDown : KeyStateKeyUp;
 
-  m_events->addEvent(Event(PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Event::kDeliverImmediately));
+  m_events->addEvent(Event(PrimaryScreenFakeInputBegin, event.getTarget(), nullptr, Flags::DeliverImmediately));
-  m_events->addEvent(Event(type, event.getTarget(), m_keyInfo, Event::kDeliverImmediately | Event::kDontFreeData));
+  m_events->addEvent(Event(type, event.getTarget(), m_keyInfo, Flags::DeliverImmediately | Flags::DontFreeData));
-  m_events->addEvent(Event(PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Event::kDeliverImmediately));
+  m_events->addEvent(Event(PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Flags::DeliverImmediately));
 }
 
 const char *InputFilter::KeystrokeAction::formatName() const
@@ -503,12 +513,14 @@ void InputFilter::MouseButtonAction::perform(const Event &event)
   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(KeyStateKeyDown, event.getTarget(), modifierInfo, Event::kDeliverImmediately));
+    m_events->addEvent(Event(KeyStateKeyDown, event.getTarget(), modifierInfo, Event::EventFlags::DeliverImmediately));
   }
 
   // send button
   EventTypes type = m_press ? PrimaryScreenButtonDown : PrimaryScreenButtonUp;
-  m_events->addEvent(Event(type, event.getTarget(), m_buttonInfo, Event::kDeliverImmediately | Event::kDontFreeData));
+  m_events->addEvent(Event(
+      type, event.getTarget(), m_buttonInfo, Event::EventFlags::DeliverImmediately | Event::EventFlags::DontFreeData
+  ));
 }
 
 const char *InputFilter::MouseButtonAction::formatName() const
@@ -867,7 +879,8 @@ void InputFilter::handleEvent(const Event &event)
 {
   // copy event and adjust target
   Event myEvent(
-      event.getType(), this, event.getData(), event.getFlags() | Event::kDontFreeData | Event::kDeliverImmediately
+      event.getType(), this, event.getData(),
+      event.getFlags() | Event::EventFlags::DontFreeData | Event::EventFlags::DeliverImmediately
   );
 
   // let each rule try to match the event until one does