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

Port simplified EventTypes from 8b23570379

Browse source
This commit is contained in:
sithlord48 2025-05-01 21:50:53 -04:00 committed by Chris Rizzitello
parent 118f867fd1
commit 55a7fa3266
55 changed files with 684 additions and 1631 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/lib/base/CMakeLists.txt
View file

@ -9,7 +9,6 @@ add_library(base STATIC
Event.h Event.h
EventQueue.cpp EventQueue.cpp
EventQueue.h EventQueue.h
EventTypes.cpp
EventTypes.h EventTypes.h
FinalAction.h FinalAction.h
FunctionEventJob.cpp FunctionEventJob.cpp

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

@ -11,12 +11,12 @@
// Event // Event
// //
Event::Event() : m_type(kUnknown), m_target(nullptr), m_data(nullptr), m_flags(0), m_dataObject(nullptr) Event::Event() : m_type(EventTypes::Unknown), m_target(nullptr), m_data(nullptr), m_flags(0), m_dataObject(nullptr)
{ {
// do nothing // do nothing
} }
Event::Event(Type type, void *target, void *data, Flags flags) Event::Event(EventTypes type, void *target, void *data, Flags flags)
: m_type(type), : m_type(type),
m_target(target), m_target(target),
m_data(data), m_data(data),
@ -26,7 +26,7 @@ Event::Event(Type type, void *target, void *data, Flags flags)
// do nothing // do nothing
} }
Event::Event(Type type, void *target, EventData *dataObject) Event::Event(EventTypes type, void *target, EventData *dataObject)
: m_type(type), : m_type(type),
m_target(target), m_target(target),
m_data(nullptr), m_data(nullptr),
@ -35,7 +35,7 @@ Event::Event(Type type, void *target, EventData *dataObject)
{ {
} }
Event::Type Event::getType() const EventTypes Event::getType() const
{ {
return m_type; return m_type;
} }
@ -63,10 +63,10 @@ Event::Flags Event::getFlags() const
void Event::deleteData(const Event &event) void Event::deleteData(const Event &event)
{ {
switch (event.getType()) { switch (event.getType()) {
case kUnknown: case EventTypes::Unknown:
case kQuit: case EventTypes::Quit:
case kSystem: case EventTypes::System:
case kTimer: case EventTypes::Timer:
break; break;
default: default:

21
src/lib/base/Event.h
View file

@ -7,8 +7,11 @@
#pragma once #pragma once
#include "EventTypes.h"
#include "common/Common.h" #include "common/Common.h"
using deskflow::EventTypes;
class EventData class EventData
{ {
public: public:
@ -23,16 +26,6 @@ A \c Event holds an event type and a pointer to event data.
class Event class Event
{ {
public: public:
using Type = uint32_t;
enum
{
kUnknown, //!< The event type is unknown
kQuit, //!< The quit event
kSystem, //!< The data points to a system event type
kTimer, //!< The data points to timer info
kLast //!< Must be last
};
using Flags = uint32_t; using Flags = uint32_t;
enum enum
{ {
@ -52,7 +45,7 @@ public:
\p target is the intended recipient of the event. \p target is the intended recipient of the event.
\p flags is any combination of \c Flags. \p flags is any combination of \c Flags.
*/ */
Event(Type type, void *target = nullptr, void *data = nullptr, Flags flags = kNone); Event(EventTypes type, void *target = nullptr, void *data = nullptr, Flags flags = kNone);
//! Create \c Event with non-POD data //! Create \c Event with non-POD data
/*! /*!
@ -60,7 +53,7 @@ public:
\p target is the intended recipient of the event. \p target is the intended recipient of the event.
\p dataObject with event data \p dataObject with event data
*/ */
Event(Type type, void *target, EventData *dataObject); Event(EventTypes type, void *target, EventData *dataObject);
//! @name manipulators //! @name manipulators
//@{ //@{
@ -86,7 +79,7 @@ public:
/*! /*!
Returns the event type. Returns the event type.
*/ */
Type getType() const; EventTypes getType() const;
//! Get the event target //! Get the event target
/*! /*!
@ -117,7 +110,7 @@ public:
//@} //@}
private: private:
Type m_type; EventTypes m_type;
void *m_target; void *m_target;
void *m_data; void *m_data;
Flags m_flags; Flags m_flags;

92
src/lib/base/EventQueue.cpp
View file

@ -16,29 +16,11 @@
#include <stdexcept> #include <stdexcept>
EVENT_TYPE_ACCESSOR(Client)
EVENT_TYPE_ACCESSOR(IStream)
EVENT_TYPE_ACCESSOR(IDataSocket)
EVENT_TYPE_ACCESSOR(IListenSocket)
EVENT_TYPE_ACCESSOR(ISocket)
EVENT_TYPE_ACCESSOR(OSXScreen)
EVENT_TYPE_ACCESSOR(ClientListener)
EVENT_TYPE_ACCESSOR(ClientProxy)
EVENT_TYPE_ACCESSOR(ClientProxyUnknown)
EVENT_TYPE_ACCESSOR(Server)
EVENT_TYPE_ACCESSOR(ServerApp)
EVENT_TYPE_ACCESSOR(IKeyState)
EVENT_TYPE_ACCESSOR(IPrimaryScreen)
EVENT_TYPE_ACCESSOR(IScreen)
EVENT_TYPE_ACCESSOR(Clipboard)
EVENT_TYPE_ACCESSOR(File)
EVENT_TYPE_ACCESSOR(Ei)
// interrupt handler. this just adds a quit event to the queue. // interrupt handler. this just adds a quit event to the queue.
static void interrupt(Arch::ESignal, void *data) static void interrupt(Arch::ESignal, void *data)
{ {
auto *events = static_cast<EventQueue *>(data); auto *events = static_cast<EventQueue *>(data);
events->addEvent(Event(Event::kQuit)); events->addEvent(Event(EventTypes::Quit));
} }
// //
@ -47,24 +29,6 @@ static void interrupt(Arch::ESignal, void *data)
EventQueue::EventQueue() EventQueue::EventQueue()
: m_systemTarget(0), : m_systemTarget(0),
m_nextType(Event::kLast),
m_typesForClient(nullptr),
m_typesForIStream(nullptr),
m_typesForIDataSocket(nullptr),
m_typesForIListenSocket(nullptr),
m_typesForISocket(nullptr),
m_typesForOSXScreen(nullptr),
m_typesForClientListener(nullptr),
m_typesForClientProxy(nullptr),
m_typesForClientProxyUnknown(nullptr),
m_typesForServer(nullptr),
m_typesForServerApp(nullptr),
m_typesForIKeyState(nullptr),
m_typesForIPrimaryScreen(nullptr),
m_typesForIScreen(nullptr),
m_typesForClipboard(nullptr),
m_typesForFile(nullptr),
m_typesForEi(nullptr),
m_readyMutex(new Mutex), m_readyMutex(new Mutex),
m_readyCondVar(new CondVar<bool>(m_readyMutex, false)) m_readyCondVar(new CondVar<bool>(m_readyMutex, false))
{ {
@ -103,49 +67,13 @@ void EventQueue::loop()
Event event; Event event;
getEvent(event); getEvent(event);
while (event.getType() != Event::kQuit) { while (event.getType() != EventTypes::Quit) {
dispatchEvent(event); dispatchEvent(event);
Event::deleteData(event); Event::deleteData(event);
getEvent(event); getEvent(event);
} }
} }
Event::Type EventQueue::registerTypeOnce(Event::Type &type, const char *name)
{
ArchMutexLock lock(m_mutex);
if (type == Event::kUnknown) {
m_typeMap.insert(std::make_pair(m_nextType, name));
LOG((CLOG_DEBUG1 "registered event type %s as %d", name, m_nextType));
type = m_nextType++;
}
return type;
}
const char *EventQueue::getTypeName(Event::Type type)
{
switch (type) {
case Event::kUnknown:
return "nil";
case Event::kQuit:
return "quit";
case Event::kSystem:
return "system";
case Event::kTimer:
return "timer";
default:
TypeMap::const_iterator i = m_typeMap.find(type);
if (i == m_typeMap.end()) {
return "<unknown>";
} else {
return i->second;
}
}
}
void EventQueue::adoptBuffer(IEventQueueBuffer *buffer) void EventQueue::adoptBuffer(IEventQueueBuffer *buffer)
{ {
ArchMutexLock lock(m_mutex); ArchMutexLock lock(m_mutex);
@ -235,7 +163,7 @@ bool EventQueue::dispatchEvent(const Event &event)
void *target = event.getTarget(); void *target = event.getTarget();
IEventJob *job = getHandler(event.getType(), target); IEventJob *job = getHandler(event.getType(), target);
if (job == nullptr) { if (job == nullptr) {
job = getHandler(Event::kUnknown, target); job = getHandler(EventTypes::Unknown, target);
} }
if (job != nullptr) { if (job != nullptr) {
job->run(event); job->run(event);
@ -248,9 +176,9 @@ void EventQueue::addEvent(const Event &event)
{ {
// discard bogus event types // discard bogus event types
switch (event.getType()) { switch (event.getType()) {
case Event::kUnknown: case EventTypes::Unknown:
case Event::kSystem: case EventTypes::System:
case Event::kTimer: case EventTypes::Timer:
return; return;
default: default:
@ -332,7 +260,7 @@ void EventQueue::deleteTimer(EventQueueTimer *timer)
m_buffer->deleteTimer(timer); m_buffer->deleteTimer(timer);
} }
void EventQueue::adoptHandler(Event::Type type, void *target, IEventJob *handler) void EventQueue::adoptHandler(EventTypes type, void *target, IEventJob *handler)
{ {
ArchMutexLock lock(m_mutex); ArchMutexLock lock(m_mutex);
IEventJob *&job = m_handlers[target][type]; IEventJob *&job = m_handlers[target][type];
@ -340,7 +268,7 @@ void EventQueue::adoptHandler(Event::Type type, void *target, IEventJob *handler
job = handler; job = handler;
} }
void EventQueue::removeHandler(Event::Type type, void *target) void EventQueue::removeHandler(EventTypes type, void *target)
{ {
IEventJob *handler = nullptr; IEventJob *handler = nullptr;
{ {
@ -385,7 +313,7 @@ bool EventQueue::isEmpty() const
return (m_buffer->isEmpty() && getNextTimerTimeout() != 0.0); return (m_buffer->isEmpty() && getNextTimerTimeout() != 0.0);
} }
IEventJob *EventQueue::getHandler(Event::Type type, void *target) const IEventJob *EventQueue::getHandler(EventTypes type, void *target) const
{ {
ArchMutexLock lock(m_mutex); ArchMutexLock lock(m_mutex);
HandlerTable::const_iterator index = m_handlers.find(target); HandlerTable::const_iterator index = m_handlers.find(target);
@ -464,7 +392,7 @@ bool EventQueue::hasTimerExpired(Event &event)
// prepare event and reset the timer's clock // prepare event and reset the timer's clock
timer.fillEvent(m_timerEvent); timer.fillEvent(m_timerEvent);
event = Event(Event::kTimer, timer.getTarget(), &m_timerEvent); event = Event(EventTypes::Timer, timer.getTarget(), &m_timerEvent);
timer.reset(); timer.reset();
// reinsert timer into queue if it's not a one-shot // reinsert timer into queue if it's not a one-shot

66
src/lib/base/EventQueue.h
View file

@ -43,13 +43,11 @@ public:
EventQueueTimer *newTimer(double duration, void *target) override; EventQueueTimer *newTimer(double duration, void *target) override;
EventQueueTimer *newOneShotTimer(double duration, void *target) override; EventQueueTimer *newOneShotTimer(double duration, void *target) override;
void deleteTimer(EventQueueTimer *) override; void deleteTimer(EventQueueTimer *) override;
void adoptHandler(Event::Type type, void *target, IEventJob *handler) override; void adoptHandler(EventTypes type, void *target, IEventJob *handler) override;
void removeHandler(Event::Type type, void *target) override; void removeHandler(EventTypes type, void *target) override;
void removeHandlers(void *target) override; void removeHandlers(void *target) override;
Event::Type registerTypeOnce(Event::Type &type, const char *name) override;
bool isEmpty() const override; bool isEmpty() const override;
IEventJob *getHandler(Event::Type type, void *target) const override; IEventJob *getHandler(EventTypes type, void *target) const override;
const char *getTypeName(Event::Type type) override;
void *getSystemTarget() override; void *getSystemTarget() override;
void waitForReady() const override; void waitForReady() const override;
@ -92,18 +90,12 @@ private:
using TimerQueue = PriorityQueue<Timer>; using TimerQueue = PriorityQueue<Timer>;
using EventTable = std::map<uint32_t, Event>; using EventTable = std::map<uint32_t, Event>;
using EventIDList = std::vector<uint32_t>; using EventIDList = std::vector<uint32_t>;
using TypeMap = std::map<Event::Type, const char *>; using TypeHandlerTable = std::map<EventTypes, IEventJob *>;
using NameMap = std::map<std::string, Event::Type>;
using TypeHandlerTable = std::map<Event::Type, IEventJob *>;
using HandlerTable = std::map<void *, TypeHandlerTable>; using HandlerTable = std::map<void *, TypeHandlerTable>;
int m_systemTarget; int m_systemTarget;
ArchMutex m_mutex; ArchMutex m_mutex;
// registered events
Event::Type m_nextType;
TypeMap m_typeMap;
// buffer of events // buffer of events
IEventQueueBuffer *m_buffer; IEventQueueBuffer *m_buffer;
@ -120,58 +112,8 @@ private:
// event handlers // event handlers
HandlerTable m_handlers; HandlerTable m_handlers;
public:
//
// Event type providers.
//
ClientEvents &forClient() override;
IStreamEvents &forIStream() override;
IDataSocketEvents &forIDataSocket() override;
IListenSocketEvents &forIListenSocket() override;
ISocketEvents &forISocket() override;
OSXScreenEvents &forOSXScreen() override;
ClientListenerEvents &forClientListener() override;
ClientProxyEvents &forClientProxy() override;
ClientProxyUnknownEvents &forClientProxyUnknown() override;
ServerEvents &forServer() override;
ServerAppEvents &forServerApp() override;
IKeyStateEvents &forIKeyState() override;
IPrimaryScreenEvents &forIPrimaryScreen() override;
IScreenEvents &forIScreen() override;
ClipboardEvents &forClipboard() override;
FileEvents &forFile() override;
EiEvents &forEi() override;
private: private:
ClientEvents *m_typesForClient;
IStreamEvents *m_typesForIStream;
IDataSocketEvents *m_typesForIDataSocket;
IListenSocketEvents *m_typesForIListenSocket;
ISocketEvents *m_typesForISocket;
OSXScreenEvents *m_typesForOSXScreen;
ClientListenerEvents *m_typesForClientListener;
ClientProxyEvents *m_typesForClientProxy;
ClientProxyUnknownEvents *m_typesForClientProxyUnknown;
ServerEvents *m_typesForServer;
ServerAppEvents *m_typesForServerApp;
IKeyStateEvents *m_typesForIKeyState;
IPrimaryScreenEvents *m_typesForIPrimaryScreen;
IScreenEvents *m_typesForIScreen;
ClipboardEvents *m_typesForClipboard;
FileEvents *m_typesForFile;
EiEvents *m_typesForEi;
Mutex *m_readyMutex; Mutex *m_readyMutex;
CondVar<bool> *m_readyCondVar; CondVar<bool> *m_readyCondVar;
std::queue<Event> m_pending; std::queue<Event> m_pending;
}; };
#define EVENT_TYPE_ACCESSOR(type_) \
type_##Events& \
EventQueue::for##type_() \
{ \
if (m_typesFor##type_ == nullptr) { \
m_typesFor##type_ = new type_##Events(); \
m_typesFor##type_->setEvents(dynamic_cast<IEventQueue *>(this)); \
} \
return *m_typesFor##type_; \
}

170
src/lib/base/EventTypes.cpp
View file

@ -1,170 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "base/EventTypes.h"
#include "base/IEventQueue.h"
#include <assert.h>
EventTypes::EventTypes() : m_events(nullptr)
{
}
IEventQueue *EventTypes::getEvents() const
{
assert(m_events != nullptr);
return m_events;
}
void EventTypes::setEvents(IEventQueue *events)
{
m_events = events;
}
//
// Client
//
REGISTER_EVENT(Client, connected)
REGISTER_EVENT(Client, connectionFailed)
REGISTER_EVENT(Client, connectionRefused)
REGISTER_EVENT(Client, disconnected)
//
// IStream
//
REGISTER_EVENT(IStream, inputReady)
REGISTER_EVENT(IStream, outputFlushed)
REGISTER_EVENT(IStream, outputError)
REGISTER_EVENT(IStream, inputShutdown)
REGISTER_EVENT(IStream, outputShutdown)
REGISTER_EVENT(IStream, inputFormatError)
//
// IDataSocket
//
REGISTER_EVENT(IDataSocket, connected)
REGISTER_EVENT(IDataSocket, secureConnected)
REGISTER_EVENT(IDataSocket, connectionFailed)
//
// IListenSocket
//
REGISTER_EVENT(IListenSocket, connecting)
//
// ISocket
//
REGISTER_EVENT(ISocket, disconnected)
REGISTER_EVENT(ISocket, stopRetry)
//
// OSXScreen
//
REGISTER_EVENT(OSXScreen, confirmSleep)
//
// ClientListener
//
REGISTER_EVENT(ClientListener, accepted)
REGISTER_EVENT(ClientListener, connected)
//
// ClientProxy
//
REGISTER_EVENT(ClientProxy, ready)
REGISTER_EVENT(ClientProxy, disconnected)
//
// ClientProxyUnknown
//
REGISTER_EVENT(ClientProxyUnknown, success)
REGISTER_EVENT(ClientProxyUnknown, failure)
//
// Server
//
REGISTER_EVENT(Server, error)
REGISTER_EVENT(Server, connected)
REGISTER_EVENT(Server, disconnected)
REGISTER_EVENT(Server, switchToScreen)
REGISTER_EVENT(Server, switchInDirection)
REGISTER_EVENT(Server, keyboardBroadcast)
REGISTER_EVENT(Server, lockCursorToScreen)
REGISTER_EVENT(Server, screenSwitched)
//
// ServerApp
//
REGISTER_EVENT(ServerApp, reloadConfig)
REGISTER_EVENT(ServerApp, forceReconnect)
REGISTER_EVENT(ServerApp, resetServer)
//
// IKeyState
//
REGISTER_EVENT(IKeyState, keyDown)
REGISTER_EVENT(IKeyState, keyUp)
REGISTER_EVENT(IKeyState, keyRepeat)
//
// IPrimaryScreen
//
REGISTER_EVENT(IPrimaryScreen, buttonDown)
REGISTER_EVENT(IPrimaryScreen, buttonUp)
REGISTER_EVENT(IPrimaryScreen, motionOnPrimary)
REGISTER_EVENT(IPrimaryScreen, motionOnSecondary)
REGISTER_EVENT(IPrimaryScreen, wheel)
REGISTER_EVENT(IPrimaryScreen, screensaverActivated)
REGISTER_EVENT(IPrimaryScreen, screensaverDeactivated)
REGISTER_EVENT(IPrimaryScreen, hotKeyDown)
REGISTER_EVENT(IPrimaryScreen, hotKeyUp)
REGISTER_EVENT(IPrimaryScreen, fakeInputBegin)
REGISTER_EVENT(IPrimaryScreen, fakeInputEnd)
//
// IScreen
//
REGISTER_EVENT(IScreen, error)
REGISTER_EVENT(IScreen, shapeChanged)
REGISTER_EVENT(IScreen, suspend)
REGISTER_EVENT(IScreen, resume)
//
// Clipboard
//
REGISTER_EVENT(Clipboard, clipboardGrabbed)
REGISTER_EVENT(Clipboard, clipboardChanged)
REGISTER_EVENT(Clipboard, clipboardSending)
//
// File
//
REGISTER_EVENT(File, fileChunkSending)
REGISTER_EVENT(File, fileReceiveCompleted)
REGISTER_EVENT(File, keepAlive)
//
// Ei
//
REGISTER_EVENT(Ei, connected)
REGISTER_EVENT(Ei, sessionClosed)

950
src/lib/base/EventTypes.h
View file

@ -1,730 +1,244 @@
/* /*
* Deskflow -- mouse and keyboard sharing utility * Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2023 Input-Leap Developers
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd. * SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/ */
#pragma once #pragma once
#include "base/Event.h" #include <stdint.h>
namespace deskflow {
class IEventQueue; enum class EventTypes : uint32_t
class EventTypes
{ {
public: /** An unknown event type. This type is used as a placeholder for unknown events when
EventTypes(); filtering events.
void setEvents(IEventQueue *events); */
Unknown,
protected: /// Exit has been requested.
IEventQueue *getEvents() const; Quit,
private: /// This event is sent when system event occurs. The data is a pointer to system event type
IEventQueue *m_events; System,
};
/// This event is sent when a timer event occurs. The data is pointer to TimerInfo.
#define REGISTER_EVENT(type_, name_) \ Timer,
Event::Type type_##Events::name_() \
{ \ /// This event is sent when the client has successfully connected to the server.
return getEvents()->registerTypeOnce(m_##name_, __FUNCTION__); \ ClientConnected,
}
/** This event is sent when the server refuses the client */
class ClientEvents : public EventTypes ClientConnectionRefused,
{
public: /** This event is sent when the server fails for some reason.
//! @name accessors The event data is a pointer to FailInfo.
//@{ */
ClientConnectionFailed,
//! Get connected event type
/*! /** This event is sent when the client has disconnected from the server (and only after having
Returns the connected event type. This is sent when the client has successfully connected).
successfully connected to the server. */
*/ ClientDisconnected,
Event::Type connected();
/// A stream sends this event when \c read() will return with data.
//! Get connection failed event type StreamInputReady,
/*!
Returns the connection failed event type. This is sent when the /** A stream sends this event when the output buffer has been flushed. If there have been no
server fails for some reason. The event data is a FailInfo*. writes since the event was posted, calling \c shutdownOutput() or close() will not discard
*/ any data and \c flush() will return immediately.
Event::Type connectionFailed(); */
StreamOutputFlushed,
//! Get connection refused event type
/*! /// A stream sends this event when a write has failed.
Returns the connection refused event type. This is sent when the StreamOutputError,
server refuses for some reason. The event data is a FailInfo*.
*/ /** This event is sent when the input side of the stream has shutdown. When the input has
Event::Type connectionRefused(); shutdown, no more data will ever be available to read.
*/
//! Get disconnected event type StreamInputShutdown,
/*!
Returns the disconnected event type. This is sent when the client /** This event is sent when the output side of the stream has shutdown. When the output has
has disconnected from the server (and only after having successfully shutdown, no more data can ever be written to the stream. Any attempt to do so will
connected). generate a output error event.
*/ */
Event::Type disconnected(); StreamOutputShutdown,
//@} /// This event is sent when a stream receives an irrecoverable input format error.
StreamInputFormatError,
private:
Event::Type m_connected = Event::kUnknown; /// A socket sends this event when a remote connection has been established.
Event::Type m_connectionFailed = Event::kUnknown; DataSocketConnected,
Event::Type m_connectionRefused = Event::kUnknown;
Event::Type m_disconnected = Event::kUnknown; /// A secure socket sends this event when a remote connection has been established.
}; DataSocketSecureConnected,
class IStreamEvents : public EventTypes /** A socket sends this event when an attempt to connect to a remote port has failed.
{ The data is a pointer to a ConnectionFailedInfo.
public: */
IStreamEvents() DataSocketConnectionFailed,
: m_inputReady(Event::kUnknown),
m_outputFlushed(Event::kUnknown), /// A socket sends this event when a remote connection is waiting to be accepted.
m_outputError(Event::kUnknown), ListenSocketConnecting,
m_inputShutdown(Event::kUnknown),
m_outputShutdown(Event::kUnknown) /** A socket sends this event when the remote side of the socket has disconnected or
{ shutdown both input and output.
} */
SocketDisconnected,
//! @name accessors
//@{ /// This is sent when the client doesn't want to reconnect after it disconnects from the server.
SocketStopRetry,
//! Get input ready event type
/*! OsxScreenConfirmSleep,
Returns the input ready event type. A stream sends this event
when \c read() will return with data. /// This event is sent whenever a server accepts a client.
*/ ClientListenerAccepted,
Event::Type inputReady();
/** This event is sent when the client has completed the initial handshake. Until it is sent,
//! Get output flushed event type the client is not fully connected.
/*! */
Returns the output flushed event type. A stream sends this event ClientProxyReady,
when the output buffer has been flushed. If there have been no
writes since the event was posted, calling \c shutdownOutput() or /** This event is sent when the client disconnects or is disconnected. The target is
\c close() will not discard any data and \c flush() will return getEventTarget().
immediately. */
*/ ClientProxyDisconnected,
Event::Type outputFlushed();
/** This event is sent when the client has correctly responded to the hello message.
//! Get output error event type The target is this.
/*! */
Returns the output error event type. A stream sends this event ClientProxyUnknownSuccess,
when a write has failed.
*/ /** This event is sent when a client fails to correctly respond to the hello message.
Event::Type outputError(); The target is this.
*/
//! Get input shutdown event type ClientProxyUnknownFailure,
/*!
Returns the input shutdown event type. This is sent when the /** This event is sent when a client screen has connected.
input side of the stream has shutdown. When the input has The event data is a pointer to ScreenConnectedInfo that indicates the connected screen.
shutdown, no more data will ever be available to read. */
*/ ServerConnected,
Event::Type inputShutdown();
/// This is event sent when all the clients have disconnected.
//! Get output shutdown event type ServerDisconnected,
/*!
Returns the output shutdown event type. This is sent when the /** This event is sent to inform the server to switch screens.
output side of the stream has shutdown. When the output has The event data is a pointer to SwitchToScreenInfo that indicates the target screen.
shutdown, no more data can ever be written to the stream. Any */
attempt to do so will generate a output error event. ServerSwitchToScreen,
*/
Event::Type outputShutdown(); /// This event is sent to inform the server to toggle screens. These is no event data.
ServerToggleScreen,
/** Get input format error event type
This is sent when a stream receives an irrecoverable input format error. /** This event is sent to inform the server to switch screens.
*/ The event data is a pointer to SwitchInDirectionInfo that indicates the target direction.
Event::Type inputFormatError(); */
ServerSwitchInDirection,
//@}
/** This event is sent to inform the server to turn keyboard broadcasting on or off.
private: The event data is a pointer to KeyboardBroadcastInfo.
Event::Type m_inputReady; */
Event::Type m_outputFlushed; ServerKeyboardBroadcast,
Event::Type m_outputError;
Event::Type m_inputShutdown; /** This event is sent to inform the server to lock the cursor to the active screen or to
Event::Type m_outputShutdown; unlock it. The event data is a pointer to LockCursorToScreenInfo.
Event::Type m_inputFormatError; */
}; ServerLockCursorToScreen,
class IDataSocketEvents : public EventTypes /// This event is sent when the screen has been switched to a client.
{ ServerScreenSwitched,
public:
IDataSocketEvents() ServerAppReloadConfig,
: m_connected(Event::kUnknown), ServerAppForceReconnect,
m_secureConnected(Event::kUnknown), ServerAppResetServer,
m_connectionFailed(Event::kUnknown)
{ /// This event is sent when key is down. Event data is a pointer to KeyInfo (count == 1)
} KeyStateKeyDown,
/// This event is sent when key is up. Event data is a pointer to KeyInfo (count == 1)
//! @name accessors KeyStateKeyUp,
//@{ /// This event is sent when key is repeated. Event data is a pointer to KeyInfo.
KeyStateKeyRepeat,
//! Get connected event type
/*! /// This event is sent when button is down. Event data is a pointer to ButtonInfo
Returns the socket connected event type. A socket sends this PrimaryScreenButtonDown,
event when a remote connection has been established.
*/ /// This event is sent when button is up. Event data is a pointer to ButtonInfo
Event::Type connected(); PrimaryScreenButtonUp,
//! Get secure connected event type /** This event is sent when mouse moves on primary screen.
/*! Event data is a pointer to MotionInfo, the values are absolute position.
Returns the secure socket connected event type. A secure socket sends */
this event when a remote connection has been established. PrimaryScreenMotionOnPrimary,
*/
Event::Type secureConnected(); /** This event is sent when mouse moves on secondary screen.
Event data is a pointer to MotionInfo, the values are relative motion deltas.
//! Get connection failed event type */
/*! PrimaryScreenMotionOnSecondary,
Returns the socket connection failed event type. A socket sends
this event when an attempt to connect to a remote port has failed. /// This event is sent when mouse wheel is rotated. Event data is a pointer to WheelInfo.
The data is a pointer to a ConnectionFailedInfo. PrimaryScreenWheel,
*/
Event::Type connectionFailed(); /// This event is sent when screensaver is activated.
PrimaryScreenSaverActivated,
//@}
/// This event is sent when screensaver is deactivated.
private: PrimaryScreenSaverDeactivated,
Event::Type m_connected;
Event::Type m_secureConnected; /// This event is sent when hotkey is down. Event data is a pointer to HotKeyInfo.
Event::Type m_connectionFailed; PrimaryScreenHotkeyDown,
};
/// This event is sent when hotkey is up. Event data is a pointer to HotKeyInfo.
class IListenSocketEvents : public EventTypes PrimaryScreenHotkeyUp,
{
public: /// This event is sent when fake input begins.
IListenSocketEvents() : m_connecting(Event::kUnknown) PrimaryScreenFakeInputBegin,
{
} /// This event is sent when fake input ends.
PrimaryScreenFakeInputEnd,
//! @name accessors
//@{ /** This event is sent whenever the screen has failed for some reason (e.g. the X Windows
server died).
//! Get connecting event type */
/*! ScreenError,
Returns the socket connecting event type. A socket sends this
event when a remote connection is waiting to be accepted. /// This event is sent whenever the screen's shape changes.
*/ ScreenShapeChanged,
Event::Type connecting();
/** This event is sent whenever the system goes to sleep or a user session is deactivated (fast
//@} user switching).
*/
private: ScreenSuspend,
Event::Type m_connecting;
}; /** This event is sent whenever the system wakes up or a user session is activated (fast user
switching).
class ISocketEvents : public EventTypes */
{ ScreenResume,
public:
ISocketEvents() : m_disconnected(Event::kUnknown), m_stopRetry(Event::kUnknown) /** This event is sent whenever the clipboard is grabbed by some other application so we
{ don't own it anymore. The data is a pointer to a ClipboardInfo.
} */
ClipboardGrabbed,
//! @name accessors
//@{ /** This event is sent whenever the contents of the clipboard has changed.
The data is a pointer to a ClipboardInfo.
//! Get disconnected event type */
/*! ClipboardChanged,
Returns the socket disconnected event type. A socket sends this
event when the remote side of the socket has disconnected or /// This event is sent whenever a clipboard chunk is transferred.
shutdown both input and output. ClipboardSending,
*/
Event::Type disconnected(); /// This event is sent whenever a file chunk is transferred.
FileChunkSending,
//! Get stop retry event type
/*! /// This event is sent whenever file has been received.
Returns the stop retry event type. This is sent when the client FileReceiveCompleted,
doesn't want to reconnect after it disconnects from the server.
*/ /// This event is a keepalive event.
Event::Type stopRetry(); FileKeepAlive,
//@} /// Start libEI
EIConnected,
private: /// Stop libEi
Event::Type m_disconnected; EISessionClosed
Event::Type m_stopRetry;
};
class OSXScreenEvents : public EventTypes
{
public:
OSXScreenEvents() : m_confirmSleep(Event::kUnknown)
{
}
//! @name accessors
//@{
Event::Type confirmSleep();
//@}
private:
Event::Type m_confirmSleep;
};
class ClientListenerEvents : public EventTypes
{
public:
ClientListenerEvents() : m_accepted(Event::kUnknown), m_connected(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get accepted event type
/*!
Returns the accepted event type. This is sent whenever a server
accepts a client.
*/
Event::Type accepted();
//! Get connected event type
/*!
Returns the connected event type. This is sent whenever a
a client connects.
*/
Event::Type connected();
//@}
private:
Event::Type m_accepted;
Event::Type m_connected;
};
class ClientProxyEvents : public EventTypes
{
public:
ClientProxyEvents() : m_ready(Event::kUnknown), m_disconnected(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get ready event type
/*!
Returns the ready event type. This is sent when the client has
completed the initial handshake. Until it is sent, the client is
not fully connected.
*/
Event::Type ready();
//! Get disconnect event type
/*!
Returns the disconnect event type. This is sent when the client
disconnects or is disconnected. The target is getEventTarget().
*/
Event::Type disconnected();
//@}
private:
Event::Type m_ready;
Event::Type m_disconnected;
};
class ClientProxyUnknownEvents : public EventTypes
{
public:
ClientProxyUnknownEvents() : m_success(Event::kUnknown), m_failure(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get success event type
/*!
Returns the success event type. This is sent when the client has
correctly responded to the hello message. The target is this.
*/
Event::Type success();
//! Get failure event type
/*!
Returns the failure event type. This is sent when a client fails
to correctly respond to the hello message. The target is this.
*/
Event::Type failure();
//@}
private:
Event::Type m_success;
Event::Type m_failure;
};
class ServerEvents : public EventTypes
{
public:
ServerEvents()
: m_error(Event::kUnknown),
m_connected(Event::kUnknown),
m_disconnected(Event::kUnknown),
m_switchToScreen(Event::kUnknown),
m_switchInDirection(Event::kUnknown),
m_keyboardBroadcast(Event::kUnknown),
m_lockCursorToScreen(Event::kUnknown),
m_screenSwitched(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get error event type
/*!
Returns the error event type. This is sent when the server fails
for some reason.
*/
Event::Type error();
//! Get connected event type
/*!
Returns the connected event type. This is sent when a client screen
has connected. The event data is a \c ScreenConnectedInfo* that
indicates the connected screen.
*/
Event::Type connected();
//! Get disconnected event type
/*!
Returns the disconnected event type. This is sent when all the
clients have disconnected.
*/
Event::Type disconnected();
//! Get switch to screen event type
/*!
Returns the switch to screen event type. The server responds to this
by switching screens. The event data is a \c SwitchToScreenInfo*
that indicates the target screen.
*/
Event::Type switchToScreen();
//! Get switch in direction event type
/*!
Returns the switch in direction event type. The server responds to this
by switching screens. The event data is a \c SwitchInDirectionInfo*
that indicates the target direction.
*/
Event::Type switchInDirection();
//! Get keyboard broadcast event type
/*!
Returns the keyboard broadcast event type. The server responds
to this by turning on keyboard broadcasting or turning it off. The
event data is a \c KeyboardBroadcastInfo*.
*/
Event::Type keyboardBroadcast();
//! Get lock cursor event type
/*!
Returns the lock cursor event type. The server responds to this
by locking the cursor to the active screen or unlocking it. The
event data is a \c LockCursorToScreenInfo*.
*/
Event::Type lockCursorToScreen();
//! Get screen switched event type
/*!
Returns the screen switched event type. This is raised when the
screen has been switched to a client.
*/
Event::Type screenSwitched();
//@}
private:
Event::Type m_error;
Event::Type m_connected;
Event::Type m_disconnected;
Event::Type m_switchToScreen;
Event::Type m_switchInDirection;
Event::Type m_keyboardBroadcast;
Event::Type m_lockCursorToScreen;
Event::Type m_screenSwitched;
};
class ServerAppEvents : public EventTypes
{
public:
ServerAppEvents() : m_reloadConfig(Event::kUnknown), m_forceReconnect(Event::kUnknown), m_resetServer(Event::kUnknown)
{
}
//! @name accessors
//@{
Event::Type reloadConfig();
Event::Type forceReconnect();
Event::Type resetServer();
//@}
private:
Event::Type m_reloadConfig;
Event::Type m_forceReconnect;
Event::Type m_resetServer;
};
class IKeyStateEvents : public EventTypes
{
public:
IKeyStateEvents() : m_keyDown(Event::kUnknown), m_keyUp(Event::kUnknown), m_keyRepeat(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get key down event type. Event data is KeyInfo*, count == 1.
Event::Type keyDown();
//! Get key up event type. Event data is KeyInfo*, count == 1.
Event::Type keyUp();
//! Get key repeat event type. Event data is KeyInfo*.
Event::Type keyRepeat();
//@}
private:
Event::Type m_keyDown;
Event::Type m_keyUp;
Event::Type m_keyRepeat;
};
class IPrimaryScreenEvents : public EventTypes
{
public:
IPrimaryScreenEvents()
: m_buttonDown(Event::kUnknown),
m_buttonUp(Event::kUnknown),
m_motionOnPrimary(Event::kUnknown),
m_motionOnSecondary(Event::kUnknown),
m_wheel(Event::kUnknown),
m_screensaverActivated(Event::kUnknown),
m_screensaverDeactivated(Event::kUnknown),
m_hotKeyDown(Event::kUnknown),
m_hotKeyUp(Event::kUnknown),
m_fakeInputBegin(Event::kUnknown),
m_fakeInputEnd(Event::kUnknown)
{
}
//! @name accessors
//@{
//! button down event type. Event data is ButtonInfo*.
Event::Type buttonDown();
//! button up event type. Event data is ButtonInfo*.
Event::Type buttonUp();
//! mouse motion on the primary screen event type
/*!
Event data is MotionInfo* and the values are an absolute position.
*/
Event::Type motionOnPrimary();
//! mouse motion on a secondary screen event type
/*!
Event data is MotionInfo* and the values are motion deltas not
absolute coordinates.
*/
Event::Type motionOnSecondary();
//! mouse wheel event type. Event data is WheelInfo*.
Event::Type wheel();
//! screensaver activated event type
Event::Type screensaverActivated();
//! screensaver deactivated event type
Event::Type screensaverDeactivated();
//! hot key down event type. Event data is HotKeyInfo*.
Event::Type hotKeyDown();
//! hot key up event type. Event data is HotKeyInfo*.
Event::Type hotKeyUp();
//! start of fake input event type
Event::Type fakeInputBegin();
//! end of fake input event type
Event::Type fakeInputEnd();
//@}
private:
Event::Type m_buttonDown;
Event::Type m_buttonUp;
Event::Type m_motionOnPrimary;
Event::Type m_motionOnSecondary;
Event::Type m_wheel;
Event::Type m_screensaverActivated;
Event::Type m_screensaverDeactivated;
Event::Type m_hotKeyDown;
Event::Type m_hotKeyUp;
Event::Type m_fakeInputBegin;
Event::Type m_fakeInputEnd;
};
class IScreenEvents : public EventTypes
{
public:
IScreenEvents()
: m_error(Event::kUnknown),
m_shapeChanged(Event::kUnknown),
m_suspend(Event::kUnknown),
m_resume(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get error event type
/*!
Returns the error event type. This is sent whenever the screen has
failed for some reason (e.g. the X Windows server died).
*/
Event::Type error();
//! Get shape changed event type
/*!
Returns the shape changed event type. This is sent whenever the
screen's shape changes.
*/
Event::Type shapeChanged();
//! Get suspend event type
/*!
Returns the suspend event type. This is sent whenever the system goes
to sleep or a user session is deactivated (fast user switching).
*/
Event::Type suspend();
//! Get resume event type
/*!
Returns the resume event type. This is sent whenever the system wakes
up or a user session is activated (fast user switching).
*/
Event::Type resume();
//@}
private:
Event::Type m_error;
Event::Type m_shapeChanged;
Event::Type m_suspend;
Event::Type m_resume;
};
class ClipboardEvents : public EventTypes
{
public:
ClipboardEvents()
: m_clipboardGrabbed(Event::kUnknown),
m_clipboardChanged(Event::kUnknown),
m_clipboardSending(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get clipboard grabbed event type
/*!
Returns the clipboard grabbed event type. This is sent whenever the
clipboard is grabbed by some other application so we don't own it
anymore. The data is a pointer to a ClipboardInfo.
*/
Event::Type clipboardGrabbed();
//! Get clipboard changed event type
/*!
Returns the clipboard changed event type. This is sent whenever the
contents of the clipboard has changed. The data is a pointer to a
IScreen::ClipboardInfo.
*/
Event::Type clipboardChanged();
//! Clipboard sending event type
/*!
Returns the clipboard sending event type. This is used to send
clipboard chunks.
*/
Event::Type clipboardSending();
//@}
private:
Event::Type m_clipboardGrabbed;
Event::Type m_clipboardChanged;
Event::Type m_clipboardSending;
};
class FileEvents : public EventTypes
{
public:
FileEvents()
: m_fileChunkSending(Event::kUnknown),
m_fileReceiveCompleted(Event::kUnknown),
m_keepAlive(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Sending a file chunk
Event::Type fileChunkSending();
//! Completed receiving a file
Event::Type fileReceiveCompleted();
//! Send a keep alive
Event::Type keepAlive();
//@}
private:
Event::Type m_fileChunkSending;
Event::Type m_fileReceiveCompleted;
Event::Type m_keepAlive;
};
class EiEvents : public EventTypes
{
public:
EiEvents() : m_connected(Event::kUnknown), m_sessionClosed(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get connected event type
/*!
This event is sent whenever connection to EIS is established and a file
descriptor for reading events is available.
*/
Event::Type connected();
//! Get session closed event type
/*!
This event is sent whenever the portal session managing our EIS connection
is closed.
*/
Event::Type sessionClosed();
//@}
private:
Event::Type m_connected;
Event::Type m_sessionClosed;
}; };
} // namespace deskflow

65
src/lib/base/IEventQueue.h
View file

@ -8,6 +8,7 @@
#pragma once #pragma once
#include "base/Event.h" #include "base/Event.h"
#include "base/EventTypes.h"
#include "common/IInterface.h" #include "common/IInterface.h"
#include <string> #include <string>
@ -18,25 +19,6 @@ class IEventQueueBuffer;
// IEventQueueBuffer. // IEventQueueBuffer.
class EventQueueTimer; class EventQueueTimer;
// Event type registration classes.
class ClientEvents;
class IStreamEvents;
class IDataSocketEvents;
class IListenSocketEvents;
class ISocketEvents;
class OSXScreenEvents;
class ClientListenerEvents;
class ClientProxyEvents;
class ClientProxyUnknownEvents;
class ServerEvents;
class ServerAppEvents;
class IKeyStateEvents;
class IPrimaryScreenEvents;
class IScreenEvents;
class ClipboardEvents;
class FileEvents;
class EiEvents;
//! Event queue interface //! Event queue interface
/*! /*!
An event queue provides a queue of Events. Clients can block waiting An event queue provides a queue of Events. Clients can block waiting
@ -137,14 +119,14 @@ public:
of type \p type. If no such handler exists it will use the handler of type \p type. If no such handler exists it will use the handler
for \p target and type \p kUnknown if it exists. for \p target and type \p kUnknown if it exists.
*/ */
virtual void adoptHandler(Event::Type type, void *target, IEventJob *handler) = 0; virtual void adoptHandler(EventTypes type, void *target, IEventJob *handler) = 0;
//! Unregister an event handler for an event type //! Unregister an event handler for an event type
/*! /*!
Unregisters an event handler for the \p type, \p target pair and Unregisters an event handler for the \p type, \p target pair and
deletes it. deletes it.
*/ */
virtual void removeHandler(Event::Type type, void *target) = 0; virtual void removeHandler(EventTypes type, void *target) = 0;
//! Unregister all event handlers for an event target //! Unregister all event handlers for an event target
/*! /*!
@ -152,14 +134,6 @@ public:
*/ */
virtual void removeHandlers(void *target) = 0; virtual void removeHandlers(void *target) = 0;
//! Creates a new event type
/*!
If \p type contains \c kUnknown then it is set to a unique event
type id otherwise it is left alone. The final value of \p type
is returned.
*/
virtual Event::Type registerTypeOnce(Event::Type &type, const char *name) = 0;
//! Wait for event queue to become ready //! Wait for event queue to become ready
/*! /*!
Blocks on the current thread until the event queue is ready for events to Blocks on the current thread until the event queue is ready for events to
@ -183,42 +157,13 @@ public:
Finds and returns the event handler for the \p type, \p target pair Finds and returns the event handler for the \p type, \p target pair
if it exists, otherwise it returns nullptr. if it exists, otherwise it returns nullptr.
*/ */
virtual IEventJob *getHandler(Event::Type type, void *target) const = 0; virtual IEventJob *getHandler(EventTypes type, void *target) const = 0;
//! Get name for event
/*!
Returns the name for the event \p type. This is primarily for
debugging.
*/
virtual const char *getTypeName(Event::Type type) = 0;
//! Get the system event type target //! Get the system event type target
/*! /*!
Returns the target to use for dispatching \c Event::kSystem events. Returns the target to use for dispatching \c EventTypes::System events.
*/ */
virtual void *getSystemTarget() = 0; virtual void *getSystemTarget() = 0;
//@} //@}
//
// Event type providers.
//
virtual ClientEvents &forClient() = 0;
virtual IStreamEvents &forIStream() = 0;
virtual IDataSocketEvents &forIDataSocket() = 0;
virtual IListenSocketEvents &forIListenSocket() = 0;
virtual ISocketEvents &forISocket() = 0;
virtual OSXScreenEvents &forOSXScreen() = 0;
virtual ClientListenerEvents &forClientListener() = 0;
virtual ClientProxyEvents &forClientProxy() = 0;
virtual ClientProxyUnknownEvents &forClientProxyUnknown() = 0;
virtual ServerEvents &forServer() = 0;
virtual ServerAppEvents &forServerApp() = 0;
virtual IKeyStateEvents &forIKeyState() = 0;
virtual IPrimaryScreenEvents &forIPrimaryScreen() = 0;
virtual IScreenEvents &forIScreen() = 0;
virtual ClipboardEvents &forClipboard() = 0;
virtual FileEvents &forFile() = 0;
virtual EiEvents &forEi() = 0;
}; };

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

@ -75,19 +75,18 @@ Client::Client(
// register suspend/resume event handlers // register suspend/resume event handlers
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().suspend(), getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleSuspend) EventTypes::ScreenSuspend, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleSuspend)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().resume(), getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleResume) EventTypes::ScreenResume, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleResume)
); );
if (m_args.m_enableDragDrop) { if (m_args.m_enableDragDrop) {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forFile().fileChunkSending(), this, new TMethodEventJob<Client>(this, &Client::handleFileChunkSending) EventTypes::FileChunkSending, this, new TMethodEventJob<Client>(this, &Client::handleFileChunkSending)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forFile().fileReceiveCompleted(), this, EventTypes::FileReceiveCompleted, this, new TMethodEventJob<Client>(this, &Client::handleFileReceiveCompleted)
new TMethodEventJob<Client>(this, &Client::handleFileReceiveCompleted)
); );
} }
@ -111,8 +110,8 @@ Client::~Client()
return; return;
} }
m_events->removeHandler(m_events->forIScreen().suspend(), getEventTarget()); m_events->removeHandler(EventTypes::ScreenSuspend, getEventTarget());
m_events->removeHandler(m_events->forIScreen().resume(), getEventTarget()); m_events->removeHandler(EventTypes::ScreenResume, getEventTarget());
cleanupTimer(); cleanupTimer();
cleanupScreen(); cleanupScreen();
@ -179,7 +178,7 @@ void Client::disconnect(const char *msg)
if (msg) { if (msg) {
sendConnectionFailedEvent(msg); sendConnectionFailedEvent(msg);
} else { } else {
sendEvent(m_events->forClient().disconnected(), nullptr); sendEvent(EventTypes::ClientDisconnected, nullptr);
} }
} }
@ -190,7 +189,7 @@ void Client::refuseConnection(const char *msg)
if (msg) { if (msg) {
auto info = new FailInfo(msg); auto info = new FailInfo(msg);
info->m_retry = true; info->m_retry = true;
Event event(m_events->forClient().connectionRefused(), getEventTarget(), info, Event::kDontFreeData); Event event(EventTypes::ClientConnectionRefused, getEventTarget(), info, Event::kDontFreeData);
m_events->addEvent(event); m_events->addEvent(event);
} }
} }
@ -199,7 +198,7 @@ void Client::handshakeComplete()
{ {
m_ready = true; m_ready = true;
m_screen->enable(); m_screen->enable();
sendEvent(m_events->forClient().connected(), nullptr); sendEvent(EventTypes::ClientConnected, nullptr);
} }
bool Client::isConnected() const bool Client::isConnected() const
@ -410,7 +409,7 @@ void Client::sendClipboard(ClipboardID id)
} }
} }
void Client::sendEvent(Event::Type type, void *data) void Client::sendEvent(EventTypes type, void *data)
{ {
m_events->addEvent(Event(type, getEventTarget(), data)); m_events->addEvent(Event(type, getEventTarget(), data));
} }
@ -419,7 +418,7 @@ void Client::sendConnectionFailedEvent(const char *msg)
{ {
auto *info = new FailInfo(msg); auto *info = new FailInfo(msg);
info->m_retry = true; info->m_retry = true;
Event event(m_events->forClient().connectionFailed(), getEventTarget(), info, Event::kDontFreeData); Event event(EventTypes::ClientConnectionFailed, getEventTarget(), info, Event::kDontFreeData);
m_events->addEvent(event); m_events->addEvent(event);
} }
@ -439,18 +438,18 @@ void Client::setupConnecting()
if (m_args.m_enableCrypto) { if (m_args.m_enableCrypto) {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIDataSocket().secureConnected(), m_stream->getEventTarget(), EventTypes::DataSocketSecureConnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnected) new TMethodEventJob<Client>(this, &Client::handleConnected)
); );
} else { } else {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIDataSocket().connected(), m_stream->getEventTarget(), EventTypes::DataSocketConnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnected) new TMethodEventJob<Client>(this, &Client::handleConnected)
); );
} }
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIDataSocket().connectionFailed(), m_stream->getEventTarget(), EventTypes::DataSocketConnectionFailed, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnectionFailed) new TMethodEventJob<Client>(this, &Client::handleConnectionFailed)
); );
} }
@ -460,28 +459,27 @@ void Client::setupConnection()
assert(m_stream != nullptr); assert(m_stream != nullptr);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forISocket().disconnected(), m_stream->getEventTarget(), EventTypes::SocketDisconnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected) new TMethodEventJob<Client>(this, &Client::handleDisconnected)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(), EventTypes::StreamInputReady, m_stream->getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleHello)
new TMethodEventJob<Client>(this, &Client::handleHello)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputError(), m_stream->getEventTarget(), EventTypes::StreamOutputError, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleOutputError) new TMethodEventJob<Client>(this, &Client::handleOutputError)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputShutdown(), m_stream->getEventTarget(), EventTypes::StreamInputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected) new TMethodEventJob<Client>(this, &Client::handleDisconnected)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputShutdown(), m_stream->getEventTarget(), EventTypes::StreamOutputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected) new TMethodEventJob<Client>(this, &Client::handleDisconnected)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forISocket().stopRetry(), m_stream->getEventTarget(), EventTypes::SocketStopRetry, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleStopRetry) new TMethodEventJob<Client>(this, &Client::handleStopRetry)
); );
} }
@ -493,12 +491,10 @@ void Client::setupScreen()
m_ready = false; m_ready = false;
m_server = new ServerProxy(this, m_stream, m_events); m_server = new ServerProxy(this, m_stream, m_events);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().shapeChanged(), getEventTarget(), EventTypes::ScreenShapeChanged, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleShapeChanged)
new TMethodEventJob<Client>(this, &Client::handleShapeChanged)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClipboard().clipboardGrabbed(), getEventTarget(), EventTypes::ClipboardGrabbed, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleClipboardGrabbed)
new TMethodEventJob<Client>(this, &Client::handleClipboardGrabbed)
); );
} }
@ -506,7 +502,7 @@ void Client::setupTimer()
{ {
assert(m_timer == nullptr); assert(m_timer == nullptr);
m_timer = m_events->newOneShotTimer(2.0, nullptr); m_timer = m_events->newOneShotTimer(2.0, nullptr);
m_events->adoptHandler(Event::kTimer, m_timer, new TMethodEventJob<Client>(this, &Client::handleConnectTimeout)); m_events->adoptHandler(EventTypes::Timer, m_timer, new TMethodEventJob<Client>(this, &Client::handleConnectTimeout));
} }
void Client::cleanup() void Client::cleanup()
@ -521,20 +517,20 @@ void Client::cleanup()
void Client::cleanupConnecting() void Client::cleanupConnecting()
{ {
if (m_stream != nullptr) { if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIDataSocket().connected(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::DataSocketConnected, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIDataSocket().connectionFailed(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::DataSocketConnectionFailed, m_stream->getEventTarget());
} }
} }
void Client::cleanupConnection() void Client::cleanupConnection()
{ {
if (m_stream != nullptr) { if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
m_events->removeHandler(m_events->forISocket().disconnected(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::SocketDisconnected, m_stream->getEventTarget());
m_events->removeHandler(m_events->forISocket().stopRetry(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::SocketStopRetry, m_stream->getEventTarget());
cleanupStream(); cleanupStream();
} }
} }
@ -546,8 +542,8 @@ void Client::cleanupScreen()
m_screen->disable(); m_screen->disable();
m_ready = false; m_ready = false;
} }
m_events->removeHandler(m_events->forIScreen().shapeChanged(), getEventTarget()); m_events->removeHandler(EventTypes::ScreenShapeChanged, getEventTarget());
m_events->removeHandler(m_events->forClipboard().clipboardGrabbed(), getEventTarget()); m_events->removeHandler(EventTypes::ClipboardGrabbed, getEventTarget());
delete m_server; delete m_server;
m_server = nullptr; m_server = nullptr;
} }
@ -556,7 +552,7 @@ void Client::cleanupScreen()
void Client::cleanupTimer() void Client::cleanupTimer()
{ {
if (m_timer != nullptr) { if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer); m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer); m_events->deleteTimer(m_timer);
m_timer = nullptr; m_timer = nullptr;
} }
@ -610,7 +606,7 @@ void Client::handleOutputError(const Event &, void *)
cleanupScreen(); cleanupScreen();
cleanupConnection(); cleanupConnection();
LOG((CLOG_WARN "error sending to server")); LOG((CLOG_WARN "error sending to server"));
sendEvent(m_events->forClient().disconnected(), nullptr); sendEvent(EventTypes::ClientDisconnected, nullptr);
} }
void Client::handleDisconnected(const Event &, void *) void Client::handleDisconnected(const Event &, void *)
@ -619,7 +615,7 @@ void Client::handleDisconnected(const Event &, void *)
cleanupScreen(); cleanupScreen();
cleanupConnection(); cleanupConnection();
LOG((CLOG_DEBUG1 "disconnected")); LOG((CLOG_DEBUG1 "disconnected"));
sendEvent(m_events->forClient().disconnected(), nullptr); sendEvent(EventTypes::ClientDisconnected, nullptr);
} }
void Client::handleShapeChanged(const Event &, void *) void Client::handleShapeChanged(const Event &, void *)
@ -663,7 +659,7 @@ void Client::handleHello(const Event &, void *)
// receive another event for already pending messages so we fake // receive another event for already pending messages so we fake
// one. // one.
if (m_stream->isReady()) { if (m_stream->isReady()) {
m_events->addEvent(Event(m_events->forIStream().inputReady(), m_stream->getEventTarget())); m_events->addEvent(Event(EventTypes::StreamInputReady, m_stream->getEventTarget()));
} }
} }

