openclaw/deskflow
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

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
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
EventQueue.cpp
EventQueue.h
EventTypes.cpp
EventTypes.h
FinalAction.h
FunctionEventJob.cpp

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

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

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

@ -7,8 +7,11 @@
#pragma once
#include "EventTypes.h"
#include "common/Common.h"
using deskflow::EventTypes;
class EventData
{
public:
@ -23,16 +26,6 @@ A \c Event holds an event type and a pointer to event data.
class Event
{
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;
enum
{
@ -52,7 +45,7 @@ public:
\p target is the intended recipient of the event.
\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
/*!
@ -60,7 +53,7 @@ public:
\p target is the intended recipient of the event.
\p dataObject with event data
*/
Event(Type type, void *target, EventData *dataObject);
Event(EventTypes type, void *target, EventData *dataObject);
//! @name manipulators
//@{
@ -86,7 +79,7 @@ public:
/*!
Returns the event type.
*/
Type getType() const;
EventTypes getType() const;
//! Get the event target
/*!
@ -117,7 +110,7 @@ public:
//@}
private:
Type m_type;
EventTypes m_type;
void *m_target;
void *m_data;
Flags m_flags;

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

@ -16,29 +16,11 @@
#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.
static void interrupt(Arch::ESignal, void *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()
: 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_readyCondVar(new CondVar<bool>(m_readyMutex, false))
{
@ -103,49 +67,13 @@ void EventQueue::loop()
Event event;
getEvent(event);
while (event.getType() != Event::kQuit) {
while (event.getType() != EventTypes::Quit) {
dispatchEvent(event);
Event::deleteData(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)
{
ArchMutexLock lock(m_mutex);
@ -235,7 +163,7 @@ bool EventQueue::dispatchEvent(const Event &event)
void *target = event.getTarget();
IEventJob *job = getHandler(event.getType(), target);
if (job == nullptr) {
job = getHandler(Event::kUnknown, target);
job = getHandler(EventTypes::Unknown, target);
}
if (job != nullptr) {
job->run(event);
@ -248,9 +176,9 @@ void EventQueue::addEvent(const Event &event)
{
// discard bogus event types
switch (event.getType()) {
case Event::kUnknown:
case Event::kSystem:
case Event::kTimer:
case EventTypes::Unknown:
case EventTypes::System:
case EventTypes::Timer:
return;
default:
@ -332,7 +260,7 @@ void EventQueue::deleteTimer(EventQueueTimer *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);
IEventJob *&job = m_handlers[target][type];
@ -340,7 +268,7 @@ void EventQueue::adoptHandler(Event::Type type, void *target, IEventJob *handler
job = handler;
}
void EventQueue::removeHandler(Event::Type type, void *target)
void EventQueue::removeHandler(EventTypes type, void *target)
{
IEventJob *handler = nullptr;
{
@ -385,7 +313,7 @@ bool EventQueue::isEmpty() const
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);
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
timer.fillEvent(m_timerEvent);
event = Event(Event::kTimer, timer.getTarget(), &m_timerEvent);
event = Event(EventTypes::Timer, timer.getTarget(), &m_timerEvent);
timer.reset();
// 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 *newOneShotTimer(double duration, void *target) override;
void deleteTimer(EventQueueTimer *) override;
void adoptHandler(Event::Type type, void *target, IEventJob *handler) override;
void removeHandler(Event::Type type, void *target) override;
void adoptHandler(EventTypes type, void *target, IEventJob *handler) override;
void removeHandler(EventTypes type, void *target) override;
void removeHandlers(void *target) override;
Event::Type registerTypeOnce(Event::Type &type, const char *name) override;
bool isEmpty() const override;
IEventJob *getHandler(Event::Type type, void *target) const override;
const char *getTypeName(Event::Type type) override;
IEventJob *getHandler(EventTypes type, void *target) const override;
void *getSystemTarget() override;
void waitForReady() const override;
@ -92,18 +90,12 @@ private:
using TimerQueue = PriorityQueue<Timer>;
using EventTable = std::map<uint32_t, Event>;
using EventIDList = std::vector<uint32_t>;
using TypeMap = std::map<Event::Type, const char *>;
using NameMap = std::map<std::string, Event::Type>;
using TypeHandlerTable = std::map<Event::Type, IEventJob *>;
using TypeHandlerTable = std::map<EventTypes, IEventJob *>;
using HandlerTable = std::map<void *, TypeHandlerTable>;
int m_systemTarget;
ArchMutex m_mutex;
// registered events
Event::Type m_nextType;
TypeMap m_typeMap;
// buffer of events
IEventQueueBuffer *m_buffer;
@ -120,58 +112,8 @@ private:
// event 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:
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;
CondVar<bool> *m_readyCondVar;
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
* SPDX-FileCopyrightText: (C) 2023 Input-Leap Developers
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#include "base/Event.h"
class IEventQueue;
class EventTypes
#include <stdint.h>
namespace deskflow {
enum class EventTypes : uint32_t
{
public:
EventTypes();
void setEvents(IEventQueue *events);
/** An unknown event type. This type is used as a placeholder for unknown events when
filtering events.
*/
Unknown,
protected:
IEventQueue *getEvents() const;
/// Exit has been requested.
Quit,
private:
IEventQueue *m_events;
};
#define REGISTER_EVENT(type_, name_) \
Event::Type type_##Events::name_() \
{ \
return getEvents()->registerTypeOnce(m_##name_, __FUNCTION__); \
}
class ClientEvents : public EventTypes
{
public:
//! @name accessors
//@{
//! Get connected event type
/*!
Returns the connected event type. This is sent when the client has
successfully connected to the server.
*/
Event::Type connected();
//! Get connection failed event type
/*!
Returns the connection failed event type. This is sent when the
server fails for some reason. The event data is a FailInfo*.
*/
Event::Type connectionFailed();
//! Get connection refused event type
/*!
Returns the connection refused event type. This is sent when the
server refuses for some reason. The event data is a FailInfo*.
*/
Event::Type connectionRefused();
//! Get disconnected event type
/*!
Returns the disconnected event type. This is sent when the client
has disconnected from the server (and only after having successfully
connected).
*/
Event::Type disconnected();
//@}
private:
Event::Type m_connected = Event::kUnknown;
Event::Type m_connectionFailed = Event::kUnknown;
Event::Type m_connectionRefused = Event::kUnknown;
Event::Type m_disconnected = Event::kUnknown;
};
class IStreamEvents : public EventTypes
{
public:
IStreamEvents()
: m_inputReady(Event::kUnknown),
m_outputFlushed(Event::kUnknown),
m_outputError(Event::kUnknown),
m_inputShutdown(Event::kUnknown),
m_outputShutdown(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get input ready event type
/*!
Returns the input ready event type. A stream sends this event
when \c read() will return with data.
*/
Event::Type inputReady();
//! Get output flushed event type
/*!
Returns the output flushed event type. A stream sends this event
when the output buffer has been flushed. If there have been no
writes since the event was posted, calling \c shutdownOutput() or
\c close() will not discard any data and \c flush() will return
immediately.
*/
Event::Type outputFlushed();
//! Get output error event type
/*!
Returns the output error event type. A stream sends this event
when a write has failed.
*/
Event::Type outputError();
//! Get input shutdown event type
/*!
Returns the input shutdown event type. This is sent when the
input side of the stream has shutdown. When the input has
shutdown, no more data will ever be available to read.
*/
Event::Type inputShutdown();
//! Get output shutdown event type
/*!
Returns the output shutdown event type. This is sent when the
output side of the stream has shutdown. When the output has
shutdown, no more data can ever be written to the stream. Any
attempt to do so will generate a output error event.
*/
Event::Type outputShutdown();
/** Get input format error event type
This is sent when a stream receives an irrecoverable input format error.
*/
Event::Type inputFormatError();
//@}
private:
Event::Type m_inputReady;
Event::Type m_outputFlushed;
Event::Type m_outputError;
Event::Type m_inputShutdown;
Event::Type m_outputShutdown;
Event::Type m_inputFormatError;
};
class IDataSocketEvents : public EventTypes
{
public:
IDataSocketEvents()
: m_connected(Event::kUnknown),
m_secureConnected(Event::kUnknown),
m_connectionFailed(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get connected event type
/*!
Returns the socket connected event type. A socket sends this
event when a remote connection has been established.
*/
Event::Type connected();
//! Get secure connected event type
/*!
Returns the secure socket connected event type. A secure socket sends
this event when a remote connection has been established.
*/
Event::Type secureConnected();
//! Get connection failed event type
/*!
Returns the socket connection failed event type. A socket sends
this event when an attempt to connect to a remote port has failed.
The data is a pointer to a ConnectionFailedInfo.
*/
Event::Type connectionFailed();
//@}
private:
Event::Type m_connected;
Event::Type m_secureConnected;
Event::Type m_connectionFailed;
};
class IListenSocketEvents : public EventTypes
{
public:
IListenSocketEvents() : m_connecting(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get connecting event type
/*!
Returns the socket connecting event type. A socket sends this
event when a remote connection is waiting to be accepted.
*/
Event::Type connecting();
//@}
private:
Event::Type m_connecting;
};
class ISocketEvents : public EventTypes
{
public:
ISocketEvents() : m_disconnected(Event::kUnknown), m_stopRetry(Event::kUnknown)
{
}
//! @name accessors
//@{
//! Get disconnected event type
/*!
Returns the socket disconnected event type. A socket sends this
event when the remote side of the socket has disconnected or
shutdown both input and output.
*/
Event::Type disconnected();
//! Get stop retry event type
/*!
Returns the stop retry event type. This is sent when the client
doesn't want to reconnect after it disconnects from the server.
*/
Event::Type stopRetry();
//@}
private:
Event::Type m_disconnected;
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;
/// This event is sent when system event occurs. The data is a pointer to system event type
System,
/// This event is sent when a timer event occurs. The data is pointer to TimerInfo.
Timer,
/// This event is sent when the client has successfully connected to the server.
ClientConnected,
/** This event is sent when the server refuses the client */
ClientConnectionRefused,
/** This event is sent when the server fails for some reason.
The event data is a pointer to FailInfo.
*/
ClientConnectionFailed,
/** This event is sent when the client has disconnected from the server (and only after having
successfully connected).
*/
ClientDisconnected,
/// A stream sends this event when \c read() will return with data.
StreamInputReady,
/** A stream sends this event when the output buffer has been flushed. If there have been no
writes since the event was posted, calling \c shutdownOutput() or close() will not discard
any data and \c flush() will return immediately.
*/
StreamOutputFlushed,
/// A stream sends this event when a write has failed.
StreamOutputError,
/** This event is sent when the input side of the stream has shutdown. When the input has
shutdown, no more data will ever be available to read.
*/
StreamInputShutdown,
/** This event is sent when the output side of the stream has shutdown. When the output has
shutdown, no more data can ever be written to the stream. Any attempt to do so will
generate a output error event.
*/
StreamOutputShutdown,
/// This event is sent when a stream receives an irrecoverable input format error.
StreamInputFormatError,
/// A socket sends this event when a remote connection has been established.
DataSocketConnected,
/// A secure socket sends this event when a remote connection has been established.
DataSocketSecureConnected,
/** A socket sends this event when an attempt to connect to a remote port has failed.
The data is a pointer to a ConnectionFailedInfo.
*/
DataSocketConnectionFailed,
/// A socket sends this event when a remote connection is waiting to be accepted.
ListenSocketConnecting,
/** A socket sends this event when the remote side of the socket has disconnected or
shutdown both input and output.
*/
SocketDisconnected,
/// This is sent when the client doesn't want to reconnect after it disconnects from the server.
SocketStopRetry,
OsxScreenConfirmSleep,
/// This event is sent whenever a server accepts a client.
ClientListenerAccepted,
/** This event is sent when the client has completed the initial handshake. Until it is sent,
the client is not fully connected.
*/
ClientProxyReady,
/** This event is sent when the client disconnects or is disconnected. The target is
getEventTarget().
*/
ClientProxyDisconnected,
/** This event is sent when the client has correctly responded to the hello message.
The target is this.
*/
ClientProxyUnknownSuccess,
/** This event is sent when a client fails to correctly respond to the hello message.
The target is this.
*/
ClientProxyUnknownFailure,
/** This event is sent when a client screen has connected.
The event data is a pointer to ScreenConnectedInfo that indicates the connected screen.
*/
ServerConnected,
/// This is event sent when all the clients have disconnected.
ServerDisconnected,
/** This event is sent to inform the server to switch screens.
The event data is a pointer to SwitchToScreenInfo that indicates the target screen.
*/
ServerSwitchToScreen,
/// This event is sent to inform the server to toggle screens. These is no event data.
ServerToggleScreen,
/** This event is sent to inform the server to switch screens.
The event data is a pointer to SwitchInDirectionInfo that indicates the target direction.
*/
ServerSwitchInDirection,
/** This event is sent to inform the server to turn keyboard broadcasting on or off.
The event data is a pointer to KeyboardBroadcastInfo.
*/
ServerKeyboardBroadcast,
/** This event is sent to inform the server to lock the cursor to the active screen or to
unlock it. The event data is a pointer to LockCursorToScreenInfo.
*/
ServerLockCursorToScreen,
/// This event is sent when the screen has been switched to a client.
ServerScreenSwitched,
ServerAppReloadConfig,
ServerAppForceReconnect,
ServerAppResetServer,
/// 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)
KeyStateKeyUp,
/// This event is sent when key is repeated. Event data is a pointer to KeyInfo.
KeyStateKeyRepeat,
/// This event is sent when button is down. Event data is a pointer to ButtonInfo
PrimaryScreenButtonDown,
/// This event is sent when button is up. Event data is a pointer to ButtonInfo
PrimaryScreenButtonUp,
/** This event is sent when mouse moves on primary screen.
Event data is a pointer to MotionInfo, the values are absolute position.
*/
PrimaryScreenMotionOnPrimary,
/** This event is sent when mouse moves on secondary screen.
Event data is a pointer to MotionInfo, the values are relative motion deltas.
*/
PrimaryScreenMotionOnSecondary,
/// This event is sent when mouse wheel is rotated. Event data is a pointer to WheelInfo.
PrimaryScreenWheel,
/// This event is sent when screensaver is activated.
PrimaryScreenSaverActivated,
/// This event is sent when screensaver is deactivated.
PrimaryScreenSaverDeactivated,
/// This event is sent when hotkey is down. Event data is a pointer to HotKeyInfo.
PrimaryScreenHotkeyDown,
/// This event is sent when hotkey is up. Event data is a pointer to HotKeyInfo.
PrimaryScreenHotkeyUp,
/// This event is sent when fake input begins.
PrimaryScreenFakeInputBegin,
/// This event is sent when fake input ends.
PrimaryScreenFakeInputEnd,
/** This event is sent whenever the screen has failed for some reason (e.g. the X Windows
server died).
*/
ScreenError,
/// This event is sent whenever the screen's shape changes.
ScreenShapeChanged,
/** This event is sent whenever the system goes to sleep or a user session is deactivated (fast
user switching).
*/
ScreenSuspend,
/** This event is sent whenever the system wakes up or a user session is activated (fast user
switching).
*/
ScreenResume,
/** 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,
/** This event is sent whenever the contents of the clipboard has changed.
The data is a pointer to a ClipboardInfo.
*/
ClipboardChanged,
/// This event is sent whenever a clipboard chunk is transferred.
ClipboardSending,
/// This event is sent whenever a file chunk is transferred.
FileChunkSending,
/// This event is sent whenever file has been received.
FileReceiveCompleted,
/// This event is a keepalive event.
FileKeepAlive,
/// Start libEI
EIConnected,
/// Stop libEi
EISessionClosed
};
} // namespace deskflow

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

@ -8,6 +8,7 @@
#pragma once
#include "base/Event.h"
#include "base/EventTypes.h"
#include "common/IInterface.h"
#include <string>
@ -18,25 +19,6 @@ class IEventQueueBuffer;
// IEventQueueBuffer.
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
/*!
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
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
/*!
Unregisters an event handler for the \p type, \p target pair and
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
/*!
@ -152,14 +134,6 @@ public:
*/
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
/*!
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
if it exists, otherwise it returns nullptr.
*/
virtual IEventJob *getHandler(Event::Type 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;
virtual IEventJob *getHandler(EventTypes type, void *target) const = 0;
//! 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;
//@}
//
// 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
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->forIScreen().resume(), getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleResume)
EventTypes::ScreenResume, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleResume)
);
if (m_args.m_enableDragDrop) {
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->forFile().fileReceiveCompleted(), this,
new TMethodEventJob<Client>(this, &Client::handleFileReceiveCompleted)
EventTypes::FileReceiveCompleted, this, new TMethodEventJob<Client>(this, &Client::handleFileReceiveCompleted)
);
}
@ -111,8 +110,8 @@ Client::~Client()
return;
}
m_events->removeHandler(m_events->forIScreen().suspend(), getEventTarget());
m_events->removeHandler(m_events->forIScreen().resume(), getEventTarget());
m_events->removeHandler(EventTypes::ScreenSuspend, getEventTarget());
m_events->removeHandler(EventTypes::ScreenResume, getEventTarget());
cleanupTimer();
cleanupScreen();
@ -179,7 +178,7 @@ void Client::disconnect(const char *msg)
if (msg) {
sendConnectionFailedEvent(msg);
} else {
sendEvent(m_events->forClient().disconnected(), nullptr);
sendEvent(EventTypes::ClientDisconnected, nullptr);
}
}
@ -190,7 +189,7 @@ void Client::refuseConnection(const char *msg)
if (msg) {
auto info = new FailInfo(msg);
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);
}
}
@ -199,7 +198,7 @@ void Client::handshakeComplete()
{
m_ready = true;
m_screen->enable();
sendEvent(m_events->forClient().connected(), nullptr);
sendEvent(EventTypes::ClientConnected, nullptr);
}
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));
}
@ -419,7 +418,7 @@ void Client::sendConnectionFailedEvent(const char *msg)
{
auto *info = new FailInfo(msg);
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);
}
@ -439,18 +438,18 @@ void Client::setupConnecting()
if (m_args.m_enableCrypto) {
m_events->adoptHandler(
m_events->forIDataSocket().secureConnected(), m_stream->getEventTarget(),
EventTypes::DataSocketSecureConnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnected)
);
} else {
m_events->adoptHandler(
m_events->forIDataSocket().connected(), m_stream->getEventTarget(),
EventTypes::DataSocketConnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnected)
);
}
m_events->adoptHandler(
m_events->forIDataSocket().connectionFailed(), m_stream->getEventTarget(),
EventTypes::DataSocketConnectionFailed, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleConnectionFailed)
);
}
@ -460,28 +459,27 @@ void Client::setupConnection()
assert(m_stream != nullptr);
m_events->adoptHandler(
m_events->forISocket().disconnected(), m_stream->getEventTarget(),
EventTypes::SocketDisconnected, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected)
);
m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleHello)
EventTypes::StreamInputReady, m_stream->getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleHello)
);
m_events->adoptHandler(
m_events->forIStream().outputError(), m_stream->getEventTarget(),
EventTypes::StreamOutputError, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleOutputError)
);
m_events->adoptHandler(
m_events->forIStream().inputShutdown(), m_stream->getEventTarget(),
EventTypes::StreamInputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected)
);
m_events->adoptHandler(
m_events->forIStream().outputShutdown(), m_stream->getEventTarget(),
EventTypes::StreamOutputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleDisconnected)
);
m_events->adoptHandler(
m_events->forISocket().stopRetry(), m_stream->getEventTarget(),
EventTypes::SocketStopRetry, m_stream->getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleStopRetry)
);
}
@ -493,12 +491,10 @@ void Client::setupScreen()
m_ready = false;
m_server = new ServerProxy(this, m_stream, m_events);
m_events->adoptHandler(
m_events->forIScreen().shapeChanged(), getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleShapeChanged)
EventTypes::ScreenShapeChanged, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleShapeChanged)
);
m_events->adoptHandler(
m_events->forClipboard().clipboardGrabbed(), getEventTarget(),
new TMethodEventJob<Client>(this, &Client::handleClipboardGrabbed)
EventTypes::ClipboardGrabbed, getEventTarget(), new TMethodEventJob<Client>(this, &Client::handleClipboardGrabbed)
);
}
@ -506,7 +502,7 @@ void Client::setupTimer()
{
assert(m_timer == 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()
@ -521,20 +517,20 @@ void Client::cleanup()
void Client::cleanupConnecting()
{
if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIDataSocket().connected(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIDataSocket().connectionFailed(), m_stream->getEventTarget());
m_events->removeHandler(EventTypes::DataSocketConnected, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::DataSocketConnectionFailed, m_stream->getEventTarget());
}
}
void Client::cleanupConnection()
{
if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forISocket().disconnected(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forISocket().stopRetry(), m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::SocketDisconnected, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::SocketStopRetry, m_stream->getEventTarget());
cleanupStream();
}
}
@ -546,8 +542,8 @@ void Client::cleanupScreen()
m_screen->disable();
m_ready = false;
}
m_events->removeHandler(m_events->forIScreen().shapeChanged(), getEventTarget());
m_events->removeHandler(m_events->forClipboard().clipboardGrabbed(), getEventTarget());
m_events->removeHandler(EventTypes::ScreenShapeChanged, getEventTarget());
m_events->removeHandler(EventTypes::ClipboardGrabbed, getEventTarget());
delete m_server;
m_server = nullptr;
}
@ -556,7 +552,7 @@ void Client::cleanupScreen()
void Client::cleanupTimer()
{
if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer);
m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer);
m_timer = nullptr;
}
@ -610,7 +606,7 @@ void Client::handleOutputError(const Event &, void *)
cleanupScreen();
cleanupConnection();
LOG((CLOG_WARN "error sending to server"));
sendEvent(m_events->forClient().disconnected(), nullptr);
sendEvent(EventTypes::ClientDisconnected, nullptr);
}
void Client::handleDisconnected(const Event &, void *)
@ -619,7 +615,7 @@ void Client::handleDisconnected(const Event &, void *)
cleanupScreen();
cleanupConnection();
LOG((CLOG_DEBUG1 "disconnected"));
sendEvent(m_events->forClient().disconnected(), nullptr);
sendEvent(EventTypes::ClientDisconnected, nullptr);
}
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
// one.
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:
void sendClipboard(ClipboardID);
void sendEvent(Event::Type, void *);
void sendEvent(EventTypes, void *);
void sendConnectionFailedEvent(const char *msg);
void sendFileChunk(const void *data);
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
m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(),
EventTypes::StreamInputReady, m_stream->getEventTarget(),
new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleData)
);
m_events->adoptHandler(
m_events->forClipboard().clipboardSending(), this,
EventTypes::ClipboardSending, this,
new TMethodEventJob<ServerProxy>(this, &ServerProxy::handleClipboardSendingEvent)
);
@ -72,20 +72,21 @@ ServerProxy::ServerProxy(Client *client, deskflow::IStream *stream, IEventQueue
ServerProxy::~ServerProxy()
{
setKeepAliveRate(-1.0);
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
}
void ServerProxy::resetKeepAliveAlarm()
{
if (m_keepAliveAlarmTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_keepAliveAlarmTimer);
m_events->removeHandler(EventTypes::Timer, m_keepAliveAlarmTimer);
m_events->deleteTimer(m_keepAliveAlarmTimer);
m_keepAliveAlarmTimer = nullptr;
}
if (m_keepAliveAlarm > 0.0) {
m_keepAliveAlarmTimer = m_events->newOneShotTimer(m_keepAliveAlarm, nullptr);
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());
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) {
if (m_client->getDragFileList().size() > 0) {
std::string filename = m_client->getDragFileList().at(0).getFilename();

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

@ -7,7 +7,7 @@
#pragma once
#include "common/Common.h"
#include <base/EventTypes.h>
#include <base/Event.h>
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 *)
{
LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
deskflow::Screen *ClientApp::openClientScreen()
@ -246,7 +246,7 @@ deskflow::Screen *ClientApp::openClientScreen()
deskflow::Screen *screen = createScreen();
screen->setEnableDragDrop(argsBase().m_enableDragDrop);
m_events->adoptHandler(
m_events->forIScreen().error(), screen->getEventTarget(),
EventTypes::ScreenError, screen->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleScreenError)
);
return screen;
@ -255,7 +255,7 @@ deskflow::Screen *ClientApp::openClientScreen()
void ClientApp::closeClientScreen(deskflow::Screen *screen)
{
if (screen != nullptr) {
m_events->removeHandler(m_events->forIScreen().error(), screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
delete screen;
}
}
@ -265,7 +265,7 @@ void ClientApp::handleClientRestart(const Event &, void *vtimer)
// discard old timer
auto *timer = static_cast<EventQueueTimer *>(vtimer);
m_events->deleteTimer(timer);
m_events->removeHandler(Event::kTimer, timer);
m_events->removeHandler(EventTypes::Timer, timer);
// reconnect
startClient();
@ -277,7 +277,7 @@ void ClientApp::scheduleClientRestart(double retryTime)
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
EventQueueTimer *timer = m_events->newOneShotTimer(retryTime, nullptr);
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);
if (!args().m_restartable || !info->m_retry) {
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 {
LOG((CLOG_WARN "failed to connect to server: %s", info->m_what.c_str()));
if (!m_suspended) {
@ -324,7 +324,7 @@ void ClientApp::handleClientDisconnected(const Event &, void *)
{
LOG((CLOG_NOTE "disconnected from server"));
if (!args().m_restartable) {
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
} else if (!m_suspended) {
scheduleClientRestart(nextRestartTimeout());
}
@ -337,22 +337,22 @@ Client *ClientApp::openClient(const std::string &name, const NetworkAddress &add
try {
m_events->adoptHandler(
m_events->forClient().connected(), client->getEventTarget(),
EventTypes::ClientConnected, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientConnected)
);
m_events->adoptHandler(
m_events->forClient().connectionFailed(), client->getEventTarget(),
EventTypes::ClientConnectionFailed, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientFailed)
);
m_events->adoptHandler(
m_events->forClient().connectionRefused(), client->getEventTarget(),
EventTypes::ClientConnectionRefused, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientRefused)
);
m_events->adoptHandler(
m_events->forClient().disconnected(), client->getEventTarget(),
EventTypes::ClientDisconnected, client->getEventTarget(),
new TMethodEventJob<ClientApp>(this, &ClientApp::handleClientDisconnected)
);
@ -370,10 +370,10 @@ void ClientApp::closeClient(Client *client)
return;
}
m_events->removeHandler(m_events->forClient().connected(), client);
m_events->removeHandler(m_events->forClient().connectionFailed(), client);
m_events->removeHandler(m_events->forClient().connectionRefused(), client);
m_events->removeHandler(m_events->forClient().disconnected(), client);
m_events->removeHandler(EventTypes::ClientConnected, client);
m_events->removeHandler(EventTypes::ClientConnectionFailed, client);
m_events->removeHandler(EventTypes::ClientConnectionRefused, client);
m_events->removeHandler(EventTypes::ClientDisconnected, 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
events in its c'tor like so:
\code
m_events->adoptHandler(Event::kSystem,
m_events->adoptHandler(EventTypes::System,
m_events->getSystemTarget(),
new TMethodEventJob<CXXXPlatformScreen>(this,
&CXXXPlatformScreen::handleSystemEvent));

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

@ -712,16 +712,16 @@ void KeyState::sendKeyEvent(
if (isAutoRepeat) {
// ignore auto-repeat on half-duplex keys
} else {
m_events->addEvent(Event(m_events->forIKeyState().keyDown(), 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::KeyStateKeyDown, target, KeyInfo::alloc(key, mask, button, 1)));
m_events->addEvent(Event(EventTypes::KeyStateKeyUp, target, KeyInfo::alloc(key, mask, button, 1)));
}
} else {
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) {
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 {
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();
if (m_inputShutdown && m_size == 0) {
m_events->addEvent(Event(m_events->forIStream().inputShutdown(), getEventTarget()));
m_events->addEvent(Event(EventTypes::StreamInputShutdown, getEventTarget()));
}
return n;
@ -121,7 +121,7 @@ bool PacketStreamFilter::readPacketSize()
m_size =
((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) {
m_events->addEvent(Event(m_events->forIStream().inputFormatError(), getEventTarget()));
m_events->addEvent(Event(EventTypes::StreamInputFormatError, getEventTarget()));
return false;
}
}
@ -159,12 +159,12 @@ bool PacketStreamFilter::readMore()
void PacketStreamFilter::filterEvent(const Event &event)
{
if (event.getType() == m_events->forIStream().inputReady()) {
if (event.getType() == EventTypes::StreamInputReady) {
Lock lock(&m_mutex);
if (!readMore()) {
return;
}
} else if (event.getType() == m_events->forIStream().inputShutdown()) {
} else if (event.getType() == EventTypes::StreamInputShutdown) {
// discard this if we have buffered data
Lock lock(&m_mutex);
m_inputShutdown = true;

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

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

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

@ -155,7 +155,7 @@ void ServerApp::help()
void ServerApp::reloadSignalHandler(Arch::ESignal, void *)
{
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 *)
@ -222,7 +222,7 @@ void ServerApp::handleClientConnected(const Event &, void *vlistener)
void ServerApp::handleClientsDisconnected(const Event &, void *)
{
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
void ServerApp::closeServer(Server *server)
@ -238,18 +238,18 @@ void ServerApp::closeServer(Server *server)
double timeout = 3.0;
EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr);
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->forServer().disconnected(), server,
EventTypes::ServerDisconnected, server,
new TMethodEventJob<ServerApp>(this, &ServerApp::handleClientsDisconnected)
);
m_events->loop();
m_events->removeHandler(Event::kTimer, timer);
m_events->removeHandler(EventTypes::Timer, timer);
m_events->deleteTimer(timer);
m_events->removeHandler(m_events->forServer().disconnected(), server);
m_events->removeHandler(EventTypes::ServerDisconnected, server);
// done with server
delete server;
@ -258,7 +258,7 @@ void ServerApp::closeServer(Server *server)
void ServerApp::stopRetryTimer()
{
if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer);
m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer);
m_timer = nullptr;
}
@ -276,7 +276,7 @@ void ServerApp::updateStatus(const std::string &msg)
void ServerApp::closeClientListener(ClientListener *listen)
{
if (listen != nullptr) {
m_events->removeHandler(m_events->forClientListener().connected(), listen);
m_events->removeHandler(EventTypes::ClientListenerAccepted, listen);
delete listen;
}
}
@ -305,9 +305,9 @@ void ServerApp::closePrimaryClient(PrimaryClient *primaryClient)
void ServerApp::closeServerScreen(deskflow::Screen *screen)
{
if (screen != nullptr) {
m_events->removeHandler(m_events->forIScreen().error(), screen->getEventTarget());
m_events->removeHandler(m_events->forIScreen().suspend(), screen->getEventTarget());
m_events->removeHandler(m_events->forIScreen().resume(), screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(EventTypes::ScreenResume, screen->getEventTarget());
delete screen;
}
}
@ -348,7 +348,7 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized;
if (!initServer()) {
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
break;
@ -356,11 +356,11 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized;
if (!initServer()) {
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
} else if (m_serverState == kInitialized) {
LOG((CLOG_DEBUG1 "starting server"));
if (!startServer()) {
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
}
break;
@ -369,7 +369,7 @@ void ServerApp::retryHandler(const Event &, void *)
LOG((CLOG_DEBUG1 "retry starting server"));
m_serverState = kInitialized;
if (!startServer()) {
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
break;
}
@ -417,7 +417,7 @@ bool ServerApp::initServer()
assert(m_timer == nullptr);
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
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;
return true;
} else {
@ -431,16 +431,15 @@ deskflow::Screen *ServerApp::openServerScreen()
deskflow::Screen *screen = createScreen();
screen->setEnableDragDrop(argsBase().m_enableDragDrop);
m_events->adoptHandler(
m_events->forIScreen().error(), screen->getEventTarget(),
EventTypes::ScreenError, screen->getEventTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenError)
);
m_events->adoptHandler(
m_events->forIScreen().suspend(), screen->getEventTarget(),
EventTypes::ScreenSuspend, screen->getEventTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::handleSuspend)
);
m_events->adoptHandler(
m_events->forIScreen().resume(), screen->getEventTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::handleResume)
EventTypes::ScreenResume, screen->getEventTarget(), new TMethodEventJob<ServerApp>(this, &ServerApp::handleResume)
);
return screen;
}
@ -497,7 +496,7 @@ bool ServerApp::startServer()
const auto retryTime = 10.0;
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
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;
return true;
} else {
@ -542,7 +541,7 @@ PrimaryClient *ServerApp::openPrimaryClient(const std::string &name, deskflow::S
void ServerApp::handleScreenError(const Event &, void *)
{
LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
}
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);
m_events->adoptHandler(
m_events->forClientListener().connected(), listen,
EventTypes::ClientListenerAccepted, 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());
try {
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->forServer().screenSwitched(), server,
new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenSwitched)
EventTypes::ServerScreenSwitched, server, new TMethodEventJob<ServerApp>(this, &ServerApp::handleScreenSwitched)
);
} catch (std::bad_alloc &ba) {
@ -653,21 +651,21 @@ int ServerApp::mainLoop()
// handle hangup signal by reloading the server's configuration
ARCH->setSignalHandler(Arch::kHANGUP, &reloadSignalHandler, nullptr);
m_events->adoptHandler(
m_events->forServerApp().reloadConfig(), m_events->getSystemTarget(),
EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::reloadConfig)
);
// handle force reconnect event by disconnecting clients. they'll
// reconnect automatically.
m_events->adoptHandler(
m_events->forServerApp().forceReconnect(), m_events->getSystemTarget(),
EventTypes::ServerAppForceReconnect, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::forceReconnect)
);
// to work around the sticky meta keys problem, we'll give users
// the option to reset the state of the server.
m_events->adoptHandler(
m_events->forServerApp().resetServer(), m_events->getSystemTarget(),
EventTypes::ServerAppResetServer, m_events->getSystemTarget(),
new TMethodEventJob<ServerApp>(this, &ServerApp::resetServer)
);
@ -693,8 +691,8 @@ int ServerApp::mainLoop()
// close down
LOG((CLOG_DEBUG1 "stopping server"));
m_events->removeHandler(m_events->forServerApp().forceReconnect(), m_events->getSystemTarget());
m_events->removeHandler(m_events->forServerApp().reloadConfig(), m_events->getSystemTarget());
m_events->removeHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget());
m_events->removeHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget());
cleanupServer();
updateStatus();
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)
std::string fileSize = deskflow::string::sizeTypeToString(size);
FileChunk *sizeMessage = FileChunk::start(fileSize);
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, sizeMessage));
events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, sizeMessage));
// send chunk messages with a fixed chunk size
size_t sentLength = 0;
@ -61,7 +60,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
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.
if (sentLength + chunkSize > size) {
@ -74,7 +73,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
FileChunk *fileChunk = FileChunk::data(data, chunkSize);
delete[] chunkData;
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, fileChunk));
events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, fileChunk));
sentLength += chunkSize;
file.seekg(sentLength, std::ios::beg);
@ -87,7 +86,7 @@ void StreamChunker::sendFile(char *filename, IEventQueue *events, void *eventTar
// send last message
FileChunk *end = FileChunk::end();
events->addEvent(Event(events->forFile().fileChunkSending(), eventTarget, end));
events->addEvent(Event(EventTypes::FileChunkSending, eventTarget, end));
file.close();
@ -102,14 +101,14 @@ void StreamChunker::sendClipboard(
std::string dataSize = deskflow::string::sizeTypeToString(size);
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
size_t sentLength = 0;
size_t chunkSize = g_chunkSize;
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.
if (sentLength + chunkSize > size) {
@ -119,7 +118,7 @@ void StreamChunker::sendClipboard(
std::string chunk(data.substr(sentLength, chunkSize).c_str(), chunkSize);
ClipboardChunk *dataChunk = ClipboardChunk::data(id, sequence, chunk);
events->addEvent(Event(events->forClipboard().clipboardSending(), eventTarget, dataChunk));
events->addEvent(Event(EventTypes::ClipboardSending, eventTarget, dataChunk));
sentLength += chunkSize;
if (sentLength == size) {
@ -130,7 +129,7 @@ void StreamChunker::sendClipboard(
// send last message
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));
}

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

@ -51,7 +51,7 @@ BOOL WINAPI AppUtilWindows::consoleHandler(DWORD)
{
LOG((CLOG_INFO "got shutdown signal"));
IEventQueue *events = AppUtil::instance().app().getEvents();
events->addEvent(Event(Event::kQuit));
events->addEvent(Event(EventTypes::Quit));
return TRUE;
}
@ -207,7 +207,7 @@ void AppUtilWindows::eventLoop()
if (closeEventResult == WAIT_OBJECT_0) {
LOG_DEBUG("windows event loop received close event");
m_events->addEvent(Event(Event::kQuit));
m_events->addEvent(Event(EventTypes::Quit));
m_eventThreadRunning = false;
} else if (closeEventResult == WAIT_OBJECT_0 + 1) {
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
m_events->removeHandlers(m_stream->getEventTarget());
m_events->adoptHandler(
Event::kUnknown, m_stream->getEventTarget(),
EventTypes::Unknown, m_stream->getEventTarget(),
new TMethodEventJob<StreamFilter>(this, &StreamFilter::handleUpstreamEvent)
);
}
StreamFilter::~StreamFilter()
{
m_events->removeHandler(Event::kUnknown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::Unknown, m_stream->getEventTarget());
if (m_adopted) {
delete m_stream;
}

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

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

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

@ -130,7 +130,7 @@ ISocketMultiplexerJob *TCPListenSocket::serviceListening(ISocketMultiplexerJob *
return nullptr;
}
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
return nullptr;
}

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

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

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

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

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

@ -117,7 +117,7 @@ IEventQueueBuffer::Type EiEventQueueBuffer::getEvent(Event &event, uint32_t &dat
return kUser;
}
event = Event(Event::kSystem, events_->getSystemTarget());
event = Event(EventTypes::System, events_->getSystemTarget());
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);
// install event handlers
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) {
events_->adoptHandler(
events_->forEi().connected(), getEventTarget(),
EventTypes::EIConnected, getEventTarget(),
new TMethodEventJob<EiScreen>(this, &EiScreen::handle_connected_to_eis_event)
);
if (is_primary) {
portal_input_capture_ = new PortalInputCapture(this, events_);
} else {
events_->adoptHandler(
events_->forEi().sessionClosed(), getEventTarget(),
EventTypes::EISessionClosed, getEventTarget(),
new TMethodEventJob<EiScreen>(this, &EiScreen::handle_portal_session_closed)
);
portal_remote_desktop_ = new PortalRemoteDesktop(this, events_);
@ -79,7 +79,7 @@ EiScreen::EiScreen(bool is_primary, IEventQueue *events, bool use_portal)
EiScreen::~EiScreen()
{
events_->adoptBuffer(nullptr);
events_->removeHandler(Event::kSystem, events_->getSystemTarget());
events_->removeHandler(EventTypes::System, events_->getSystemTarget());
cleanup_ei();
@ -437,7 +437,7 @@ void EiScreen::update_shape()
cursor_x_ = x_ + w_ / 2;
cursor_y_ = y_ + h_ / 2;
sendEvent(events_->forIScreen().shapeChanged(), nullptr);
sendEvent(EventTypes::ScreenShapeChanged, nullptr);
}
void EiScreen::add_device(struct ei_device *device)
@ -509,7 +509,7 @@ void EiScreen::remove_device(struct ei_device *device)
update_shape();
}
void EiScreen::sendEvent(Event::Type type, void *data)
void EiScreen::sendEvent(EventTypes type, void *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.
auto id = it->second.find_by_mask(mask);
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));
return true;
}
@ -594,7 +594,7 @@ void EiScreen::on_button_event(ei_event *event)
return;
}
auto eventType = pressed ? events_->forIPrimaryScreen().buttonDown() : events_->forIPrimaryScreen().buttonUp();
auto eventType = pressed ? EventTypes::PrimaryScreenButtonDown : EventTypes::PrimaryScreenButtonUp;
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).
if (x != 0 || y != 0)
sendEvent(
events_->forIPrimaryScreen().wheel(),
EventTypes::PrimaryScreenWheel,
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
// to send the opposite of the value reported by EI if we want to
// 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)
@ -675,7 +675,7 @@ void EiScreen::on_motion_event(ei_event *event)
if (is_on_screen_) {
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()) {
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);
if (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_dy -= pixel_dy;
}

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

@ -88,7 +88,7 @@ protected:
private:
void init_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;
void on_key_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.
m_timer = m_events->newTimer(0.2, nullptr);
m_events->adoptHandler(
Event::kTimer, m_timer, new TMethodEventJob<MSWindowsDesks>(this, &MSWindowsDesks::handleCheckDesk)
EventTypes::Timer, m_timer, new TMethodEventJob<MSWindowsDesks>(this, &MSWindowsDesks::handleCheckDesk)
);
updateKeys();
@ -167,7 +167,7 @@ void MSWindowsDesks::disable()
{
// remove timer
if (m_timer != nullptr) {
m_events->removeHandler(Event::kTimer, m_timer);
m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer);
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) {
return kNone;
} else if (result == 0) {
event = Event(Event::kQuit);
event = Event(EventTypes::Quit);
return kSystem;
} else if (m_daemonQuit != 0 && m_event.message == m_daemonQuit) {
event = Event(Event::kQuit);
event = Event(EventTypes::Quit);
return kSystem;
} else if (m_event.message == m_userEvent) {
dataID = static_cast<uint32_t>(m_event.wParam);
return kUser;
} else {
event = Event(Event::kSystem, m_events->getSystemTarget(), &m_event);
event = Event(EventTypes::System, m_events->getSystemTarget(), &m_event);
return kSystem;
}
}

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

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

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

