Event.h

Go to the documentation of this file.

/*
 * Deskflow -- mouse and keyboard sharing utility
 * SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
 * SPDX-FileCopyrightText: (C) 2004 Chris Schoeneman
 * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
 */
 
#pragma once
 
#include "EventTypes.h"
 
#include <assert.h>
#include <cstdlib>
 
using deskflow::EventTypes;
 
class EventData
{
public:
  EventData() = default;
  virtual ~EventData() = default;
};
 
class ExitEventData : public EventData
{
public:
  explicit ExitEventData(int exitCode) : m_exitCode(exitCode) {};
  ~ExitEventData() override = default;
  int exitCode() const
  {
    return m_exitCode;
  }
 
private:
  int m_exitCode;
};


class Event
{
public:
  using Flags = uint32_t;
  struct EventFlags
  {
    inline static const Flags NoFlags = 0x00;            
    inline static const Flags DeliverImmediately = 0x01; 
    inline static const Flags DontFreeData = 0x02;       
  };
 
  Event() = default;
  Event(const Event &) = delete;
  Event(Event &&other) = default;
  Event &operator=(const Event &) = delete;
  Event &operator=(Event &&) = default;


  explicit Event(EventTypes type, void *target = nullptr, void *data = nullptr, Flags flags = EventFlags::NoFlags)
      : m_type(type),
        m_target(target),
        m_data(data),
        m_flags(flags)
  {
    // do nothing
  }
 
  Event(EventTypes type, void *target, EventData *dataObject) : m_type(type), m_target(target), m_dataObject(dataObject)
  {
    // do nothing
  }




  static void deleteData(const Event &event)
  {
    switch (event.getType()) {
      using enum EventTypes;
    case Unknown:
    case System:
    case Timer:
      break;
 
    default:
      if ((event.getFlags() & EventFlags::DontFreeData) == 0) {
        free(event.getData());
        delete event.getDataObject();
      }
      break;
    }
  }


  void setDataObject(EventData *dataObject)
  {
    assert(m_dataObject == nullptr);
    m_dataObject = dataObject;
  };




  EventTypes getType() const
  {
    return m_type;
  }


  void *getTarget() const
  {
    return m_target;
  }


  void *getData() const
  {
    return m_data;
  }


  EventData *getDataObject() const
  {
    return m_dataObject;
  }


  Flags getFlags() const
  {
    return m_flags;
  }

 
private:
  EventTypes m_type = EventTypes::Unknown;
  void *m_target = nullptr;
  void *m_data = nullptr;
  Flags m_flags = EventFlags::NoFlags;
  EventData *m_dataObject = nullptr;
};