2
src/lib/client/Client.h
View file

@ -186,7 +186,7 @@ public:
private: private:
void sendClipboard(ClipboardID); void sendClipboard(ClipboardID);
void sendEvent(Event::Type, void *); void sendEvent(EventTypes, void *);
void sendConnectionFailedEvent(const char *msg); void sendConnectionFailedEvent(const char *msg);
void sendFileChunk(const void *data); void sendFileChunk(const void *data);
void sendFileThread(void *); void sendFileThread(void *);

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

@ -56,12 +56,12 @@ ServerProxy::ServerProxy(Client *client, deskflow::IStream *stream, IEventQueue
// handle data on stream // handle data on stream
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(), EventTypes::StreamInputReady, m_stream->getEventTarget(),
new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleData) new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleData)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClipboard().clipboardSending(), this, EventTypes::ClipboardSending, this,
new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleClipboardSendingEvent) new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleClipboardSendingEvent)
); );
@ -72,20 +72,21 @@ ServerProxy::ServerProxy(Client *client, deskflow::IStream *stream, IEventQueue
ServerProxy::~ServerProxy() ServerProxy::~ServerProxy()
{ {
setKeepAliveRate(-1.0); setKeepAliveRate(-1.0);
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
} }
void ServerProxy::resetKeepAliveAlarm() void ServerProxy::resetKeepAliveAlarm()
{ {
if (m_keepAliveAlarmTimer != nullptr) { if (m_keepAliveAlarmTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_keepAliveAlarmTimer); m_events->removeHandler(EventTypes::Timer, m_keepAliveAlarmTimer);
m_events->deleteTimer(m_keepAliveAlarmTimer); m_events->deleteTimer(m_keepAliveAlarmTimer);
m_keepAliveAlarmTimer = nullptr; m_keepAliveAlarmTimer = nullptr;
} }
if (m_keepAliveAlarm > 0.0) { if (m_keepAliveAlarm > 0.0) {
m_keepAliveAlarmTimer = m_events->newOneShotTimer(m_keepAliveAlarm, nullptr); m_keepAliveAlarmTimer = m_events->newOneShotTimer(m_keepAliveAlarm, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, m_keepAliveAlarmTimer, new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleKeepAliveAlarm) EventTypes::Timer, m_keepAliveAlarmTimer,
new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleKeepAliveAlarm)
); );
} }
} }
@ -822,7 +823,7 @@ void ServerProxy::fileChunkReceived()
int result = FileChunk::assemble(m_stream, m_client->getReceivedFileData(), m_client->getExpectedFileSize()); int result = FileChunk::assemble(m_stream, m_client->getReceivedFileData(), m_client->getExpectedFileSize());
if (result == kFinish) { if (result == kFinish) {
m_events->addEvent(Event(m_events->forFile().fileReceiveCompleted(), m_client)); m_events->addEvent(Event(EventTypes::FileReceiveCompleted, m_client));
} else if (result == kStart) { } else if (result == kStart) {
if (m_client->getDragFileList().size() > 0) { if (m_client->getDragFileList().size() > 0) {
std::string filename = m_client->getDragFileList().at(0).getFilename(); std::string filename = m_client->getDragFileList().at(0).getFilename();

2
src/lib/deskflow/Chunk.h
View file

@ -7,7 +7,7 @@
#pragma once #pragma once
#include "common/Common.h" #include "common/Common.h"
#include <base/EventTypes.h> #include <base/Event.h>
class Chunk : public EventData class Chunk : public EventData
{ {

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

@ -238,7 +238,7 @@ double ClientApp::nextRestartTimeout()
void ClientApp::handleScreenError(const Event &, void *) void ClientApp::handleScreenError(const Event &, void *)
{ {
LOG((CLOG_CRIT "error on screen")); LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
deskflow::Screen *ClientApp::openClientScreen() deskflow::Screen *ClientApp::openClientScreen()
@ -246,7 +246,7 @@ deskflow::Screen *ClientApp::openClientScreen()
deskflow::Screen *screen = createScreen(); deskflow::Screen *screen = createScreen();
screen->setEnableDragDrop(argsBase().m_enableDragDrop); screen->setEnableDragDrop(argsBase().m_enableDragDrop);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().error(), screen->getEventTarget(), EventTypes::ScreenError, screen->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleScreenError) new TMethodEventJob<ClientApp>(this, &ClientApp::handleScreenError)
); );
return screen; return screen;
@ -255,7 +255,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(m_events->forIScreen().error(), screen->getEventTarget()); m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
delete screen; delete screen;
} }
} }
@ -265,7 +265,7 @@ void ClientApp::handleClientRestart(const Event &, void *vtimer)
// discard old timer // discard old timer
auto *timer = static_cast<EventQueueTimer *>(vtimer); auto *timer = static_cast<EventQueueTimer *>(vtimer);
m_events->deleteTimer(timer); m_events->deleteTimer(timer);
m_events->removeHandler(Event::kTimer, timer); m_events->removeHandler(EventTypes::Timer, timer);
// reconnect // reconnect
startClient(); startClient();
@ -277,7 +277,7 @@ void ClientApp::scheduleClientRestart(double retryTime)
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 = m_events->newOneShotTimer(retryTime, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, timer, new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientRestart, timer) EventTypes::Timer, timer, new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientRestart, timer)
); );
} }
@ -311,7 +311,7 @@ void ClientApp::handleClientRefused(const Event &e, void *)
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(Event::kQuit)); m_events->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) {
@ -324,7 +324,7 @@ void ClientApp::handleClientDisconnected(const Event &, void *)
{ {
LOG((CLOG_NOTE "disconnected from server")); LOG((CLOG_NOTE "disconnected from server"));
if (!args().m_restartable) { if (!args().m_restartable) {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} else if (!m_suspended) { } else if (!m_suspended) {
scheduleClientRestart(nextRestartTimeout()); scheduleClientRestart(nextRestartTimeout());
} }
@ -337,22 +337,22 @@ Client *ClientApp::openClient(const std::string &name, const NetworkAddress &add
try { try {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClient().connected(), client->getEventTarget(), EventTypes::ClientConnected, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientConnected) new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientConnected)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClient().connectionFailed(), client->getEventTarget(), EventTypes::ClientConnectionFailed, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientFailed) new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientFailed)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClient().connectionRefused(), client->getEventTarget(), EventTypes::ClientConnectionRefused, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientRefused) new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientRefused)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClient().disconnected(), client->getEventTarget(), EventTypes::ClientDisconnected, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientDisconnected) new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientDisconnected)
); );
@ -370,10 +370,10 @@ void ClientApp::closeClient(Client *client)
return; return;
} }
m_events->removeHandler(m_events->forClient().connected(), client); m_events->removeHandler(EventTypes::ClientConnected, client);
m_events->removeHandler(m_events->forClient().connectionFailed(), client); m_events->removeHandler(EventTypes::ClientConnectionFailed, client);
m_events->removeHandler(m_events->forClient().connectionRefused(), client); m_events->removeHandler(EventTypes::ClientConnectionRefused, client);
m_events->removeHandler(m_events->forClient().disconnected(), client); m_events->removeHandler(EventTypes::ClientDisconnected, client);
delete client; delete client;
} }