@ -172,7 +172,7 @@ MSWindowsScreen::MSWindowsScreen(
// install event handlers
m_events->adoptHandler(
Event::kSystem, m_events->getSystemTarget(),
EventTypes::System, m_events->getSystemTarget(),
new TMethodEventJob<MSWindowsScreen>(this, &MSWindowsScreen::handleSystemEvent)
);
@ -186,7 +186,7 @@ MSWindowsScreen::~MSWindowsScreen()
disable();
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_desks;
delete m_screensaver;
@ -222,7 +222,7 @@ void MSWindowsScreen::enable()
// we need to poll some things to fix them
m_fixTimer = m_events->newTimer(1.0, nullptr);
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
@ -265,7 +265,7 @@ void MSWindowsScreen::disable()
// uninstall fix timer
if (m_fixTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_fixTimer);
m_events->removeHandler(EventTypes::Timer, m_fixTimer);
m_events->deleteTimer(m_fixTimer);
m_fixTimer = nullptr;
}
@ -416,8 +416,8 @@ void MSWindowsScreen::checkClipboards()
if (m_ownClipboard && !MSWindowsClipboard::isOwnedByDeskflow()) {
LOG((CLOG_DEBUG "clipboard changed: lost ownership and no notification received"));
m_ownClipboard = false;
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection);
sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
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));
}
void MSWindowsScreen::sendClipboardEvent(Event::Type type, ClipboardID id)
void MSWindowsScreen::sendClipboardEvent(EventTypes type, ClipboardID id)
{
ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
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.
We receive only WM_TIMECHANGE hence this message is used to resume.*/
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;
case WM_POWERBROADCAST:
@ -1058,12 +1058,11 @@ bool MSWindowsScreen::onEvent(HWND, UINT msg, WPARAM wParam, LPARAM lParam, LRES
case PBT_APMRESUMEAUTOMATIC:
case PBT_APMRESUMECRITICAL:
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;
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;
}
*result = TRUE;
@ -1242,15 +1241,15 @@ bool MSWindowsScreen::onHotKey(WPARAM wParam, LPARAM lParam)
}
// find what kind of event
Event::Type type;
EventTypes type;
if ((lParam & 0x80000000u) == 0u) {
if ((lParam & 0x40000000u) != 0u) {
// ignore key repeats but it counts as a hot key
return true;
}
type = m_events->forIPrimaryScreen().hotKeyDown();
type = EventTypes::PrimaryScreenHotkeyDown;
} else {
type = m_events->forIPrimaryScreen().hotKeyUp();
type = EventTypes::PrimaryScreenHotkeyUp;
}
// generate event
@ -1287,12 +1286,12 @@ bool MSWindowsScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
if (pressed) {
LOG((CLOG_DEBUG1 "event: button press button=%d", button));
if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonDown(), ButtonInfo::alloc(button, mask));
sendEvent(EventTypes::PrimaryScreenButtonDown, ButtonInfo::alloc(button, mask));
}
} else {
LOG((CLOG_DEBUG1 "event: button release button=%d", button));
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) {
// 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) {
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));
} else {
// 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
if (!ignore()) {
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;
}
@ -1391,12 +1390,12 @@ bool MSWindowsScreen::onScreensaver(bool activated)
if (activated) {
if (!m_screensaverActive && m_screensaver->checkStarted(DESKFLOW_MSG_SCREEN_SAVER, FALSE, 0)) {
m_screensaverActive = true;
sendEvent(m_events->forIPrimaryScreen().screensaverActivated());
sendEvent(EventTypes::PrimaryScreenSaverActivated);
}
} else {
if (m_screensaverActive) {
m_screensaverActive = false;
sendEvent(m_events->forIPrimaryScreen().screensaverDeactivated());
sendEvent(EventTypes::PrimaryScreenSaverDeactivated);
}
}
@ -1428,7 +1427,7 @@ bool MSWindowsScreen::onDisplayChange()
}
// 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)" : ""));
}
@ -1444,8 +1443,8 @@ void MSWindowsScreen::onClipboardChange()
if (m_ownClipboard) {
LOG((CLOG_DEBUG "clipboard changed: lost ownership"));
m_ownClipboard = false;
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection);
sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardSelection);
}
} else if (!m_ownClipboard) {
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
public: // HACK
void sendEvent(Event::Type type, void * = nullptr);
void sendEvent(EventTypes type, void * = nullptr);
private: // HACK
void sendClipboardEvent(Event::Type type, ClipboardID id);
void sendClipboardEvent(EventTypes type, ClipboardID id);
// handle message before it gets dispatched. returns true iff
// the message should not be dispatched.

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

@ -116,8 +116,8 @@ private:
void postMouseEvent(CGPoint &) const;
// convenience function to send events
void sendEvent(Event::Type type, void * = nullptr) const;
void sendClipboardEvent(Event::Type type, ClipboardID id) const;
void sendEvent(EventTypes type, void * = nullptr) const;
void sendClipboardEvent(EventTypes type, ClipboardID id) const;
// message handlers
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
m_events->adoptHandler(
m_events->forOSXScreen().confirmSleep(), getEventTarget(),
EventTypes::OsxScreenConfirmSleep, getEventTarget(),
new TMethodEventJob<OSXScreen>(this, &OSXScreen::handleConfirmSleep)
);
@ -161,7 +161,7 @@ OSXScreen::OSXScreen(
LOG((CLOG_DEBUG "starting watchSystemPowerThread"));
m_pmWatchThread = new Thread(new TMethodJob<OSXScreen>(this, &OSXScreen::watchSystemPowerThread));
} catch (...) {
m_events->removeHandler(m_events->forOSXScreen().confirmSleep(), getEventTarget());
m_events->removeHandler(EventTypes::OsxScreenConfirmSleep, getEventTarget());
if (m_switchEventHandlerRef != 0) {
RemoveEventHandler(m_switchEventHandlerRef);
}
@ -175,7 +175,8 @@ OSXScreen::OSXScreen(
// install event handlers
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
@ -187,7 +188,7 @@ OSXScreen::~OSXScreen()
disable();
m_events->adoptBuffer(nullptr);
m_events->removeHandler(Event::kSystem, m_events->getSystemTarget());
m_events->removeHandler(EventTypes::System, m_events->getSystemTarget());
if (m_pmWatchThread) {
// make sure the thread has setup the runloop.
@ -208,7 +209,7 @@ OSXScreen::~OSXScreen()
delete m_pmThreadReady;
delete m_pmMutex;
m_events->removeHandler(m_events->forOSXScreen().confirmSleep(), getEventTarget());
m_events->removeHandler(EventTypes::OsxScreenConfirmSleep, getEventTarget());
RemoveEventHandler(m_switchEventHandlerRef);
@ -701,7 +702,7 @@ void OSXScreen::enable()
// watch the clipboard
m_clipboardTimer = m_events->newTimer(1.0, nullptr);
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) {
@ -766,7 +767,7 @@ void OSXScreen::disable()
// uninstall clipboard timer
if (m_clipboardTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_clipboardTimer);
m_events->removeHandler(EventTypes::Timer, m_clipboardTimer);
m_events->deleteTimer(m_clipboardTimer);
m_clipboardTimer = nullptr;
}
@ -854,8 +855,8 @@ void OSXScreen::checkClipboards()
LOG((CLOG_DEBUG2 "checking clipboard"));
if (m_pasteboard.synchronize()) {
LOG((CLOG_DEBUG "clipboard changed"));
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardClipboard);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), kClipboardSelection);
sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardClipboard);
sendClipboardEvent(EventTypes::ClipboardGrabbed, kClipboardSelection);
}
}
@ -903,12 +904,12 @@ bool OSXScreen::isPrimary() const
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));
}
void OSXScreen::sendClipboardEvent(Event::Type type, ClipboardID id) const
void OSXScreen::sendClipboardEvent(EventTypes type, ClipboardID id) const
{
ClipboardInfo *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
info->m_id = id;
@ -1009,7 +1010,7 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
if (m_isOnScreen) {
// 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)) {
m_draggingStarted = true;
}
@ -1043,7 +1044,7 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
// And keep only the fractional part
m_xFractionalMove -= intX;
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));
if (button != kButtonNone) {
KeyModifierMask mask = m_keyState->getActiveModifiers();
sendEvent(m_events->forIPrimaryScreen().buttonDown(), ButtonInfo::alloc(button, mask));
sendEvent(EventTypes::PrimaryScreenButtonDown, ButtonInfo::alloc(button, mask));
}
} else {
LOG((CLOG_DEBUG1 "event: button release button=%d", button));
if (button != kButtonNone) {
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
{
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;
}
@ -1160,9 +1161,9 @@ bool OSXScreen::onKey(CGEventRef event)
if (m_modifierHotKeys.count(newMask) > 0) {
m_activeModifierHotKey = m_modifierHotKeys[newMask];
m_activeModifierHotKeyMask = newMask;
m_events->addEvent(Event(
m_events->forIPrimaryScreen().hotKeyDown(), getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey)
));
m_events->addEvent(
Event(EventTypes::PrimaryScreenHotkeyDown, getEventTarget(), HotKeyInfo::alloc(m_activeModifierHotKey))
);
}
}
@ -1172,7 +1173,7 @@ bool OSXScreen::onKey(CGEventRef event)
KeyModifierMask mask = (newMask & m_activeModifierHotKeyMask);
if (mask != m_activeModifierHotKeyMask) {
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_activeModifierHotKeyMask = 0;
@ -1189,11 +1190,11 @@ bool OSXScreen::onKey(CGEventRef event)
uint32_t id = i->second;
// determine event type
Event::Type type;
EventTypes type;
if (eventKind == kCGEventKeyDown) {
type = m_events->forIPrimaryScreen().hotKeyDown();
type = EventTypes::PrimaryScreenHotkeyDown;
} else if (eventKind == kCGEventKeyUp) {
type = m_events->forIPrimaryScreen().hotKeyUp();
type = EventTypes::PrimaryScreenHotkeyUp;
} else {
return false;
}
@ -1273,12 +1274,12 @@ bool OSXScreen::onHotKey(EventRef event) const
uint32_t id = hkid.id;
// determine event type
Event::Type type;
EventTypes type;
uint32_t eventKind = GetEventKind(event);
if (eventKind == kEventHotKeyPressed) {
type = m_events->forIPrimaryScreen().hotKeyDown();
type = EventTypes::PrimaryScreenHotkeyDown;
} else if (eventKind == kEventHotKeyReleased) {
type = m_events->forIPrimaryScreen().hotKeyUp();
type = EventTypes::PrimaryScreenHotkeyUp;
} else {
return false;
}
@ -1361,14 +1362,16 @@ void OSXScreen::enableDragTimer(bool enable)
{
if (enable && m_dragTimer == 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);
CGPoint mouse = CGEventGetLocation(event);
m_dragLastPoint.h = (short)mouse.x;
m_dragLastPoint.v = (short)mouse.y;
CFRelease(event);
} 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_dragTimer = nullptr;
}
@ -1448,7 +1451,7 @@ bool OSXScreen::updateScreenShape()
delete[] displays;
// We want to notify the peer screen whether we are primary screen or not
sendEvent(m_events->forIScreen().shapeChanged());
sendEvent(EventTypes::ScreenShapeChanged);
LOG(
(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) {
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) {
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));
}
@ -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
// queue a confirm sleep event here. we actually don't allow the
// system to sleep until the event is handled.
m_events->addEvent(
Event(m_events->forOSXScreen().confirmSleep(), getEventTarget(), messageArg, Event::kDontFreeData)
);
m_events->addEvent(Event(EventTypes::OsxScreenConfirmSleep, getEventTarget(), messageArg, Event::kDontFreeData));
return;
case kIOMessageSystemHasPoweredOn:
LOG((CLOG_DEBUG "system wakeup"));
m_events->addEvent(Event(m_events->forIScreen().resume(), getEventTarget()));
m_events->addEvent(Event(EventTypes::ScreenResume, getEventTarget()));
break;
default:
@ -1601,8 +1602,7 @@ void OSXScreen::handleConfirmSleep(const Event &event, void *)
Lock lock(m_pmMutex);
if (m_pmRootPort != 0) {
// 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"));
IOAllowPowerChange(m_pmRootPort, messageArg);

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

@ -92,7 +92,7 @@ void OSXScreenSaver::processLaunched(ProcessSerialNumber psn)
m_screenSaverPSN = psn;
LOG((CLOG_DEBUG1 "screen saver engine launched, enabled=%d", 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) {
LOG((CLOG_DEBUG1 "screen saver engine terminated, enabled=%d", 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;

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");
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
g_signal_handler_disconnect(session, signals_[SESSION_CLOSED]);
signals_[SESSION_CLOSED] = 0;
@ -125,7 +125,7 @@ void PortalInputCapture::cb_init_input_capture_session(GObject *object, GAsyncRe
if (!session) {
LOG_ERR("failed to initialize input capture session, quitting: %s", error->message);
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
return;
}
@ -141,12 +141,12 @@ void PortalInputCapture::cb_init_input_capture_session(GObject *object, GAsyncRe
if (fd < 0) {
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
return;
}
}
// 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
// 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");
g_signal_handler_disconnect(session, session_signal_id_);
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
g_clear_object(&session_);
@ -87,7 +87,7 @@ void PortalRemoteDesktop::cb_session_started(GObject *object, GAsyncResult *res)
if (!success) {
LOG_ERR("failed to start portal remote desktop session, quitting: %s", error->message);
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
return;
}
@ -100,12 +100,12 @@ void PortalRemoteDesktop::cb_session_started(GObject *object, GAsyncResult *res)
fd = xdp_session_connect_to_eis(session, &error);
if (fd < 0) {
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
return;
}
// 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)
@ -120,7 +120,7 @@ void PortalRemoteDesktop::cb_init_remote_desktop_session(GObject *object, GAsync
// fails.
if (session_iteration_ == 0) {
g_main_loop_quit(glib_main_loop_);
events_->addEvent(Event::kQuit);
events_->addEvent(EventTypes::Quit);
} else {
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]);
return kUser;
} else {
event = Event(Event::kSystem, m_events->getSystemTarget(), &m_event);
event = Event(EventTypes::System, m_events->getSystemTarget(), &m_event);
return kSystem;
}
}

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

@ -185,7 +185,7 @@ XWindowsScreen::XWindowsScreen(
// install event handlers
m_events->adoptHandler(
Event::kSystem, m_events->getSystemTarget(),
EventTypes::System, m_events->getSystemTarget(),
new TMethodEventJob<XWindowsScreen>(this, &XWindowsScreen::handleSystemEvent)
);
@ -199,7 +199,7 @@ XWindowsScreen::~XWindowsScreen()
assert(m_display != 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) {
delete m_clipboard[id];
}
@ -1110,12 +1110,12 @@ void XWindowsScreen::openIM()
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));
}
void XWindowsScreen::sendClipboardEvent(Event::Type type, ClipboardID id)
void XWindowsScreen::sendClipboardEvent(EventTypes type, ClipboardID id)
{
auto *info = (ClipboardInfo *)malloc(sizeof(ClipboardInfo));
info->m_id = id;
@ -1272,7 +1272,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
ClipboardID id = getClipboardID(xevent->xselectionclear.selection);
if (id != kClipboardEnd) {
m_clipboard[id]->lost(xevent->xselectionclear.time);
sendClipboardEvent(m_events->forClipboard().clipboardGrabbed(), id);
sendClipboardEvent(EventTypes::ClipboardGrabbed, id);
return;
}
} break;
@ -1345,7 +1345,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
case ConfigureNotify:
if (!m_isPrimary && xevent->xconfigure.window == m_root) {
setShape(xevent->xconfigure.width, xevent->xconfigure.height);
sendEvent(m_events->forIScreen().shapeChanged());
sendEvent(EventTypes::ScreenShapeChanged);
}
return;
@ -1390,7 +1390,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
XResizeWindow(m_display, m_window, m_w, m_h);
}
sendEvent(m_events->forIScreen().shapeChanged());
sendEvent(EventTypes::ScreenShapeChanged);
}
}
#endif
@ -1478,11 +1478,11 @@ bool XWindowsScreen::onHotKey(XKeyEvent &xkey, bool isRepeat)
}
// find what kind of event
Event::Type type;
EventTypes type;
if (xkey.type == KeyPress) {
type = m_events->forIPrimaryScreen().hotKeyDown();
type = EventTypes::PrimaryScreenHotkeyDown;
} else if (xkey.type == KeyRelease) {
type = m_events->forIPrimaryScreen().hotKeyUp();
type = EventTypes::PrimaryScreenHotkeyUp;
} else {
return false;
}
@ -1500,7 +1500,7 @@ void XWindowsScreen::onMousePress(const XButtonEvent &xbutton)
ButtonID button = mapButtonFromX(&xbutton);
KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state);
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);
KeyModifierMask mask = m_keyState->mapModifiersFromX(xbutton.state);
if (button != kButtonNone) {
sendEvent(m_events->forIPrimaryScreen().buttonUp(), ButtonInfo::alloc(button, mask));
sendEvent(EventTypes::PrimaryScreenButtonUp, ButtonInfo::alloc(button, mask));
} else if (xbutton.button == 4) {
// 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) {
// 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
}
@ -1552,7 +1552,7 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
cntr = 0;
} else if (m_isOnScreen) {
// 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 {
// motion on secondary screen. warp mouse back to
// center.
@ -1579,7 +1579,7 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
// warping to the primary screen's enter position,
// effectively overriding it.
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;
// notify of failure
sendEvent(m_events->forIScreen().error(), nullptr);
sendEvent(EventTypes::ScreenError, nullptr);
// FIXME -- should ensure that we ignore operations that involve
// 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:
// event sending
void sendEvent(Event::Type, void * = nullptr);
void sendClipboardEvent(Event::Type, ClipboardID);
void sendEvent(EventTypes, void * = nullptr);
void sendClipboardEvent(EventTypes, ClipboardID);
// create the transparent cursor
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
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) {
m_events->deleteTimer(m_disableTimer);
}
m_events->removeHandler(Event::kTimer, this);
m_events->removeHandler(EventTypes::Timer, this);
if (m_display != nullptr) {
enableDPMS(m_dpmsEnabled);
@ -366,9 +366,9 @@ void XWindowsScreenSaver::setXScreenSaverActive(bool activated)
updateDisableTimer();
if (activated) {
m_events->addEvent(Event(m_events->forIPrimaryScreen().screensaverActivated(), m_eventTarget));
m_events->addEvent(Event(EventTypes::PrimaryScreenSaverActivated, m_eventTarget));
} 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()) {
client = m_waitingClients.front();
m_waitingClients.pop_front();
m_events->removeHandler(m_events->forClientProxy().disconnected(), client);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
}
return client;
}
@ -78,7 +78,7 @@ void ClientListener::start()
// setup event handler
m_events->adoptHandler(
m_events->forIListenSocket().connecting(), m_listen,
EventTypes::ListenSocketConnecting, m_listen,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientConnecting)
);
@ -94,9 +94,9 @@ void ClientListener::stop()
// discard already connected clients
for (auto index = m_newClients.begin(); index != m_newClients.end(); ++index) {
ClientProxyUnknown *client = *index;
m_events->removeHandler(m_events->forClientProxyUnknown().success(), client);
m_events->removeHandler(m_events->forClientProxyUnknown().failure(), client);
m_events->removeHandler(m_events->forClientProxy().disconnected(), client);
m_events->removeHandler(EventTypes::ClientProxyUnknownSuccess, client);
m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, client);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, client);
delete client;
}
@ -107,7 +107,7 @@ void ClientListener::stop()
client = getNextClient();
}
m_events->removeHandler(m_events->forIListenSocket().connecting(), m_listen);
m_events->removeHandler(EventTypes::ListenSocketConnecting, m_listen);
cleanupListenSocket();
cleanupClientSockets();
}
@ -115,8 +115,8 @@ void ClientListener::stop()
void ClientListener::removeUnknownClient(ClientProxyUnknown *unknownClient)
{
if (unknownClient) {
m_events->removeHandler(m_events->forClientProxyUnknown().success(), unknownClient);
m_events->removeHandler(m_events->forClientProxyUnknown().failure(), unknownClient);
m_events->removeHandler(EventTypes::ClientProxyUnknownSuccess, unknownClient);
m_events->removeHandler(EventTypes::ClientProxyUnknownFailure, unknownClient);
m_newClients.erase(unknownClient);
delete unknownClient;
}
@ -134,14 +134,15 @@ void ClientListener::handleClientConnecting(const Event &, void *)
m_clientSockets.insert(socket);
m_events->adoptHandler(
m_events->forClientListener().accepted(), socket->getEventTarget(),
EventTypes::ClientListenerAccepted, socket->getEventTarget(),
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientAccepted, socket)
);
// When using non SSL, server accepts clients immediately, while SSL
// has to call secure accept which may require retry
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
m_events->adoptHandler(
m_events->forClientProxyUnknown().success(), client,
EventTypes::ClientProxyUnknownSuccess, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClient, client)
);
m_events->adoptHandler(
m_events->forClientProxyUnknown().failure(), client,
EventTypes::ClientProxyUnknownFailure, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleUnknownClientFailure, client)
);
}
@ -183,11 +184,11 @@ void ClientListener::handleUnknownClient(const Event &, void *vclient)
if (client) {
// handshake was successful
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
m_events->adoptHandler(
m_events->forClientProxy().disconnected(), client,
EventTypes::ClientProxyDisconnected, client,
new TMethodEventJob<ClientListener>(this, &ClientListener::handleClientDisconnected, client)
);
} 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) {
if (*i == client) {
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
// 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
m_events->adoptHandler(
m_events->forIStream().inputReady(), stream->getEventTarget(),
EventTypes::StreamInputReady, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleData, nullptr)
);
m_events->adoptHandler(
m_events->forIStream().outputError(), stream->getEventTarget(),
EventTypes::StreamOutputError, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr)
);
m_events->adoptHandler(
m_events->forIStream().inputShutdown(), stream->getEventTarget(),
EventTypes::StreamInputShutdown, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr)
);
m_events->adoptHandler(
m_events->forIStream().inputFormatError(), stream->getEventTarget(),
EventTypes::StreamInputFormatError, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleDisconnect, nullptr)
);
m_events->adoptHandler(
m_events->forIStream().outputShutdown(), stream->getEventTarget(),
EventTypes::StreamOutputShutdown, stream->getEventTarget(),
new TMethodEventJob<ClientProxy1_0>(this, &ClientProxy1_0::handleWriteError, nullptr)
);
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);
@ -66,18 +66,18 @@ void ClientProxy1_0::disconnect()
{
removeHandlers();
getStream()->close();
m_events->addEvent(Event(m_events->forClientProxy().disconnected(), getEventTarget()));
m_events->addEvent(Event(EventTypes::ClientProxyDisconnected, getEventTarget()));
}
void ClientProxy1_0::removeHandlers()
{
// uninstall event handlers
m_events->removeHandler(m_events->forIStream().inputReady(), getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), getStream()->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputFormatError(), getStream()->getEventTarget());
m_events->removeHandler(Event::kTimer, this);
m_events->removeHandler(EventTypes::StreamInputReady, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputFormatError, getStream()->getEventTarget());
m_events->removeHandler(EventTypes::Timer, this);
// remove timer
removeHeartbeatTimer();
@ -165,7 +165,7 @@ bool ClientProxy1_0::parseHandshakeMessage(const uint8_t *code)
// future messages get parsed by parseMessage
m_parser = &ClientProxy1_0::parseMessage;
if (recvInfo()) {
m_events->addEvent(Event(m_events->forClientProxy().ready(), getEventTarget()));
m_events->addEvent(Event(EventTypes::ClientProxyReady, getEventTarget()));
addHeartbeatTimer();
return true;
}
@ -177,7 +177,7 @@ bool ClientProxy1_0::parseMessage(const uint8_t *code)
{
if (memcmp(code, kMsgDInfo, 4) == 0) {
if (recvInfo()) {
m_events->addEvent(Event(m_events->forIScreen().shapeChanged(), getEventTarget()));
m_events->addEvent(Event(EventTypes::ScreenShapeChanged, getEventTarget()));
return true;
}
return false;
@ -433,7 +433,7 @@ bool ClientProxy1_0::recvGrabClipboard()
auto *info = new ClipboardInfo;
info->m_id = id;
info->m_sequenceNumber = seqNum;
m_events->addEvent(Event(m_events->forClipboard().clipboardGrabbed(), getEventTarget(), info));
m_events->addEvent(Event(EventTypes::ClipboardGrabbed, getEventTarget(), info));
return true;
}

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

@ -76,7 +76,7 @@ void ClientProxy1_3::addHeartbeatTimer()
if (m_keepAliveRate > 0.0) {
m_keepAliveTimer = m_events->newTimer(m_keepAliveRate, nullptr);
m_events->adoptHandler(
Event::kTimer, m_keepAliveTimer,
EventTypes::Timer, m_keepAliveTimer,
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
if (m_keepAliveTimer != nullptr) {
m_events->removeHandler(Event::kTimer, m_keepAliveTimer);
m_events->removeHandler(EventTypes::Timer, m_keepAliveTimer);
m_events->deleteTimer(m_keepAliveTimer);
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->forFile().keepAlive(), this,
EventTypes::FileKeepAlive, this,
new TMethodEventJob<ClientProxy1_3>(this, &ClientProxy1_3::handleKeepAlive, nullptr)
);
}
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)
@ -67,7 +67,7 @@ void ClientProxy1_5::fileChunkReceived()
int result = FileChunk::assemble(getStream(), server->getReceivedFileData(), server->getExpectedFileSize());
if (result == kFinish) {
m_events->addEvent(Event(m_events->forFile().fileReceiveCompleted(), server));
m_events->addEvent(Event(EventTypes::FileReceiveCompleted, server));
} else if (result == kStart) {
if (server->getFakeDragFileList().size() > 0) {
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->adoptHandler(
m_events->forClipboard().clipboardSending(), this,
EventTypes::ClipboardSending, this,
new TMethodEventJob<ClientProxy1_6>(this, &ClientProxy1_6::handleClipboardSendingEvent)
);
}
@ -75,7 +75,7 @@ bool ClientProxy1_6::recvClipboard()
auto *info = new ClipboardInfo;
info->m_id = id;
info->m_sequenceNumber = seq;
m_events->addEvent(Event(m_events->forClipboard().clipboardChanged(), getEventTarget(), info));
m_events->addEvent(Event(EventTypes::ClipboardChanged, getEventTarget(), info));
}
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);
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);
addStreamHandlers();
@ -80,7 +81,7 @@ void ClientProxyUnknown::sendSuccess()
{
m_ready = true;
removeTimer();
m_events->addEvent(Event(m_events->forClientProxyUnknown().success(), this));
m_events->addEvent(Event(EventTypes::ClientProxyUnknownSuccess, this));
}
void ClientProxyUnknown::sendFailure()
@ -90,31 +91,30 @@ void ClientProxyUnknown::sendFailure()
m_ready = false;
removeHandlers();
removeTimer();
m_events->addEvent(Event(m_events->forClientProxyUnknown().failure(), this));
m_events->addEvent(Event(EventTypes::ClientProxyUnknownFailure, this));
}
void ClientProxyUnknown::addStreamHandlers()
{
assert(m_stream != nullptr);
m_events->adoptHandler(
m_events->forIStream().inputReady(), m_stream->getEventTarget(),
EventTypes::StreamInputReady, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleData)
);
m_events->adoptHandler(
m_events->forIStream().outputError(), m_stream->getEventTarget(),
EventTypes::StreamOutputError, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError)
);
m_events->adoptHandler(
m_events->forIStream().inputShutdown(), m_stream->getEventTarget(),
EventTypes::StreamInputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
);
m_events->adoptHandler(
m_events->forIStream().inputFormatError(), m_stream->getEventTarget(),
EventTypes::StreamInputFormatError, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
);
m_events->adoptHandler(
m_events->forIStream().outputShutdown(), m_stream->getEventTarget(),
EventTypes::StreamOutputShutdown, m_stream->getEventTarget(),
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleWriteError)
);
}
@ -124,11 +124,11 @@ void ClientProxyUnknown::addProxyHandlers()
assert(m_proxy != nullptr);
m_events->adoptHandler(
m_events->forClientProxy().ready(), m_proxy,
EventTypes::ClientProxyReady, m_proxy,
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleReady)
);
m_events->adoptHandler(
m_events->forClientProxy().disconnected(), m_proxy,
EventTypes::ClientProxyDisconnected, m_proxy,
new TMethodEventJob<ClientProxyUnknown>(this, &ClientProxyUnknown::handleDisconnect)
);
}
@ -136,15 +136,15 @@ void ClientProxyUnknown::addProxyHandlers()
void ClientProxyUnknown::removeHandlers()
{
if (m_stream != nullptr) {
m_events->removeHandler(m_events->forIStream().inputReady(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputError(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputShutdown(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().inputFormatError(), m_stream->getEventTarget());
m_events->removeHandler(m_events->forIStream().outputShutdown(), m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputReady, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputShutdown, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamInputFormatError, m_stream->getEventTarget());
m_events->removeHandler(EventTypes::StreamOutputShutdown, m_stream->getEventTarget());
}
if (m_proxy != nullptr) {
m_events->removeHandler(m_events->forClientProxy().ready(), m_proxy);
m_events->removeHandler(m_events->forClientProxy().disconnected(), m_proxy);
m_events->removeHandler(EventTypes::ClientProxyReady, m_proxy);
m_events->removeHandler(EventTypes::ClientProxyDisconnected, m_proxy);
}
}
@ -152,7 +152,7 @@ void ClientProxyUnknown::removeTimer()
{
if (m_timer != nullptr) {
m_events->deleteTimer(m_timer);
m_events->removeHandler(Event::kTimer, this);
m_events->removeHandler(EventTypes::Timer, this);
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;
// check for hotkey events
Event::Type type = event.getType();
if (type == m_events->forIPrimaryScreen().hotKeyDown()) {
EventTypes type = event.getType();
if (type == EventTypes::PrimaryScreenHotkeyDown) {
status = kActivate;
} else if (type == m_events->forIPrimaryScreen().hotKeyUp()) {
} else if (type == EventTypes::PrimaryScreenHotkeyUp) {
status = kDeactivate;
} else {
return kNoMatch;
@ -150,10 +150,10 @@ InputFilter::EFilterStatus InputFilter::MouseButtonCondition::match(const Event
EFilterStatus status;
// check for hotkey events
Event::Type type = event.getType();
if (type == m_events->forIPrimaryScreen().buttonDown()) {
EventTypes type = event.getType();
if (type == EventTypes::PrimaryScreenButtonDown) {
status = kActivate;
} else if (type == m_events->forIPrimaryScreen().buttonUp()) {
} else if (type == EventTypes::PrimaryScreenButtonUp) {
status = kDeactivate;
} else {
return kNoMatch;
@ -188,7 +188,7 @@ std::string InputFilter::ScreenConnectedCondition::format() const
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());
if (m_screen == info->m_screen || m_screen.empty()) {
return kActivate;
@ -234,9 +234,7 @@ void InputFilter::LockCursorToScreenAction::perform(const Event &event)
// send event
Server::LockCursorToScreenInfo *info = Server::LockCursorToScreenInfo::alloc(s_state[m_mode]);
m_events->addEvent(
Event(m_events->forServer().lockCursorToScreen(), event.getTarget(), info, Event::kDeliverImmediately)
);
m_events->addEvent(Event(EventTypes::ServerLockCursorToScreen, event.getTarget(), info, Event::kDeliverImmediately));
}
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
// event if it has one.
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());
screen = info->m_screen;
}
// send event
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)
@ -332,9 +329,7 @@ std::string InputFilter::SwitchInDirectionAction::format() const
void InputFilter::SwitchInDirectionAction::perform(const Event &event)
{
Server::SwitchInDirectionInfo *info = Server::SwitchInDirectionInfo::alloc(m_direction);
m_events->addEvent(
Event(m_events->forServer().switchInDirection(), event.getTarget(), info, Event::kDeliverImmediately)
);
m_events->addEvent(Event(EventTypes::ServerSwitchInDirection, event.getTarget(), info, Event::kDeliverImmediately));
}
InputFilter::KeyboardBroadcastAction::KeyboardBroadcastAction(IEventQueue *events, Mode mode)
@ -394,9 +389,7 @@ void InputFilter::KeyboardBroadcastAction::perform(const Event &event)
// send event
Server::KeyboardBroadcastInfo *info = Server::KeyboardBroadcastInfo::alloc(s_state[m_mode], m_screens);
m_events->addEvent(
Event(m_events->forServer().keyboardBroadcast(), event.getTarget(), info, Event::kDeliverImmediately)
);
m_events->addEvent(Event(EventTypes::ServerKeyboardBroadcast, event.getTarget(), info, Event::kDeliverImmediately));
}
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)
{
Event::Type type = m_press ? m_events->forIKeyState().keyDown() : m_events->forIKeyState().keyUp();
EventTypes type = m_press ? EventTypes::KeyStateKeyDown : EventTypes::KeyStateKeyUp;
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(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) {
KeyID key = m_press ? kKeySetModifiers : kKeyClearModifiers;
modifierInfo = IKeyState::KeyInfo::alloc(key, m_buttonInfo->m_mask, 0, 1);
m_events->addEvent(
Event(m_events->forIKeyState().keyDown(), event.getTarget(), modifierInfo, Event::kDeliverImmediately)
);
m_events->addEvent(Event(EventTypes::KeyStateKeyDown, event.getTarget(), modifierInfo, Event::kDeliverImmediately));
}
// 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));
}
@ -805,49 +796,49 @@ void InputFilter::setPrimaryClient(PrimaryClient *client)
rule->disable(m_primaryClient);
}
m_events->removeHandler(m_events->forIKeyState().keyDown(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIKeyState().keyUp(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIKeyState().keyRepeat(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().buttonDown(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().buttonUp(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().hotKeyDown(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forIPrimaryScreen().hotKeyUp(), m_primaryClient->getEventTarget());
m_events->removeHandler(m_events->forServer().connected(), m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget());
m_events->removeHandler(EventTypes::ServerConnected, m_primaryClient->getEventTarget());
}
m_primaryClient = client;
if (m_primaryClient != nullptr) {
m_events->adoptHandler(
m_events->forIKeyState().keyDown(), m_primaryClient->getEventTarget(),
EventTypes::KeyStateKeyDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIKeyState().keyUp(), m_primaryClient->getEventTarget(),
EventTypes::KeyStateKeyUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIKeyState().keyRepeat(), m_primaryClient->getEventTarget(),
EventTypes::KeyStateKeyRepeat, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonDown(), m_primaryClient->getEventTarget(),
EventTypes::PrimaryScreenButtonDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIPrimaryScreen().buttonUp(), m_primaryClient->getEventTarget(),
EventTypes::PrimaryScreenButtonUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIPrimaryScreen().hotKeyDown(), m_primaryClient->getEventTarget(),
EventTypes::PrimaryScreenHotkeyDown, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forIPrimaryScreen().hotKeyUp(), m_primaryClient->getEventTarget(),
EventTypes::PrimaryScreenHotkeyUp, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);
m_events->adoptHandler(
m_events->forServer().connected(), m_primaryClient->getEventTarget(),
EventTypes::ServerConnected, m_primaryClient->getEventTarget(),
new TMethodEventJob<InputFilter>(this, &InputFilter::handleEvent)
);

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

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

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

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

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

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

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

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