2
src/lib/deskflow/IPlatformScreen.h
View file

@ -203,7 +203,7 @@ protected:
A platform screen is expected to install a handler for system A platform screen is expected to install a handler for system
events in its c'tor like so: events in its c'tor like so:
\code \code
m_events->adoptHandler(Event::kSystem, m_events->adoptHandler(EventTypes::System,
m_events->getSystemTarget(), m_events->getSystemTarget(),
new TMethodEventJob<CXXXPlatformScreen>(this, new TMethodEventJob<CXXXPlatformScreen>(this,
&CXXXPlatformScreen::handleSystemEvent)); &CXXXPlatformScreen::handleSystemEvent));

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

@ -712,16 +712,16 @@ void KeyState::sendKeyEvent(
if (isAutoRepeat) { if (isAutoRepeat) {
// ignore auto-repeat on half-duplex keys // ignore auto-repeat on half-duplex keys
} else { } else {
m_events->addEvent(Event(m_events->forIKeyState().keyDown(), target, KeyInfo::alloc(key, mask, button, 1))); m_events->addEvent(Event(EventTypes::KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(m_events->forIKeyState().keyUp(), target, KeyInfo::alloc(key, mask, button, 1))); m_events->addEvent(Event(EventTypes::KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
} }
} else { } else {
if (isAutoRepeat) { if (isAutoRepeat) {
m_events->addEvent(Event(m_events->forIKeyState().keyRepeat(), target, KeyInfo::alloc(key, mask, button, count))); m_events->addEvent(Event(EventTypes::KeyStateKeyRepeat, target, KeyInfo::alloc(key, mask, button, count)));
} else if (press) { } else if (press) {
m_events->addEvent(Event(m_events->forIKeyState().keyDown(), target, KeyInfo::alloc(key, mask, button, 1))); m_events->addEvent(Event(EventTypes::KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
} else { } else {
m_events->addEvent(Event(m_events->forIKeyState().keyUp(), target, KeyInfo::alloc(key, mask, button, 1))); m_events->addEvent(Event(EventTypes::KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
} }
} }
} }

8
src/lib/deskflow/PacketStreamFilter.cpp
View file

@ -65,7 +65,7 @@ uint32_t PacketStreamFilter::read(void *buffer, uint32_t n)
readPacketSize(); readPacketSize();
if (m_inputShutdown && m_size == 0) { if (m_inputShutdown && m_size == 0) {
m_events->addEvent(Event(m_events->forIStream().inputShutdown(), getEventTarget())); m_events->addEvent(Event(EventTypes::StreamInputShutdown, getEventTarget()));
} }
return n; return n;
@ -121,7 +121,7 @@ bool PacketStreamFilter::readPacketSize()
m_size = m_size =
((uint32_t)buffer[0] << 24) | ((uint32_t)buffer[1] << 16) | ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3]; ((uint32_t)buffer[0] << 24) | ((uint32_t)buffer[1] << 16) | ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3];
if (m_size > PROTOCOL_MAX_MESSAGE_LENGTH) { if (m_size > PROTOCOL_MAX_MESSAGE_LENGTH) {
m_events->addEvent(Event(m_events->forIStream().inputFormatError(), getEventTarget())); m_events->addEvent(Event(EventTypes::StreamInputFormatError, getEventTarget()));
return false; return false;
} }
} }
@ -159,12 +159,12 @@ bool PacketStreamFilter::readMore()
void PacketStreamFilter::filterEvent(const Event &event) void PacketStreamFilter::filterEvent(const Event &event)
{ {
if (event.getType() == m_events->forIStream().inputReady()) { if (event.getType() == EventTypes::StreamInputReady) {
Lock lock(&m_mutex); Lock lock(&m_mutex);
if (!readMore()) { if (!readMore()) {
return; return;
} }
} else if (event.getType() == m_events->forIStream().inputShutdown()) { } else if (event.getType() == EventTypes::StreamInputShutdown) {
// discard this if we have buffered data // discard this if we have buffered data
Lock lock(&m_mutex); Lock lock(&m_mutex);
m_inputShutdown = true; m_inputShutdown = true;

2
src/lib/deskflow/Screen.cpp
View file

@ -430,7 +430,7 @@ void Screen::enablePrimary()
m_screen->openScreensaver(true); m_screen->openScreensaver(true);
// claim screen changed size // claim screen changed size
m_events->addEvent(Event(m_events->forIScreen().shapeChanged(), getEventTarget())); m_events->addEvent(Event(EventTypes::ScreenShapeChanged, getEventTarget()));
} }
void Screen::enableSecondary() void Screen::enableSecondary()

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

@ -155,7 +155,7 @@ void ServerApp::help()
void ServerApp::reloadSignalHandler(Arch::ESignal, void *) void ServerApp::reloadSignalHandler(Arch::ESignal, void *)
{ {
IEventQueue *events = App::instance().getEvents(); IEventQueue *events = App::instance().getEvents();
events->addEvent(Event(events->forServerApp().reloadConfig(), events->getSystemTarget())); events->addEvent(Event(EventTypes::ServerAppReloadConfig, events->getSystemTarget()));
} }
void ServerApp::reloadConfig(const Event &, void *) void ServerApp::reloadConfig(const Event &, void *)
@ -222,7 +222,7 @@ void ServerApp::handleClientConnected(const Event &, void *vlistener)
void ServerApp::handleClientsDisconnected(const Event &, void *) void ServerApp::handleClientsDisconnected(const Event &, void *)
{ {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
void ServerApp::closeServer(Server *server) void ServerApp::closeServer(Server *server)
@ -238,18 +238,18 @@ void ServerApp::closeServer(Server *server)
double timeout = 3.0; double timeout = 3.0;
EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr); EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, timer, new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientsDisconnected) EventTypes::Timer, timer, new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientsDisconnected)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().disconnected(), server, EventTypes::ServerDisconnected, server,
new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientsDisconnected) new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientsDisconnected)
); );
m_events->loop(); m_events->loop();
m_events->removeHandler(Event::kTimer, timer); m_events->removeHandler(EventTypes::Timer, timer);
m_events->deleteTimer(timer); m_events->deleteTimer(timer);
m_events->removeHandler(m_events->forServer().disconnected(), server); m_events->removeHandler(EventTypes::ServerDisconnected, server);
// done with server // done with server
delete server; delete server;
@ -258,7 +258,7 @@ void ServerApp::closeServer(Server *server)
void ServerApp::stopRetryTimer() void ServerApp::stopRetryTimer()
{ {
if (m_timer != nullptr) { if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer); m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer); m_events->deleteTimer(m_timer);
m_timer = nullptr; m_timer = nullptr;
} }
@ -276,7 +276,7 @@ void ServerApp::updateStatus(const std::string &msg)
void ServerApp::closeClientListener(ClientListener *listen) void ServerApp::closeClientListener(ClientListener *listen)
{ {
if (listen != nullptr) { if (listen != nullptr) {
m_events->removeHandler(m_events->forClientListener().connected(), listen); m_events->removeHandler(EventTypes::ClientListenerAccepted, listen);
delete listen; delete listen;
} }
} }
@ -305,9 +305,9 @@ void ServerApp::closePrimaryClient(PrimaryClient *primaryClient)
void ServerApp::closeServerScreen(deskflow::Screen *screen) void ServerApp::closeServerScreen(deskflow::Screen *screen)
{ {
if (screen != nullptr) { if (screen != nullptr) {
m_events->removeHandler(m_events->forIScreen().error(), screen->getEventTarget()); m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
m_events->removeHandler(m_events->forIScreen().suspend(), screen->getEventTarget()); m_events->removeHandler(EventTypes::ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(m_events->forIScreen().resume(), screen->getEventTarget()); m_events->removeHandler(EventTypes::ScreenResume, screen->getEventTarget());
delete screen; delete screen;
} }
} }
@ -348,7 +348,7 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized; m_serverState = kUninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
break; break;
@ -356,11 +356,11 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized; m_serverState = kUninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} else if (m_serverState == kInitialized) { } else if (m_serverState == kInitialized) {
LOG((CLOG_DEBUG1 "starting server")); LOG((CLOG_DEBUG1 "starting server"));
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
} }
break; break;
@ -369,7 +369,7 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry starting server")); LOG((CLOG_DEBUG1 "retry starting server"));
m_serverState = kInitialized; m_serverState = kInitialized;
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
break; break;
} }
@ -417,7 +417,7 @@ bool ServerApp::initServer()
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 = m_events->newOneShotTimer(retryTime, nullptr);
m_events->adoptHandler(Event::kTimer, m_timer, new TMethodEventJob<ServerApp>(this, &ServerApp::retryHandler)); m_events->adoptHandler(EventTypes::Timer, m_timer, new TMethodEventJob<ServerApp>(this, &ServerApp::retryHandler));
m_serverState = kInitializing; m_serverState = kInitializing;
return true; return true;
} else { } else {
@ -431,16 +431,15 @@ deskflow::Screen *ServerApp::openServerScreen()
deskflow::Screen *screen = createScreen(); deskflow::Screen *screen = createScreen();
screen->setEnableDragDrop(argsBase().m_enableDragDrop); screen->setEnableDragDrop(argsBase().m_enableDragDrop);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().error(), screen->getEventTarget(), EventTypes::ScreenError, screen->getEventTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenError) new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenError)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().suspend(), screen->getEventTarget(), EventTypes::ScreenSuspend, screen->getEventTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::handleSuspend) new TMethodEventJob<ServerApp>(this, &ServerApp::handleSuspend)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().resume(), screen->getEventTarget(), EventTypes::ScreenResume, screen->getEventTarget(), new TMethodEventJob<ServerApp>(this, &ServerApp::handleResume)
new TMethodEventJob<ServerApp>(this, &ServerApp::handleResume)
); );
return screen; return screen;
} }
@ -497,7 +496,7 @@ bool ServerApp::startServer()
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 = m_events->newOneShotTimer(retryTime, nullptr);
m_events->adoptHandler(Event::kTimer, m_timer, new TMethodEventJob<ServerApp>(this, &ServerApp::retryHandler)); m_events->adoptHandler(EventTypes::Timer, m_timer, new TMethodEventJob<ServerApp>(this, &ServerApp::retryHandler));
m_serverState = kStarting; m_serverState = kStarting;
return true; return true;
} else { } else {
@ -542,7 +541,7 @@ PrimaryClient *ServerApp::openPrimaryClient(const std::string &name, deskflow::S
void ServerApp::handleScreenError(const Event &, void *) void ServerApp::handleScreenError(const Event &, void *)
{ {
LOG((CLOG_CRIT "error on screen")); LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
} }
void ServerApp::handleSuspend(const Event &, void *) void ServerApp::handleSuspend(const Event &, void *)
@ -571,7 +570,7 @@ ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel); auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientListener().connected(), listen, EventTypes::ClientListenerAccepted, listen,
new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientConnected, listen) new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientConnected, listen)
); );
@ -583,12 +582,11 @@ 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, m_events, args());
try { try {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().disconnected(), server, new TMethodEventJob<ServerApp>(this, &ServerApp::handleNoClients) EventTypes::ServerDisconnected, server, new TMethodEventJob<ServerApp>(this, &ServerApp::handleNoClients)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().screenSwitched(), server, EventTypes::ServerScreenSwitched, server, new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenSwitched)
new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenSwitched)
); );
} catch (std::bad_alloc &ba) { } catch (std::bad_alloc &ba) {
@ -653,21 +651,21 @@ int ServerApp::mainLoop()
// handle hangup signal by reloading the server's configuration // handle hangup signal by reloading the server's configuration
ARCH->setSignalHandler(Arch::kHANGUP, &reloadSignalHandler, nullptr); ARCH->setSignalHandler(Arch::kHANGUP, &reloadSignalHandler, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServerApp().reloadConfig(), m_events->getSystemTarget(), EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::reloadConfig) new TMethodEventJob<ServerApp>(this, &ServerApp::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->adoptHandler( m_events->adoptHandler(
m_events->forServerApp().forceReconnect(), m_events->getSystemTarget(), EventTypes::ServerAppForceReconnect, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::forceReconnect) new TMethodEventJob<ServerApp>(this, &ServerApp::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->adoptHandler( m_events->adoptHandler(
m_events->forServerApp().resetServer(), m_events->getSystemTarget(), EventTypes::ServerAppResetServer, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::resetServer) new TMethodEventJob<ServerApp>(this, &ServerApp::resetServer)
); );
@ -693,8 +691,8 @@ int ServerApp::mainLoop()
// close down // close down
LOG((CLOG_DEBUG1 "stopping server")); LOG((CLOG_DEBUG1 "stopping server"));
m_events->removeHandler(m_events->forServerApp().forceReconnect(), m_events->getSystemTarget()); m_events->removeHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget());
m_events->removeHandler(m_events->forServerApp().reloadConfig(), m_events->getSystemTarget()); m_events->removeHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget());
cleanupServer(); cleanupServer();
updateStatus(); updateStatus();
LOG((CLOG_NOTE "stopped server")); LOG((CLOG_NOTE "stopped server"));

17
src/lib/deskflow/StreamChunker.cpp
View file

@ -46,8 +46,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
// send first message (file size) // send first message (file size)
std::string fileSize = deskflow::string::sizeTypeToString(size); std::string fileSize = deskflow::string::sizeTypeToString(size);
FileChunk *sizeMessage = FileChunk::start(fileSize); FileChunk *sizeMessage = FileChunk::start(fileSize);
events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, sizeMessage));
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, sizeMessage));
// send chunk messages with a fixed chunk size // send chunk messages with a fixed chunk size
size_t sentLength = 0; size_t sentLength = 0;
@ -61,7 +60,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
break; break;
} }
events->addEvent(Event(events->forFile().keepAlive(), eventTarget)); events->addEvent(Event(EventTypes::FileKeepAlive, eventTarget));
// make sure we don't read too much from the mock data. // make sure we don't read too much from the mock data.
if (sentLength + chunkSize > size) { if (sentLength + chunkSize > size) {
@ -74,7 +73,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
FileChunk *fileChunk = FileChunk::data(data, chunkSize); FileChunk *fileChunk = FileChunk::data(data, chunkSize);
delete[] chunkData; delete[] chunkData;
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, fileChunk)); events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, fileChunk));
sentLength += chunkSize; sentLength += chunkSize;
file.seekg(sentLength, std::ios::beg); file.seekg(sentLength, std::ios::beg);
@ -87,7 +86,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
// send last message // send last message
FileChunk *end = FileChunk::end(); FileChunk *end = FileChunk::end();
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, end)); events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, end));
file.close(); file.close();
@ -102,14 +101,14 @@ void StreamChunker::sendClipboard(
std::string dataSize = deskflow::string::sizeTypeToString(size); std::string dataSize = deskflow::string::sizeTypeToString(size);
ClipboardChunk *sizeMessage = ClipboardChunk::start(id, sequence, dataSize); ClipboardChunk *sizeMessage = ClipboardChunk::start(id, sequence, dataSize);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, sizeMessage)); events->addEvent(Event(EventTypes::ClipboardSending, eventTarget, sizeMessage));
// send clipboard chunk with a fixed size // send clipboard chunk with a fixed size
size_t sentLength = 0; size_t sentLength = 0;
size_t chunkSize = g_chunkSize; size_t chunkSize = g_chunkSize;
while (true) { while (true) {
events->addEvent(Event(events->forFile().keepAlive(), eventTarget)); events->addEvent(Event(EventTypes::FileKeepAlive, eventTarget));
// make sure we don't read too much from the mock data. // make sure we don't read too much from the mock data.
if (sentLength + chunkSize > size) { if (sentLength + chunkSize > size) {
@ -119,7 +118,7 @@ void StreamChunker::sendClipboard(
std::string chunk(data.substr(sentLength, chunkSize).c_str(), chunkSize); std::string chunk(data.substr(sentLength, chunkSize).c_str(), chunkSize);
ClipboardChunk *dataChunk = ClipboardChunk::data(id, sequence, chunk); ClipboardChunk *dataChunk = ClipboardChunk::data(id, sequence, chunk);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, dataChunk)); events->addEvent(Event(EventTypes::ClipboardSending, eventTarget, dataChunk));
sentLength += chunkSize; sentLength += chunkSize;
if (sentLength == size) { if (sentLength == size) {
@ -130,7 +129,7 @@ void StreamChunker::sendClipboard(
// send last message // send last message
ClipboardChunk *end = ClipboardChunk::end(id, sequence); ClipboardChunk *end = ClipboardChunk::end(id, sequence);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, end)); events->addEvent(Event(EventTypes::ClipboardSending, eventTarget, end));
LOG((CLOG_DEBUG "sent clipboard size=%d", sentLength)); LOG((CLOG_DEBUG "sent clipboard size=%d", sentLength));
} }

4
src/lib/deskflow/win32/AppUtilWindows.cpp
View file

@ -51,7 +51,7 @@ BOOL WINAPI AppUtilWindows::consoleHandler(DWORD)
{ {
LOG((CLOG_INFO "got shutdown signal")); LOG((CLOG_INFO "got shutdown signal"));
IEventQueue *events = AppUtil::instance().app().getEvents(); IEventQueue *events = AppUtil::instance().app().getEvents();
events->addEvent(Event(Event::kQuit)); events->addEvent(Event(EventTypes::Quit));
return TRUE; return TRUE;
} }
@ -207,7 +207,7 @@ void AppUtilWindows::eventLoop()
if (closeEventResult == WAIT_OBJECT_0) { if (closeEventResult == WAIT_OBJECT_0) {
LOG_DEBUG("windows event loop received close event"); LOG_DEBUG("windows event loop received close event");
m_events->addEvent(Event(Event::kQuit)); m_events->addEvent(Event(EventTypes::Quit));
m_eventThreadRunning = false; m_eventThreadRunning = false;
} else if (closeEventResult == WAIT_OBJECT_0 + 1) { } else if (closeEventResult == WAIT_OBJECT_0 + 1) {
MSG msg; MSG msg;

4
src/lib/io/StreamFilter.cpp
View file

@ -21,14 +21,14 @@ StreamFilter::StreamFilter(IEventQueue *events, deskflow::IStream *stream, bool
// replace handlers for m_stream // replace handlers for m_stream
m_events->removeHandlers(m_stream->getEventTarget()); m_events->removeHandlers(m_stream->getEventTarget());
m_events->adoptHandler( m_events->adoptHandler(
Event::kUnknown, m_stream->getEventTarget(), EventTypes::Unknown, m_stream->getEventTarget(),
new TMethodEventJob<StreamFilter>(this, &StreamFilter::handleUpstreamEvent) new TMethodEventJob<StreamFilter>(this, &StreamFilter::handleUpstreamEvent)
); );
} }
StreamFilter::~StreamFilter() StreamFilter::~StreamFilter()
{ {
m_events->removeHandler(Event::kUnknown, m_stream->getEventTarget()); m_events->removeHandler(EventTypes::Unknown, m_stream->getEventTarget());
if (m_adopted) { if (m_adopted) {
delete m_stream; delete m_stream;
} }

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

@ -92,7 +92,7 @@ void SecureSocket::close()
void SecureSocket::connect(const NetworkAddress &addr) void SecureSocket::connect(const NetworkAddress &addr)
{ {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIDataSocket().connected(), getEventTarget(), EventTypes::DataSocketConnected, getEventTarget(),
new TMethodEventJob<SecureSocket>(this, &SecureSocket::handleTCPConnected) new TMethodEventJob<SecureSocket>(this, &SecureSocket::handleTCPConnected)
); );
@ -161,15 +161,15 @@ TCPSocket::EJobResult SecureSocket::doRead()
// send input ready if input buffer was empty // send input ready if input buffer was empty
if (wasEmpty) { if (wasEmpty) {
sendEvent(m_events->forIStream().inputReady()); sendEvent(EventTypes::StreamInputReady);
} }
} else { } else {
// remote write end of stream hungup. our input side // remote write end of stream hungup. our input side
// has therefore shutdown but don't flush our buffer // has therefore shutdown but don't flush our buffer
// since there's still data to be read. // since there's still data to be read.
sendEvent(m_events->forIStream().inputShutdown()); sendEvent(EventTypes::StreamInputShutdown);
if (!m_writable && m_inputBuffer.getSize() == 0) { if (!m_writable && m_inputBuffer.getSize() == 0) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
m_connected = false; m_connected = false;
} }
m_readable = false; m_readable = false;
@ -640,9 +640,9 @@ void SecureSocket::checkResult(int status, int &retry)
void SecureSocket::disconnect() void SecureSocket::disconnect()
{ {
sendEvent(getEvents()->forISocket().stopRetry()); sendEvent(EventTypes::SocketStopRetry);
sendEvent(getEvents()->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
sendEvent(getEvents()->forIStream().inputShutdown()); sendEvent(EventTypes::StreamInputShutdown);
} }
bool SecureSocket::verifyCertFingerprint(const deskflow::fs::path &fingerprintDbPath) bool SecureSocket::verifyCertFingerprint(const deskflow::fs::path &fingerprintDbPath)
@ -709,7 +709,7 @@ ISocketMultiplexerJob *SecureSocket::serviceConnect(ISocketMultiplexerJob *job,
// If status > 0, success // If status > 0, success
if (status > 0) { if (status > 0) {
sendEvent(m_events->forIDataSocket().secureConnected()); sendEvent(EventTypes::DataSocketSecureConnected);
return newJob(); return newJob();
} }
@ -736,7 +736,7 @@ ISocketMultiplexerJob *SecureSocket::serviceAccept(ISocketMultiplexerJob *job, b
// If status > 0, success // If status > 0, success
if (status > 0) { if (status > 0) {
sendEvent(m_events->forClientListener().accepted()); sendEvent(EventTypes::ClientListenerAccepted);
return newJob(); return newJob();
} }

2
src/lib/net/TCPListenSocket.cpp
View file

@ -130,7 +130,7 @@ ISocketMultiplexerJob *TCPListenSocket::serviceListening(ISocketMultiplexerJob *
return nullptr; return nullptr;
} }
if (read) { if (read) {
m_events->addEvent(Event(m_events->forIListenSocket().connecting(), this)); m_events->addEvent(Event(EventTypes::ListenSocketConnecting, this));
// stop polling on this socket until the client accepts // stop polling on this socket until the client accepts
return nullptr; return nullptr;
} }

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

@ -96,7 +96,7 @@ void TCPSocket::close()
// clear buffers and enter disconnected state // clear buffers and enter disconnected state
if (m_connected) { if (m_connected) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
} }
onDisconnected(); onDisconnected();
@ -133,7 +133,7 @@ uint32_t TCPSocket::read(void *buffer, uint32_t n)
// if no more data and we cannot read or write then send disconnected // if no more data and we cannot read or write then send disconnected
if (n > 0 && m_inputBuffer.getSize() == 0 && !m_readable && !m_writable) { if (n > 0 && m_inputBuffer.getSize() == 0 && !m_readable && !m_writable) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
m_connected = false; m_connected = false;
} }
@ -148,7 +148,7 @@ void TCPSocket::write(const void *buffer, uint32_t n)
// must not have shutdown output // must not have shutdown output
if (!m_writable) { if (!m_writable) {
sendEvent(m_events->forIStream().outputError()); sendEvent(EventTypes::StreamOutputError);
return; return;
} }
@ -195,7 +195,7 @@ void TCPSocket::shutdownInput()
// shutdown buffer for reading // shutdown buffer for reading
if (m_readable) { if (m_readable) {
sendEvent(m_events->forIStream().inputShutdown()); sendEvent(EventTypes::StreamInputShutdown);
onInputShutdown(); onInputShutdown();
useNewJob = true; useNewJob = true;
} }
@ -221,7 +221,7 @@ void TCPSocket::shutdownOutput()
// shutdown buffer for writing // shutdown buffer for writing
if (m_writable) { if (m_writable) {
sendEvent(m_events->forIStream().outputShutdown()); sendEvent(EventTypes::StreamOutputShutdown);
onOutputShutdown(); onOutputShutdown();
useNewJob = true; useNewJob = true;
} }
@ -263,7 +263,7 @@ void TCPSocket::connect(const NetworkAddress &addr)
try { try {
if (ARCH->connectSocket(m_socket, addr.getAddress())) { if (ARCH->connectSocket(m_socket, addr.getAddress())) {
sendEvent(m_events->forIDataSocket().connected()); sendEvent(EventTypes::DataSocketConnected);
onConnected(); onConnected();
} else { } else {
// connection is in progress // connection is in progress
@ -324,15 +324,15 @@ TCPSocket::EJobResult TCPSocket::doRead()
// send input ready if input buffer was empty // send input ready if input buffer was empty
if (wasEmpty) { if (wasEmpty) {
sendEvent(m_events->forIStream().inputReady()); sendEvent(EventTypes::StreamInputReady);
} }
} else { } else {
// remote write end of stream hungup. our input side // remote write end of stream hungup. our input side
// has therefore shutdown but don't flush our buffer // has therefore shutdown but don't flush our buffer
// since there's still data to be read. // since there's still data to be read.
sendEvent(m_events->forIStream().inputShutdown()); sendEvent(EventTypes::StreamInputShutdown);
if (!m_writable && m_inputBuffer.getSize() == 0) { if (!m_writable && m_inputBuffer.getSize() == 0) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
m_connected = false; m_connected = false;
} }
m_readable = false; m_readable = false;
@ -397,11 +397,10 @@ ISocketMultiplexerJob *TCPSocket::newJob()
void TCPSocket::sendConnectionFailedEvent(const char *msg) void TCPSocket::sendConnectionFailedEvent(const char *msg)
{ {
auto *info = new ConnectionFailedInfo(msg); auto *info = new ConnectionFailedInfo(msg);
m_events->addEvent(Event(m_events->forIDataSocket().connectionFailed(), getEventTarget(), info, Event::kDontFreeData) m_events->addEvent(Event(EventTypes::DataSocketConnectionFailed, getEventTarget(), info, Event::kDontFreeData));
);
} }
void TCPSocket::sendEvent(Event::Type type) void TCPSocket::sendEvent(EventTypes type)
{ {
m_events->addEvent(Event(type, getEventTarget())); m_events->addEvent(Event(type, getEventTarget()));
} }
@ -410,7 +409,7 @@ void TCPSocket::discardWrittenData(int bytesWrote)
{ {
m_outputBuffer.pop(bytesWrote); m_outputBuffer.pop(bytesWrote);
if (m_outputBuffer.getSize() == 0) { if (m_outputBuffer.getSize() == 0) {
sendEvent(m_events->forIStream().outputFlushed()); sendEvent(EventTypes::StreamOutputFlushed);
m_flushed = true; m_flushed = true;
m_flushed.broadcast(); m_flushed.broadcast();
} }
@ -480,7 +479,7 @@ ISocketMultiplexerJob *TCPSocket::serviceConnecting(ISocketMultiplexerJob *job,
} }
if (write) { if (write) {
sendEvent(m_events->forIDataSocket().connected()); sendEvent(EventTypes::DataSocketConnected);
onConnected(); onConnected();
return newJob(); return newJob();
} }
@ -493,7 +492,7 @@ ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, b
Lock lock(&m_mutex); Lock lock(&m_mutex);
if (error) { if (error) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
onDisconnected(); onDisconnected();
return newJob(); return newJob();
} }
@ -506,23 +505,23 @@ ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, b
// remote read end of stream hungup. our output side // remote read end of stream hungup. our output side
// has therefore shutdown. // has therefore shutdown.
onOutputShutdown(); onOutputShutdown();
sendEvent(m_events->forIStream().outputShutdown()); sendEvent(EventTypes::StreamOutputShutdown);
if (!m_readable && m_inputBuffer.getSize() == 0) { if (!m_readable && m_inputBuffer.getSize() == 0) {
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
m_connected = false; m_connected = false;
} }
result = kNew; result = kNew;
} catch (XArchNetworkDisconnected &) { } catch (XArchNetworkDisconnected &) {
// stream hungup // stream hungup
onDisconnected(); onDisconnected();
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
result = kNew; result = kNew;
} catch (XArchNetwork &e) { } catch (XArchNetwork &e) {
// other write error // other write error
LOG((CLOG_WARN "error writing socket: %s", e.what())); LOG((CLOG_WARN "error writing socket: %s", e.what()));
onDisconnected(); onDisconnected();
sendEvent(m_events->forIStream().outputError()); sendEvent(EventTypes::StreamOutputError);
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
result = kNew; result = kNew;
} }
} }
@ -532,7 +531,7 @@ ISocketMultiplexerJob *TCPSocket::serviceConnected(ISocketMultiplexerJob *job, b
result = doRead(); result = doRead();
} catch (XArchNetworkDisconnected &) { } catch (XArchNetworkDisconnected &) {
// stream hungup // stream hungup
sendEvent(m_events->forISocket().disconnected()); sendEvent(EventTypes::SocketDisconnected);
onDisconnected(); onDisconnected();
result = kNew; result = kNew;
} catch (XArchNetwork &e) { } catch (XArchNetwork &e) {

2
src/lib/net/TCPSocket.h
View file

@ -93,7 +93,7 @@ protected:
return m_mutex; return m_mutex;
} }
void sendEvent(Event::Type); void sendEvent(EventTypes);
void discardWrittenData(int bytesWrote); void discardWrittenData(int bytesWrote);
private: private:

2
src/lib/platform/EiEventQueueBuffer.cpp
View file

@ -117,7 +117,7 @@ IEventQueueBuffer::Type EiEventQueueBuffer::getEvent(Event &event, uint32_t &dat
return kUser; return kUser;
} }
event = Event(Event::kSystem, events_->getSystemTarget()); event = Event(EventTypes::System, events_->getSystemTarget());
return kSystem; return kSystem;
} }

24
src/lib/platform/EiScreen.cpp
View file

@ -49,19 +49,19 @@ EiScreen::EiScreen(bool is_primary, IEventQueue *events, bool use_portal)
key_state_ = new EiKeyState(this, events); key_state_ = new EiKeyState(this, events);
// install event handlers // install event handlers
events_->adoptHandler( events_->adoptHandler(
Event::kSystem, events_->getSystemTarget(), new TMethodEventJob<EiScreen>(this, &EiScreen::handleSystemEvent) EventTypes::System, events_->getSystemTarget(), new TMethodEventJob<EiScreen>(this, &EiScreen::handleSystemEvent)
); );
if (use_portal) { if (use_portal) {
events_->adoptHandler( events_->adoptHandler(
events_->forEi().connected(), getEventTarget(), EventTypes::EIConnected, getEventTarget(),
new TMethodEventJob<EiScreen>(this, &EiScreen::handle_connected_to_eis_event) new TMethodEventJob<EiScreen>(this, &EiScreen::handle_connected_to_eis_event)
); );
if (is_primary) { if (is_primary) {
portal_input_capture_ = new PortalInputCapture(this, events_); portal_input_capture_ = new PortalInputCapture(this, events_);
} else { } else {
events_->adoptHandler( events_->adoptHandler(
events_->forEi().sessionClosed(), getEventTarget(), EventTypes::EISessionClosed, getEventTarget(),
new TMethodEventJob<EiScreen>(this, &EiScreen::handle_portal_session_closed) new TMethodEventJob<EiScreen>(this, &EiScreen::handle_portal_session_closed)
); );
portal_remote_desktop_ = new PortalRemoteDesktop(this, events_); portal_remote_desktop_ = new PortalRemoteDesktop(this, events_);
@ -79,7 +79,7 @@ EiScreen::EiScreen(bool is_primary, IEventQueue *events, bool use_portal)
EiScreen::~EiScreen() EiScreen::~EiScreen()
{ {
events_->adoptBuffer(nullptr); events_->adoptBuffer(nullptr);
events_->removeHandler(Event::kSystem, events_->getSystemTarget()); events_->removeHandler(EventTypes::System, events_->getSystemTarget());
cleanup_ei(); cleanup_ei();
@ -437,7 +437,7 @@ void EiScreen::update_shape()
cursor_x_ = x_ + w_ / 2; cursor_x_ = x_ + w_ / 2;
cursor_y_ = y_ + h_ / 2; cursor_y_ = y_ + h_ / 2;
sendEvent(events_->forIScreen().shapeChanged(), nullptr); sendEvent(EventTypes::ScreenShapeChanged, nullptr);
} }
void EiScreen::add_device(struct ei_device *device) void EiScreen::add_device(struct ei_device *device)
@ -509,7 +509,7 @@ void EiScreen::remove_device(struct ei_device *device)
update_shape(); update_shape();
} }
void EiScreen::sendEvent(Event::Type type, void *data) void EiScreen::sendEvent(EventTypes type, void *data)
{ {
events_->addEvent(Event(type, getEventTarget(), data)); events_->addEvent(Event(type, getEventTarget(), data));
} }
@ -549,7 +549,7 @@ bool EiScreen::on_hotkey(KeyID keyid, bool is_pressed, KeyModifierMask mask)
// key combinations may not work correctly, more effort is needed here. // key combinations may not work correctly, more effort is needed here.
auto id = it->second.find_by_mask(mask); auto id = it->second.find_by_mask(mask);
if (id != 0) { if (id != 0) {
Event::Type type = is_pressed ? events_->forIPrimaryScreen().hotKeyDown() : events_->forIPrimaryScreen().hotKeyUp(); EventTypes type = is_pressed ? EventTypes::PrimaryScreenHotkeyDown : EventTypes::PrimaryScreenHotkeyUp;
sendEvent(type, HotKeyInfo::alloc(id)); sendEvent(type, HotKeyInfo::alloc(id));
return true; return true;
} }
@ -594,7 +594,7 @@ void EiScreen::on_button_event(ei_event *event)
return; return;
} }
auto eventType = pressed ? events_->forIPrimaryScreen().buttonDown() : events_->forIPrimaryScreen().buttonUp(); auto eventType = pressed ? EventTypes::PrimaryScreenButtonDown : EventTypes::PrimaryScreenButtonUp;
sendEvent(eventType, ButtonInfo::alloc(button, mask)); sendEvent(eventType, ButtonInfo::alloc(button, mask));
} }
@ -639,7 +639,7 @@ void EiScreen::on_pointer_scroll_event(ei_event *event)
// remain compatible with other platforms (including X11). // remain compatible with other platforms (including X11).
if (x != 0 || y != 0) if (x != 0 || y != 0)
sendEvent( sendEvent(
events_->forIPrimaryScreen().wheel(), EventTypes::PrimaryScreenWheel,
WheelInfo::alloc((int32_t)-x * PIXEL_TO_WHEEL_RATIO, (int32_t)-y * PIXEL_TO_WHEEL_RATIO) WheelInfo::alloc((int32_t)-x * PIXEL_TO_WHEEL_RATIO, (int32_t)-y * PIXEL_TO_WHEEL_RATIO)
); );
@ -663,7 +663,7 @@ void EiScreen::on_pointer_scroll_discrete_event(ei_event *event)
// libei and deskflow seem to use opposite directions, so we have // libei and deskflow seem to use opposite directions, so we have
// to send the opposite of the value reported by EI if we want to // to send the opposite of the value reported by EI if we want to
// remain compatible with other platforms (including X11). // remain compatible with other platforms (including X11).
sendEvent(events_->forIPrimaryScreen().wheel(), WheelInfo::alloc(-dx, -dy)); sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(-dx, -dy));
} }
void EiScreen::on_motion_event(ei_event *event) void EiScreen::on_motion_event(ei_event *event)
@ -675,7 +675,7 @@ void EiScreen::on_motion_event(ei_event *event)
if (is_on_screen_) { if (is_on_screen_) {
LOG_DEBUG("event: motion on primary x=%i y=%i)", cursor_x_, cursor_y_); LOG_DEBUG("event: motion on primary x=%i y=%i)", cursor_x_, cursor_y_);
sendEvent(events_->forIPrimaryScreen().motionOnPrimary(), MotionInfo::alloc(cursor_x_, cursor_y_)); sendEvent(EventTypes::PrimaryScreenMotionOnPrimary, MotionInfo::alloc(cursor_x_, cursor_y_));
if (portal_input_capture_->is_active()) { if (portal_input_capture_->is_active()) {
portal_input_capture_->release(); portal_input_capture_->release();
} }
@ -686,7 +686,7 @@ void EiScreen::on_motion_event(ei_event *event)
auto pixel_dy = static_cast<std::int32_t>(buffer_dy); auto pixel_dy = static_cast<std::int32_t>(buffer_dy);
if (pixel_dx || pixel_dy) { if (pixel_dx || pixel_dy) {
LOG_DEBUG1("event: motion on secondary x=%d y=%d", pixel_dx, pixel_dy); LOG_DEBUG1("event: motion on secondary x=%d y=%d", pixel_dx, pixel_dy);
sendEvent(events_->forIPrimaryScreen().motionOnSecondary(), MotionInfo::alloc(pixel_dx, pixel_dy)); sendEvent(EventTypes::PrimaryScreenMotionOnSecondary, MotionInfo::alloc(pixel_dx, pixel_dy));
buffer_dx -= pixel_dx; buffer_dx -= pixel_dx;
buffer_dy -= pixel_dy; buffer_dy -= pixel_dy;
} }

2
src/lib/platform/EiScreen.h
View file

@ -88,7 +88,7 @@ protected:
private: private:
void init_ei(); void init_ei();
void cleanup_ei(); void cleanup_ei();
void sendEvent(Event::Type type, void *data); void sendEvent(EventTypes type, void *data);
ButtonID map_button_from_evdev(ei_event *event) const; ButtonID map_button_from_evdev(ei_event *event) const;
void on_key_event(ei_event *event); void on_key_event(ei_event *event);
void on_button_event(ei_event *event); void on_button_event(ei_event *event);

4
src/lib/platform/MSWindowsDesks.cpp
View file

@ -157,7 +157,7 @@ void MSWindowsDesks::enable()
// change but as far as i can tell it doesn't. // change but as far as i can tell it doesn't.
m_timer = m_events->newTimer(0.2, nullptr); m_timer = m_events->newTimer(0.2, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, m_timer, new TMethodEventJob<MSWindowsDesks>(this, &MSWindowsDesks::handleCheckDesk) EventTypes::Timer, m_timer, new TMethodEventJob<MSWindowsDesks>(this, &MSWindowsDesks::handleCheckDesk)
); );
updateKeys(); updateKeys();
@ -167,7 +167,7 @@ void MSWindowsDesks::disable()
{ {
// remove timer // remove timer
if (m_timer != nullptr) { if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer); m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer); m_events->deleteTimer(m_timer);
m_timer = nullptr; m_timer = nullptr;
} }

6
src/lib/platform/MSWindowsEventQueueBuffer.cpp
View file

@ -81,16 +81,16 @@ IEventQueueBuffer::Type MSWindowsEventQueueBuffer::getEvent(Event &event, uint32
if (result == -1) { if (result == -1) {
return kNone; return kNone;
} else if (result == 0) { } else if (result == 0) {
event = Event(Event::kQuit); event = Event(EventTypes::Quit);
return kSystem; return kSystem;
} else if (m_daemonQuit != 0 && m_event.message == m_daemonQuit) { } else if (m_daemonQuit != 0 && m_event.message == m_daemonQuit) {
event = Event(Event::kQuit); event = Event(EventTypes::Quit);
return kSystem; return kSystem;
} else if (m_event.message == m_userEvent) { } else if (m_event.message == m_userEvent) {
dataID = static_cast<uint32_t>(m_event.wParam); dataID = static_cast<uint32_t>(m_event.wParam);
return kUser; return kUser;
} else { } else {
event = Event(Event::kSystem, m_events->getSystemTarget(), &m_event); event = Event(EventTypes::System, m_events->getSystemTarget(), &m_event);
return kSystem; return kSystem;
} }
} }

2
src/lib/platform/MSWindowsKeyState.cpp
View file

@ -605,7 +605,7 @@ void MSWindowsKeyState::init()
void MSWindowsKeyState::disable() void MSWindowsKeyState::disable()
{ {
if (m_fixTimer != nullptr) { if (m_fixTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_fixTimer); m_events->removeHandler(EventTypes::Timer, m_fixTimer);
m_events->deleteTimer(m_fixTimer); m_events->deleteTimer(m_fixTimer);
m_fixTimer = nullptr; m_fixTimer = nullptr;
} }

49
src/lib/platform/MSWindowsScreen.cpp
View file

@ -172,7 +172,7 @@ MSWindowsScreen::MSWindowsScreen(
// install event handlers // install event handlers
m_events->adoptHandler( m_events->adoptHandler(
Event::kSystem, m_events->getSystemTarget(), EventTypes::System, m_events->getSystemTarget(),
new TMethodEventJob<MSWindowsScreen>(this, &MSWindowsScreen::handleSystemEvent) new TMethodEventJob<MSWindowsScreen>(this, &MSWindowsScreen::handleSystemEvent)
); );
@ -186,7 +186,7 @@ MSWindowsScreen::~MSWindowsScreen()
disable(); disable();
m_events->adoptBuffer(nullptr); m_events->adoptBuffer(nullptr);
m_events->removeHandler(Event::kSystem, m_events->getSystemTarget()); m_events->removeHandler(EventTypes::System, m_events->getSystemTarget());
delete m_keyState; delete m_keyState;
delete m_desks; delete m_desks;
delete m_screensaver; delete m_screensaver;
@ -222,7 +222,7 @@ void MSWindowsScreen::enable()
// we need to poll some things to fix them // we need to poll some things to fix them
m_fixTimer = m_events->newTimer(1.0, nullptr); m_fixTimer = m_events->newTimer(1.0, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, m_fixTimer, new TMethodEventJob<MSWindowsScreen>(this, &MSWindowsScreen::handleFixes) EventTypes::Timer, m_fixTimer, new TMethodEventJob<MSWindowsScreen>(this, &MSWindowsScreen::handleFixes)
); );
// install our clipboard snooper // install our clipboard snooper
@ -265,7 +265,7 @@ void MSWindowsScreen::disable()
// uninstall fix timer // uninstall fix timer
if (m_fixTimer != nullptr) { if (m_fixTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_fixTimer); m_events->removeHandler(EventTypes::Timer, m_fixTimer);
m_events->deleteTimer(m_fixTimer); m_events->deleteTimer(m_fixTimer);
m_fixTimer = nullptr; m_fixTimer = nullptr;
} }
@ -416,8 +416,8 @@ void MSWindowsScreen::checkClipboards()
if (m_ownClipboard && !MSWindowsClipboard::isOwnedByDeskflow()) { if (m_ownClipboard && !MSWindowsClipboard::isOwnedByDeskflow()) {
LOG((CLOG_DEBUG "clipboard changed: lost ownership and no notification received")); LOG((CLOG_DEBUG "clipboard changed: lost ownership and no notification received"));
m_ownClipboard = false; m_ownClipboard = false;
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardSelection);
} }
} }
@ -909,12 +909,12 @@ void MSWindowsScreen::destroyWindow(HWND hwnd) const
} }
} }
void MSWindowsScreen::sendEvent(Event::Type type, void *data) void MSWindowsScreen::sendEvent(EventTypes type, void *data)
{ {
m_events->addEvent(Event(type, getEventTarget(), data)); m_events->addEvent(Event(type, getEventTarget(), data));
} }
void MSWindowsScreen::sendClipboardEvent(Event::Type type, ClipboardID id) void MSWindowsScreen::sendClipboardEvent(EventTypes type, ClipboardID id)
{ {
ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo)); ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
if (info == nullptr) { if (info == nullptr) {
@ -1050,7 +1050,7 @@ bool MSWindowsScreen::onEvent(HWND, UINT msg, WPARAM wParam, LPARAM lParam, LRES
/* On windows 10 we don't receive WM_POWERBROADCAST after sleep. /* On windows 10 we don't receive WM_POWERBROADCAST after sleep.
We receive only WM_TIMECHANGE hence this message is used to resume.*/ We receive only WM_TIMECHANGE hence this message is used to resume.*/
case WM_TIMECHANGE: case WM_TIMECHANGE:
m_events->addEvent(Event(m_events->forIScreen().resume(), getEventTarget(), nullptr, Event::kDeliverImmediately)); m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::kDeliverImmediately));
break; break;
case WM_POWERBROADCAST: case WM_POWERBROADCAST:
@ -1058,12 +1058,11 @@ bool MSWindowsScreen::onEvent(HWND, UINT msg, WPARAM wParam, LPARAM lParam, LRES
case PBT_APMRESUMEAUTOMATIC: case PBT_APMRESUMEAUTOMATIC:
case PBT_APMRESUMECRITICAL: case PBT_APMRESUMECRITICAL:
case PBT_APMRESUMESUSPEND: case PBT_APMRESUMESUSPEND:
m_events->addEvent(Event(m_events->forIScreen().resume(), getEventTarget(), nullptr, Event::kDeliverImmediately)); m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget(), nullptr, Event::kDeliverImmediately));
break; break;
case PBT_APMSUSPEND: case PBT_APMSUSPEND:
m_events->addEvent(Event(m_events->forIScreen().suspend(), getEventTarget(), nullptr, Event::kDeliverImmediately) m_events->addEvent(Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::kDeliverImmediately));
);
break; break;
} }
*result = TRUE; *result = TRUE;
@ -1242,15 +1241,15 @@ bool MSWindowsScreen::onHotKey(WPARAM wParam, LPARAM lParam)
} }
// find what kind of event // find what kind of event
Event::Type type; EventTypes type;
if ((lParam & 0x80000000u) == 0u) { if ((lParam & 0x80000000u) == 0u) {
if ((lParam & 0x40000000u) != 0u) { if ((lParam & 0x40000000u) != 0u) {
// ignore key repeats but it counts as a hot key // ignore key repeats but it counts as a hot key
return true; return true;
} }
type = m_events->forIPrimaryScreen().hotKeyDown(); type = EventTypes::PrimaryScreenHotkeyDown;
} else { } else {
type = m_events->forIPrimaryScreen().hotKeyUp(); type = EventTypes::PrimaryScreenHotkeyUp;
} }
// generate event // generate event
@ -1287,12 +1286,12 @@ bool MSWindowsScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
if (pressed) { if (pressed) {
LOG((CLOG_DEBUG1 "event: button press button=%d", button)); LOG((CLOG_DEBUG1 "event: button press button=%d", button));
if (button != kButtonNone) { if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonDown(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonDown, ButtonInfo::alloc(button, mask));
} }
} else { } else {
LOG((CLOG_DEBUG1 "event: button release button=%d", button)); LOG((CLOG_DEBUG1 "event: button release button=%d", button));
if (button != kButtonNone) { if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonUp(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
} }
} }
} }
@ -1331,7 +1330,7 @@ bool MSWindowsScreen::onMouseMove(int32_t mx, int32_t my)
if (m_isOnScreen) { if (m_isOnScreen) {
// motion on primary screen // motion on primary screen
sendEvent(m_events->forIPrimaryScreen().motionOnPrimary(), MotionInfo::alloc(m_xCursor, m_yCursor)); sendEvent(EventTypes::PrimaryScreenMotionOnPrimary, MotionInfo::alloc(m_xCursor, m_yCursor));
if (m_buttons[kButtonLeft] == true && m_draggingStarted == false) { if (m_buttons[kButtonLeft] == true && m_draggingStarted == false) {
m_draggingStarted = true; m_draggingStarted = true;
@ -1356,7 +1355,7 @@ bool MSWindowsScreen::onMouseMove(int32_t mx, int32_t my)
LOG((CLOG_DEBUG "dropped bogus delta motion: %+d,%+d", x, y)); LOG((CLOG_DEBUG "dropped bogus delta motion: %+d,%+d", x, y));
} else { } else {
// send motion // send motion
sendEvent(m_events->forIPrimaryScreen().motionOnSecondary(), MotionInfo::alloc(x, y)); sendEvent(EventTypes::PrimaryScreenMotionOnSecondary, MotionInfo::alloc(x, y));
} }
} }
@ -1368,7 +1367,7 @@ bool MSWindowsScreen::onMouseWheel(int32_t xDelta, int32_t yDelta)
// ignore message if posted prior to last mark change // ignore message if posted prior to last mark change
if (!ignore()) { if (!ignore()) {
LOG((CLOG_DEBUG1 "event: button wheel delta=%+d,%+d", xDelta, yDelta)); LOG((CLOG_DEBUG1 "event: button wheel delta=%+d,%+d", xDelta, yDelta));
sendEvent(m_events->forIPrimaryScreen().wheel(), WheelInfo::alloc(xDelta, yDelta)); sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(xDelta, yDelta));
} }
return true; return true;
} }
@ -1391,12 +1390,12 @@ bool MSWindowsScreen::onScreensaver(bool activated)
if (activated) { if (activated) {
if (!m_screensaverActive && m_screensaver->checkStarted(DESKFLOW_MSG_SCREEN_SAVER, FALSE, 0)) { if (!m_screensaverActive && m_screensaver->checkStarted(DESKFLOW_MSG_SCREEN_SAVER, FALSE, 0)) {
m_screensaverActive = true; m_screensaverActive = true;
sendEvent(m_events->forIPrimaryScreen().screensaverActivated()); sendEvent(EventTypes::PrimaryScreenSaverActivated);
} }
} else { } else {
if (m_screensaverActive) { if (m_screensaverActive) {
m_screensaverActive = false; m_screensaverActive = false;
sendEvent(m_events->forIPrimaryScreen().screensaverDeactivated()); sendEvent(EventTypes::PrimaryScreenSaverDeactivated);
} }
} }
@ -1428,7 +1427,7 @@ bool MSWindowsScreen::onDisplayChange()
} }
// send new screen info // send new screen info
sendEvent(m_events->forIScreen().shapeChanged()); sendEvent(EventTypes::ScreenShapeChanged);
LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_w, m_h, m_multimon ? "(multi-monitor)" : "")); LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_w, m_h, m_multimon ? "(multi-monitor)" : ""));
} }
@ -1444,8 +1443,8 @@ void MSWindowsScreen::onClipboardChange()
if (m_ownClipboard) { if (m_ownClipboard) {
LOG((CLOG_DEBUG "clipboard changed: lost ownership")); LOG((CLOG_DEBUG "clipboard changed: lost ownership"));
m_ownClipboard = false; m_ownClipboard = false;
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardSelection);
} }
} else if (!m_ownClipboard) { } else if (!m_ownClipboard) {
LOG((CLOG_DEBUG "clipboard changed: %s owned", kAppId)); LOG((CLOG_DEBUG "clipboard changed: %s owned", kAppId));

4
src/lib/platform/MSWindowsScreen.h
View file

@ -152,10 +152,10 @@ private:
// convenience function to send events // convenience function to send events
public: // HACK public: // HACK
void sendEvent(Event::Type type, void * = nullptr); void sendEvent(EventTypes type, void * = nullptr);
private: // HACK private: // HACK
void sendClipboardEvent(Event::Type type, ClipboardID id); void sendClipboardEvent(EventTypes type, ClipboardID id);
// handle message before it gets dispatched. returns true iff // handle message before it gets dispatched. returns true iff
// the message should not be dispatched. // the message should not be dispatched.

4
src/lib/platform/OSXScreen.h
View file

@ -116,8 +116,8 @@ private:
void postMouseEvent(CGPoint &) const; void postMouseEvent(CGPoint &) const;
// convenience function to send events // convenience function to send events
void sendEvent(Event::Type type, void * = nullptr) const; void sendEvent(EventTypes type, void * = nullptr) const;
void sendClipboardEvent(Event::Type type, ClipboardID id) const; void sendClipboardEvent(EventTypes type, ClipboardID id) const;
// message handlers // message handlers
bool onMouseMove(CGFloat mx, CGFloat my); bool onMouseMove(CGFloat mx, CGFloat my);

74
src/lib/platform/OSXScreen.mm
View file

@ -150,7 +150,7 @@ OSXScreen::OSXScreen(
// watch for requests to sleep // watch for requests to sleep
m_events->adoptHandler( m_events->adoptHandler(
m_events->forOSXScreen().confirmSleep(), getEventTarget(), EventTypes::OsxScreenConfirmSleep, getEventTarget(),
new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleConfirmSleep) new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleConfirmSleep)
); );
@ -161,7 +161,7 @@ OSXScreen::OSXScreen(
LOG((CLOG_DEBUG "starting watchSystemPowerThread")); LOG((CLOG_DEBUG "starting watchSystemPowerThread"));
m_pmWatchThread = new Thread(new TMethodJob<OSXScreen>(this, &OSXScreen::watchSystemPowerThread)); m_pmWatchThread = new Thread(new TMethodJob<OSXScreen>(this, &OSXScreen::watchSystemPowerThread));
} catch (...) { } catch (...) {
m_events->removeHandler(m_events->forOSXScreen().confirmSleep(), getEventTarget()); m_events->removeHandler(EventTypes::OsxScreenConfirmSleep, getEventTarget());
if (m_switchEventHandlerRef != 0) { if (m_switchEventHandlerRef != 0) {
RemoveEventHandler(m_switchEventHandlerRef); RemoveEventHandler(m_switchEventHandlerRef);
} }
@ -175,7 +175,8 @@ OSXScreen::OSXScreen(
// install event handlers // install event handlers
m_events->adoptHandler( m_events->adoptHandler(
Event::kSystem, m_events->getSystemTarget(), new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleSystemEvent) EventTypes::System, m_events->getSystemTarget(),
new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleSystemEvent)
); );
// install the platform event queue // install the platform event queue
@ -187,7 +188,7 @@ OSXScreen::~OSXScreen()
disable(); disable();
m_events->adoptBuffer(nullptr); m_events->adoptBuffer(nullptr);
m_events->removeHandler(Event::kSystem, m_events->getSystemTarget()); m_events->removeHandler(EventTypes::System, m_events->getSystemTarget());
if (m_pmWatchThread) { if (m_pmWatchThread) {
// make sure the thread has setup the runloop. // make sure the thread has setup the runloop.
@ -208,7 +209,7 @@ OSXScreen::~OSXScreen()
delete m_pmThreadReady; delete m_pmThreadReady;
delete m_pmMutex; delete m_pmMutex;
m_events->removeHandler(m_events->forOSXScreen().confirmSleep(), getEventTarget()); m_events->removeHandler(EventTypes::OsxScreenConfirmSleep, getEventTarget());
RemoveEventHandler(m_switchEventHandlerRef); RemoveEventHandler(m_switchEventHandlerRef);
@ -701,7 +702,7 @@ void OSXScreen::enable()
// watch the clipboard // watch the clipboard
m_clipboardTimer = m_events->newTimer(1.0, nullptr); m_clipboardTimer = m_events->newTimer(1.0, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, m_clipboardTimer, new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleClipboardCheck) EventTypes::Timer, m_clipboardTimer, new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleClipboardCheck)
); );
if (m_isPrimary) { if (m_isPrimary) {
@ -766,7 +767,7 @@ void OSXScreen::disable()
// uninstall clipboard timer // uninstall clipboard timer
if (m_clipboardTimer != nullptr) { if (m_clipboardTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_clipboardTimer); m_events->removeHandler(EventTypes::Timer, m_clipboardTimer);
m_events->deleteTimer(m_clipboardTimer); m_events->deleteTimer(m_clipboardTimer);
m_clipboardTimer = nullptr; m_clipboardTimer = nullptr;
} }
@ -854,8 +855,8 @@ void OSXScreen::checkClipboards()
LOG((CLOG_DEBUG2 "checking clipboard")); LOG((CLOG_DEBUG2 "checking clipboard"));
if (m_pasteboard.synchronize()) { if (m_pasteboard.synchronize()) {
LOG((CLOG_DEBUG "clipboard changed")); LOG((CLOG_DEBUG "clipboard changed"));
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection); sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardSelection);
} }
} }
@ -903,12 +904,12 @@ bool OSXScreen::isPrimary() const
return m_isPrimary; return m_isPrimary;
} }
void OSXScreen::sendEvent(Event::Type type, void *data) const void OSXScreen::sendEvent(EventTypes type, void *data) const
{ {
m_events->addEvent(Event(type, getEventTarget(), data)); m_events->addEvent(Event(type, getEventTarget(), data));
} }
void OSXScreen::sendClipboardEvent(Event::Type type, ClipboardID id) const void OSXScreen::sendClipboardEvent(EventTypes type, ClipboardID id) const
{ {
ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo)); ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
info->m_id = id; info->m_id = id;
@ -1009,7 +1010,7 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
if (m_isOnScreen) { if (m_isOnScreen) {
// motion on primary screen // motion on primary screen
sendEvent(m_events->forIPrimaryScreen().motionOnPrimary(), MotionInfo::alloc(m_xCursor, m_yCursor)); sendEvent(EventTypes::PrimaryScreenMotionOnPrimary, MotionInfo::alloc(m_xCursor, m_yCursor));
if (m_buttonState.test(0)) { if (m_buttonState.test(0)) {
m_draggingStarted = true; m_draggingStarted = true;
} }
@ -1043,7 +1044,7 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
// And keep only the fractional part // And keep only the fractional part
m_xFractionalMove -= intX; m_xFractionalMove -= intX;
m_yFractionalMove -= intY; m_yFractionalMove -= intY;
sendEvent(m_events->forIPrimaryScreen().motionOnSecondary(), MotionInfo::alloc(intX, intY)); sendEvent(EventTypes::PrimaryScreenMotionOnSecondary, MotionInfo::alloc(intX, intY));
} }
} }
@ -1059,13 +1060,13 @@ bool OSXScreen::onMouseButton(bool pressed, uint16_t macButton)
LOG((CLOG_DEBUG1 "event: button press button=%d", button)); LOG((CLOG_DEBUG1 "event: button press button=%d", button));
if (button != kButtonNone) { if (button != kButtonNone) {
KeyModifierMask mask = m_keyState->getActiveModifiers(); KeyModifierMask mask = m_keyState->getActiveModifiers();
sendEvent(m_events->forIPrimaryScreen().buttonDown(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonDown, ButtonInfo::alloc(button, mask));
} }
} else { } else {
LOG((CLOG_DEBUG1 "event: button release button=%d", button)); LOG((CLOG_DEBUG1 "event: button release button=%d", button));
if (button != kButtonNone) { if (button != kButtonNone) {
KeyModifierMask mask = m_keyState->getActiveModifiers(); KeyModifierMask mask = m_keyState->getActiveModifiers();
sendEvent(m_events->forIPrimaryScreen().buttonUp(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
} }
} }
@ -1106,7 +1107,7 @@ bool OSXScreen::onMouseButton(bool pressed, uint16_t macButton)
bool OSXScreen::onMouseWheel(int32_t xDelta, int32_t yDelta) const bool OSXScreen::onMouseWheel(int32_t xDelta, int32_t yDelta) const
{ {
LOG((CLOG_DEBUG1 "event: button wheel delta=%+d,%+d", xDelta, yDelta)); LOG((CLOG_DEBUG1 "event: button wheel delta=%+d,%+d", xDelta, yDelta));
sendEvent(m_events->forIPrimaryScreen().wheel(), WheelInfo::alloc(xDelta, yDelta)); sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(xDelta, yDelta));
return true; return true;
} }
@ -1160,9 +1161,9 @@ bool OSXScreen::onKey(CGEventRef event)
if (m_modifierHotKeys.count(newMask) > 0) { if (m_modifierHotKeys.count(newMask) > 0) {
m_activeModifierHotKey = m_modifierHotKeys[newMask]; m_activeModifierHotKey = m_modifierHotKeys[newMask];
m_activeModifierHotKeyMask = newMask; m_activeModifierHotKeyMask = newMask;
m_events->addEvent(Event( m_events->addEvent(
m_events->forIPrimaryScreen().hotKeyDown(), getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey) Event(EventTypes::PrimaryScreenHotkeyDown, getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey))
)); );
} }
} }
@ -1172,7 +1173,7 @@ bool OSXScreen::onKey(CGEventRef event)
KeyModifierMask mask = (newMask & m_activeModifierHotKeyMask); KeyModifierMask mask = (newMask & m_activeModifierHotKeyMask);
if (mask != m_activeModifierHotKeyMask) { if (mask != m_activeModifierHotKeyMask) {
m_events->addEvent( m_events->addEvent(
Event(m_events->forIPrimaryScreen().hotKeyUp(), getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey)) Event(EventTypes::PrimaryScreenHotkeyUp, getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey))
); );
m_activeModifierHotKey = 0; m_activeModifierHotKey = 0;
m_activeModifierHotKeyMask = 0; m_activeModifierHotKeyMask = 0;
@ -1189,11 +1190,11 @@ bool OSXScreen::onKey(CGEventRef event)
uint32_t id = i->second; uint32_t id = i->second;
// determine event type // determine event type
Event::Type type; EventTypes type;
if (eventKind == kCGEventKeyDown) { if (eventKind == kCGEventKeyDown) {
type = m_events->forIPrimaryScreen().hotKeyDown(); type = EventTypes::PrimaryScreenHotkeyDown;
} else if (eventKind == kCGEventKeyUp) { } else if (eventKind == kCGEventKeyUp) {
type = m_events->forIPrimaryScreen().hotKeyUp(); type = EventTypes::PrimaryScreenHotkeyUp;
} else { } else {
return false; return false;
} }
@ -1273,12 +1274,12 @@ bool OSXScreen::onHotKey(EventRef event) const
uint32_t id = hkid.id; uint32_t id = hkid.id;
// determine event type // determine event type
Event::Type type; EventTypes type;
uint32_t eventKind = GetEventKind(event); uint32_t eventKind = GetEventKind(event);
if (eventKind == kEventHotKeyPressed) { if (eventKind == kEventHotKeyPressed) {
type = m_events->forIPrimaryScreen().hotKeyDown(); type = EventTypes::PrimaryScreenHotkeyDown;
} else if (eventKind == kEventHotKeyReleased) { } else if (eventKind == kEventHotKeyReleased) {
type = m_events->forIPrimaryScreen().hotKeyUp(); type = EventTypes::PrimaryScreenHotkeyUp;
} else { } else {
return false; return false;
} }
@ -1361,14 +1362,16 @@ void OSXScreen::enableDragTimer(bool enable)
{ {
if (enable && m_dragTimer == nullptr) { if (enable && m_dragTimer == nullptr) {
m_dragTimer = m_events->newTimer(0.01, nullptr); m_dragTimer = m_events->newTimer(0.01, nullptr);
m_events->adoptHandler(Event::kTimer, m_dragTimer, new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleDrag)); m_events->adoptHandler(
EventTypes::Timer, m_dragTimer, new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleDrag)
);
CGEventRef event = CGEventCreate(nullptr); CGEventRef event = CGEventCreate(nullptr);
CGPoint mouse = CGEventGetLocation(event); CGPoint mouse = CGEventGetLocation(event);
m_dragLastPoint.h = (short)mouse.x; m_dragLastPoint.h = (short)mouse.x;
m_dragLastPoint.v = (short)mouse.y; m_dragLastPoint.v = (short)mouse.y;
CFRelease(event); CFRelease(event);
} else if (!enable && m_dragTimer != nullptr) { } else if (!enable && m_dragTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_dragTimer); m_events->removeHandler(EventTypes::Timer, m_dragTimer);
m_events->deleteTimer(m_dragTimer); m_events->deleteTimer(m_dragTimer);
m_dragTimer = nullptr; m_dragTimer = nullptr;
} }
@ -1448,7 +1451,7 @@ bool OSXScreen::updateScreenShape()
delete[] displays; delete[] displays;
// We want to notify the peer screen whether we are primary screen or not // We want to notify the peer screen whether we are primary screen or not
sendEvent(m_events->forIScreen().shapeChanged()); sendEvent(EventTypes::ScreenShapeChanged);
LOG( LOG(
(CLOG_DEBUG "screen shape: center=%d,%d size=%dx%d on %u %s", m_x, m_y, m_w, m_h, displayCount, (CLOG_DEBUG "screen shape: center=%d,%d size=%dx%d on %u %s", m_x, m_y, m_w, m_h, displayCount,
@ -1476,10 +1479,10 @@ pascal OSStatus OSXScreen::userSwitchCallback(EventHandlerCallRef nextHandler, E
if (kind == kEventSystemUserSessionDeactivated) { if (kind == kEventSystemUserSessionDeactivated) {
LOG((CLOG_DEBUG "user session deactivated")); LOG((CLOG_DEBUG "user session deactivated"));
events->addEvent(Event(events->forIScreen().suspend(), screen->getEventTarget())); events->addEvent(Event(EventTypes::ScreenSuspend, screen->getEventTarget()));
} else if (kind == kEventSystemUserSessionActivated) { } else if (kind == kEventSystemUserSessionActivated) {
LOG((CLOG_DEBUG "user session activated")); LOG((CLOG_DEBUG "user session activated"));
events->addEvent(Event(events->forIScreen().resume(), screen->getEventTarget())); events->addEvent(Event(EventTypes::ScreenResume, screen->getEventTarget()));
} }
return (CallNextEventHandler(nextHandler, theEvent)); return (CallNextEventHandler(nextHandler, theEvent));
} }
@ -1574,14 +1577,12 @@ void OSXScreen::handlePowerChangeRequest(natural_t messageType, void *messageArg
// OSXScreen has to handle this in the main thread so we have to // 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 // queue a confirm sleep event here. we actually don't allow the
// system to sleep until the event is handled. // system to sleep until the event is handled.
m_events->addEvent( m_events->addEvent(Event(EventTypes::OsxScreenConfirmSleep, getEventTarget(), messageArg, Event::kDontFreeData));
Event(m_events->forOSXScreen().confirmSleep(), getEventTarget(), messageArg, Event::kDontFreeData)
);
return; return;
case kIOMessageSystemHasPoweredOn: case kIOMessageSystemHasPoweredOn:
LOG((CLOG_DEBUG "system wakeup")); LOG((CLOG_DEBUG "system wakeup"));
m_events->addEvent(Event(m_events->forIScreen().resume(), getEventTarget())); m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget()));
break; break;
default: default:
@ -1601,8 +1602,7 @@ void OSXScreen::handleConfirmSleep(const Event &event, void *)
Lock lock(m_pmMutex); Lock lock(m_pmMutex);
if (m_pmRootPort != 0) { if (m_pmRootPort != 0) {
// deliver suspend event immediately. // deliver suspend event immediately.
m_events->addEvent(Event(m_events->forIScreen().suspend(), getEventTarget(), nullptr, Event::kDeliverImmediately) m_events->addEvent(Event(EventTypes::ScreenSuspend, getEventTarget(), nullptr, Event::kDeliverImmediately));
);
LOG((CLOG_DEBUG "system will sleep")); LOG((CLOG_DEBUG "system will sleep"));
IOAllowPowerChange(m_pmRootPort, messageArg); IOAllowPowerChange(m_pmRootPort, messageArg);

4
src/lib/platform/OSXScreenSaver.cpp
View file

@ -92,7 +92,7 @@ void OSXScreenSaver::processLaunched(ProcessSerialNumber psn)
m_screenSaverPSN = psn; m_screenSaverPSN = psn;
LOG((CLOG_DEBUG1 "screen saver engine launched, enabled=%d", m_enabled)); LOG((CLOG_DEBUG1 "screen saver engine launched, enabled=%d", m_enabled));
if (m_enabled) { if (m_enabled) {
m_events->addEvent(Event(m_events->forIPrimaryScreen().screensaverActivated(), m_eventTarget)); m_events->addEvent(Event(EventTypes::PrimaryScreenSaverActivated, m_eventTarget));
} }
} }
} }
@ -102,7 +102,7 @@ void OSXScreenSaver::processTerminated(ProcessSerialNumber psn)
if (m_screenSaverPSN.highLongOfPSN == psn.highLongOfPSN && m_screenSaverPSN.lowLongOfPSN == psn.lowLongOfPSN) { if (m_screenSaverPSN.highLongOfPSN == psn.highLongOfPSN && m_screenSaverPSN.lowLongOfPSN == psn.lowLongOfPSN) {
LOG((CLOG_DEBUG1 "screen saver engine terminated, enabled=%d", m_enabled)); LOG((CLOG_DEBUG1 "screen saver engine terminated, enabled=%d", m_enabled));
if (m_enabled) { if (m_enabled) {
m_events->addEvent(Event(m_events->forIPrimaryScreen().screensaverDeactivated(), m_eventTarget)); m_events->addEvent(Event(EventTypes::PrimaryScreenSaverDeactivated, m_eventTarget));
} }
m_screenSaverPSN.highLongOfPSN = 0; m_screenSaverPSN.highLongOfPSN = 0;

8
src/lib/platform/PortalInputCapture.cpp
View file

@ -110,7 +110,7 @@ void PortalInputCapture::cb_session_closed(XdpSession *session)
{ {
LOG_ERR("portal input capture session was closed, exiting"); LOG_ERR("portal input capture session was closed, exiting");
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
g_signal_handler_disconnect(session, signals_[SESSION_CLOSED]); g_signal_handler_disconnect(session, signals_[SESSION_CLOSED]);
signals_[SESSION_CLOSED] = 0; signals_[SESSION_CLOSED] = 0;
@ -125,7 +125,7 @@ void PortalInputCapture::cb_init_input_capture_session(GObject *object, GAsyncRe
if (!session) { if (!session) {
LOG_ERR("failed to initialize input capture session, quitting: %s", error->message); LOG_ERR("failed to initialize input capture session, quitting: %s", error->message);
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
return; return;
} }
@ -141,12 +141,12 @@ void PortalInputCapture::cb_init_input_capture_session(GObject *object, GAsyncRe
if (fd < 0) { if (fd < 0) {
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
return; return;
} }
} }
// Socket ownership is transferred to the EiScreen // Socket ownership is transferred to the EiScreen
events_->addEvent(Event(events_->forEi().connected(), screen_->getEventTarget(), EiScreen::EiConnectInfo::alloc(fd))); events_->addEvent(Event(EventTypes::EIConnected, screen_->getEventTarget(), EiScreen::EiConnectInfo::alloc(fd)));
// FIXME: the lambda trick doesn't work here for unknown reasons, we need // FIXME: the lambda trick doesn't work here for unknown reasons, we need
// the static function // the static function

10
src/lib/platform/PortalRemoteDesktop.cpp
View file

@ -71,7 +71,7 @@ void PortalRemoteDesktop::cb_session_closed(XdpSession *session)
LOG_ERR("portal remote desktop session was closed, reconnecting"); LOG_ERR("portal remote desktop session was closed, reconnecting");
g_signal_handler_disconnect(session, session_signal_id_); g_signal_handler_disconnect(session, session_signal_id_);
session_signal_id_ = 0; session_signal_id_ = 0;
events_->addEvent(Event(events_->forEi().sessionClosed(), screen_->getEventTarget())); events_->addEvent(Event(EventTypes::EISessionClosed, screen_->getEventTarget()));
// gcc warning "Suspicious usage of 'sizeof(A*)'" can be ignored // gcc warning "Suspicious usage of 'sizeof(A*)'" can be ignored
g_clear_object(&session_); g_clear_object(&session_);
@ -87,7 +87,7 @@ void PortalRemoteDesktop::cb_session_started(GObject *object, GAsyncResult *res)
if (!success) { if (!success) {
LOG_ERR("failed to start portal remote desktop session, quitting: %s", error->message); LOG_ERR("failed to start portal remote desktop session, quitting: %s", error->message);
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
return; return;
} }
@ -100,12 +100,12 @@ void PortalRemoteDesktop::cb_session_started(GObject *object, GAsyncResult *res)
fd = xdp_session_connect_to_eis(session, &error); fd = xdp_session_connect_to_eis(session, &error);
if (fd < 0) { if (fd < 0) {
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
return; return;
} }
// Socket ownership is transferred to the EiScreen // Socket ownership is transferred to the EiScreen
events_->addEvent(Event(events_->forEi().connected(), screen_->getEventTarget(), EiScreen::EiConnectInfo::alloc(fd))); events_->addEvent(Event(EventTypes::EIConnected, screen_->getEventTarget(), EiScreen::EiConnectInfo::alloc(fd)));
} }
void PortalRemoteDesktop::cb_init_remote_desktop_session(GObject *object, GAsyncResult *res) void PortalRemoteDesktop::cb_init_remote_desktop_session(GObject *object, GAsyncResult *res)
@ -120,7 +120,7 @@ void PortalRemoteDesktop::cb_init_remote_desktop_session(GObject *object, GAsync
// fails. // fails.
if (session_iteration_ == 0) { if (session_iteration_ == 0) {
g_main_loop_quit(glib_main_loop_); g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit); events_->addEvent(EventTypes::Quit);
} else { } else {
this->reconnect(1000); this->reconnect(1000);
} }

2
src/lib/platform/XWindowsEventQueueBuffer.cpp
View file

@ -150,7 +150,7 @@ IEventQueueBuffer::Type XWindowsEventQueueBuffer::getEvent(Event &event, uint32_
dataID = static_cast<uint32_t>(m_event.xclient.data.l[0]); dataID = static_cast<uint32_t>(m_event.xclient.data.l[0]);
return kUser; return kUser;
} else { } else {
event = Event(Event::kSystem, m_events->getSystemTarget(), &m_event); event = Event(EventTypes::System, m_events->getSystemTarget(), &m_event);
return kSystem; return kSystem;
} }
} }

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

@ -185,7 +185,7 @@ XWindowsScreen::XWindowsScreen(
// install event handlers // install event handlers
m_events->adoptHandler( m_events->adoptHandler(
Event::kSystem, m_events->getSystemTarget(), EventTypes::System, m_events->getSystemTarget(),
new TMethodEventJob<XWindowsScreen>(this, &XWindowsScreen::handleSystemEvent) new TMethodEventJob<XWindowsScreen>(this, &XWindowsScreen::handleSystemEvent)
); );
@ -199,7 +199,7 @@ XWindowsScreen::~XWindowsScreen()
assert(m_display != nullptr); assert(m_display != nullptr);
m_events->adoptBuffer(nullptr); m_events->adoptBuffer(nullptr);
m_events->removeHandler(Event::kSystem, m_events->getSystemTarget()); m_events->removeHandler(EventTypes::System, m_events->getSystemTarget());
for (ClipboardID id = 0; id < kClipboardEnd; ++id) { for (ClipboardID id = 0; id < kClipboardEnd; ++id) {
delete m_clipboard[id]; delete m_clipboard[id];
} }
@ -1110,12 +1110,12 @@ void XWindowsScreen::openIM()
XSelectInput(m_display, m_root, StructureNotifyMask); XSelectInput(m_display, m_root, StructureNotifyMask);
} }
void XWindowsScreen::sendEvent(Event::Type type, void *data) void XWindowsScreen::sendEvent(EventTypes type, void *data)
{ {
m_events->addEvent(Event(type, getEventTarget(), data)); m_events->addEvent(Event(type, getEventTarget(), data));
} }
void XWindowsScreen::sendClipboardEvent(Event::Type type, ClipboardID id) void XWindowsScreen::sendClipboardEvent(EventTypes type, ClipboardID id)
{ {
auto *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo)); auto *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
info->m_id = id; info->m_id = id;
@ -1272,7 +1272,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
ClipboardID id = getClipboardID(xevent->xselectionclear.selection); ClipboardID id = getClipboardID(xevent->xselectionclear.selection);
if (id != kClipboardEnd) { if (id != kClipboardEnd) {
m_clipboard[id]->lost(xevent->xselectionclear.time); m_clipboard[id]->lost(xevent->xselectionclear.time);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), id); sendClipboardEvent(EventTypes::ClipboardGrabbed, id);
return; return;
} }
} break; } break;
@ -1345,7 +1345,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
case ConfigureNotify: case ConfigureNotify:
if (!m_isPrimary && xevent->xconfigure.window == m_root) { if (!m_isPrimary && xevent->xconfigure.window == m_root) {
setShape(xevent->xconfigure.width, xevent->xconfigure.height); setShape(xevent->xconfigure.width, xevent->xconfigure.height);
sendEvent(m_events->forIScreen().shapeChanged()); sendEvent(EventTypes::ScreenShapeChanged);
} }
return; return;
@ -1390,7 +1390,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
XResizeWindow(m_display, m_window, m_w, m_h); XResizeWindow(m_display, m_window, m_w, m_h);
} }
sendEvent(m_events->forIScreen().shapeChanged()); sendEvent(EventTypes::ScreenShapeChanged);
} }
} }
#endif #endif
@ -1478,11 +1478,11 @@ bool XWindowsScreen::onHotKey(XKeyEvent &xkey, bool isRepeat)
} }
// find what kind of event // find what kind of event
Event::Type type; EventTypes type;
if (xkey.type == KeyPress) { if (xkey.type == KeyPress) {
type = m_events->forIPrimaryScreen().hotKeyDown(); type = EventTypes::PrimaryScreenHotkeyDown;
} else if (xkey.type == KeyRelease) { } else if (xkey.type == KeyRelease) {
type = m_events->forIPrimaryScreen().hotKeyUp(); type = EventTypes::PrimaryScreenHotkeyUp;
} else { } else {
return false; return false;
} }
@ -1500,7 +1500,7 @@ void XWindowsScreen::onMousePress(const XButtonEvent &xbutton)
ButtonID button = mapButtonFromX(&xbutton); ButtonID button = mapButtonFromX(&xbutton);
KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state); KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state);
if (button != kButtonNone) { if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonDown(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonDown, ButtonInfo::alloc(button, mask));
} }
} }
@ -1510,13 +1510,13 @@ void XWindowsScreen::onMouseRelease(const XButtonEvent &xbutton)
ButtonID button = mapButtonFromX(&xbutton); ButtonID button = mapButtonFromX(&xbutton);
KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state); KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state);
if (button != kButtonNone) { if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonUp(), ButtonInfo::alloc(button, mask)); sendEvent(EventTypes::PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
} else if (xbutton.button == 4) { } else if (xbutton.button == 4) {
// wheel forward (away from user) // wheel forward (away from user)
sendEvent(m_events->forIPrimaryScreen().wheel(), WheelInfo::alloc(0, 120)); sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(0, 120));
} else if (xbutton.button == 5) { } else if (xbutton.button == 5) {
// wheel backward (toward user) // wheel backward (toward user)
sendEvent(m_events->forIPrimaryScreen().wheel(), WheelInfo::alloc(0, -120)); sendEvent(EventTypes::PrimaryScreenWheel, WheelInfo::alloc(0, -120));
} }
// XXX -- support x-axis scrolling // XXX -- support x-axis scrolling
} }
@ -1552,7 +1552,7 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
cntr = 0; cntr = 0;
} else if (m_isOnScreen) { } else if (m_isOnScreen) {
// motion on primary screen // motion on primary screen
sendEvent(m_events->forIPrimaryScreen().motionOnPrimary(), MotionInfo::alloc(m_xCursor, m_yCursor)); sendEvent(EventTypes::PrimaryScreenMotionOnPrimary, MotionInfo::alloc(m_xCursor, m_yCursor));
} else { } else {
// motion on secondary screen. warp mouse back to // motion on secondary screen. warp mouse back to
// center. // center.
@ -1579,7 +1579,7 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
// warping to the primary screen's enter position, // warping to the primary screen's enter position,
// effectively overriding it. // effectively overriding it.
if (x != 0 || y != 0) { if (x != 0 || y != 0) {
sendEvent(m_events->forIPrimaryScreen().motionOnSecondary(), MotionInfo::alloc(x, y)); sendEvent(EventTypes::PrimaryScreenMotionOnSecondary, MotionInfo::alloc(x, y));
} }
} }
} }
@ -1659,7 +1659,7 @@ void XWindowsScreen::onError()
m_display = nullptr; m_display = nullptr;
// notify of failure // notify of failure
sendEvent(m_events->forIScreen().error(), nullptr); sendEvent(EventTypes::ScreenError, nullptr);
// FIXME -- should ensure that we ignore operations that involve // FIXME -- should ensure that we ignore operations that involve
// m_display from now on. however, Xlib will simply exit the // m_display from now on. however, Xlib will simply exit the

4
src/lib/platform/XWindowsScreen.h
View file

@ -89,8 +89,8 @@ protected:
private: private:
// event sending // event sending
void sendEvent(Event::Type, void * = nullptr); void sendEvent(EventTypes, void * = nullptr);
void sendClipboardEvent(Event::Type, ClipboardID); void sendClipboardEvent(EventTypes, ClipboardID);
// create the transparent cursor // create the transparent cursor
Cursor createBlankCursor() const; Cursor createBlankCursor() const;

8
src/lib/platform/XWindowsScreenSaver.cpp
View file

@ -107,7 +107,7 @@ XWindowsScreenSaver::XWindowsScreenSaver(Display *display, Window window, void *
// install disable timer event handler // install disable timer event handler
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, this, new TMethodEventJob<XWindowsScreenSaver>(this, &XWindowsScreenSaver::handleDisableTimer) EventTypes::Timer, this, new TMethodEventJob<XWindowsScreenSaver>(this, &XWindowsScreenSaver::handleDisableTimer)
); );
} }
@ -117,7 +117,7 @@ XWindowsScreenSaver::~XWindowsScreenSaver()
if (m_disableTimer != nullptr) { if (m_disableTimer != nullptr) {
m_events->deleteTimer(m_disableTimer); m_events->deleteTimer(m_disableTimer);
} }
m_events->removeHandler(Event::kTimer, this); m_events->removeHandler(EventTypes::Timer, this);
if (m_display != nullptr) { if (m_display != nullptr) {
enableDPMS(m_dpmsEnabled); enableDPMS(m_dpmsEnabled);
@ -366,9 +366,9 @@ void XWindowsScreenSaver::setXScreenSaverActive(bool activated)
updateDisableTimer(); updateDisableTimer();
if (activated) { if (activated) {
m_events->addEvent(Event(m_events->forIPrimaryScreen().screensaverActivated(), m_eventTarget)); m_events->addEvent(Event(EventTypes::PrimaryScreenSaverActivated, m_eventTarget));
} else { } else {
m_events->addEvent(Event(m_events->forIPrimaryScreen().screensaverDeactivated(), m_eventTarget)); m_events->addEvent(Event(EventTypes::PrimaryScreenSaverDeactivated, m_eventTarget));
} }
} }
} }

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

@ -67,7 +67,7 @@ ClientProxy *ClientListener::getNextClient()
if (!m_waitingClients.empty()) { if (!m_waitingClients.empty()) {
client = m_waitingClients.front(); client = m_waitingClients.front();
m_waitingClients.pop_front(); m_waitingClients.pop_front();
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
} }
return client; return client;
} }
@ -78,7 +78,7 @@ void ClientListener::start()
// setup event handler // setup event handler
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIListenSocket().connecting(), m_listen, EventTypes::ListenSocketConnecting, m_listen,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientConnecting) new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientConnecting)
); );
@ -94,9 +94,9 @@ void ClientListener::stop()
// discard already connected clients // discard already connected clients
for (auto index = m_newClients.begin(); index != m_newClients.end(); ++index) { for (auto index = m_newClients.begin(); index != m_newClients.end(); ++index) {
ClientProxyUnknown *client = *index; ClientProxyUnknown *client = *index;
m_events->removeHandler(m_events->forClientProxyUnknown().success(), client); m_events->removeHandler(EventTypes::ClientProxyUnknownSuccess, client);
m_events->removeHandler(m_events->forClientProxyUnknown().failure(), client); m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, client);
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
delete client; delete client;
} }
@ -107,7 +107,7 @@ void ClientListener::stop()
client = getNextClient(); client = getNextClient();
} }
m_events->removeHandler(m_events->forIListenSocket().connecting(), m_listen); m_events->removeHandler(EventTypes::ListenSocketConnecting, m_listen);
cleanupListenSocket(); cleanupListenSocket();
cleanupClientSockets(); cleanupClientSockets();
} }
@ -115,8 +115,8 @@ void ClientListener::stop()
void ClientListener::removeUnknownClient(ClientProxyUnknown *unknownClient) void ClientListener::removeUnknownClient(ClientProxyUnknown *unknownClient)
{ {
if (unknownClient) { if (unknownClient) {
m_events->removeHandler(m_events->forClientProxyUnknown().success(), unknownClient); m_events->removeHandler(EventTypes::ClientProxyUnknownSuccess, unknownClient);
m_events->removeHandler(m_events->forClientProxyUnknown().failure(), unknownClient); m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, unknownClient);
m_newClients.erase(unknownClient); m_newClients.erase(unknownClient);
delete unknownClient; delete unknownClient;
} }
@ -134,14 +134,15 @@ void ClientListener::handleClientConnecting(const Event &, void *)
m_clientSockets.insert(socket); m_clientSockets.insert(socket);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientListener().accepted(), socket->getEventTarget(), EventTypes::ClientListenerAccepted, socket->getEventTarget(),
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientAccepted, socket) new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientAccepted, socket)
); );
// When using non SSL, server accepts clients immediately, while SSL // When using non SSL, server accepts clients immediately, while SSL
// has to call secure accept which may require retry // has to call secure accept which may require retry
if (m_securityLevel == SecurityLevel::PlainText) { if (m_securityLevel == SecurityLevel::PlainText) {
m_events->addEvent(Event(m_events->forClientListener().accepted(), socket->getEventTarget()));
m_events->addEvent(Event(EventTypes::ClientListenerAccepted, socket->getEventTarget()));
} }
} }
@ -162,11 +163,11 @@ void ClientListener::handleClientAccepted(const Event &, void *vsocket)
// watch for events from unknown client // watch for events from unknown client
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxyUnknown().success(), client, EventTypes::ClientProxyUnknownSuccess, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClient, client) new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClient, client)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxyUnknown().failure(), client, EventTypes::ClientProxyUnknownFailure, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClientFailure, client) new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClientFailure, client)
); );
} }
@ -183,11 +184,11 @@ void ClientListener::handleUnknownClient(const Event &, void *vclient)
if (client) { if (client) {
// handshake was successful // handshake was successful
m_waitingClients.push_back(client); m_waitingClients.push_back(client);
m_events->addEvent(Event(m_events->forClientListener().connected(), this)); m_events->addEvent(Event(EventTypes::ClientListenerAccepted, this));
// watch for client to disconnect while it's in our queue // watch for client to disconnect while it's in our queue
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxy().disconnected(), client, EventTypes::ClientProxyDisconnected, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientDisconnected, client) new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientDisconnected, client)
); );
} else { } else {
@ -215,7 +216,7 @@ void ClientListener::handleClientDisconnected(const Event &, void *vclient)
for (WaitingClients::iterator i = m_waitingClients.begin(), n = m_waitingClients.end(); i != n; ++i) { for (WaitingClients::iterator i = m_waitingClients.begin(), n = m_waitingClients.end(); i != n; ++i) {
if (*i == client) { if (*i == client) {
m_waitingClients.erase(i); m_waitingClients.erase(i);
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
// pull out the socket before deleting the client so // pull out the socket before deleting the client so
// we know which socket we no longer need // we know which socket we no longer need

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

@ -28,27 +28,27 @@ ClientProxy1_0::ClientProxy1_0(const std::string &name, deskflow::IStream *strea
{ {
// install event handlers // install event handlers
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputReady(), stream->getEventTarget(), EventTypes::StreamInputReady, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleData, nullptr) new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleData, nullptr)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputError(), stream->getEventTarget(), EventTypes::StreamOutputError, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr) new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputShutdown(), stream->getEventTarget(), EventTypes::StreamInputShutdown, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr) new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputFormatError(), stream->getEventTarget(), EventTypes::StreamInputFormatError, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr) new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputShutdown(), stream->getEventTarget(), EventTypes::StreamOutputShutdown, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr) new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr)
); );
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, this, new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleFlatline, nullptr) EventTypes::Timer, this, new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleFlatline, nullptr)
); );
setHeartbeatRate(kHeartRate, kHeartRate * kHeartBeatsUntilDeath); setHeartbeatRate(kHeartRate, kHeartRate * kHeartBeatsUntilDeath);
@ -66,18 +66,18 @@ void ClientProxy1_0::disconnect()
{ {
removeHandlers(); removeHandlers();
getStream()->close(); getStream()->close();
m_events->addEvent(Event(m_events->forClientProxy().disconnected(), getEventTarget())); m_events->addEvent(Event(EventTypes::ClientProxyDisconnected, getEventTarget()));
} }
void ClientProxy1_0::removeHandlers() void ClientProxy1_0::removeHandlers()
{ {
// uninstall event handlers // uninstall event handlers
m_events->removeHandler(m_events->forIStream().inputReady(), getStream()->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputReady, getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), getStream()->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputError, getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), getStream()->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputShutdown, getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), getStream()->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputShutdown, getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputFormatError(), getStream()->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputFormatError, getStream()->getEventTarget());
m_events->removeHandler(Event::kTimer, this); m_events->removeHandler(EventTypes::Timer, this);
// remove timer // remove timer
removeHeartbeatTimer(); removeHeartbeatTimer();
@ -165,7 +165,7 @@ bool ClientProxy1_0::parseHandshakeMessage(const uint8_t *code)
// future messages get parsed by parseMessage // future messages get parsed by parseMessage
m_parser = &ClientProxy1_0::parseMessage; m_parser = &ClientProxy1_0::parseMessage;
if (recvInfo()) { if (recvInfo()) {
m_events->addEvent(Event(m_events->forClientProxy().ready(), getEventTarget())); m_events->addEvent(Event(EventTypes::ClientProxyReady, getEventTarget()));
addHeartbeatTimer(); addHeartbeatTimer();
return true; return true;
} }
@ -177,7 +177,7 @@ bool ClientProxy1_0::parseMessage(const uint8_t *code)
{ {
if (memcmp(code, kMsgDInfo, 4) == 0) { if (memcmp(code, kMsgDInfo, 4) == 0) {
if (recvInfo()) { if (recvInfo()) {
m_events->addEvent(Event(m_events->forIScreen().shapeChanged(), getEventTarget())); m_events->addEvent(Event(EventTypes::ScreenShapeChanged, getEventTarget()));
return true; return true;
} }
return false; return false;
@ -433,7 +433,7 @@ bool ClientProxy1_0::recvGrabClipboard()
auto *info = new ClipboardInfo; auto *info = new ClipboardInfo;
info->m_id = id; info->m_id = id;
info->m_sequenceNumber = seqNum; info->m_sequenceNumber = seqNum;
m_events->addEvent(Event(m_events->forClipboard().clipboardGrabbed(), getEventTarget(), info)); m_events->addEvent(Event(EventTypes::ClipboardGrabbed, getEventTarget(), info));
return true; return true;
} }

4
src/lib/server/ClientProxy1_3.cpp
View file

@ -76,7 +76,7 @@ void ClientProxy1_3::addHeartbeatTimer()
if (m_keepAliveRate > 0.0) { if (m_keepAliveRate > 0.0) {
m_keepAliveTimer = m_events->newTimer(m_keepAliveRate, nullptr); m_keepAliveTimer = m_events->newTimer(m_keepAliveRate, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, m_keepAliveTimer, EventTypes::Timer, m_keepAliveTimer,
new TMethodEventJob<ClientProxy1_3>(this, &ClientProxy1_3::handleKeepAlive, nullptr) new TMethodEventJob<ClientProxy1_3>(this, &ClientProxy1_3::handleKeepAlive, nullptr)
); );
} }
@ -89,7 +89,7 @@ void ClientProxy1_3::removeHeartbeatTimer()
{ {
// remove the timer that sends keep alives periodically // remove the timer that sends keep alives periodically
if (m_keepAliveTimer != nullptr) { if (m_keepAliveTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_keepAliveTimer); m_events->removeHandler(EventTypes::Timer, m_keepAliveTimer);
m_events->deleteTimer(m_keepAliveTimer); m_events->deleteTimer(m_keepAliveTimer);
m_keepAliveTimer = nullptr; m_keepAliveTimer = nullptr;
} }

6
src/lib/server/ClientProxy1_5.cpp
View file

@ -26,14 +26,14 @@ ClientProxy1_5::ClientProxy1_5(const std::string &name, deskflow::IStream *strea
{ {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forFile().keepAlive(), this, EventTypes::FileKeepAlive, this,
new TMethodEventJob<ClientProxy1_3>(this, &ClientProxy1_3::handleKeepAlive, nullptr) new TMethodEventJob<ClientProxy1_3>(this, &ClientProxy1_3::handleKeepAlive, nullptr)
); );
} }
ClientProxy1_5::~ClientProxy1_5() ClientProxy1_5::~ClientProxy1_5()
{ {
m_events->removeHandler(m_events->forFile().keepAlive(), this); m_events->removeHandler(EventTypes::FileKeepAlive, this);
} }
void ClientProxy1_5::sendDragInfo(uint32_t fileCount, const char *info, size_t size) void ClientProxy1_5::sendDragInfo(uint32_t fileCount, const char *info, size_t size)
@ -67,7 +67,7 @@ void ClientProxy1_5::fileChunkReceived()
int result = FileChunk::assemble(getStream(), server->getReceivedFileData(), server->getExpectedFileSize()); int result = FileChunk::assemble(getStream(), server->getReceivedFileData(), server->getExpectedFileSize());
if (result == kFinish) { if (result == kFinish) {
m_events->addEvent(Event(m_events->forFile().fileReceiveCompleted(), server)); m_events->addEvent(Event(EventTypes::FileReceiveCompleted, server));
} else if (result == kStart) { } else if (result == kStart) {
if (server->getFakeDragFileList().size() > 0) { if (server->getFakeDragFileList().size() > 0) {
std::string filename = server->getFakeDragFileList().at(0).getFilename(); std::string filename = server->getFakeDragFileList().at(0).getFilename();

4
src/lib/server/ClientProxy1_6.cpp
View file

@ -23,7 +23,7 @@ ClientProxy1_6::ClientProxy1_6(const std::string &name, deskflow::IStream *strea
m_events(events) m_events(events)
{ {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClipboard().clipboardSending(), this, EventTypes::ClipboardSending, this,
new TMethodEventJob<ClientProxy1_6>(this, &ClientProxy1_6::handleClipboardSendingEvent) new TMethodEventJob<ClientProxy1_6>(this, &ClientProxy1_6::handleClipboardSendingEvent)
); );
} }
@ -75,7 +75,7 @@ bool ClientProxy1_6::recvClipboard()
auto *info = new ClipboardInfo; auto *info = new ClipboardInfo;
info->m_id = id; info->m_id = id;
info->m_sequenceNumber = seq; info->m_sequenceNumber = seq;
m_events->addEvent(Event(m_events->forClipboard().clipboardChanged(), getEventTarget(), info)); m_events->addEvent(Event(EventTypes::ClipboardChanged, getEventTarget(), info));
} }
return true; return true;

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

@ -44,7 +44,8 @@ ClientProxyUnknown::ClientProxyUnknown(deskflow::IStream *stream, double timeout
assert(m_server != nullptr); assert(m_server != nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, this, new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleTimeout, nullptr) EventTypes::Timer, this,
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleTimeout, nullptr)
); );
m_timer = m_events->newOneShotTimer(timeout, this); m_timer = m_events->newOneShotTimer(timeout, this);
addStreamHandlers(); addStreamHandlers();
@ -80,7 +81,7 @@ void ClientProxyUnknown::sendSuccess()
{ {
m_ready = true; m_ready = true;
removeTimer(); removeTimer();
m_events->addEvent(Event(m_events->forClientProxyUnknown().success(), this)); m_events->addEvent(Event(EventTypes::ClientProxyUnknownSuccess, this));
} }
void ClientProxyUnknown::sendFailure() void ClientProxyUnknown::sendFailure()
@ -90,31 +91,30 @@ void ClientProxyUnknown::sendFailure()
m_ready = false; m_ready = false;
removeHandlers(); removeHandlers();
removeTimer(); removeTimer();
m_events->addEvent(Event(m_events->forClientProxyUnknown().failure(), this)); m_events->addEvent(Event(EventTypes::ClientProxyUnknownFailure, this));
} }
void ClientProxyUnknown::addStreamHandlers() void ClientProxyUnknown::addStreamHandlers()
{ {
assert(m_stream != nullptr); assert(m_stream != nullptr);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(), EventTypes::StreamInputReady, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleData) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleData)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputError(), m_stream->getEventTarget(), EventTypes::StreamOutputError, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputShutdown(), m_stream->getEventTarget(), EventTypes::StreamInputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().inputFormatError(), m_stream->getEventTarget(), EventTypes::StreamInputFormatError, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIStream().outputShutdown(), m_stream->getEventTarget(), EventTypes::StreamOutputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError)
); );
} }
@ -124,11 +124,11 @@ void ClientProxyUnknown::addProxyHandlers()
assert(m_proxy != nullptr); assert(m_proxy != nullptr);
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxy().ready(), m_proxy, EventTypes::ClientProxyReady, m_proxy,
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleReady) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleReady)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxy().disconnected(), m_proxy, EventTypes::ClientProxyDisconnected, m_proxy,
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect) new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
); );
} }
@ -136,15 +136,15 @@ void ClientProxyUnknown::addProxyHandlers()
void ClientProxyUnknown::removeHandlers() void ClientProxyUnknown::removeHandlers()
{ {
if (m_stream != nullptr) { if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputFormatError(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamInputFormatError, m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), m_stream->getEventTarget()); m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
} }
if (m_proxy != nullptr) { if (m_proxy != nullptr) {
m_events->removeHandler(m_events->forClientProxy().ready(), m_proxy); m_events->removeHandler(EventTypes::ClientProxyReady, m_proxy);
m_events->removeHandler(m_events->forClientProxy().disconnected(), m_proxy); m_events->removeHandler(EventTypes::ClientProxyDisconnected, m_proxy);
} }
} }
@ -152,7 +152,7 @@ void ClientProxyUnknown::removeTimer()
{ {
if (m_timer != nullptr) { if (m_timer != nullptr) {
m_events->deleteTimer(m_timer); m_events->deleteTimer(m_timer);
m_events->removeHandler(Event::kTimer, this); m_events->removeHandler(EventTypes::Timer, this);
m_timer = nullptr; m_timer = nullptr;
} }
} }

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

@ -73,10 +73,10 @@ InputFilter::EFilterStatus InputFilter::KeystrokeCondition::match(const Event &e
EFilterStatus status; EFilterStatus status;
// check for hotkey events // check for hotkey events
Event::Type type = event.getType(); EventTypes type = event.getType();
if (type == m_events->forIPrimaryScreen().hotKeyDown()) { if (type == EventTypes::PrimaryScreenHotkeyDown) {
status = kActivate; status = kActivate;
} else if (type == m_events->forIPrimaryScreen().hotKeyUp()) { } else if (type == EventTypes::PrimaryScreenHotkeyUp) {
status = kDeactivate; status = kDeactivate;
} else { } else {
return kNoMatch; return kNoMatch;
@ -150,10 +150,10 @@ InputFilter::EFilterStatus InputFilter::MouseButtonCondition::match(const Event
EFilterStatus status; EFilterStatus status;
// check for hotkey events // check for hotkey events
Event::Type type = event.getType(); EventTypes type = event.getType();
if (type == m_events->forIPrimaryScreen().buttonDown()) { if (type == EventTypes::PrimaryScreenButtonDown) {
status = kActivate; status = kActivate;
} else if (type == m_events->forIPrimaryScreen().buttonUp()) { } else if (type == EventTypes::PrimaryScreenButtonUp) {
status = kDeactivate; status = kDeactivate;
} else { } else {
return kNoMatch; return kNoMatch;
@ -188,7 +188,7 @@ std::string InputFilter::ScreenConnectedCondition::format() const
InputFilter::EFilterStatus InputFilter::ScreenConnectedCondition::match(const Event &event) InputFilter::EFilterStatus InputFilter::ScreenConnectedCondition::match(const Event &event)
{ {
if (event.getType() == m_events->forServer().connected()) { if (event.getType() == EventTypes::ServerConnected) {
auto *info = static_cast<Server::ScreenConnectedInfo *>(event.getData()); auto *info = static_cast<Server::ScreenConnectedInfo *>(event.getData());
if (m_screen == info->m_screen || m_screen.empty()) { if (m_screen == info->m_screen || m_screen.empty()) {
return kActivate; return kActivate;
@ -234,9 +234,7 @@ void InputFilter::LockCursorToScreenAction::perform(const Event &event)
// send event // send event
Server::LockCursorToScreenInfo *info = Server::LockCursorToScreenInfo::alloc(s_state[m_mode]); Server::LockCursorToScreenInfo *info = Server::LockCursorToScreenInfo::alloc(s_state[m_mode]);
m_events->addEvent( m_events->addEvent(Event(EventTypes::ServerLockCursorToScreen, event.getTarget(), info, Event::kDeliverImmediately));
Event(m_events->forServer().lockCursorToScreen(), event.getTarget(), info, Event::kDeliverImmediately)
);
} }
InputFilter::RestartServer::RestartServer(IEventQueue *events, Mode mode) : m_mode(mode), m_events(events) InputFilter::RestartServer::RestartServer(IEventQueue *events, Mode mode) : m_mode(mode), m_events(events)
@ -294,15 +292,14 @@ void InputFilter::SwitchToScreenAction::perform(const Event &event)
// pick screen name. if m_screen is empty then use the screen from // pick screen name. if m_screen is empty then use the screen from
// event if it has one. // event if it has one.
std::string screen = m_screen; std::string screen = m_screen;
if (screen.empty() && event.getType() == m_events->forServer().connected()) { if (screen.empty() && event.getType() == EventTypes::ServerConnected) {
auto *info = static_cast<Server::ScreenConnectedInfo *>(event.getData()); auto *info = static_cast<Server::ScreenConnectedInfo *>(event.getData());
screen = info->m_screen; screen = info->m_screen;
} }
// send event // send event
Server::SwitchToScreenInfo *info = Server::SwitchToScreenInfo::alloc(screen); Server::SwitchToScreenInfo *info = Server::SwitchToScreenInfo::alloc(screen);
m_events->addEvent(Event(m_events->forServer().switchToScreen(), event.getTarget(), info, Event::kDeliverImmediately) m_events->addEvent(Event(EventTypes::ServerSwitchToScreen, event.getTarget(), info, Event::kDeliverImmediately));
);
} }
InputFilter::SwitchInDirectionAction::SwitchInDirectionAction(IEventQueue *events, EDirection direction) InputFilter::SwitchInDirectionAction::SwitchInDirectionAction(IEventQueue *events, EDirection direction)
@ -332,9 +329,7 @@ std::string InputFilter::SwitchInDirectionAction::format() const
void InputFilter::SwitchInDirectionAction::perform(const Event &event) void InputFilter::SwitchInDirectionAction::perform(const Event &event)
{ {
Server::SwitchInDirectionInfo *info = Server::SwitchInDirectionInfo::alloc(m_direction); Server::SwitchInDirectionInfo *info = Server::SwitchInDirectionInfo::alloc(m_direction);
m_events->addEvent( m_events->addEvent(Event(EventTypes::ServerSwitchInDirection, event.getTarget(), info, Event::kDeliverImmediately));
Event(m_events->forServer().switchInDirection(), event.getTarget(), info, Event::kDeliverImmediately)
);
} }
InputFilter::KeyboardBroadcastAction::KeyboardBroadcastAction(IEventQueue *events, Mode mode) InputFilter::KeyboardBroadcastAction::KeyboardBroadcastAction(IEventQueue *events, Mode mode)
@ -394,9 +389,7 @@ void InputFilter::KeyboardBroadcastAction::perform(const Event &event)
// send event // send event
Server::KeyboardBroadcastInfo *info = Server::KeyboardBroadcastInfo::alloc(s_state[m_mode], m_screens); Server::KeyboardBroadcastInfo *info = Server::KeyboardBroadcastInfo::alloc(s_state[m_mode], m_screens);
m_events->addEvent( m_events->addEvent(Event(EventTypes::ServerKeyboardBroadcast, event.getTarget(), info, Event::kDeliverImmediately));
Event(m_events->forServer().keyboardBroadcast(), event.getTarget(), info, Event::kDeliverImmediately)
);
} }
InputFilter::KeystrokeAction::KeystrokeAction(IEventQueue *events, IPlatformScreen::KeyInfo *info, bool press) InputFilter::KeystrokeAction::KeystrokeAction(IEventQueue *events, IPlatformScreen::KeyInfo *info, bool press)
@ -456,14 +449,14 @@ std::string InputFilter::KeystrokeAction::format() const
void InputFilter::KeystrokeAction::perform(const Event &event) void InputFilter::KeystrokeAction::perform(const Event &event)
{ {
Event::Type type = m_press ? m_events->forIKeyState().keyDown() : m_events->forIKeyState().keyUp(); EventTypes type = m_press ? EventTypes::KeyStateKeyDown : EventTypes::KeyStateKeyUp;
m_events->addEvent( m_events->addEvent(
Event(m_events->forIPrimaryScreen().fakeInputBegin(), 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(Event(type, event.getTarget(), m_keyInfo, Event::kDeliverImmediately | Event::kDontFreeData));
m_events->addEvent( m_events->addEvent(
Event(m_events->forIPrimaryScreen().fakeInputEnd(), event.getTarget(), nullptr, Event::kDeliverImmediately) Event(EventTypes::PrimaryScreenFakeInputEnd, event.getTarget(), nullptr, Event::kDeliverImmediately)
); );
} }
@ -517,13 +510,11 @@ void InputFilter::MouseButtonAction::perform(const Event &event)
if (m_buttonInfo->m_mask != 0) { if (m_buttonInfo->m_mask != 0) {
KeyID key = m_press ? kKeySetModifiers : kKeyClearModifiers; KeyID key = m_press ? kKeySetModifiers : kKeyClearModifiers;
modifierInfo = IKeyState::KeyInfo::alloc(key, m_buttonInfo->m_mask, 0, 1); modifierInfo = IKeyState::KeyInfo::alloc(key, m_buttonInfo->m_mask, 0, 1);
m_events->addEvent( m_events->addEvent(Event(EventTypes::KeyStateKeyDown, event.getTarget(), modifierInfo, Event::kDeliverImmediately));
Event(m_events->forIKeyState().keyDown(), event.getTarget(), modifierInfo, Event::kDeliverImmediately)
);
} }
// send button // send button
Event::Type type = m_press ? m_events->forIPrimaryScreen().buttonDown() : m_events->forIPrimaryScreen().buttonUp(); EventTypes type = m_press ? EventTypes::PrimaryScreenButtonDown : EventTypes::PrimaryScreenButtonUp;
m_events->addEvent(Event(type, event.getTarget(), m_buttonInfo, Event::kDeliverImmediately | Event::kDontFreeData)); m_events->addEvent(Event(type, event.getTarget(), m_buttonInfo, Event::kDeliverImmediately | Event::kDontFreeData));
} }
@ -805,49 +796,49 @@ void InputFilter::setPrimaryClient(PrimaryClient *client)
rule->disable(m_primaryClient); rule->disable(m_primaryClient);
} }
m_events->removeHandler(m_events->forIKeyState().keyDown(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIKeyState().keyUp(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIKeyState().keyRepeat(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().buttonDown(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().buttonUp(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().hotKeyDown(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().hotKeyUp(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forServer().connected(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::ServerConnected, m_primaryClient->getEventTarget());
} }
m_primaryClient = client; m_primaryClient = client;
if (m_primaryClient != nullptr) { if (m_primaryClient != nullptr) {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyDown(), m_primaryClient->getEventTarget(), EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyUp(), m_primaryClient->getEventTarget(), EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyRepeat(), m_primaryClient->getEventTarget(), EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonDown(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonUp(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().hotKeyDown(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().hotKeyUp(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().connected(), m_primaryClient->getEventTarget(), EventTypes::ServerConnected, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent) new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
); );

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

@ -103,77 +103,74 @@ Server::Server(
} }
// install event handlers // install event handlers
m_events->adoptHandler(Event::kTimer, this, new TMethodEventJob<Server>(this, &Server::handleSwitchWaitTimeout)); m_events->adoptHandler(EventTypes::Timer, this, new TMethodEventJob<Server>(this, &Server::handleSwitchWaitTimeout));
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyDown(), m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleKeyDownEvent) EventTypes::KeyStateKeyDown, m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleKeyDownEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyUp(), m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleKeyUpEvent) EventTypes::KeyStateKeyUp, m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleKeyUpEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIKeyState().keyRepeat(), m_inputFilter, EventTypes::KeyStateKeyRepeat, m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleKeyRepeatEvent)
new TMethodEventJob<Server>(this, &Server::handleKeyRepeatEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonDown(), m_inputFilter, EventTypes::PrimaryScreenButtonDown, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleButtonDownEvent) new TMethodEventJob<Server>(this, &Server::handleButtonDownEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonUp(), m_inputFilter, EventTypes::PrimaryScreenButtonUp, m_inputFilter, new TMethodEventJob<Server>(this, &Server::handleButtonUpEvent)
new TMethodEventJob<Server>(this, &Server::handleButtonUpEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().motionOnPrimary(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleMotionPrimaryEvent) new TMethodEventJob<Server>(this, &Server::handleMotionPrimaryEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().motionOnSecondary(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleMotionSecondaryEvent) new TMethodEventJob<Server>(this, &Server::handleMotionSecondaryEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().wheel(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenWheel, m_primaryClient->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleWheelEvent) new TMethodEventJob<Server>(this, &Server::handleWheelEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().screensaverActivated(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenSaverActivated, m_primaryClient->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleScreensaverActivatedEvent) new TMethodEventJob<Server>(this, &Server::handleScreensaverActivatedEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().screensaverDeactivated(), m_primaryClient->getEventTarget(), EventTypes::PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleScreensaverDeactivatedEvent) new TMethodEventJob<Server>(this, &Server::handleScreensaverDeactivatedEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().switchToScreen(), m_inputFilter, EventTypes::ServerSwitchToScreen, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleSwitchToScreenEvent) new TMethodEventJob<Server>(this, &Server::handleSwitchToScreenEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().switchInDirection(), m_inputFilter, EventTypes::ServerSwitchInDirection, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleSwitchInDirectionEvent) new TMethodEventJob<Server>(this, &Server::handleSwitchInDirectionEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().keyboardBroadcast(), m_inputFilter, EventTypes::ServerKeyboardBroadcast, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleKeyboardBroadcastEvent) new TMethodEventJob<Server>(this, &Server::handleKeyboardBroadcastEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forServer().lockCursorToScreen(), m_inputFilter, EventTypes::ServerLockCursorToScreen, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleLockCursorToScreenEvent) new TMethodEventJob<Server>(this, &Server::handleLockCursorToScreenEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().fakeInputBegin(), m_inputFilter, EventTypes::PrimaryScreenFakeInputBegin, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleFakeInputBeginEvent) new TMethodEventJob<Server>(this, &Server::handleFakeInputBeginEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIPrimaryScreen().fakeInputEnd(), m_inputFilter, EventTypes::PrimaryScreenFakeInputEnd, m_inputFilter,
new TMethodEventJob<Server>(this, &Server::handleFakeInputEndEvent) new TMethodEventJob<Server>(this, &Server::handleFakeInputEndEvent)
); );
if (m_args.m_enableDragDrop) { if (m_args.m_enableDragDrop) {
m_events->adoptHandler( m_events->adoptHandler(
m_events->forFile().fileChunkSending(), this, EventTypes::FileChunkSending, this, new TMethodEventJob<Server>(this, &Server::handleFileChunkSendingEvent)
new TMethodEventJob<Server>(this, &Server::handleFileChunkSendingEvent)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forFile().fileReceiveCompleted(), this, EventTypes::FileReceiveCompleted, this,
new TMethodEventJob<Server>(this, &Server::handleFileReceiveCompletedEvent) new TMethodEventJob<Server>(this, &Server::handleFileReceiveCompletedEvent)
); );
} }
@ -203,19 +200,19 @@ Server::~Server()
} }
// remove event handlers and timers // remove event handlers and timers
m_events->removeHandler(m_events->forIKeyState().keyDown(), m_inputFilter); m_events->removeHandler(EventTypes::KeyStateKeyDown, m_inputFilter);
m_events->removeHandler(m_events->forIKeyState().keyUp(), m_inputFilter); m_events->removeHandler(EventTypes::KeyStateKeyUp, m_inputFilter);
m_events->removeHandler(m_events->forIKeyState().keyRepeat(), m_inputFilter); m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_inputFilter);
m_events->removeHandler(m_events->forIPrimaryScreen().buttonDown(), m_inputFilter); m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_inputFilter);
m_events->removeHandler(m_events->forIPrimaryScreen().buttonUp(), m_inputFilter); m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_inputFilter);
m_events->removeHandler(m_events->forIPrimaryScreen().motionOnPrimary(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenMotionOnPrimary, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().motionOnSecondary(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenMotionOnSecondary, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().wheel(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenWheel, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().screensaverActivated(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenSaverActivated, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().screensaverDeactivated(), m_primaryClient->getEventTarget()); m_events->removeHandler(EventTypes::PrimaryScreenSaverDeactivated, m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().fakeInputBegin(), m_inputFilter); m_events->removeHandler(EventTypes::PrimaryScreenFakeInputBegin, m_inputFilter);
m_events->removeHandler(m_events->forIPrimaryScreen().fakeInputEnd(), m_inputFilter); m_events->removeHandler(EventTypes::PrimaryScreenFakeInputEnd, m_inputFilter);
m_events->removeHandler(Event::kTimer, this); m_events->removeHandler(EventTypes::Timer, this);
stopSwitch(); stopSwitch();
try { try {
@ -228,8 +225,8 @@ Server::~Server()
for (auto index = m_oldClients.begin(); index != m_oldClients.end(); ++index) { for (auto index = m_oldClients.begin(); index != m_oldClients.end(); ++index) {
BaseClientProxy *client = index->first; BaseClientProxy *client = index->first;
m_events->deleteTimer(index->second); m_events->deleteTimer(index->second);
m_events->removeHandler(Event::kTimer, client); m_events->removeHandler(EventTypes::Timer, client);
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
delete client; delete client;
} }
@ -287,7 +284,7 @@ void Server::adoptClient(BaseClientProxy *client)
// watch for client disconnection // watch for client disconnection
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClientProxy().disconnected(), client, EventTypes::ClientProxyDisconnected, client,
new TMethodEventJob<Server>(this, &Server::handleClientDisconnected, client) new TMethodEventJob<Server>(this, &Server::handleClientDisconnected, client)
); );
@ -317,7 +314,7 @@ void Server::adoptClient(BaseClientProxy *client)
// send notification // send notification
auto *info = new Server::ScreenConnectedInfo(getName(client)); auto *info = new Server::ScreenConnectedInfo(getName(client));
m_events->addEvent(Event(m_events->forServer().connected(), m_primaryClient->getEventTarget(), info)); m_events->addEvent(Event(EventTypes::ServerConnected, m_primaryClient->getEventTarget(), info));
} }
void Server::disconnect() void Server::disconnect()
@ -327,7 +324,7 @@ void Server::disconnect()
Config emptyConfig(m_events); Config emptyConfig(m_events);
closeClients(emptyConfig); closeClients(emptyConfig);
} else { } else {
m_events->addEvent(Event(m_events->forServer().disconnected(), this)); m_events->addEvent(Event(EventTypes::ServerDisconnected, this));
} }
} }
@ -526,7 +523,7 @@ void Server::switchScreen(BaseClientProxy *dst, int32_t x, int32_t y, bool forSc
} }
Server::SwitchToScreenInfo *info = Server::SwitchToScreenInfo::alloc(m_active->getName()); Server::SwitchToScreenInfo *info = Server::SwitchToScreenInfo::alloc(m_active->getName());
m_events->addEvent(Event(m_events->forServer().screenSwitched(), this, info)); m_events->addEvent(Event(EventTypes::ServerScreenSwitched, this, info));
} else { } else {
m_active->mouseMove(x, y); m_active->mouseMove(x, y);
} }
@ -2013,15 +2010,15 @@ bool Server::addClient(BaseClientProxy *client)
// add event handlers // add event handlers
m_events->adoptHandler( m_events->adoptHandler(
m_events->forIScreen().shapeChanged(), client->getEventTarget(), EventTypes::ScreenShapeChanged, client->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleShapeChanged, client) new TMethodEventJob<Server>(this, &Server::handleShapeChanged, client)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClipboard().clipboardGrabbed(), client->getEventTarget(), EventTypes::ClipboardGrabbed, client->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleClipboardGrabbed, client) new TMethodEventJob<Server>(this, &Server::handleClipboardGrabbed, client)
); );
m_events->adoptHandler( m_events->adoptHandler(
m_events->forClipboard().clipboardChanged(), client->getEventTarget(), EventTypes::ClipboardChanged, client->getEventTarget(),
new TMethodEventJob<Server>(this, &Server::handleClipboardChanged, client) new TMethodEventJob<Server>(this, &Server::handleClipboardChanged, client)
); );
@ -2049,9 +2046,9 @@ bool Server::removeClient(BaseClientProxy *client)
} }
// remove event handlers // remove event handlers
m_events->removeHandler(m_events->forIScreen().shapeChanged(), client->getEventTarget()); m_events->removeHandler(EventTypes::ScreenShapeChanged, client->getEventTarget());
m_events->removeHandler(m_events->forClipboard().clipboardGrabbed(), client->getEventTarget()); m_events->removeHandler(EventTypes::ClipboardGrabbed, client->getEventTarget());
m_events->removeHandler(m_events->forClipboard().clipboardChanged(), client->getEventTarget()); m_events->removeHandler(EventTypes::ClipboardChanged, client->getEventTarget());
// remove from list // remove from list
m_clients.erase(getName(client)); m_clients.erase(getName(client));
@ -2083,7 +2080,7 @@ void Server::closeClient(BaseClientProxy *client, const char *msg)
double timeout = 5.0; double timeout = 5.0;
EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr); EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr);
m_events->adoptHandler( m_events->adoptHandler(
Event::kTimer, timer, new TMethodEventJob<Server>(this, &Server::handleClientCloseTimeout, client) EventTypes::Timer, timer, new TMethodEventJob<Server>(this, &Server::handleClientCloseTimeout, client)
); );
// move client to closing list // move client to closing list
@ -2122,9 +2119,9 @@ void Server::removeActiveClient(BaseClientProxy *client)
{ {
if (removeClient(client)) { if (removeClient(client)) {
forceLeaveClient(client); forceLeaveClient(client);
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
if (m_clients.size() == 1 && m_oldClients.empty()) { if (m_clients.size() == 1 && m_oldClients.empty()) {
m_events->addEvent(Event(m_events->forServer().disconnected(), this)); m_events->addEvent(Event(EventTypes::ServerDisconnected, this));
} }
} }
} }
@ -2133,12 +2130,12 @@ void Server::removeOldClient(BaseClientProxy *client)
{ {
OldClients::iterator i = m_oldClients.find(client); OldClients::iterator i = m_oldClients.find(client);
if (i != m_oldClients.end()) { if (i != m_oldClients.end()) {
m_events->removeHandler(m_events->forClientProxy().disconnected(), client); m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
m_events->removeHandler(Event::kTimer, i->second); m_events->removeHandler(EventTypes::Timer, i->second);
m_events->deleteTimer(i->second); m_events->deleteTimer(i->second);
m_oldClients.erase(i); m_oldClients.erase(i);
if (m_clients.size() == 1 && m_oldClients.empty()) { if (m_clients.size() == 1 && m_oldClients.empty()) {
m_events->addEvent(Event(m_events->forServer().disconnected(), this)); m_events->addEvent(Event(EventTypes::ServerDisconnected, this));
} }
} }
} }

27
src/test/mock/deskflow/MockEventQueue.h
View file

@ -19,34 +19,15 @@ public:
MOCK_METHOD(EventQueueTimer *, newTimer, (double, void *), (override)); MOCK_METHOD(EventQueueTimer *, newTimer, (double, void *), (override));
MOCK_METHOD(bool, getEvent, (Event &, double), (override)); MOCK_METHOD(bool, getEvent, (Event &, double), (override));
MOCK_METHOD(void, adoptBuffer, (IEventQueueBuffer *), (override)); MOCK_METHOD(void, adoptBuffer, (IEventQueueBuffer *), (override));
MOCK_METHOD(Event::Type, registerTypeOnce, (Event::Type &, const char *), (override));
MOCK_METHOD(void, removeHandlers, (void *), (override)); MOCK_METHOD(void, removeHandlers, (void *), (override));
MOCK_METHOD(Event::Type, registerType, (const char *)); MOCK_METHOD(EventTypes, registerType, (const char *));
MOCK_METHOD(bool, isEmpty, (), (const, override)); MOCK_METHOD(bool, isEmpty, (), (const, override));
MOCK_METHOD(void, adoptHandler, (Event::Type, void *, IEventJob *), (override)); MOCK_METHOD(void, adoptHandler, (EventTypes, void *, IEventJob *), (override));
MOCK_METHOD(const char *, getTypeName, (Event::Type), (override));
MOCK_METHOD(void, addEvent, (const Event &), (override)); MOCK_METHOD(void, addEvent, (const Event &), (override));
MOCK_METHOD(void, removeHandler, (Event::Type, void *), (override)); MOCK_METHOD(void, removeHandler, (EventTypes, void *), (override));
MOCK_METHOD(bool, dispatchEvent, (const Event &), (override)); MOCK_METHOD(bool, dispatchEvent, (const Event &), (override));
MOCK_METHOD(IEventJob *, getHandler, (Event::Type, void *), (const, override)); MOCK_METHOD(IEventJob *, getHandler, (EventTypes, void *), (const, override));
MOCK_METHOD(void, deleteTimer, (EventQueueTimer *), (override)); MOCK_METHOD(void, deleteTimer, (EventQueueTimer *), (override));
MOCK_METHOD(void *, getSystemTarget, (), (override)); MOCK_METHOD(void *, getSystemTarget, (), (override));
MOCK_METHOD(ClientEvents &, forClient, (), (override));
MOCK_METHOD(IStreamEvents &, forIStream, (), (override));
MOCK_METHOD(IDataSocketEvents &, forIDataSocket, (), (override));
MOCK_METHOD(IListenSocketEvents &, forIListenSocket, (), (override));
MOCK_METHOD(ISocketEvents &, forISocket, (), (override));
MOCK_METHOD(OSXScreenEvents &, forOSXScreen, (), (override));
MOCK_METHOD(ClientListenerEvents &, forClientListener, (), (override));
MOCK_METHOD(ClientProxyEvents &, forClientProxy, (), (override));
MOCK_METHOD(ClientProxyUnknownEvents &, forClientProxyUnknown, (), (override));
MOCK_METHOD(ServerEvents &, forServer, (), (override));
MOCK_METHOD(ServerAppEvents &, forServerApp, (), (override));
MOCK_METHOD(IKeyStateEvents &, forIKeyState, (), (override));
MOCK_METHOD(IPrimaryScreenEvents &, forIPrimaryScreen, (), (override));
MOCK_METHOD(IScreenEvents &, forIScreen, (), (override));
MOCK_METHOD(ClipboardEvents &, forClipboard, (), (override));
MOCK_METHOD(FileEvents &, forFile, (), (override));
MOCK_METHOD(EiEvents &, forEi, (), (override));
MOCK_METHOD(void, waitForReady, (), (const, override)); MOCK_METHOD(void, waitForReady, (), (const, override));
}; };

8
src/test/mock/io/MockStream.h
View file

@ -27,10 +27,10 @@ public:
MOCK_METHOD(void, flush, (), (override)); MOCK_METHOD(void, flush, (), (override));
MOCK_METHOD(void, shutdownInput, (), (override)); MOCK_METHOD(void, shutdownInput, (), (override));
MOCK_METHOD(void, shutdownOutput, (), (override)); MOCK_METHOD(void, shutdownOutput, (), (override));
MOCK_METHOD(Event::Type, getInputReadyEvent, ()); MOCK_METHOD(EventTypes, getInputReadyEvent, ());
MOCK_METHOD(Event::Type, getOutputErrorEvent, ()); MOCK_METHOD(EventTypes, getOutputErrorEvent, ());
MOCK_METHOD(Event::Type, getInputShutdownEvent, ()); MOCK_METHOD(EventTypes, getInputShutdownEvent, ());
MOCK_METHOD(Event::Type, getOutputShutdownEvent, ()); MOCK_METHOD(EventTypes, getOutputShutdownEvent, ());
MOCK_METHOD(void *, getEventTarget, (), (const, override)); MOCK_METHOD(void *, getEventTarget, (), (const, override));
MOCK_METHOD(bool, isReady, (), (const, override)); MOCK_METHOD(bool, isReady, (), (const, override));
MOCK_METHOD(uint32_t, getSize, (), (const, override)); MOCK_METHOD(uint32_t, getSize, (), (const, override));

7
src/test/shared/TestEventQueue.cpp
View file

@ -12,7 +12,7 @@
void TestEventQueue::raiseQuitEvent() void TestEventQueue::raiseQuitEvent()
{ {
addEvent(Event(Event::kQuit)); addEvent(Event(EventTypes::Quit));
} }
void TestEventQueue::initQuitTimeout(double timeout) void TestEventQueue::initQuitTimeout(double timeout)
@ -20,13 +20,14 @@ void TestEventQueue::initQuitTimeout(double timeout)
assert(m_pQuitTimeoutTimer == nullptr); assert(m_pQuitTimeoutTimer == nullptr);
m_pQuitTimeoutTimer = newOneShotTimer(timeout, nullptr); m_pQuitTimeoutTimer = newOneShotTimer(timeout, nullptr);
adoptHandler( adoptHandler(
Event::kTimer, m_pQuitTimeoutTimer, new TMethodEventJob<TestEventQueue>(this, &TestEventQueue::handleQuitTimeout) EventTypes::Timer, m_pQuitTimeoutTimer,
new TMethodEventJob<TestEventQueue>(this, &TestEventQueue::handleQuitTimeout)
); );
} }
void TestEventQueue::cleanupQuitTimeout() void TestEventQueue::cleanupQuitTimeout()
{ {
removeHandler(Event::kTimer, m_pQuitTimeoutTimer); removeHandler(EventTypes::Timer, m_pQuitTimeoutTimer);
deleteTimer(m_pQuitTimeoutTimer); deleteTimer(m_pQuitTimeoutTimer);
m_pQuitTimeoutTimer = nullptr; m_pQuitTimeoutTimer = nullptr;
} }

61
src/test/unittests/deskflow/KeyStateTests.cpp
View file

@ -77,67 +77,6 @@ TEST(KeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
keyState.sendKeyEvent(nullptr, false, true, kKeyCapsLock, 0, 0, 0); keyState.sendKeyEvent(nullptr, false, true, kKeyCapsLock, 0, 0, 0);
} }
TEST(KeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
{
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
ON_CALL(eventQueue, forIKeyState()).WillByDefault(ReturnRef(keyStateEvents));
EXPECT_CALL(eventQueue, addEvent(_)).Times(2);
keyState.sendKeyEvent(nullptr, false, false, kKeyCapsLock, 0, 0, 0);
}
TEST(KeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
{
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
ON_CALL(eventQueue, forIKeyState()).WillByDefault(ReturnRef(keyStateEvents));
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
keyState.sendKeyEvent(nullptr, false, true, 1, 0, 0, 0);
}
TEST(KeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
{
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
ON_CALL(eventQueue, forIKeyState()).WillByDefault(ReturnRef(keyStateEvents));
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
keyState.sendKeyEvent(nullptr, true, false, 1, 0, 0, 0);
}
TEST(KeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
{
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
ON_CALL(eventQueue, forIKeyState()).WillByDefault(ReturnRef(keyStateEvents));
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
keyState.sendKeyEvent(nullptr, false, false, 1, 0, 0, 0);
}
TEST(KeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock) TEST(KeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
{ {
NiceMock<MockKeyMap> keyMap; NiceMock<MockKeyMap> keyMap;

2
src/test/unittests/server/ConfigTests.cpp
View file

@ -18,7 +18,7 @@ public:
std::string format() const override { return ""; } std::string format() const override { return ""; }
InputFilter::EFilterStatus match(const Event &ev) override { InputFilter::EFilterStatus match(const Event &ev) override {
return ev.getType() == Event::kSystem ? InputFilter::kActivate return ev.getType() == EventTypes::System ? InputFilter::kActivate
: InputFilter::kNoMatch; : InputFilter::kNoMatch;
} }
}; };