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

refactor: replace SInt32 with int32_t

Browse source
This commit is contained in:
sithlord48 2025-01-10 20:11:56 -05:00 committed by Nick Bolton
parent 7487eeaa3a
commit 27eb83c981
77 changed files with 586 additions and 583 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -240,17 +240,17 @@ bool Client::getClipboard(ClipboardID id, IClipboard *clipboard) const
return m_screen->getClipboard(id, clipboard);
}
void Client::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void Client::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
m_screen->getShape(x, y, w, h);
}
void Client::getCursorPos(SInt32 &x, SInt32 &y) const
void Client::getCursorPos(int32_t &x, int32_t &y) const
{
m_screen->getCursorPos(x, y);
}
void Client::enter(SInt32 xAbs, SInt32 yAbs, UInt32, KeyModifierMask mask, bool)
void Client::enter(int32_t xAbs, int32_t yAbs, UInt32, KeyModifierMask mask, bool)
{
m_active = true;
m_screen->mouseMove(xAbs, yAbs);
@ -304,7 +304,7 @@ void Client::keyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std
m_screen->keyDown(id, mask, button, lang);
}
void Client::keyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang)
void Client::keyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang)
{
m_screen->keyRepeat(id, mask, count, button, lang);
}
@ -324,17 +324,17 @@ void Client::mouseUp(ButtonID id)
m_screen->mouseUp(id);
}
void Client::mouseMove(SInt32 x, SInt32 y)
void Client::mouseMove(int32_t x, int32_t y)
{
m_screen->mouseMove(x, y);
}
void Client::mouseRelativeMove(SInt32 dx, SInt32 dy)
void Client::mouseRelativeMove(int32_t dx, int32_t dy)
{
m_screen->mouseRelativeMove(dx, dy);
}
void Client::mouseWheel(SInt32 xDelta, SInt32 yDelta)
void Client::mouseWheel(int32_t xDelta, int32_t yDelta)
{
m_screen->mouseWheel(xDelta, yDelta);
}

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

@ -173,23 +173,23 @@ public:
// IScreen overrides
virtual void *getEventTarget() const;
virtual bool getClipboard(ClipboardID id, IClipboard *) const;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const;
virtual void getCursorPos(int32_t &x, int32_t &y) const;
// IClient overrides
virtual void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver);
virtual void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver);
virtual bool leave();
virtual void setClipboard(ClipboardID, const IClipboard *);
virtual void grabClipboard(ClipboardID);
virtual void setClipboardDirty(ClipboardID, bool);
virtual void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &);
virtual void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &lang);
virtual void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &lang);
virtual void keyUp(KeyID, KeyModifierMask, KeyButton);
virtual void mouseDown(ButtonID);
virtual void mouseUp(ButtonID);
virtual void mouseMove(SInt32 xAbs, SInt32 yAbs);
virtual void mouseRelativeMove(SInt32 xRel, SInt32 yRel);
virtual void mouseWheel(SInt32 xDelta, SInt32 yDelta);
virtual void mouseMove(int32_t xAbs, int32_t yAbs);
virtual void mouseRelativeMove(int32_t xRel, int32_t yRel);
virtual void mouseWheel(int32_t xDelta, int32_t yDelta);
virtual void screensaver(bool activate);
virtual void resetOptions();
virtual void setOptions(const OptionsList &options);

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

@ -193,7 +193,7 @@ ServerProxy::EResult ServerProxy::parseHandshakeMessage(const uint8_t *code)
}
else if (memcmp(code, kMsgEIncompatible, 4) == 0) {
SInt32 major, minor;
int32_t major, minor;
ProtocolUtil::readf(m_stream, kMsgEIncompatible + 4, &major, &minor);
LOG((CLOG_ERR "server has incompatible version %d.%d", major, minor));
m_client->refuseConnection("server has incompatible version");

4
src/lib/client/ServerProxy.h
View file

@ -138,8 +138,8 @@ private:
bool m_compressMouse;
bool m_compressMouseRelative;
SInt32 m_xMouse, m_yMouse;
SInt32 m_dxMouse, m_dyMouse;
int32_t m_xMouse, m_yMouse;
int32_t m_dxMouse, m_dyMouse;
bool m_ignoreMouse;

1
src/lib/common/basic_types.h
View file

@ -84,7 +84,6 @@
#if defined(__APPLE__)
#include <CoreServices/CoreServices.h>
#else
using SInt32 = signed TYPE_OF_SIZE_4;
using UInt32 = unsigned TYPE_OF_SIZE_4;
#endif
#endif

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

@ -39,7 +39,7 @@ bool Clipboard::empty()
assert(m_open);
// clear all data
for (SInt32 index = 0; index < kNumFormats; ++index) {
for (int32_t index = 0; index < kNumFormats; ++index) {
m_data[index] = "";
m_added[index] = false;
}

14
src/lib/deskflow/IClient.h
View file

@ -45,7 +45,7 @@ public:
screen is being entered because the screen saver is starting.
Subsequent clipboard events should report \p seqNum.
*/
virtual void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) = 0;
virtual void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) = 0;
//! Leave screen
/*!
@ -94,7 +94,7 @@ public:
Synthesize key events to generate a press and release of key \c id
\c count times. If possible match the given modifier mask.
*/
virtual void keyRepeat(KeyID id, KeyModifierMask, SInt32 count, KeyButton, const std::string &lang) = 0;
virtual void keyRepeat(KeyID id, KeyModifierMask, int32_t count, KeyButton, const std::string &lang) = 0;
//! Notify of key release
/*!
@ -120,14 +120,14 @@ public:
Synthesize mouse events to generate mouse motion to the absolute
screen position \c xAbs,yAbs.
*/
virtual void mouseMove(SInt32 xAbs, SInt32 yAbs) = 0;
virtual void mouseMove(int32_t xAbs, int32_t yAbs) = 0;
//! Notify of mouse motion
/*!
Synthesize mouse events to generate mouse motion by the relative
amount \c xRel,yRel.
*/
virtual void mouseRelativeMove(SInt32 xRel, SInt32 yRel) = 0;
virtual void mouseRelativeMove(int32_t xRel, int32_t yRel) = 0;
//! Notify of mouse wheel motion
/*!
@ -136,7 +136,7 @@ public:
to the right and negative for motion towards the user or to the left.
Each wheel click should generate a delta of +/-120.
*/
virtual void mouseWheel(SInt32 xDelta, SInt32 yDelta) = 0;
virtual void mouseWheel(int32_t xDelta, int32_t yDelta) = 0;
//! Notify of screen saver change
virtual void screensaver(bool activate) = 0;
@ -169,6 +169,6 @@ public:
// IScreen overrides
virtual void *getEventTarget() const = 0;
virtual bool getClipboard(ClipboardID id, IClipboard *) const = 0;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const = 0;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const = 0;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const = 0;
virtual void getCursorPos(int32_t &x, int32_t &y) const = 0;
};

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

@ -125,7 +125,7 @@ bool IClipboard::copy(IClipboard *dst, const IClipboard *src, Time time)
if (src->open(time)) {
if (dst->open(time)) {
if (dst->empty()) {
for (SInt32 format = 0; format != IClipboard::kNumFormats; ++format) {
for (int32_t format = 0; format != IClipboard::kNumFormats; ++format) {
IClipboard::EFormat eFormat = (IClipboard::EFormat)format;
if (src->has(eFormat)) {
dst->add(eFormat, src->get(eFormat));

4
src/lib/deskflow/IKeyState.cpp
View file

@ -34,7 +34,7 @@ IKeyState::IKeyState(IEventQueue *events)
// IKeyState::KeyInfo
//
IKeyState::KeyInfo *IKeyState::KeyInfo::alloc(KeyID id, KeyModifierMask mask, KeyButton button, SInt32 count)
IKeyState::KeyInfo *IKeyState::KeyInfo::alloc(KeyID id, KeyModifierMask mask, KeyButton button, int32_t count)
{
KeyInfo *info = (KeyInfo *)malloc(sizeof(KeyInfo));
info->m_key = id;
@ -47,7 +47,7 @@ IKeyState::KeyInfo *IKeyState::KeyInfo::alloc(KeyID id, KeyModifierMask mask, Ke
}
IKeyState::KeyInfo *IKeyState::KeyInfo::alloc(
KeyID id, KeyModifierMask mask, KeyButton button, SInt32 count, const std::set<std::string> &destinations
KeyID id, KeyModifierMask mask, KeyButton button, int32_t count, const std::set<std::string> &destinations
)
{
std::string screens = join(destinations);

10
src/lib/deskflow/IKeyState.h
View file

@ -44,8 +44,8 @@ public:
class KeyInfo
{
public:
static KeyInfo *alloc(KeyID, KeyModifierMask, KeyButton, SInt32 count);
static KeyInfo *alloc(KeyID, KeyModifierMask, KeyButton, SInt32 count, const std::set<std::string> &destinations);
static KeyInfo *alloc(KeyID, KeyModifierMask, KeyButton, int32_t count);
static KeyInfo *alloc(KeyID, KeyModifierMask, KeyButton, int32_t count, const std::set<std::string> &destinations);
static KeyInfo *alloc(const KeyInfo &);
static bool isDefault(const char *screens);
@ -58,7 +58,7 @@ public:
KeyID m_key;
KeyModifierMask m_mask;
KeyButton m_button;
SInt32 m_count;
int32_t m_count;
char *m_screens;
char m_screensBuffer[1];
};
@ -101,7 +101,7 @@ public:
Synthesizes a key repeat event and updates the key state.
*/
virtual bool
fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang) = 0;
fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang) = 0;
//! Fake a key release
/*!
@ -159,7 +159,7 @@ public:
/*!
Returns the active keyboard layout according to the operating system.
*/
virtual SInt32 pollActiveGroup() const = 0;
virtual int32_t pollActiveGroup() const = 0;
//! Get the keys currently pressed from OS
/*!

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

@ -163,25 +163,25 @@ public:
// IScreen overrides
virtual void *getEventTarget() const = 0;
virtual bool getClipboard(ClipboardID id, IClipboard *) const = 0;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const = 0;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const = 0;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const = 0;
virtual void getCursorPos(int32_t &x, int32_t &y) const = 0;
// IPrimaryScreen overrides
virtual void reconfigure(UInt32 activeSides) = 0;
virtual void warpCursor(SInt32 x, SInt32 y) = 0;
virtual void warpCursor(int32_t x, int32_t y) = 0;
virtual UInt32 registerHotKey(KeyID key, KeyModifierMask mask) = 0;
virtual void unregisterHotKey(UInt32 id) = 0;
virtual void fakeInputBegin() = 0;
virtual void fakeInputEnd() = 0;
virtual SInt32 getJumpZoneSize() const = 0;
virtual int32_t getJumpZoneSize() const = 0;
virtual bool isAnyMouseButtonDown(UInt32 &buttonID) const = 0;
virtual void getCursorCenter(SInt32 &x, SInt32 &y) const = 0;
virtual void getCursorCenter(int32_t &x, int32_t &y) const = 0;
// ISecondaryScreen overrides
virtual void fakeMouseButton(ButtonID id, bool press) = 0;
virtual void fakeMouseMove(SInt32 x, SInt32 y) = 0;
virtual void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const = 0;
virtual void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const = 0;
virtual void fakeMouseMove(int32_t x, int32_t y) = 0;
virtual void fakeMouseRelativeMove(int32_t dx, int32_t dy) const = 0;
virtual void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const = 0;
// IKeyState overrides
virtual void updateKeyMap() = 0;
@ -189,7 +189,7 @@ public:
virtual void setHalfDuplexMask(KeyModifierMask) = 0;
virtual void fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std::string &lang) = 0;
virtual bool
fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang) = 0;
fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang) = 0;
virtual bool fakeKeyUp(KeyButton button) = 0;
virtual void fakeAllKeysUp() = 0;
virtual bool fakeCtrlAltDel() = 0;
@ -197,7 +197,7 @@ public:
virtual bool isKeyDown(KeyButton) const = 0;
virtual KeyModifierMask getActiveModifiers() const = 0;
virtual KeyModifierMask pollActiveModifiers() const = 0;
virtual SInt32 pollActiveGroup() const = 0;
virtual int32_t pollActiveGroup() const = 0;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const = 0;
virtual std::string &getDraggingFilename() = 0;

4
src/lib/deskflow/IPrimaryScreen.cpp
View file

@ -50,7 +50,7 @@ bool IPrimaryScreen::ButtonInfo::equal(const ButtonInfo *a, const ButtonInfo *b)
// IPrimaryScreen::MotionInfo
//
IPrimaryScreen::MotionInfo *IPrimaryScreen::MotionInfo::alloc(SInt32 x, SInt32 y)
IPrimaryScreen::MotionInfo *IPrimaryScreen::MotionInfo::alloc(int32_t x, int32_t y)
{
MotionInfo *info = (MotionInfo *)malloc(sizeof(MotionInfo));
info->m_x = x;
@ -62,7 +62,7 @@ IPrimaryScreen::MotionInfo *IPrimaryScreen::MotionInfo::alloc(SInt32 x, SInt32 y
// IPrimaryScreen::WheelInfo
//
IPrimaryScreen::WheelInfo *IPrimaryScreen::WheelInfo::alloc(SInt32 xDelta, SInt32 yDelta)
IPrimaryScreen::WheelInfo *IPrimaryScreen::WheelInfo::alloc(int32_t xDelta, int32_t yDelta)
{
WheelInfo *info = (WheelInfo *)malloc(sizeof(WheelInfo));
info->m_xDelta = xDelta;

18
src/lib/deskflow/IPrimaryScreen.h
View file

@ -49,21 +49,21 @@ public:
class MotionInfo
{
public:
static MotionInfo *alloc(SInt32 x, SInt32 y);
static MotionInfo *alloc(int32_t x, int32_t y);
public:
SInt32 m_x;
SInt32 m_y;
int32_t m_x;
int32_t m_y;
};
//! Wheel motion event data
class WheelInfo
{
public:
static WheelInfo *alloc(SInt32 xDelta, SInt32 yDelta);
static WheelInfo *alloc(int32_t xDelta, int32_t yDelta);
public:
SInt32 m_xDelta;
SInt32 m_yDelta;
int32_t m_xDelta;
int32_t m_yDelta;
};
//! Hot key event data
class HotKeyInfo
@ -102,7 +102,7 @@ public:
discard input events up to and including the warp before
returning.
*/
virtual void warpCursor(SInt32 x, SInt32 y) = 0;
virtual void warpCursor(int32_t x, int32_t y) = 0;
//! Register a system hotkey
/*!
@ -157,7 +157,7 @@ public:
Return the jump zone size, the size of the regions on the edges of
the screen that cause the cursor to jump to another screen.
*/
virtual SInt32 getJumpZoneSize() const = 0;
virtual int32_t getJumpZoneSize() const = 0;
//! Test if mouse is pressed
/*!
@ -173,7 +173,7 @@ public:
cursor to compute cursor motion deltas and should be far from
the edges of the screen, typically the center.
*/
virtual void getCursorCenter(SInt32 &x, SInt32 &y) const = 0;
virtual void getCursorCenter(int32_t &x, int32_t &y) const = 0;
//@}
};

4
src/lib/deskflow/IScreen.h
View file

@ -60,13 +60,13 @@ public:
Return the position of the upper-left corner of the screen in \c x and
\c y and the size of the screen in \c width and \c height.
*/
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const = 0;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const = 0;
//! Get cursor position
/*!
Return the current position of the cursor in \c x and \c y.
*/
virtual void getCursorPos(SInt32 &x, SInt32 &y) const = 0;
virtual void getCursorPos(int32_t &x, int32_t &y) const = 0;
//@}
};

6
src/lib/deskflow/ISecondaryScreen.h
View file

@ -44,19 +44,19 @@ public:
/*!
Synthesize a mouse move to the absolute coordinates \c x,y.
*/
virtual void fakeMouseMove(SInt32 x, SInt32 y) = 0;
virtual void fakeMouseMove(int32_t x, int32_t y) = 0;
//! Fake mouse move
/*!
Synthesize a mouse move to the relative coordinates \c dx,dy.
*/
virtual void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const = 0;
virtual void fakeMouseRelativeMove(int32_t dx, int32_t dy) const = 0;
//! Fake mouse wheel
/*!
Synthesize a mouse wheel event of amount \c xDelta and \c yDelta.
*/
virtual void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const = 0;
virtual void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const = 0;
//@}
};

96
src/lib/deskflow/KeyMap.cpp
View file

@ -57,7 +57,7 @@ void KeyMap::swap(KeyMap &x)
m_modifierKeys.swap(x.m_modifierKeys);
m_halfDuplex.swap(x.m_halfDuplex);
m_halfDuplexMods.swap(x.m_halfDuplexMods);
SInt32 tmp1 = m_numGroups;
int32_t tmp1 = m_numGroups;
m_numGroups = x.m_numGroups;
x.m_numGroups = tmp1;
bool tmp2 = m_composeAcrossGroups;
@ -73,7 +73,7 @@ void KeyMap::addKeyEntry(const KeyItem &item)
}
// resize number of groups for key
SInt32 numGroups = item.m_group + 1;
int32_t numGroups = item.m_group + 1;
if (getNumGroups() > numGroups) {
numGroups = getNumGroups();
}
@ -110,7 +110,7 @@ void KeyMap::addKeyEntry(const KeyItem &item)
}
void KeyMap::addKeyAliasEntry(
KeyID targetID, SInt32 group, KeyModifierMask targetRequired, KeyModifierMask targetSensitive, KeyID sourceID,
KeyID targetID, int32_t group, KeyModifierMask targetRequired, KeyModifierMask targetSensitive, KeyID sourceID,
KeyModifierMask sourceRequired, KeyModifierMask sourceSensitive
)
{
@ -120,8 +120,8 @@ void KeyMap::addKeyAliasEntry(
}
// find a compatible source, preferably in the same group
for (SInt32 gd = 0, n = getNumGroups(); gd < n; ++gd) {
SInt32 eg = getEffectiveGroup(group, gd);
for (int32_t gd = 0, n = getNumGroups(); gd < n; ++gd) {
int32_t eg = getEffectiveGroup(group, gd);
const KeyItemList *sourceEntry = findCompatibleKey(sourceID, eg, sourceRequired, sourceSensitive);
if (sourceEntry != NULL && sourceEntry->size() == 1) {
KeyMap::KeyItem targetItem = sourceEntry->back();
@ -133,14 +133,14 @@ void KeyMap::addKeyAliasEntry(
}
}
bool KeyMap::addKeyCombinationEntry(KeyID id, SInt32 group, const KeyID *keys, UInt32 numKeys)
bool KeyMap::addKeyCombinationEntry(KeyID id, int32_t group, const KeyID *keys, UInt32 numKeys)
{
// disallow kKeyNone
if (id == kKeyNone) {
return false;
}
SInt32 numGroups = group + 1;
int32_t numGroups = group + 1;
if (getNumGroups() > numGroups) {
numGroups = getNumGroups();
}
@ -164,14 +164,14 @@ bool KeyMap::addKeyCombinationEntry(KeyID id, SInt32 group, const KeyID *keys, U
// if we allow group switching during composition then search all
// groups for keys, otherwise search just the given group.
SInt32 n = 1;
int32_t n = 1;
if (m_composeAcrossGroups) {
n = (SInt32)groupTable.size();
n = (int32_t)groupTable.size();
}
bool found = false;
for (SInt32 gd = 0; gd < n && !found; ++gd) {
SInt32 eg = (group + gd) % getNumGroups();
for (int32_t gd = 0; gd < n && !found; ++gd) {
int32_t eg = (group + gd) % getNumGroups();
const KeyEntryList &entries = groupTable[eg];
for (size_t j = 0; j < entries.size(); ++j) {
if (entries[j].size() == 1) {
@ -234,7 +234,7 @@ void KeyMap::foreachKey(ForeachKeyCallback cb, void *userData)
for (size_t j = 0; j < entryList.size(); ++j) {
KeyItemList &itemList = entryList[j];
for (size_t k = 0; k < itemList.size(); ++k) {
(*cb)(i->first, static_cast<SInt32>(group), itemList[k], userData);
(*cb)(i->first, static_cast<int32_t>(group), itemList[k], userData);
}
}
}
@ -242,7 +242,7 @@ void KeyMap::foreachKey(ForeachKeyCallback cb, void *userData)
}
const KeyMap::KeyItem *KeyMap::mapKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const
{
@ -315,9 +315,9 @@ void KeyMap::setLanguageData(std::vector<std::string> layouts)
m_keyboardLayouts = std::move(layouts);
}
SInt32 KeyMap::getLanguageGroupID(SInt32 group, const std::string &lang) const
int32_t KeyMap::getLanguageGroupID(int32_t group, const std::string &lang) const
{
SInt32 id = group;
int32_t id = group;
auto it = std::find(m_keyboardLayouts.begin(), m_keyboardLayouts.end(), lang);
if (it != m_keyboardLayouts.end()) {
@ -330,18 +330,18 @@ SInt32 KeyMap::getLanguageGroupID(SInt32 group, const std::string &lang) const
return id;
}
SInt32 KeyMap::getNumGroups() const
int32_t KeyMap::getNumGroups() const
{
return m_numGroups;
}
SInt32 KeyMap::getEffectiveGroup(SInt32 group, SInt32 offset) const
int32_t KeyMap::getEffectiveGroup(int32_t group, int32_t offset) const
{
return (group + offset + getNumGroups()) % getNumGroups();
}
const KeyMap::KeyItemList *
KeyMap::findCompatibleKey(KeyID id, SInt32 group, KeyModifierMask required, KeyModifierMask sensitive) const
KeyMap::findCompatibleKey(KeyID id, int32_t group, KeyModifierMask required, KeyModifierMask sensitive) const
{
assert(group >= 0 && group < getNumGroups());
@ -442,7 +442,7 @@ void KeyMap::initModifierKey(KeyItem &item)
}
}
SInt32 KeyMap::findNumGroups() const
int32_t KeyMap::findNumGroups() const
{
size_t max = 0;
for (KeyIDMap::const_iterator i = m_keyIDMap.begin(); i != m_keyIDMap.end(); ++i) {
@ -450,7 +450,7 @@ SInt32 KeyMap::findNumGroups() const
max = i->second.size();
}
}
return static_cast<SInt32>(max);
return static_cast<int32_t>(max);
}
void KeyMap::setModifierKeys()
@ -474,10 +474,10 @@ void KeyMap::setModifierKeys()
}
// add key to each indicated modifier in this group
for (SInt32 b = 0; b < kKeyModifierNumBits; ++b) {
for (int32_t b = 0; b < kKeyModifierNumBits; ++b) {
// skip if item doesn't generate bit b
if (((1u << b) & item.m_generates) != 0) {
SInt32 mIndex = (SInt32)g * kKeyModifierNumBits + b;
int32_t mIndex = (int32_t)g * kKeyModifierNumBits + b;
m_modifierKeys[mIndex].push_back(&item);
}
}
@ -487,7 +487,7 @@ void KeyMap::setModifierKeys()
}
const KeyMap::KeyItem *KeyMap::mapCommandKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const
{
@ -504,9 +504,9 @@ const KeyMap::KeyItem *KeyMap::mapCommandKey(
// find the first key that generates this KeyID
const KeyItem *keyItem = NULL;
SInt32 numGroups = getNumGroups();
for (SInt32 groupOffset = 0; groupOffset < numGroups; ++groupOffset) {
SInt32 effectiveGroup = getEffectiveGroup(group, groupOffset);
int32_t numGroups = getNumGroups();
for (int32_t groupOffset = 0; groupOffset < numGroups; ++groupOffset) {
int32_t effectiveGroup = getEffectiveGroup(group, groupOffset);
const KeyEntryList &entryList = keyGroupTable[effectiveGroup];
for (size_t i = 0; i < entryList.size(); ++i) {
if (entryList[i].size() != 1) {
@ -542,7 +542,7 @@ const KeyMap::KeyItem *KeyMap::mapCommandKey(
// make working copy of modifiers
ModifierToKeys newModifiers = activeModifiers;
KeyModifierMask newState = currentState;
SInt32 newGroup = group;
int32_t newGroup = group;
// don't try to change CapsLock
desiredMask = (desiredMask & ~KeyModifierCapsLock) | (currentState & KeyModifierCapsLock);
@ -571,12 +571,12 @@ const KeyMap::KeyItem *KeyMap::mapCommandKey(
}
const KeyMap::KeyItemList *
KeyMap::getKeyItemList(const KeyMap::KeyGroupTable &keyGroupTable, SInt32 group, KeyModifierMask desiredMask) const
KeyMap::getKeyItemList(const KeyMap::KeyGroupTable &keyGroupTable, int32_t group, KeyModifierMask desiredMask) const
{
const KeyItemList *itemList = nullptr;
// find best key in any group, starting with the active group
for (SInt32 groupOffset = 0; groupOffset < getNumGroups(); ++groupOffset) {
for (int32_t groupOffset = 0; groupOffset < getNumGroups(); ++groupOffset) {
auto effectiveGroup = getEffectiveGroup(group, groupOffset);
auto keyIndex = findBestKey(keyGroupTable[effectiveGroup], desiredMask);
if (keyIndex != -1) {
@ -590,7 +590,7 @@ KeyMap::getKeyItemList(const KeyMap::KeyGroupTable &keyGroupTable, SInt32 group,
}
const KeyMap::KeyItem *KeyMap::mapCharacterKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const
{
@ -616,7 +616,7 @@ const KeyMap::KeyItem *KeyMap::mapCharacterKey(
// make working copy of modifiers
ModifierToKeys newModifiers = activeModifiers;
KeyModifierMask newState = currentState;
SInt32 newGroup = group;
int32_t newGroup = group;
// add each key
for (size_t j = 0; j < itemList->size(); ++j) {
@ -641,24 +641,24 @@ const KeyMap::KeyItem *KeyMap::mapCharacterKey(
return &keyItem;
}
void KeyMap::addGroupToKeystroke(Keystrokes &keys, SInt32 &group, const std::string &lang) const
void KeyMap::addGroupToKeystroke(Keystrokes &keys, int32_t &group, const std::string &lang) const
{
group = getLanguageGroupID(group, lang);
keys.push_back(Keystroke(group, true, false));
}
const KeyMap::KeyItem *KeyMap::mapModifierKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const
{
return mapCharacterKey(keys, id, group, activeModifiers, currentState, desiredMask, isAutoRepeat, lang);
}
SInt32 KeyMap::findBestKey(const KeyEntryList &entryList, KeyModifierMask desiredState) const
int32_t KeyMap::findBestKey(const KeyEntryList &entryList, KeyModifierMask desiredState) const
{
// check for an item that can accommodate the desiredState exactly
for (SInt32 i = 0; i < (SInt32)entryList.size(); ++i) {
for (int32_t i = 0; i < (int32_t)entryList.size(); ++i) {
const KeyItem &item = entryList[i].back();
if ((item.m_required & desiredState) == item.m_required &&
(item.m_required & desiredState) == (item.m_sensitive & desiredState)) {
@ -668,12 +668,12 @@ SInt32 KeyMap::findBestKey(const KeyEntryList &entryList, KeyModifierMask desire
}
// choose the item that requires the fewest modifier changes
SInt32 bestCount = 32;
SInt32 bestIndex = -1;
for (SInt32 i = 0; i < (SInt32)entryList.size(); ++i) {
int32_t bestCount = 32;
int32_t bestIndex = -1;
for (int32_t i = 0; i < (int32_t)entryList.size(); ++i) {
const KeyItem &item = entryList[i].back();
KeyModifierMask change = ((item.m_required ^ desiredState) & item.m_sensitive);
SInt32 n = getNumModifiers(change);
int32_t n = getNumModifiers(change);
if (n < bestCount) {
bestCount = n;
bestIndex = i;
@ -686,7 +686,7 @@ SInt32 KeyMap::findBestKey(const KeyEntryList &entryList, KeyModifierMask desire
return bestIndex;
}
const KeyMap::KeyItem *KeyMap::keyForModifier(KeyButton button, SInt32 group, SInt32 modifierBit) const
const KeyMap::KeyItem *KeyMap::keyForModifier(KeyButton button, int32_t group, int32_t modifierBit) const
{
assert(modifierBit >= 0 && modifierBit < kKeyModifierNumBits);
assert(group >= 0 && group < getNumGroups());
@ -706,7 +706,7 @@ const KeyMap::KeyItem *KeyMap::keyForModifier(KeyButton button, SInt32 group, SI
}
bool KeyMap::keysForKeyItem(
const KeyItem &keyItem, SInt32 &group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const KeyItem &keyItem, int32_t &group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredState, KeyModifierMask overrideModifiers, bool isAutoRepeat, Keystrokes &keystrokes,
const std::string &lang
) const
@ -782,7 +782,7 @@ bool KeyMap::keysForKeyItem(
}
bool KeyMap::keysToRestoreModifiers(
const KeyItem &keyItem, SInt32, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const KeyItem &keyItem, int32_t, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const ModifierToKeys &desiredModifiers, Keystrokes &keystrokes
) const
{
@ -823,7 +823,7 @@ bool KeyMap::keysToRestoreModifiers(
}
bool KeyMap::keysForModifierState(
KeyButton button, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyButton button, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask requiredState, KeyModifierMask sensitiveMask, KeyModifierMask notRequiredMask,
Keystrokes &keystrokes
) const
@ -850,7 +850,7 @@ bool KeyMap::keysForModifierState(
// we'll assume that modifiers with higher bits are affected by modifiers
// with lower bits. there's not much basis for that assumption except
// that we're pretty sure shift isn't changed by other modifiers.
SInt32 bit = kKeyModifierNumBits;
int32_t bit = kKeyModifierNumBits;
while (bit-- > 0) {
KeyModifierMask mask = (1u << bit);
if ((flipMask & mask) == 0) {
@ -1016,9 +1016,9 @@ void KeyMap::addKeystrokes(
}
}
SInt32 KeyMap::getNumModifiers(KeyModifierMask state)
int32_t KeyMap::getNumModifiers(KeyModifierMask state)
{
SInt32 n = 0;
int32_t n = 0;
for (; state != 0; state >>= 1) {
if ((state & 1) != 0) {
++n;
@ -1096,7 +1096,7 @@ std::string KeyMap::formatKey(KeyID key, KeyModifierMask mask)
initKeyNameMaps();
std::string x;
for (SInt32 i = 0; i < kKeyModifierNumBits; ++i) {
for (int32_t i = 0; i < kKeyModifierNumBits; ++i) {
KeyModifierMask mod = (1u << i);
if ((mask & mod) != 0 && s_modifierToNameMap->count(mod) > 0) {
x += s_modifierToNameMap->find(mod)->second;
@ -1253,7 +1253,7 @@ KeyMap::Keystroke::Keystroke(KeyButton button, bool press, bool repeat, UInt32 d
m_data.m_button.m_client = data;
}
KeyMap::Keystroke::Keystroke(SInt32 group, bool absolute, bool restore) : m_type(kGroup)
KeyMap::Keystroke::Keystroke(int32_t group, bool absolute, bool restore) : m_type(kGroup)
{
m_data.m_group.m_group = group;
m_data.m_group.m_absolute = absolute;

48
src/lib/deskflow/KeyMap.h
View file

@ -53,7 +53,7 @@ public:
{
public:
KeyID m_id{}; //!< KeyID
SInt32 m_group{}; //!< Group for key
int32_t m_group{}; //!< Group for key
KeyButton m_button{}; //!< Button to generate KeyID
KeyModifierMask m_required{}; //!< Modifiers required for KeyID
KeyModifierMask m_sensitive{}; //!< Modifiers key is sensitive to
@ -89,7 +89,7 @@ public:
};
Keystroke(KeyButton, bool press, bool repeat, UInt32 clientData);
Keystroke(SInt32 group, bool absolute, bool restore);
Keystroke(int32_t group, bool absolute, bool restore);
public:
struct Button
@ -103,7 +103,7 @@ public:
struct Group
{
public:
SInt32 m_group{}; //!< Group/offset to change to/by
int32_t m_group{}; //!< Group/offset to change to/by
bool m_absolute{}; //!< \c true iff change to, else by
bool m_restore{}; //!< \c true iff for restoring state
};
@ -128,7 +128,7 @@ public:
using ButtonToKeyMap = std::map<KeyButton, const KeyItem *>;
//! Callback type for \c foreachKey
typedef void (*ForeachKeyCallback)(KeyID, SInt32 group, KeyItem &, void *userData);
typedef void (*ForeachKeyCallback)(KeyID, int32_t group, KeyItem &, void *userData);
//! @name manipulators
//@{
@ -154,7 +154,7 @@ public:
can generate \p targetID using \p sourceID).
*/
void addKeyAliasEntry(
KeyID targetID, SInt32 group, KeyModifierMask targetRequired, KeyModifierMask targetSensitive, KeyID sourceID,
KeyID targetID, int32_t group, KeyModifierMask targetRequired, KeyModifierMask targetSensitive, KeyID sourceID,
KeyModifierMask sourceRequired, KeyModifierMask sourceSensitive
);
@ -168,7 +168,7 @@ public:
least one key in \p keys is not in the map then nothing is added
and this returns \c false, otherwise it returns \c true.
*/
bool addKeyCombinationEntry(KeyID id, SInt32 group, const KeyID *keys, UInt32 numKeys);
bool addKeyCombinationEntry(KeyID id, int32_t group, const KeyID *keys, UInt32 numKeys);
//! Enable composition across groups
/*!
@ -224,7 +224,7 @@ public:
pressed/repeated, or NULL if the key cannot be mapped.
*/
virtual const KeyItem *mapKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const;
@ -234,13 +234,13 @@ public:
/*!
Returns the number of keyboard groups (independent layouts) in the map.
*/
SInt32 getNumGroups() const;
int32_t getNumGroups() const;
//! Compute a group number
/*!
Returns the number of the group \p offset groups after group \p group.
*/
SInt32 getEffectiveGroup(SInt32 group, SInt32 offset) const;
int32_t getEffectiveGroup(int32_t group, int32_t offset) const;
//! Find key entry compatible with modifiers
/*!
@ -252,7 +252,7 @@ public:
for every modifier indicated by \p sensitive.
*/
const KeyItemList *
findCompatibleKey(KeyID id, SInt32 group, KeyModifierMask required, KeyModifierMask sensitive) const;
findCompatibleKey(KeyID id, int32_t group, KeyModifierMask required, KeyModifierMask sensitive) const;
//! Test if modifier is half-duplex
/*!
@ -356,7 +356,7 @@ private:
using KeyEntryList = std::vector<KeyItemList>;
// computes the number of groups
SInt32 findNumGroups() const;
int32_t findNumGroups() const;
// computes the map of modifiers to the keys that generate the modifiers
void setModifierKeys();
@ -368,7 +368,7 @@ private:
// to what character they would synthesize. we disallow multikey
// entries since they don't make sense as hotkeys.
const KeyItem *mapCommandKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const;
@ -376,32 +376,32 @@ private:
// particular KeyID and isn't entirely concerned with the modifiers
// used to do it.
const KeyItem *mapCharacterKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const;
// maps a modifier key
const KeyItem *mapModifierKey(
Keystrokes &keys, KeyID id, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
Keystrokes &keys, KeyID id, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
) const;
// returns the index into \p entryList of the KeyItemList requiring
// the fewest modifier changes between \p currentState and
// \p desiredState.
SInt32 findBestKey(const KeyEntryList &entryList, KeyModifierMask desiredState) const;
int32_t findBestKey(const KeyEntryList &entryList, KeyModifierMask desiredState) const;
// gets the \c KeyItem used to synthesize the modifier who's bit is
// given by \p modifierBit in group \p group and does not synthesize
// the key \p button.
const KeyItem *keyForModifier(KeyButton button, SInt32 group, SInt32 modifierBit) const;
const KeyItem *keyForModifier(KeyButton button, int32_t group, int32_t modifierBit) const;
// fills \p keystrokes with the keys to synthesize the key in
// \p keyItem taking the modifiers into account. returns \c true
// iff successful and sets \p currentState to the
// resulting modifier state.
bool keysForKeyItem(
const KeyItem &keyItem, SInt32 &group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const KeyItem &keyItem, int32_t &group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask desiredState, KeyModifierMask overrideModifiers, bool isAutoRepeat, Keystrokes &keystrokes,
const std::string &lang
) const;
@ -411,7 +411,7 @@ private:
// \p activeModifiers not including the key in \p keyItem.
// returns \c true iff successful.
bool keysToRestoreModifiers(
const KeyItem &keyItem, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const KeyItem &keyItem, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
const ModifierToKeys &desiredModifiers, Keystrokes &keystrokes
) const;
@ -421,7 +421,7 @@ private:
// returns \c true iff successful and sets \p currentState to the
// resulting modifier state.
bool keysForModifierState(
KeyButton button, SInt32 group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyButton button, int32_t group, ModifierToKeys &activeModifiers, KeyModifierMask &currentState,
KeyModifierMask requiredState, KeyModifierMask sensitiveMask, KeyModifierMask notRequiredMask,
Keystrokes &keystrokes
) const;
@ -434,7 +434,7 @@ private:
) const;
// Returns the number of modifiers indicated in \p state.
static SInt32 getNumModifiers(KeyModifierMask state);
static int32_t getNumModifiers(KeyModifierMask state);
// Initialize key name/id maps
static void initKeyNameMaps();
@ -442,11 +442,11 @@ private:
// Ways to synthesize a KeyID over multiple keyboard groups
using KeyGroupTable = std::vector<KeyEntryList>;
void addGroupToKeystroke(Keystrokes &keys, SInt32 &group, const std::string &lang) const;
void addGroupToKeystroke(Keystrokes &keys, int32_t &group, const std::string &lang) const;
SInt32 getLanguageGroupID(SInt32 group, const std::string &lang) const;
int32_t getLanguageGroupID(int32_t group, const std::string &lang) const;
const KeyItemList *
getKeyItemList(const KeyGroupTable &keyGroupTable, SInt32 group, KeyModifierMask desiredMask) const;
getKeyItemList(const KeyGroupTable &keyGroupTable, int32_t group, KeyModifierMask desiredMask) const;
// not implemented
KeyMap(const KeyMap &);
@ -476,7 +476,7 @@ private:
// KeyID info
KeyIDMap m_keyIDMap;
SInt32 m_numGroups;
int32_t m_numGroups;
ModifierToKeyTable m_modifierKeys;
// composition info

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

@ -716,7 +716,7 @@ void KeyState::onKey(KeyButton button, bool down, KeyModifierMask newState)
}
void KeyState::sendKeyEvent(
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, int32_t count, KeyButton button
)
{
if (m_keyMap.isHalfDuplex(key, button)) {
@ -781,7 +781,7 @@ void KeyState::updateKeyState()
LOG((CLOG_DEBUG1 "modifiers on update: 0x%04x", m_mask));
}
void KeyState::addActiveModifierCB(KeyID, SInt32 group, deskflow::KeyMap::KeyItem &keyItem, void *vcontext)
void KeyState::addActiveModifierCB(KeyID, int32_t group, deskflow::KeyMap::KeyItem &keyItem, void *vcontext)
{
AddActiveModifierContext *context = static_cast<AddActiveModifierContext *>(vcontext);
if (group == context->m_activeGroup && (keyItem.m_generates & context->m_mask) != 0) {
@ -850,7 +850,7 @@ void KeyState::fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton serverID, c
fakeKeys(keys, 1);
}
bool KeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton serverID, const std::string &lang)
bool KeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton serverID, const std::string &lang)
{
LOG((CLOG_DEBUG2 "fakeKeyRepeat"));
serverID &= kButtonMask;
@ -986,7 +986,7 @@ KeyModifierMask &KeyState::getActiveModifiersRValue()
return m_mask;
}
SInt32 KeyState::getEffectiveGroup(SInt32 group, SInt32 offset) const
int32_t KeyState::getEffectiveGroup(int32_t group, int32_t offset) const
{
return m_keyMap.getEffectiveGroup(group, offset);
}
@ -1004,7 +1004,7 @@ bool KeyState::isIgnoredKey(KeyID key, KeyModifierMask) const
}
}
KeyButton KeyState::getButton(KeyID id, SInt32 group) const
KeyButton KeyState::getButton(KeyID id, int32_t group) const
{
const deskflow::KeyMap::KeyItemList *items = m_keyMap.findCompatibleKey(id, group, 0, 0);
if (items == NULL) {
@ -1016,7 +1016,7 @@ KeyButton KeyState::getButton(KeyID id, SInt32 group) const
void KeyState::addAliasEntries()
{
for (SInt32 g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
for (int32_t g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
// if we can't shift any kKeyTab key in a particular group but we can
// shift kKeyLeftTab then add a shifted kKeyTab entry that matches a
// shifted kKeyLeftTab entry.
@ -1037,7 +1037,7 @@ void KeyState::addKeypadEntries()
{
// map every numpad key to its equivalent non-numpad key if it's not
// on the keyboard.
for (SInt32 g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
for (int32_t g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
for (size_t i = 0; i < sizeof(s_numpadTable) / sizeof(s_numpadTable[0]); i += 2) {
m_keyMap.addKeyCombinationEntry(s_numpadTable[i], g, s_numpadTable + i + 1, 1);
}
@ -1046,7 +1046,7 @@ void KeyState::addKeypadEntries()
void KeyState::addCombinationEntries()
{
for (SInt32 g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
for (int32_t g = 0, n = m_keyMap.getNumGroups(); g < n; ++g) {
// add dead and compose key composition sequences
const KeyID *i = s_decomposeTable;
while (*i != 0) {
@ -1148,7 +1148,7 @@ void KeyState::updateModifierKeyState(
//
KeyState::AddActiveModifierContext::AddActiveModifierContext(
SInt32 group, KeyModifierMask mask, ModifierToKeys &activeModifiers
int32_t group, KeyModifierMask mask, ModifierToKeys &activeModifiers
)
: m_activeGroup(group),
m_mask(mask),

22
src/lib/deskflow/KeyState.h
View file

@ -52,7 +52,7 @@ public:
to the superclass.
*/
virtual void sendKeyEvent(
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, int32_t count, KeyButton button
);
//@}
@ -70,7 +70,7 @@ public:
void updateKeyState() override;
void setHalfDuplexMask(KeyModifierMask) override;
void fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std::string &lang) override;
bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang) override;
bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang) override;
bool fakeKeyUp(KeyButton button) override;
void fakeAllKeysUp() override;
bool fakeMediaKey(KeyID id) override;
@ -80,10 +80,10 @@ public:
// Left abstract
virtual bool fakeCtrlAltDel() override = 0;
virtual KeyModifierMask pollActiveModifiers() const override = 0;
virtual SInt32 pollActiveGroup() const override = 0;
virtual int32_t pollActiveGroup() const override = 0;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const override = 0;
SInt32 getKeyState(KeyButton keyButton)
int32_t getKeyState(KeyButton keyButton)
{
return m_keys[keyButton];
}
@ -121,7 +121,7 @@ protected:
/*!
Returns the number of the group \p offset groups after group \p group.
*/
SInt32 getEffectiveGroup(SInt32 group, SInt32 offset) const;
int32_t getEffectiveGroup(int32_t group, int32_t offset) const;
//! Check if key is ignored
/*!
@ -135,7 +135,7 @@ protected:
Return the button mapped to key \p id in group \p group if any,
otherwise returns 0.
*/
KeyButton getButton(KeyID id, SInt32 group) const;
KeyButton getButton(KeyID id, int32_t group) const;
//@}
@ -147,10 +147,10 @@ public:
struct AddActiveModifierContext
{
public:
AddActiveModifierContext(SInt32 group, KeyModifierMask mask, ModifierToKeys &activeModifiers);
AddActiveModifierContext(int32_t group, KeyModifierMask mask, ModifierToKeys &activeModifiers);
public:
SInt32 m_activeGroup;
int32_t m_activeGroup;
KeyModifierMask m_mask;
ModifierToKeys &m_activeModifiers;
@ -197,7 +197,7 @@ private:
void updateModifierKeyState(KeyButton button, const ModifierToKeys &oldModifiers, const ModifierToKeys &newModifiers);
// active modifiers collection callback
static void addActiveModifierCB(KeyID id, SInt32 group, deskflow::KeyMap::KeyItem &keyItem, void *vcontext);
static void addActiveModifierCB(KeyID id, int32_t group, deskflow::KeyMap::KeyItem &keyItem, void *vcontext);
private:
// must be declared before m_keyMap. used when this class owns the key map.
@ -215,13 +215,13 @@ private:
// current keyboard state (> 0 if pressed, 0 otherwise). this is
// initialized to the keyboard state according to the system then
// it tracks synthesized events.
SInt32 m_keys[kNumButtons];
int32_t m_keys[kNumButtons];
// synthetic keyboard state (> 0 if pressed, 0 otherwise). this
// tracks the synthesized keyboard state. if m_keys[n] > 0 but
// m_syntheticKeys[n] == 0 then the key was pressed locally and
// not synthesized yet.
SInt32 m_syntheticKeys[kNumButtons];
int32_t m_syntheticKeys[kNumButtons];
// client data for each pressed key
UInt32 m_keyClientData[kNumButtons];

6
src/lib/deskflow/PlatformScreen.cpp
View file

@ -55,7 +55,7 @@ void PlatformScreen::fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton butto
}
bool PlatformScreen::fakeKeyRepeat(
KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang
KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang
)
{
return getKeyState()->fakeKeyRepeat(id, mask, count, button, lang);
@ -91,7 +91,7 @@ KeyModifierMask PlatformScreen::pollActiveModifiers() const
return getKeyState()->pollActiveModifiers();
}
SInt32 PlatformScreen::pollActiveGroup() const
int32_t PlatformScreen::pollActiveGroup() const
{
return getKeyState()->pollActiveGroup();
}
@ -109,7 +109,7 @@ bool PlatformScreen::isDraggingStarted()
return false;
}
SInt32 PlatformScreen::mapClientScrollDirection(SInt32 x) const
int32_t PlatformScreen::mapClientScrollDirection(int32_t x) const
{
return (x * m_clientScrollDirection);
}

22
src/lib/deskflow/PlatformScreen.h
View file

@ -40,39 +40,39 @@ public:
// IScreen overrides
virtual void *getEventTarget() const = 0;
virtual bool getClipboard(ClipboardID id, IClipboard *) const = 0;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const = 0;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const = 0;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const = 0;
virtual void getCursorPos(int32_t &x, int32_t &y) const = 0;
// IPrimaryScreen overrides
virtual void reconfigure(UInt32 activeSides) = 0;
virtual void warpCursor(SInt32 x, SInt32 y) = 0;
virtual void warpCursor(int32_t x, int32_t y) = 0;
virtual UInt32 registerHotKey(KeyID key, KeyModifierMask mask) = 0;
virtual void unregisterHotKey(UInt32 id) = 0;
virtual void fakeInputBegin() = 0;
virtual void fakeInputEnd() = 0;
virtual SInt32 getJumpZoneSize() const = 0;
virtual int32_t getJumpZoneSize() const = 0;
virtual bool isAnyMouseButtonDown(UInt32 &buttonID) const = 0;
virtual void getCursorCenter(SInt32 &x, SInt32 &y) const = 0;
virtual void getCursorCenter(int32_t &x, int32_t &y) const = 0;
// ISecondaryScreen overrides
virtual void fakeMouseButton(ButtonID id, bool press) = 0;
virtual void fakeMouseMove(SInt32 x, SInt32 y) = 0;
virtual void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const = 0;
virtual void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const = 0;
virtual void fakeMouseMove(int32_t x, int32_t y) = 0;
virtual void fakeMouseRelativeMove(int32_t dx, int32_t dy) const = 0;
virtual void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const = 0;
// IKeyState overrides
virtual void updateKeyMap();
virtual void updateKeyState();
virtual void setHalfDuplexMask(KeyModifierMask);
virtual void fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std::string &);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang);
virtual bool fakeKeyUp(KeyButton button);
virtual void fakeAllKeysUp();
virtual bool fakeCtrlAltDel();
virtual bool isKeyDown(KeyButton) const;
virtual KeyModifierMask getActiveModifiers() const;
virtual KeyModifierMask pollActiveModifiers() const;
virtual SInt32 pollActiveGroup() const;
virtual int32_t pollActiveGroup() const;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const;
virtual void setDraggingStarted(bool started)
@ -140,7 +140,7 @@ protected:
* Convert scroll according to client scroll directio
* \return converted value according to the client scroll direction
*/
virtual SInt32 mapClientScrollDirection(SInt32) const;
virtual int32_t mapClientScrollDirection(int32_t) const;
protected:
std::string m_draggingFilename;

6
src/lib/deskflow/ProtocolUtil.h
View file

@ -64,9 +64,9 @@ public:
Format specifiers are:
- \%\% -- read (and discard) a literal `\%'
- \%1i -- reads a 1 byte integer; argument is a SInt32* or UInt32*
- \%2i -- reads an NBO 2 byte integer; arg is SInt32* or UInt32*
- \%4i -- reads an NBO 4 byte integer; arg is SInt32* or UInt32*
- \%1i -- reads a 1 byte integer; argument is a int32_t* or UInt32*
- \%2i -- reads an NBO 2 byte integer; arg is int32_t* or UInt32*
- \%4i -- reads an NBO 4 byte integer; arg is int32_t* or UInt32*
- \%1I -- reads 1 byte integers; arg is std::vector<uint8_t>*
- \%2I -- reads NBO 2 byte integers; arg is std::vector<uint16_t>*
- \%4I -- reads NBO 4 byte integers; arg is std::vector<UInt32>*

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

@ -177,7 +177,7 @@ void Screen::reconfigure(UInt32 activeSides)
m_screen->reconfigure(activeSides);
}
void Screen::warpCursor(SInt32 x, SInt32 y)
void Screen::warpCursor(int32_t x, int32_t y)
{
assert(m_isPrimary);
m_screen->warpCursor(x, y);
@ -210,7 +210,7 @@ void Screen::keyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std
m_screen->fakeKeyDown(id, mask, button, lang);
}
void Screen::keyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang)
void Screen::keyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang)
{
assert(!m_isPrimary);
m_screen->fakeKeyRepeat(id, mask, count, button, lang);
@ -231,19 +231,19 @@ void Screen::mouseUp(ButtonID button)
m_screen->fakeMouseButton(button, false);
}
void Screen::mouseMove(SInt32 x, SInt32 y)
void Screen::mouseMove(int32_t x, int32_t y)
{
assert(!m_isPrimary);
m_screen->fakeMouseMove(x, y);
}
void Screen::mouseRelativeMove(SInt32 dx, SInt32 dy)
void Screen::mouseRelativeMove(int32_t dx, int32_t dy)
{
assert(!m_isPrimary);
m_screen->fakeMouseRelativeMove(dx, dy);
}
void Screen::mouseWheel(SInt32 xDelta, SInt32 yDelta) const
void Screen::mouseWheel(int32_t xDelta, int32_t yDelta) const
{
assert(!m_isPrimary);
m_screen->fakeMouseWheel(xDelta, yDelta);
@ -351,7 +351,7 @@ bool Screen::isLockedToScreen() const
return false;
}
SInt32 Screen::getJumpZoneSize() const
int32_t Screen::getJumpZoneSize() const
{
if (!m_isPrimary) {
return 0;
@ -360,7 +360,7 @@ SInt32 Screen::getJumpZoneSize() const
}
}
void Screen::getCursorCenter(SInt32 &x, SInt32 &y) const
void Screen::getCursorCenter(int32_t &x, int32_t &y) const
{
m_screen->getCursorCenter(x, y);
}
@ -425,12 +425,12 @@ bool Screen::getClipboard(ClipboardID id, IClipboard *clipboard) const
return m_screen->getClipboard(id, clipboard);
}
void Screen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void Screen::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
m_screen->getShape(x, y, w, h);
}
void Screen::getCursorPos(SInt32 &x, SInt32 &y) const
void Screen::getCursorPos(int32_t &x, int32_t &y) const
{
m_screen->getCursorPos(x, y);
}

18
src/lib/deskflow/Screen.h
View file

@ -98,7 +98,7 @@ public:
discards input events up to and including the warp before
returning.
*/
void warpCursor(SInt32 x, SInt32 y);
void warpCursor(int32_t x, int32_t y);
//! Set clipboard
/*!
@ -136,7 +136,7 @@ public:
Synthesize key events to generate a press and release of key \c id
\c count times. If possible match the given modifier mask.
*/
void keyRepeat(KeyID id, KeyModifierMask, SInt32 count, KeyButton, const std::string &lang);
void keyRepeat(KeyID id, KeyModifierMask, int32_t count, KeyButton, const std::string &lang);
//! Notify of key release
/*!
@ -162,14 +162,14 @@ public:
Synthesize mouse events to generate mouse motion to the absolute
screen position \c xAbs,yAbs.
*/
void mouseMove(SInt32 xAbs, SInt32 yAbs);
void mouseMove(int32_t xAbs, int32_t yAbs);
//! Notify of mouse motion
/*!
Synthesize mouse events to generate mouse motion by the relative
amount \c xRel,yRel.
*/
void mouseRelativeMove(SInt32 xRel, SInt32 yRel);
void mouseRelativeMove(int32_t xRel, int32_t yRel);
//! Notify of mouse wheel motion
/*!
@ -178,7 +178,7 @@ public:
to the right and negative for motion towards the user or to the left.
Each wheel click should generate a delta of +/-120.
*/
void mouseWheel(SInt32 xDelta, SInt32 yDelta) const;
void mouseWheel(int32_t xDelta, int32_t yDelta) const;
//! Notify of options changes
/*!
@ -266,7 +266,7 @@ public:
Return the jump zone size, the size of the regions on the edges of
the screen that cause the cursor to jump to another screen.
*/
SInt32 getJumpZoneSize() const;
int32_t getJumpZoneSize() const;
//! Get cursor center position
/*!
@ -274,7 +274,7 @@ public:
cursor to compute cursor motion deltas and should be far from
the edges of the screen, typically the center.
*/
void getCursorCenter(SInt32 &x, SInt32 &y) const;
void getCursorCenter(int32_t &x, int32_t &y) const;
//! Get the active modifiers
/*!
@ -310,8 +310,8 @@ public:
// IScreen overrides
virtual void *getEventTarget() const;
virtual bool getClipboard(ClipboardID id, IClipboard *) const;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const;
virtual void getCursorPos(int32_t &x, int32_t &y) const;
IPlatformScreen *getPlatformScreen()
{

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

@ -93,7 +93,7 @@ static const UInt32 kKeyModifierBitLevel5Lock = 6;
static const UInt32 kKeyModifierBitCapsLock = 12;
static const UInt32 kKeyModifierBitNumLock = 13;
static const UInt32 kKeyModifierBitScrollLock = 14;
static const SInt32 kKeyModifierNumBits = 16;
static const int32_t kKeyModifierNumBits = 16;
//@}
//! @name Modifier key identifiers

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

@ -31,7 +31,7 @@ using OptionID = UInt32;
/*!
Type to hold an option value.
*/
using OptionValue = SInt32;
using OptionValue = int32_t;
// for now, options are just pairs of integers
using OptionsList = std::vector<UInt32>;

8
src/lib/deskflow/protocol_types.h
View file

@ -364,20 +364,20 @@ public:
The position of the upper-left corner of the screen. This is
typically 0,0.
*/
SInt32 m_x, m_y;
int32_t m_x, m_y;
//! Screen size
/*!
The size of the screen in pixels.
*/
SInt32 m_w, m_h;
int32_t m_w, m_h;
//! Obsolete (jump zone size)
SInt32 obsolete1;
int32_t obsolete1;
//! Mouse position
/*!
The current location of the mouse cursor.
*/
SInt32 m_mx, m_my;
int32_t m_mx, m_my;
};

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

@ -79,8 +79,8 @@ std::string MSWindowsClipboardHTMLConverter::doToIClipboard(const std::string &d
}
// convert args to integers
SInt32 start = (SInt32)atoi(startArg.c_str());
SInt32 end = (SInt32)atoi(endArg.c_str());
int32_t start = (int32_t)atoi(startArg.c_str());
int32_t end = (int32_t)atoi(endArg.c_str());
if (start <= 0 || end <= 0 || start >= end) {
return std::string();
}

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

@ -222,7 +222,7 @@ void MSWindowsDesks::updateKeys()
}
void MSWindowsDesks::setShape(
SInt32 x, SInt32 y, SInt32 width, SInt32 height, SInt32 xCenter, SInt32 yCenter, bool isMultimon
int32_t x, int32_t y, int32_t width, int32_t height, int32_t xCenter, int32_t yCenter, bool isMultimon
)
{
m_x = x;
@ -252,7 +252,7 @@ void MSWindowsDesks::fakeInputEnd()
sendMessage(DESKFLOW_MSG_FAKE_INPUT, 0, 0);
}
void MSWindowsDesks::getCursorPos(SInt32 &x, SInt32 &y) const
void MSWindowsDesks::getCursorPos(int32_t &x, int32_t &y) const
{
POINT pos;
sendMessage(DESKFLOW_MSG_CURSOR_POS, reinterpret_cast<WPARAM>(&pos), 0);
@ -317,17 +317,17 @@ void MSWindowsDesks::fakeMouseButton(ButtonID button, bool press)
sendMessage(DESKFLOW_MSG_FAKE_BUTTON, flags, data);
}
void MSWindowsDesks::fakeMouseMove(SInt32 x, SInt32 y) const
void MSWindowsDesks::fakeMouseMove(int32_t x, int32_t y) const
{
sendMessage(DESKFLOW_MSG_FAKE_MOVE, static_cast<WPARAM>(x), static_cast<LPARAM>(y));
}
void MSWindowsDesks::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
void MSWindowsDesks::fakeMouseRelativeMove(int32_t dx, int32_t dy) const
{
sendMessage(DESKFLOW_MSG_FAKE_REL_MOVE, static_cast<WPARAM>(dx), static_cast<LPARAM>(dy));
}
void MSWindowsDesks::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
void MSWindowsDesks::fakeMouseWheel(int32_t xDelta, int32_t yDelta) const
{
sendMessage(DESKFLOW_MSG_FAKE_WHEEL, xDelta, yDelta);
}
@ -434,20 +434,20 @@ LRESULT CALLBACK MSWindowsDesks::secondaryDeskProc(HWND hwnd, UINT msg, WPARAM w
return DefWindowProc(hwnd, msg, wParam, lParam);
}
void MSWindowsDesks::deskMouseMove(SInt32 x, SInt32 y) const
void MSWindowsDesks::deskMouseMove(int32_t x, int32_t y) const
{
// when using absolute positioning with mouse_event(),
// the normalized device coordinates range over only
// the primary screen.
SInt32 w = GetSystemMetrics(SM_CXSCREEN);
SInt32 h = GetSystemMetrics(SM_CYSCREEN);
int32_t w = GetSystemMetrics(SM_CXSCREEN);
int32_t h = GetSystemMetrics(SM_CYSCREEN);
send_mouse_input(
MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, (DWORD)((65535.0f * x) / (w - 1) + 0.5f),
(DWORD)((65535.0f * y) / (h - 1) + 0.5f), 0
);
}
void MSWindowsDesks::deskMouseRelativeMove(SInt32 dx, SInt32 dy) const
void MSWindowsDesks::deskMouseRelativeMove(int32_t dx, int32_t dy) const
{
// relative moves are subject to cursor acceleration which we don't
// want.so we disable acceleration, do the relative move, then
@ -666,11 +666,11 @@ void MSWindowsDesks::deskThread(void *vdesk)
break;
case DESKFLOW_MSG_FAKE_MOVE:
deskMouseMove(static_cast<SInt32>(msg.wParam), static_cast<SInt32>(msg.lParam));
deskMouseMove(static_cast<int32_t>(msg.wParam), static_cast<int32_t>(msg.lParam));
break;
case DESKFLOW_MSG_FAKE_REL_MOVE:
deskMouseRelativeMove(static_cast<SInt32>(msg.wParam), static_cast<SInt32>(msg.lParam));
deskMouseRelativeMove(static_cast<int32_t>(msg.wParam), static_cast<int32_t>(msg.lParam));
break;
case DESKFLOW_MSG_FAKE_WHEEL:

20
src/lib/platform/MSWindowsDesks.h
View file

@ -126,7 +126,7 @@ public:
/*!
This tells the desks that the display size has changed.
*/
void setShape(SInt32 x, SInt32 y, SInt32 width, SInt32 height, SInt32 xCenter, SInt32 yCenter, bool isMultimon);
void setShape(int32_t x, int32_t y, int32_t width, int32_t height, int32_t xCenter, int32_t yCenter, bool isMultimon);
//! Install/uninstall screensaver hooks
/*!
@ -156,7 +156,7 @@ public:
/*!
Return the current position of the cursor in \c x and \c y.
*/
void getCursorPos(SInt32 &x, SInt32 &y) const;
void getCursorPos(int32_t &x, int32_t &y) const;
//! Fake key press/release
/*!
@ -174,19 +174,19 @@ public:
/*!
Synthesize a mouse move to the absolute coordinates \c x,y.
*/
void fakeMouseMove(SInt32 x, SInt32 y) const;
void fakeMouseMove(int32_t x, int32_t y) const;
//! Fake mouse move
/*!
Synthesize a mouse move to the relative coordinates \c dx,dy.
*/
void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const;
void fakeMouseRelativeMove(int32_t dx, int32_t dy) const;
//! Fake mouse wheel
/*!
Synthesize a mouse wheel event of amount \c delta in direction \c axis.
*/
void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const;
void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const;
//@}
@ -214,8 +214,8 @@ private:
void destroyWindow(HWND) const;
// message handlers
void deskMouseMove(SInt32 x, SInt32 y) const;
void deskMouseRelativeMove(SInt32 dx, SInt32 dy) const;
void deskMouseMove(int32_t x, int32_t y) const;
void deskMouseRelativeMove(int32_t dx, int32_t dy) const;
void deskEnter(Desk *desk);
void deskLeave(Desk *desk, HKL keyLayout);
void deskThread(void *vdesk);
@ -258,9 +258,9 @@ private:
HCURSOR m_cursor;
// screen shape stuff
SInt32 m_x, m_y;
SInt32 m_w, m_h;
SInt32 m_xCenter, m_yCenter;
int32_t m_x, m_y;
int32_t m_w, m_h;
int32_t m_xCenter, m_yCenter;
// true if system appears to have multiple monitors
bool m_multimon;

20
src/lib/platform/MSWindowsHook.cpp
View file

@ -31,11 +31,11 @@ static HHOOK g_mouseLL = NULL;
static bool g_screenSaver = false;
static EHookMode g_mode = kHOOK_DISABLE;
static UInt32 g_zoneSides = 0;
static SInt32 g_zoneSize = 0;
static SInt32 g_xScreen = 0;
static SInt32 g_yScreen = 0;
static SInt32 g_wScreen = 0;
static SInt32 g_hScreen = 0;
static int32_t g_zoneSize = 0;
static int32_t g_xScreen = 0;
static int32_t g_yScreen = 0;
static int32_t g_wScreen = 0;
static int32_t g_hScreen = 0;
static WPARAM g_deadVirtKey = 0;
static WPARAM g_deadRelease = 0;
static LPARAM g_deadLParam = 0;
@ -130,7 +130,7 @@ void MSWindowsHook::setSides(UInt32 sides)
g_zoneSides = sides;
}
void MSWindowsHook::setZone(SInt32 x, SInt32 y, SInt32 w, SInt32 h, SInt32 jumpZoneSize)
void MSWindowsHook::setZone(int32_t x, int32_t y, int32_t w, int32_t h, int32_t jumpZoneSize)
{
g_zoneSize = jumpZoneSize;
g_xScreen = x;
@ -477,7 +477,7 @@ static LRESULT CALLBACK keyboardLLHook(int code, WPARAM wParam, LPARAM lParam)
// events very early. the earlier the better.
//
static bool mouseHookHandler(WPARAM wParam, SInt32 x, SInt32 y, SInt32 data)
static bool mouseHookHandler(WPARAM wParam, int32_t x, int32_t y, int32_t data)
{
switch (wParam) {
case WM_LBUTTONDOWN:
@ -585,9 +585,9 @@ static LRESULT CALLBACK mouseLLHook(int code, WPARAM wParam, LPARAM lParam)
return CallNextHookEx(g_mouseLL, code, wParam, lParam);
}
SInt32 x = static_cast<SInt32>(info->pt.x);
SInt32 y = static_cast<SInt32>(info->pt.y);
SInt32 w = static_cast<int16_t>(HIWORD(info->mouseData));
int32_t x = static_cast<int32_t>(info->pt.x);
int32_t y = static_cast<int32_t>(info->pt.y);
int32_t w = static_cast<int16_t>(HIWORD(info->mouseData));
// handle the message
if (mouseHookHandler(wParam, x, y, w)) {

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

@ -38,7 +38,7 @@ public:
void setSides(UInt32 sides);
void setZone(SInt32 x, SInt32 y, SInt32 w, SInt32 h, SInt32 jumpZoneSize);
void setZone(int32_t x, int32_t y, int32_t w, int32_t h, int32_t jumpZoneSize);
void setMode(EHookMode mode);

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

@ -729,7 +729,7 @@ void MSWindowsKeyState::onKey(KeyButton button, bool down, KeyModifierMask newSt
}
void MSWindowsKeyState::sendKeyEvent(
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, int32_t count, KeyButton button
)
{
if (press || isAutoRepeat) {
@ -755,7 +755,7 @@ void MSWindowsKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton bu
}
bool MSWindowsKeyState::fakeKeyRepeat(
KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang
KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang
)
{
return KeyState::fakeKeyRepeat(id, mask, count, button, lang);
@ -824,7 +824,7 @@ KeyModifierMask MSWindowsKeyState::pollActiveModifiers() const
return state;
}
SInt32 MSWindowsKeyState::pollActiveGroup() const
int32_t MSWindowsKeyState::pollActiveGroup() const
{
// determine the thread that'll receive this event
HWND targetWindow = GetForegroundWindow();
@ -874,8 +874,8 @@ void MSWindowsKeyState::getKeyMap(deskflow::KeyMap &keyMap)
// update keyboard groups
if (getGroups(m_groups)) {
m_groupMap.clear();
SInt32 numGroups = (SInt32)m_groups.size();
for (SInt32 g = 0; g < numGroups; ++g) {
int32_t numGroups = (int32_t)m_groups.size();
for (int32_t g = 0; g < numGroups; ++g) {
m_groupMap[m_groups[g]] = g;
}
}
@ -886,8 +886,8 @@ void MSWindowsKeyState::getKeyMap(deskflow::KeyMap &keyMap)
m_keyToVKMap.clear();
deskflow::KeyMap::KeyItem item;
SInt32 numGroups = (SInt32)m_groups.size();
for (SInt32 g = 0; g < numGroups; ++g) {
int32_t numGroups = (int32_t)m_groups.size();
for (int32_t g = 0; g < numGroups; ++g) {
item.m_group = g;
ActivateKeyboardLayout(m_groups[g], 0);
@ -1259,7 +1259,7 @@ bool MSWindowsKeyState::getGroups(GroupList &groups) const
return true;
}
void MSWindowsKeyState::setWindowGroup(SInt32 group)
void MSWindowsKeyState::setWindowGroup(int32_t group)
{
HWND targetWindow = GetForegroundWindow();

10
src/lib/platform/MSWindowsKeyState.h
View file

@ -143,16 +143,16 @@ public:
// IKeyState overrides
virtual void fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std::string &lang);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang);
virtual bool fakeCtrlAltDel();
virtual KeyModifierMask pollActiveModifiers() const;
virtual SInt32 pollActiveGroup() const;
virtual int32_t pollActiveGroup() const;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const;
// KeyState overrides
virtual void onKey(KeyButton button, bool down, KeyModifierMask newState);
virtual void sendKeyEvent(
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button
void *target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, int32_t count, KeyButton button
);
// Unit test accessors
@ -186,7 +186,7 @@ private:
static void ctrlAltDelThread(void *);
bool getGroups(GroupList &) const;
void setWindowGroup(SInt32 group);
void setWindowGroup(int32_t group);
KeyID getIDForKey(deskflow::KeyMap::KeyItem &item, KeyButton button, UINT virtualKey, PBYTE keyState, HKL hkl) const;
@ -200,7 +200,7 @@ private:
MSWindowsKeyState &operator=(const MSWindowsKeyState &);
private:
using GroupMap = std::map<HKL, SInt32>;
using GroupMap = std::map<HKL, int32_t>;
using KeyToVKMap = std::map<KeyID, UINT>;
void *m_eventTarget;

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

@ -501,7 +501,7 @@ bool MSWindowsScreen::getClipboard(ClipboardID, IClipboard *dst) const
return true;
}
void MSWindowsScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void MSWindowsScreen::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
assert(m_class != 0);
@ -511,7 +511,7 @@ void MSWindowsScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
h = m_h;
}
void MSWindowsScreen::getCursorPos(SInt32 &x, SInt32 &y) const
void MSWindowsScreen::getCursorPos(int32_t &x, int32_t &y) const
{
m_desks->getCursorPos(x, y);
}
@ -575,7 +575,7 @@ void MSWindowsScreen::reconfigure(UInt32 activeSides)
m_hook.setSides(activeSides);
}
void MSWindowsScreen::warpCursor(SInt32 x, SInt32 y)
void MSWindowsScreen::warpCursor(int32_t x, int32_t y)
{
// warp mouse
warpCursorNoFlush(x, y);
@ -590,7 +590,7 @@ void MSWindowsScreen::warpCursor(SInt32 x, SInt32 y)
saveMousePosition(x, y);
}
void MSWindowsScreen::saveMousePosition(SInt32 x, SInt32 y)
void MSWindowsScreen::saveMousePosition(int32_t x, int32_t y)
{
m_xCursor = x;
m_yCursor = y;
@ -723,7 +723,7 @@ void MSWindowsScreen::fakeInputEnd()
}
}
SInt32 MSWindowsScreen::getJumpZoneSize() const
int32_t MSWindowsScreen::getJumpZoneSize() const
{
return 1;
}
@ -744,7 +744,7 @@ bool MSWindowsScreen::isAnyMouseButtonDown(UInt32 &buttonID) const
return false;
}
void MSWindowsScreen::getCursorCenter(SInt32 &x, SInt32 &y) const
void MSWindowsScreen::getCursorCenter(int32_t &x, int32_t &y) const
{
x = m_xCenter;
y = m_yCenter;
@ -765,7 +765,7 @@ void MSWindowsScreen::fakeMouseButton(ButtonID id, bool press)
}
}
void MSWindowsScreen::fakeMouseMove(SInt32 x, SInt32 y)
void MSWindowsScreen::fakeMouseMove(int32_t x, int32_t y)
{
m_desks->fakeMouseMove(x, y);
if (m_buttons[kButtonLeft]) {
@ -773,12 +773,12 @@ void MSWindowsScreen::fakeMouseMove(SInt32 x, SInt32 y)
}
}
void MSWindowsScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
void MSWindowsScreen::fakeMouseRelativeMove(int32_t dx, int32_t dy) const
{
m_desks->fakeMouseRelativeMove(dx, dy);
}
void MSWindowsScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
void MSWindowsScreen::fakeMouseWheel(int32_t xDelta, int32_t yDelta) const
{
xDelta = mapClientScrollDirection(xDelta);
yDelta = mapClientScrollDirection(yDelta);
@ -797,7 +797,7 @@ void MSWindowsScreen::fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton butt
}
bool MSWindowsScreen::fakeKeyRepeat(
KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang
KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang
)
{
bool result = PlatformScreen::fakeKeyRepeat(id, mask, count, button, lang);
@ -985,15 +985,15 @@ bool MSWindowsScreen::onPreDispatchPrimary(HWND, UINT message, WPARAM wParam, LP
return onMouseButton(wParam, lParam);
case DESKFLOW_MSG_MOUSE_MOVE:
return onMouseMove(static_cast<SInt32>(wParam), static_cast<SInt32>(lParam));
return onMouseMove(static_cast<int32_t>(wParam), static_cast<int32_t>(lParam));
case DESKFLOW_MSG_MOUSE_WHEEL:
// XXX -- support x-axis scrolling
return onMouseWheel(0, static_cast<SInt32>(wParam));
return onMouseWheel(0, static_cast<int32_t>(wParam));
case DESKFLOW_MSG_PRE_WARP: {
// save position to compute delta of next motion
saveMousePosition(static_cast<SInt32>(wParam), static_cast<SInt32>(lParam));
saveMousePosition(static_cast<int32_t>(wParam), static_cast<int32_t>(lParam));
// we warped the mouse. discard events until we find the
// matching post warp event. see warpCursorNoFlush() for
@ -1201,7 +1201,7 @@ bool MSWindowsScreen::onKey(WPARAM wParam, LPARAM lParam)
// do it
m_keyState->sendKeyEvent(
getEventTarget(), ((lParam & 0x80000000u) == 0), ((lParam & 0x40000000u) != 0), key, mask,
(SInt32)(lParam & 0xffff), button
(int32_t)(lParam & 0xffff), button
);
} else {
LOG((CLOG_DEBUG1 "cannot map key"));
@ -1305,12 +1305,12 @@ bool MSWindowsScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
// seems)
// 5. sends the delta movement to the client (could be +1,+1 or -1,+4 for
// example)
bool MSWindowsScreen::onMouseMove(SInt32 mx, SInt32 my)
bool MSWindowsScreen::onMouseMove(int32_t mx, int32_t my)
{
// compute motion delta (relative to the last known
// mouse position)
SInt32 x = mx - m_xCursor;
SInt32 y = my - m_yCursor;
int32_t x = mx - m_xCursor;
int32_t y = my - m_yCursor;
LOG((CLOG_DEBUG3 "mouse move - motion delta: %+d=(%+d - %+d),%+d=(%+d - %+d)", x, mx, m_xCursor, y, my, m_yCursor));
@ -1344,7 +1344,7 @@ bool MSWindowsScreen::onMouseMove(SInt32 mx, SInt32 my)
// it's probably a bogus motion that we want to
// ignore (see warpCursorNoFlush() for a further
// description).
static SInt32 bogusZoneSize = 10;
static int32_t bogusZoneSize = 10;
if (-x + bogusZoneSize > m_xCenter - m_x || x + bogusZoneSize > m_x + m_w - m_xCenter ||
-y + bogusZoneSize > m_yCenter - m_y || y + bogusZoneSize > m_y + m_h - m_yCenter) {
@ -1358,7 +1358,7 @@ bool MSWindowsScreen::onMouseMove(SInt32 mx, SInt32 my)
return true;
}
bool MSWindowsScreen::onMouseWheel(SInt32 xDelta, SInt32 yDelta)
bool MSWindowsScreen::onMouseWheel(int32_t xDelta, int32_t yDelta)
{
// ignore message if posted prior to last mark change
if (!ignore()) {
@ -1401,7 +1401,7 @@ bool MSWindowsScreen::onScreensaver(bool activated)
bool MSWindowsScreen::onDisplayChange()
{
// screen resolution may have changed. save old shape.
SInt32 xOld = m_x, yOld = m_y, wOld = m_w, hOld = m_h;
int32_t xOld = m_x, yOld = m_y, wOld = m_w, hOld = m_h;
// update shape
updateScreenShape();
@ -1448,7 +1448,7 @@ void MSWindowsScreen::onClipboardChange()
}
}
void MSWindowsScreen::warpCursorNoFlush(SInt32 x, SInt32 y)
void MSWindowsScreen::warpCursorNoFlush(int32_t x, int32_t y)
{
// send an event that we can recognize before the mouse warp
PostThreadMessage(GetCurrentThreadId(), DESKFLOW_MSG_PRE_WARP, x, y);
@ -1786,8 +1786,8 @@ std::string &MSWindowsScreen::getDraggingFilename()
int halfSize = m_dropWindowSize / 2;
SInt32 xPos = m_isPrimary ? m_xCursor : m_xCenter;
SInt32 yPos = m_isPrimary ? m_yCursor : m_yCenter;
int32_t xPos = m_isPrimary ? m_xCursor : m_xCenter;
int32_t yPos = m_isPrimary ? m_yCursor : m_yCenter;
xPos = (xPos - halfSize) < 0 ? 0 : xPos - halfSize;
yPos = (yPos - halfSize) < 0 ? 0 : yPos - halfSize;
SetWindowPos(m_dropWindow, HWND_TOPMOST, xPos, yPos, m_dropWindowSize, m_dropWindowSize, SWP_SHOWWINDOW);

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

@ -74,8 +74,8 @@ public:
// IScreen overrides
virtual void *getEventTarget() const;
virtual bool getClipboard(ClipboardID id, IClipboard *) const;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const;
virtual void getCursorPos(int32_t &x, int32_t &y) const;
/**
* \brief Get the position of the cursor on the current machine
@ -99,25 +99,25 @@ public:
// IPrimaryScreen overrides
virtual void reconfigure(UInt32 activeSides);
virtual void warpCursor(SInt32 x, SInt32 y);
virtual void warpCursor(int32_t x, int32_t y);
virtual UInt32 registerHotKey(KeyID key, KeyModifierMask mask);
virtual void unregisterHotKey(UInt32 id);
virtual void fakeInputBegin();
virtual void fakeInputEnd();
virtual SInt32 getJumpZoneSize() const;
virtual int32_t getJumpZoneSize() const;
virtual bool isAnyMouseButtonDown(UInt32 &buttonID) const;
virtual void getCursorCenter(SInt32 &x, SInt32 &y) const;
virtual void getCursorCenter(int32_t &x, int32_t &y) const;
// ISecondaryScreen overrides
virtual void fakeMouseButton(ButtonID id, bool press);
virtual void fakeMouseMove(SInt32 x, SInt32 y);
virtual void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const;
virtual void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const;
virtual void fakeMouseMove(int32_t x, int32_t y);
virtual void fakeMouseRelativeMove(int32_t dx, int32_t dy) const;
virtual void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const;
// IKeyState overrides
virtual void updateKeys();
virtual void fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button, const std::string &lang);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang);
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang);
virtual bool fakeKeyUp(KeyButton button);
virtual void fakeAllKeysUp();
@ -189,14 +189,14 @@ private: // HACK
bool onKey(WPARAM, LPARAM);
bool onHotKey(WPARAM, LPARAM);
bool onMouseButton(WPARAM, LPARAM);
bool onMouseMove(SInt32 x, SInt32 y);
bool onMouseWheel(SInt32 xDelta, SInt32 yDelta);
bool onMouseMove(int32_t x, int32_t y);
bool onMouseWheel(int32_t xDelta, int32_t yDelta);
bool onScreensaver(bool activated);
bool onDisplayChange();
void onClipboardChange();
// warp cursor without discarding queued events
void warpCursorNoFlush(SInt32 x, SInt32 y);
void warpCursorNoFlush(int32_t x, int32_t y);
// discard posted messages
void nextMark();
@ -239,7 +239,7 @@ private: // HACK
static LRESULT CALLBACK wndProc(HWND, UINT, WPARAM, LPARAM);
// save last position of mouse to compute next delta movement
void saveMousePosition(SInt32 x, SInt32 y);
void saveMousePosition(int32_t x, int32_t y);
// check if it is a modifier key repeating message
bool isModifierRepeat(KeyModifierMask oldState, KeyModifierMask state, WPARAM wParam) const;
@ -281,15 +281,15 @@ private:
ATOM m_class;
// screen shape stuff
SInt32 m_x, m_y;
SInt32 m_w, m_h;
SInt32 m_xCenter, m_yCenter;
int32_t m_x, m_y;
int32_t m_w, m_h;
int32_t m_xCenter, m_yCenter;
// true if system appears to have multiple monitors
bool m_multimon;
// last mouse position
SInt32 m_xCursor, m_yCursor;
int32_t m_xCursor, m_yCursor;
// last clipboard
UInt32 m_sequenceNumber;

16
src/lib/platform/OSXKeyState.cpp
View file

@ -440,7 +440,7 @@ KeyModifierMask OSXKeyState::pollActiveModifiers() const
return outMask;
}
SInt32 OSXKeyState::pollActiveGroup() const
int32_t OSXKeyState::pollActiveGroup() const
{
AutoTISInputSourceRef keyboardLayout(TISCopyCurrentKeyboardLayoutInputSource(), CFRelease);
CFDataRef id = (CFDataRef)TISGetInputSourceProperty(keyboardLayout.get(), kTISPropertyInputSourceID);
@ -472,11 +472,11 @@ void OSXKeyState::pollPressedKeys(KeyButtonSet &pressedKeys) const
void OSXKeyState::getKeyMap(deskflow::KeyMap &keyMap)
{
// update keyboard groups
SInt32 numGroups{0};
int32_t numGroups{0};
if (getGroups(m_groups)) {
m_groupMap.clear();
numGroups = CFArrayGetCount(m_groups.get());
for (SInt32 g = 0; g < numGroups; ++g) {
for (int32_t g = 0; g < numGroups; ++g) {
TISInputSourceRef keyboardLayout = (TISInputSourceRef)CFArrayGetValueAtIndex(m_groups.get(), g);
CFDataRef id = (CFDataRef)TISGetInputSourceProperty(keyboardLayout, kTISPropertyInputSourceID);
m_groupMap[id] = g;
@ -484,7 +484,7 @@ void OSXKeyState::getKeyMap(deskflow::KeyMap &keyMap)
}
UInt32 keyboardType = LMGetKbdType();
for (SInt32 g = 0; g < numGroups; ++g) {
for (int32_t g = 0; g < numGroups; ++g) {
// add special keys
getKeyMapForSpecialKeys(keyMap, g);
@ -630,7 +630,7 @@ void OSXKeyState::fakeKey(const Keystroke &keystroke)
}
case Keystroke::kGroup: {
SInt32 group = keystroke.m_data.m_group.m_group;
int32_t group = keystroke.m_data.m_group.m_group;
if (!keystroke.m_data.m_group.m_restore) {
if (keystroke.m_data.m_group.m_absolute) {
LOG((CLOG_DEBUG1 " group %d", group));
@ -649,7 +649,7 @@ void OSXKeyState::fakeKey(const Keystroke &keystroke)
}
}
void OSXKeyState::getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, SInt32 group) const
void OSXKeyState::getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, int32_t group) const
{
// special keys are insensitive to modifers and none are dead keys
deskflow::KeyMap::KeyItem item;
@ -678,7 +678,7 @@ void OSXKeyState::getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, SInt32 group
// anyway.
}
bool OSXKeyState::getKeyMap(deskflow::KeyMap &keyMap, SInt32 group, const IOSXKeyResource &r) const
bool OSXKeyState::getKeyMap(deskflow::KeyMap &keyMap, int32_t group, const IOSXKeyResource &r) const
{
if (!r.isValid()) {
return false;
@ -876,7 +876,7 @@ bool OSXKeyState::getGroups(AutoCFArray &groups) const
return true;
}
void OSXKeyState::setGroup(SInt32 group)
void OSXKeyState::setGroup(int32_t group)
{
TISInputSourceRef keyboardLayout = (TISInputSourceRef)CFArrayGetValueAtIndex(m_groups.get(), group);
if (!keyboardLayout) {

10
src/lib/platform/OSXKeyState.h
View file

@ -91,7 +91,7 @@ public:
virtual bool fakeCtrlAltDel();
virtual bool fakeMediaKey(KeyID id);
virtual KeyModifierMask pollActiveModifiers() const;
virtual SInt32 pollActiveGroup() const;
virtual int32_t pollActiveGroup() const;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const;
CGEventFlags getModifierStateAsOSXFlags() const;
@ -105,16 +105,16 @@ private:
class KeyResource;
// Add hard coded special keys to a deskflow::KeyMap.
void getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, SInt32 group) const;
void getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, int32_t group) const;
// Convert keyboard resource to a key map
bool getKeyMap(deskflow::KeyMap &keyMap, SInt32 group, const IOSXKeyResource &r) const;
bool getKeyMap(deskflow::KeyMap &keyMap, int32_t group, const IOSXKeyResource &r) const;
// Get the available keyboard groups
bool getGroups(AutoCFArray &) const;
// Change active keyboard group to group
void setGroup(SInt32 group);
void setGroup(int32_t group);
// Send an event for the given modifier key
void handleModifierKey(void *target, UInt32 virtualKey, KeyID id, bool down, KeyModifierMask newMask);
@ -160,7 +160,7 @@ private:
KeyButtonOffset = 1
};
using GroupMap = std::map<CFDataRef, SInt32>;
using GroupMap = std::map<CFDataRef, int32_t>;
using VirtualKeyMap = std::map<UInt32, KeyID>;
VirtualKeyMap m_virtualKeyMap;

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

@ -69,25 +69,25 @@ public:
// IScreen overrides
void *getEventTarget() const override;
bool getClipboard(ClipboardID id, IClipboard *) const override;
void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const override;
void getCursorPos(SInt32 &x, SInt32 &y) const override;
void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override;
void getCursorPos(int32_t &x, int32_t &y) const override;
// IPrimaryScreen overrides
void reconfigure(UInt32 activeSides) override;
void warpCursor(SInt32 x, SInt32 y) override;
void warpCursor(int32_t x, int32_t y) override;
UInt32 registerHotKey(KeyID key, KeyModifierMask mask) override;
void unregisterHotKey(UInt32 id) override;
void fakeInputBegin() override;
void fakeInputEnd() override;
SInt32 getJumpZoneSize() const override;
int32_t getJumpZoneSize() const override;
bool isAnyMouseButtonDown(UInt32 &buttonID) const override;
void getCursorCenter(SInt32 &x, SInt32 &y) const override;
void getCursorCenter(int32_t &x, int32_t &y) const override;
// ISecondaryScreen overrides
void fakeMouseButton(ButtonID id, bool press) override;
void fakeMouseMove(SInt32 x, SInt32 y) override;
void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const override;
void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const override;
void fakeMouseMove(int32_t x, int32_t y) override;
void fakeMouseRelativeMove(int32_t dx, int32_t dy) const override;
void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const override;
// IPlatformScreen overrides
void enable() override;
@ -135,7 +135,7 @@ private:
// event, false if it is a mouseup event. macButton is the index
// of the button pressed using the mac button mapping.
bool onMouseButton(bool pressed, uint16_t macButton);
bool onMouseWheel(SInt32 xDelta, SInt32 yDelta) const;
bool onMouseWheel(int32_t xDelta, int32_t yDelta) const;
void constructMouseButtonEventMap();
@ -156,10 +156,10 @@ private:
ButtonID mapMacButtonToDeskflow(uint16_t) const;
// map mac scroll wheel value to a deskflow scroll wheel value
SInt32 mapScrollWheelToDeskflow(SInt32) const;
int32_t mapScrollWheelToDeskflow(int32_t) const;
// map deskflow scroll wheel value to a mac scroll wheel value
SInt32 mapScrollWheelFromDeskflow(SInt32) const;
int32_t mapScrollWheelFromDeskflow(int32_t) const;
// get the current scroll wheel speed
double getScrollSpeed() const;
@ -257,12 +257,12 @@ private:
CGDirectDisplayID m_displayID;
// screen shape stuff
SInt32 m_x, m_y;
SInt32 m_w, m_h;
SInt32 m_xCenter, m_yCenter;
int32_t m_x, m_y;
int32_t m_w, m_h;
int32_t m_xCenter, m_yCenter;
// mouse state
mutable SInt32 m_xCursor, m_yCursor;
mutable int32_t m_xCursor, m_yCursor;
mutable bool m_cursorPosValid;
/* FIXME: this data structure is explicitly marked mutable due
@ -276,7 +276,7 @@ private:
std::vector<MouseButtonEventMapType> MouseButtonEventMap;
bool m_cursorHidden;
SInt32 m_dragNumButtonsDown;
int32_t m_dragNumButtonsDown;
Point m_dragLastPoint;
EventQueueTimer *m_dragTimer;
@ -331,8 +331,8 @@ private:
// for double click coalescing.
double m_lastClickTime;
int m_clickState;
SInt32 m_lastSingleClickXCursor;
SInt32 m_lastSingleClickYCursor;
int32_t m_lastSingleClickXCursor;
int32_t m_lastSingleClickYCursor;
IEventQueue *m_events;

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

@ -255,7 +255,7 @@ bool OSXScreen::getClipboard(ClipboardID, IClipboard *dst) const
return true;
}
void OSXScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void OSXScreen::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
x = m_x;
y = m_y;
@ -263,7 +263,7 @@ void OSXScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
h = m_h;
}
void OSXScreen::getCursorPos(SInt32 &x, SInt32 &y) const
void OSXScreen::getCursorPos(int32_t &x, int32_t &y) const
{
CGEventRef event = CGEventCreate(NULL);
CGPoint mouse = CGEventGetLocation(event);
@ -280,7 +280,7 @@ void OSXScreen::reconfigure(UInt32)
// do nothing
}
void OSXScreen::warpCursor(SInt32 x, SInt32 y)
void OSXScreen::warpCursor(int32_t x, int32_t y)
{
// move cursor without generating events
CGPoint pos;
@ -304,7 +304,7 @@ void OSXScreen::fakeInputEnd()
// FIXME -- not implemented
}
SInt32 OSXScreen::getJumpZoneSize() const
int32_t OSXScreen::getJumpZoneSize() const
{
return 1;
}
@ -319,7 +319,7 @@ bool OSXScreen::isAnyMouseButtonDown(UInt32 &buttonID) const
return (GetCurrentButtonState() != 0);
}
void OSXScreen::getCursorCenter(SInt32 &x, SInt32 &y) const
void OSXScreen::getCursorCenter(int32_t &x, int32_t &y) const
{
x = m_xCenter;
y = m_yCenter;
@ -514,7 +514,7 @@ void OSXScreen::fakeMouseButton(ButtonID id, bool press)
CGPoint pos;
if (!m_cursorPosValid) {
SInt32 x, y;
int32_t x, y;
getCursorPos(x, y);
}
pos.x = m_xCursor;
@ -522,8 +522,8 @@ void OSXScreen::fakeMouseButton(ButtonID id, bool press)
// variable used to detect mouse coordinate differences between
// old & new mouse clicks. Used in double click detection.
SInt32 xDiff = m_xCursor - m_lastSingleClickXCursor;
SInt32 yDiff = m_yCursor - m_lastSingleClickYCursor;
int32_t xDiff = m_xCursor - m_lastSingleClickXCursor;
int32_t yDiff = m_yCursor - m_lastSingleClickYCursor;
double diff = sqrt(xDiff * xDiff + yDiff * yDiff);
// max sqrt(x^2 + y^2) difference allowed to double click
// since we don't have double click distance in NX APIs
@ -612,7 +612,7 @@ void OSXScreen::getDropTargetThread(void *)
m_fakeDraggingStarted = false;
}
void OSXScreen::fakeMouseMove(SInt32 x, SInt32 y)
void OSXScreen::fakeMouseMove(int32_t x, int32_t y)
{
if (m_fakeDraggingStarted) {
m_buttonState.set(0, kMouseButtonDown);
@ -630,12 +630,12 @@ void OSXScreen::fakeMouseMove(SInt32 x, SInt32 y)
postMouseEvent(pos);
// save new cursor position
m_xCursor = static_cast<SInt32>(pos.x);
m_yCursor = static_cast<SInt32>(pos.y);
m_xCursor = static_cast<int32_t>(pos.x);
m_yCursor = static_cast<int32_t>(pos.y);
m_cursorPosValid = true;
}
void OSXScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
void OSXScreen::fakeMouseRelativeMove(int32_t dx, int32_t dy) const
{
// OS X does not appear to have a fake relative mouse move function.
// simulate it by getting the current mouse position and adding to
@ -649,8 +649,8 @@ void OSXScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
// synthesize event
CGPoint pos;
m_xCursor = static_cast<SInt32>(oldPos.x);
m_yCursor = static_cast<SInt32>(oldPos.y);
m_xCursor = static_cast<int32_t>(oldPos.x);
m_yCursor = static_cast<int32_t>(oldPos.y);
pos.x = oldPos.x + dx;
pos.y = oldPos.y + dy;
postMouseEvent(pos);
@ -659,7 +659,7 @@ void OSXScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
m_cursorPosValid = false;
}
void OSXScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
void OSXScreen::fakeMouseWheel(int32_t xDelta, int32_t yDelta) const
{
if (xDelta != 0 || yDelta != 0) {
// create a scroll event, post it and release it. not sure if kCGScrollEventUnitLine
@ -1027,8 +1027,8 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
}
// save position to compute delta of next motion
m_xCursor = (SInt32)mx;
m_yCursor = (SInt32)my;
m_xCursor = (int32_t)mx;
m_yCursor = (int32_t)my;
if (m_isOnScreen) {
// motion on primary screen
@ -1046,7 +1046,7 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
// it's probably a bogus motion that we want to
// ignore (see warpCursorNoFlush() for a further
// description).
static SInt32 bogusZoneSize = 10;
static int32_t bogusZoneSize = 10;
if (-x + bogusZoneSize > m_xCenter - m_x || x + bogusZoneSize > m_x + m_w - m_xCenter ||
-y + bogusZoneSize > m_yCenter - m_y || y + bogusZoneSize > m_y + m_h - m_yCenter) {
LOG((CLOG_DEBUG "dropped bogus motion %+d,%+d", x, y));
@ -1060,8 +1060,8 @@ bool OSXScreen::onMouseMove(CGFloat mx, CGFloat my)
m_yFractionalMove += y;
// Return the integer part
SInt32 intX = (SInt32)m_xFractionalMove;
SInt32 intY = (SInt32)m_yFractionalMove;
int32_t intX = (int32_t)m_xFractionalMove;
int32_t intY = (int32_t)m_yFractionalMove;
// And keep only the fractional part
m_xFractionalMove -= intX;
@ -1126,7 +1126,7 @@ bool OSXScreen::onMouseButton(bool pressed, uint16_t macButton)
return true;
}
bool OSXScreen::onMouseWheel(SInt32 xDelta, SInt32 yDelta) const
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));
@ -1342,18 +1342,18 @@ ButtonID OSXScreen::mapMacButtonToDeskflow(uint16_t macButton) const
return static_cast<ButtonID>(macButton);
}
SInt32 OSXScreen::mapScrollWheelToDeskflow(SInt32 x) const
int32_t OSXScreen::mapScrollWheelToDeskflow(int32_t x) const
{
// return accelerated scrolling
double d = (1.0 + getScrollSpeed()) * x;
return static_cast<SInt32>(120.0 * d);
return static_cast<int32_t>(120.0 * d);
}
SInt32 OSXScreen::mapScrollWheelFromDeskflow(SInt32 x) const
int32_t OSXScreen::mapScrollWheelFromDeskflow(int32_t x) const
{
// use server's acceleration with a little boost since other platforms
// take one wheel step as a larger step than the mac does.
auto result = static_cast<SInt32>(3.0 * x / 120.0);
auto result = static_cast<int32_t>(3.0 * x / 120.0);
return mapClientScrollDirection(result);
}
@ -1407,7 +1407,7 @@ void OSXScreen::handleDrag(const Event &, void *)
if ((short)p.x != m_dragLastPoint.h || (short)p.y != m_dragLastPoint.v) {
m_dragLastPoint.h = (short)p.x;
m_dragLastPoint.v = (short)p.y;
onMouseMove((SInt32)p.x, (SInt32)p.y);
onMouseMove((int32_t)p.x, (int32_t)p.y);
}
}
@ -1459,10 +1459,10 @@ bool OSXScreen::updateScreenShape()
}
// get shape of default screen
m_x = (SInt32)totalBounds.origin.x;
m_y = (SInt32)totalBounds.origin.y;
m_w = (SInt32)totalBounds.size.width;
m_h = (SInt32)totalBounds.size.height;
m_x = (int32_t)totalBounds.origin.x;
m_y = (int32_t)totalBounds.origin.y;
m_w = (int32_t)totalBounds.size.width;
m_h = (int32_t)totalBounds.size.height;
// get center of default screen
CGDirectDisplayID main = CGMainDisplayID();

14
src/lib/platform/XWindowsClipboard.cpp
View file

@ -431,7 +431,7 @@ void XWindowsClipboard::doClearCache()
{
m_checkCache = false;
m_cached = false;
for (SInt32 index = 0; index < kNumFormats; ++index) {
for (int32_t index = 0; index < kNumFormats; ++index) {
m_data[index] = "";
m_added[index] = false;
}
@ -615,7 +615,7 @@ bool XWindowsClipboard::motifOwnsClipboard() const
// get the Motif clipboard header property from the root window
Atom target;
SInt32 format;
int32_t format;
std::string data;
Window root = RootWindow(m_display, DefaultScreen(m_display));
if (!XWindowsUtil::getWindowProperty(m_display, root, m_atomMotifClipHeader, &data, &target, &format, False)) {
@ -640,7 +640,7 @@ void XWindowsClipboard::motifFillCache()
// get the Motif clipboard header property from the root window
Atom target;
SInt32 format;
int32_t format;
std::string data;
Window root = RootWindow(m_display, DefaultScreen(m_display));
if (!XWindowsUtil::getWindowProperty(m_display, root, m_atomMotifClipHeader, &data, &target, &format, False)) {
@ -676,13 +676,13 @@ void XWindowsClipboard::motifFillCache()
}
// format list is after static item structure elements
const SInt32 numFormats = item.m_numFormats - item.m_numDeletedFormats;
auto formats = static_cast<const SInt32 *>(static_cast<const void *>(item.m_size + data.data()));
const int32_t numFormats = item.m_numFormats - item.m_numDeletedFormats;
auto formats = static_cast<const int32_t *>(static_cast<const void *>(item.m_size + data.data()));
// get the available formats
using MotifFormatMap = std::map<Atom, std::string>;
MotifFormatMap motifFormats;
for (SInt32 i = 0; i < numFormats; ++i) {
for (int32_t i = 0; i < numFormats; ++i) {
// get Motif format property from the root window
snprintf(name, buffer_size, "_MOTIF_CLIP_ITEM_%d", formats[i]);
Atom atomFormat = XInternAtom(m_display, name, False);
@ -775,7 +775,7 @@ bool XWindowsClipboard::insertMultipleReply(Window requestor, ::Time time, Atom
{
// get the requested targets
Atom target;
SInt32 format;
int32_t format;
std::string data;
if (!XWindowsUtil::getWindowProperty(m_display, requestor, property, &data, &target, &format, False)) {
// can't get the requested targets

40
src/lib/platform/XWindowsClipboard.h
View file

@ -183,7 +183,7 @@ protected:
};
// Motif structure IDs
enum class MotifClip : SInt32
enum class MotifClip : int32_t
{
Format = 1,
Item = 2,
@ -195,13 +195,13 @@ protected:
{
public:
MotifClip m_id;
SInt32 m_pad1[3];
SInt32 m_item;
SInt32 m_pad2[4];
SInt32 m_numItems;
SInt32 m_pad3[3];
SInt32 m_selectionOwner; // a Window
SInt32 m_pad4[2];
int32_t m_pad1[3];
int32_t m_item;
int32_t m_pad2[4];
int32_t m_numItems;
int32_t m_pad3[3];
int32_t m_selectionOwner; // a Window
int32_t m_pad4[2];
};
// Motif clip item structure
@ -209,11 +209,11 @@ protected:
{
public:
MotifClip m_id;
SInt32 m_pad1[5];
SInt32 m_size;
SInt32 m_numFormats;
SInt32 m_numDeletedFormats;
SInt32 m_pad2[6];
int32_t m_pad1[5];
int32_t m_size;
int32_t m_numFormats;
int32_t m_numDeletedFormats;
int32_t m_pad2[6];
};
// Motif clip format structure
@ -221,13 +221,13 @@ protected:
{
public:
MotifClip m_id;
SInt32 m_pad1[6];
SInt32 m_length;
SInt32 m_data;
SInt32 m_type; // an Atom
SInt32 m_pad2[1];
SInt32 m_deleted;
SInt32 m_pad3[4];
int32_t m_pad1[6];
int32_t m_length;
int32_t m_data;
int32_t m_type; // an Atom
int32_t m_pad2[1];
int32_t m_deleted;
int32_t m_pad3[4];
};
// stores data needed to respond to a selection request

22
src/lib/platform/XWindowsClipboardAnyBitmapConverter.cpp
View file

@ -23,14 +23,14 @@ struct CBMPInfoHeader
{
public:
UInt32 biSize;
SInt32 biWidth;
SInt32 biHeight;
int32_t biWidth;
int32_t biHeight;
uint16_t biPlanes;
uint16_t biBitCount;
UInt32 biCompression;
UInt32 biSizeImage;
SInt32 biXPelsPerMeter;
SInt32 biYPelsPerMeter;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
UInt32 biClrUsed;
UInt32 biClrImportant;
};
@ -44,7 +44,7 @@ static void toLE(uint8_t *&dst, uint16_t src)
dst += 2;
}
static void toLE(uint8_t *&dst, SInt32 src)
static void toLE(uint8_t *&dst, int32_t src)
{
dst[0] = static_cast<uint8_t>(src & 0xffu);
dst[1] = static_cast<uint8_t>((src >> 8) & 0xffu);
@ -67,9 +67,9 @@ static inline uint16_t fromLEU16(const uint8_t *data)
return static_cast<uint16_t>(data[0]) | (static_cast<uint16_t>(data[1]) << 8);
}
static inline SInt32 fromLES32(const uint8_t *data)
static inline int32_t fromLES32(const uint8_t *data)
{
return static_cast<SInt32>(
return static_cast<int32_t>(
static_cast<UInt32>(data[0]) | (static_cast<UInt32>(data[1]) << 8) | (static_cast<UInt32>(data[2]) << 16) |
(static_cast<UInt32>(data[3]) << 24)
);
@ -150,14 +150,14 @@ std::string XWindowsClipboardAnyBitmapConverter::toIClipboard(const std::string
uint8_t infoHeader[40];
uint8_t *dst = infoHeader;
toLE(dst, static_cast<UInt32>(40));
toLE(dst, static_cast<SInt32>(w));
toLE(dst, static_cast<SInt32>(h));
toLE(dst, static_cast<int32_t>(w));
toLE(dst, static_cast<int32_t>(h));
toLE(dst, static_cast<uint16_t>(1));
toLE(dst, static_cast<uint16_t>(depth));
toLE(dst, static_cast<UInt32>(0)); // BI_RGB
toLE(dst, static_cast<UInt32>(image.size()));
toLE(dst, static_cast<SInt32>(2834)); // 72 dpi
toLE(dst, static_cast<SInt32>(2834)); // 72 dpi
toLE(dst, static_cast<int32_t>(2834)); // 72 dpi
toLE(dst, static_cast<int32_t>(2834)); // 72 dpi
toLE(dst, static_cast<UInt32>(0));
toLE(dst, static_cast<UInt32>(0));

12
src/lib/platform/XWindowsKeyState.cpp
View file

@ -89,7 +89,7 @@ void XWindowsKeyState::init(Display *display, bool useXKB)
setActiveGroup(kGroupPoll);
}
void XWindowsKeyState::setActiveGroup(SInt32 group)
void XWindowsKeyState::setActiveGroup(int32_t group)
{
if (group == kGroupPollAndSet) {
// we need to set the group to -1 in order for pollActiveGroup() to
@ -135,7 +135,7 @@ bool XWindowsKeyState::mapModifiersToX(KeyModifierMask mask, unsigned int &modif
{
modifiers = 0;
for (SInt32 i = 0; i < kKeyModifierNumBits; ++i) {
for (int32_t i = 0; i < kKeyModifierNumBits; ++i) {
KeyModifierMask bit = (1u << i);
if ((mask & bit) != 0) {
KeyModifierToXMask::const_iterator j = m_modifierToX.find(bit);
@ -176,7 +176,7 @@ KeyModifierMask XWindowsKeyState::pollActiveModifiers() const
return mapModifiersFromX(state);
}
SInt32 XWindowsKeyState::pollActiveGroup() const
int32_t XWindowsKeyState::pollActiveGroup() const
{
// fixed condition where any group < -1 would have undetermined behaviour
if (m_group >= 0) {
@ -229,7 +229,7 @@ void XWindowsKeyState::getKeyMap(deskflow::KeyMap &keyMap)
updateKeysymMap(keyMap);
}
bool XWindowsKeyState::setCurrentLanguageWithDBus(SInt32 group) const
bool XWindowsKeyState::setCurrentLanguageWithDBus(int32_t group) const
{
QString service = "org.gnome.Shell";
QString path = "/org/gnome/Shell";
@ -711,7 +711,7 @@ void XWindowsKeyState::updateKeysymMapXKB(deskflow::KeyMap &keyMap)
UInt32 modifierBit = XWindowsUtil::getModifierBitForKeySym(keysym);
if (isModifier && modifierBit != kKeyModifierBitNone) {
item.m_generates = (1u << modifierBit);
for (SInt32 j = 0; j < 8; ++j) {
for (int32_t j = 0; j < 8; ++j) {
// skip modifiers this key doesn't generate
if ((modifierMask & (1u << j)) == 0) {
continue;
@ -789,7 +789,7 @@ void XWindowsKeyState::updateKeysymMapXKB(deskflow::KeyMap &keyMap)
}
#endif
void XWindowsKeyState::remapKeyModifiers(KeyID id, SInt32 group, deskflow::KeyMap::KeyItem &item, void *vself)
void XWindowsKeyState::remapKeyModifiers(KeyID id, int32_t group, deskflow::KeyMap::KeyItem &item, void *vself)
{
XWindowsKeyState *self = static_cast<XWindowsKeyState *>(vself);
item.m_required = self->mapModifiersFromX(XkbBuildCoreState(item.m_required, group));

14
src/lib/platform/XWindowsKeyState.h
View file

@ -67,7 +67,7 @@ public:
on X11. If \p group is \c kGroupPollAndSet then this will poll the
active group now and use it for future calls to \c pollActiveGroup().
*/
void setActiveGroup(SInt32 group);
void setActiveGroup(int32_t group);
//! Set the auto-repeat state
/*!
@ -106,7 +106,7 @@ public:
// IKeyState overrides
virtual bool fakeCtrlAltDel();
virtual KeyModifierMask pollActiveModifiers() const;
virtual SInt32 pollActiveGroup() const;
virtual int32_t pollActiveGroup() const;
virtual void pollPressedKeys(KeyButtonSet &pressedKeys) const;
protected:
@ -126,9 +126,9 @@ private:
/*!
Returns the existance of nedeed DBus interface.
*/
bool setCurrentLanguageWithDBus(SInt32 group) const;
bool setCurrentLanguageWithDBus(int32_t group) const;
static void remapKeyModifiers(KeyID, SInt32, deskflow::KeyMap::KeyItem &, void *);
static void remapKeyModifiers(KeyID, int32_t, deskflow::KeyMap::KeyItem &, void *);
private:
struct XKBModifierInfo
@ -154,7 +154,7 @@ private:
#if HAVE_XKB_EXTENSION
XkbDescPtr m_xkb;
#endif
SInt32 m_group;
int32_t m_group;
XKBModifierMap m_lastGoodXKBModifiers;
NonXKBModifierMap m_lastGoodNonXKBModifiers;
@ -172,11 +172,11 @@ private:
#ifdef TEST_ENV
public:
SInt32 group() const
int32_t group() const
{
return m_group;
}
void group(const SInt32 &group)
void group(const int32_t &group)
{
m_group = group;
}

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

@ -498,7 +498,7 @@ bool XWindowsScreen::getClipboard(ClipboardID id, IClipboard *clipboard) const
return Clipboard::copy(clipboard, m_clipboard[id], timestamp);
}
void XWindowsScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void XWindowsScreen::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
x = m_x;
y = m_y;
@ -506,7 +506,7 @@ void XWindowsScreen::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
h = m_h;
}
void XWindowsScreen::getCursorPos(SInt32 &x, SInt32 &y) const
void XWindowsScreen::getCursorPos(int32_t &x, int32_t &y) const
{
Window root, window;
int mx, my, xWindow, yWindow;
@ -525,7 +525,7 @@ void XWindowsScreen::reconfigure(UInt32)
// do nothing
}
void XWindowsScreen::warpCursor(SInt32 x, SInt32 y)
void XWindowsScreen::warpCursor(int32_t x, int32_t y)
{
// warp mouse
warpCursorNoFlush(x, y);
@ -770,7 +770,7 @@ void XWindowsScreen::fakeInputEnd()
// FIXME -- not implemented
}
SInt32 XWindowsScreen::getJumpZoneSize() const
int32_t XWindowsScreen::getJumpZoneSize() const
{
return 1;
}
@ -788,7 +788,7 @@ bool XWindowsScreen::isAnyMouseButtonDown(UInt32 &buttonID) const
return false;
}
void XWindowsScreen::getCursorCenter(SInt32 &x, SInt32 &y) const
void XWindowsScreen::getCursorCenter(int32_t &x, int32_t &y) const
{
x = m_xCenter;
y = m_yCenter;
@ -803,7 +803,7 @@ void XWindowsScreen::fakeMouseButton(ButtonID button, bool press)
}
}
void XWindowsScreen::fakeMouseMove(SInt32 x, SInt32 y)
void XWindowsScreen::fakeMouseMove(int32_t x, int32_t y)
{
if (m_xinerama && m_xtestIsXineramaUnaware) {
XWarpPointer(m_display, None, m_root, 0, 0, 0, 0, x, y);
@ -813,14 +813,14 @@ void XWindowsScreen::fakeMouseMove(SInt32 x, SInt32 y)
XFlush(m_display);
}
void XWindowsScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
void XWindowsScreen::fakeMouseRelativeMove(int32_t dx, int32_t dy) const
{
// FIXME -- ignore xinerama for now
XTestFakeRelativeMotionEvent(m_display, dx, dy, CurrentTime);
XFlush(m_display);
}
void XWindowsScreen::fakeMouseWheel(SInt32, SInt32 yDelta) const
void XWindowsScreen::fakeMouseWheel(int32_t, int32_t yDelta) const
{
// XXX -- support x-axis scrolling
if (yDelta == 0) {
@ -965,7 +965,7 @@ void XWindowsScreen::saveShape()
#endif
}
void XWindowsScreen::setShape(SInt32 width, SInt32 height)
void XWindowsScreen::setShape(int32_t width, int32_t height)
{
// set shape
m_x = 0;
@ -1021,7 +1021,7 @@ Window XWindowsScreen::openWindow() const
attr.cursor = createBlankCursor();
// adjust attributes and get size and shape
SInt32 x, y, w, h;
int32_t x, y, w, h;
if (m_isPrimary) {
// grab window attributes. this window is used to capture user
// input when the user is focused on another client. it covers
@ -1371,7 +1371,7 @@ void XWindowsScreen::handleSystemEvent(const Event &event, void *)
case XkbStateNotify:
LOG((CLOG_INFO "group change: %d", xkbEvent->state.group));
m_keyState->setActiveGroup((SInt32)xkbEvent->state.group);
m_keyState->setActiveGroup((int32_t)xkbEvent->state.group);
return;
}
}
@ -1538,8 +1538,8 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
// compute motion delta (relative to the last known
// mouse position)
SInt32 x = xmotion.x_root - m_xCursor;
SInt32 y = xmotion.y_root - m_yCursor;
int32_t x = xmotion.x_root - m_xCursor;
int32_t y = xmotion.y_root - m_yCursor;
// save position to compute delta of next motion
m_xCursor = xmotion.x_root;
@ -1577,7 +1577,7 @@ void XWindowsScreen::onMouseMove(const XMotionEvent &xmotion)
// pixel) but the latter is a PITA. to work around
// it we only warp when the mouse has moved more
// than s_size pixels from the center.
static const SInt32 s_size = 32;
static const int32_t s_size = 32;
if (xmotion.x_root - m_xCenter < -s_size || xmotion.x_root - m_xCenter > s_size ||
xmotion.y_root - m_yCenter < -s_size || xmotion.y_root - m_yCenter > s_size) {
warpCursorNoFlush(m_xCenter, m_yCenter);
@ -1843,7 +1843,7 @@ unsigned int XWindowsScreen::mapButtonToX(ButtonID id) const
return static_cast<unsigned int>(id);
}
void XWindowsScreen::warpCursorNoFlush(SInt32 x, SInt32 y)
void XWindowsScreen::warpCursorNoFlush(int32_t x, int32_t y)
{
assert(m_window != None);

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

@ -54,25 +54,25 @@ public:
// IScreen overrides
void *getEventTarget() const override;
bool getClipboard(ClipboardID id, IClipboard *) const override;
void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const override;
void getCursorPos(SInt32 &x, SInt32 &y) const override;
void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override;
void getCursorPos(int32_t &x, int32_t &y) const override;
// IPrimaryScreen overrides
void reconfigure(UInt32 activeSides) override;
void warpCursor(SInt32 x, SInt32 y) override;
void warpCursor(int32_t x, int32_t y) override;
UInt32 registerHotKey(KeyID key, KeyModifierMask mask) override;
void unregisterHotKey(UInt32 id) override;
void fakeInputBegin() override;
void fakeInputEnd() override;
SInt32 getJumpZoneSize() const override;
int32_t getJumpZoneSize() const override;
bool isAnyMouseButtonDown(UInt32 &buttonID) const override;
void getCursorCenter(SInt32 &x, SInt32 &y) const override;
void getCursorCenter(int32_t &x, int32_t &y) const override;
// ISecondaryScreen overrides
void fakeMouseButton(ButtonID id, bool press) override;
void fakeMouseMove(SInt32 x, SInt32 y) override;
void fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const override;
void fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const override;
void fakeMouseMove(int32_t x, int32_t y) override;
void fakeMouseRelativeMove(int32_t dx, int32_t dy) const override;
void fakeMouseWheel(int32_t xDelta, int32_t yDelta) const override;
// IPlatformScreen overrides
void enable() override;
@ -131,7 +131,7 @@ private:
Display *openDisplay(const char *displayName);
void saveShape();
void setShape(SInt32 width, SInt32 height);
void setShape(int32_t width, int32_t height);
Window openWindow() const;
void openIM();
@ -154,7 +154,7 @@ private:
ButtonID mapButtonFromX(const XButtonEvent *) const;
unsigned int mapButtonToX(ButtonID id) const;
void warpCursorNoFlush(SInt32 x, SInt32 y);
void warpCursorNoFlush(int32_t x, int32_t y);
void refreshKeyboard(XEvent *);
@ -190,12 +190,12 @@ private:
bool m_isOnScreen;
// screen shape stuff
SInt32 m_x, m_y;
SInt32 m_w, m_h;
SInt32 m_xCenter, m_yCenter;
int32_t m_x, m_y;
int32_t m_w, m_h;
int32_t m_xCenter, m_yCenter;
// last mouse position
SInt32 m_xCursor, m_yCursor;
int32_t m_xCursor, m_yCursor;
// keyboard stuff
XWindowsKeyState *m_keyState;

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

@ -169,7 +169,7 @@ private:
// fake mouse motion position for suppressing the screen saver.
// xscreensaver since 2.21 requires the mouse to move more than 10
// pixels to be considered significant.
SInt32 m_disablePos;
int32_t m_disablePos;
IEventQueue *m_events;
};

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

@ -1515,7 +1515,7 @@ static const KeySym s_map1008FF[] = {
XWindowsUtil::KeySymMap XWindowsUtil::s_keySymToUCS4;
bool XWindowsUtil::getWindowProperty(
Display *display, Window window, Atom property, std::string *data, Atom *type, SInt32 *format, bool deleteProperty
Display *display, Window window, Atom property, std::string *data, Atom *type, int32_t *format, bool deleteProperty
)
{
assert(display != NULL);
@ -1587,7 +1587,7 @@ bool XWindowsUtil::getWindowProperty(
*type = actualType;
}
if (format != NULL) {
*format = static_cast<SInt32>(actualDatumSize);
*format = static_cast<int32_t>(actualDatumSize);
}
if (okay) {
@ -1601,7 +1601,7 @@ bool XWindowsUtil::getWindowProperty(
}
bool XWindowsUtil::setWindowProperty(
Display *display, Window window, Atom property, const void *vdata, UInt32 size, Atom type, SInt32 format
Display *display, Window window, Atom property, const void *vdata, UInt32 size, Atom type, int32_t format
)
{
const UInt32 length = 4 * XMaxRequestSize(display);

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

@ -45,7 +45,7 @@ public:
property is deleted after being read.
*/
static bool getWindowProperty(
Display *, Window window, Atom property, std::string *data, Atom *type, SInt32 *format, bool deleteProperty
Display *, Window window, Atom property, std::string *data, Atom *type, int32_t *format, bool deleteProperty
);
//! Set property
@ -54,7 +54,7 @@ public:
\c data.
*/
static bool
setWindowProperty(Display *, Window window, Atom property, const void *data, UInt32 size, Atom type, SInt32 format);
setWindowProperty(Display *, Window window, Atom property, const void *data, UInt32 size, Atom type, int32_t format);
//! Get X server time
/*!

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

@ -32,13 +32,13 @@ BaseClientProxy::~BaseClientProxy()
// do nothing
}
void BaseClientProxy::setJumpCursorPos(SInt32 x, SInt32 y)
void BaseClientProxy::setJumpCursorPos(int32_t x, int32_t y)
{
m_x = x;
m_y = y;
}
void BaseClientProxy::getJumpCursorPos(SInt32 &x, SInt32 &y) const
void BaseClientProxy::getJumpCursorPos(int32_t &x, int32_t &y) const
{
x = m_x;
y = m_y;

20
src/lib/server/BaseClientProxy.h
View file

@ -41,7 +41,7 @@ public:
/*!
Save the position of the cursor when jumping from client.
*/
void setJumpCursorPos(SInt32 x, SInt32 y);
void setJumpCursorPos(int32_t x, int32_t y);
//@}
//! @name accessors
@ -51,7 +51,7 @@ public:
/*!
Get the position of the cursor when last jumping from client.
*/
void getJumpCursorPos(SInt32 &x, SInt32 &y) const;
void getJumpCursorPos(int32_t &x, int32_t &y) const;
//! Get cursor position
/*!
@ -67,23 +67,23 @@ public:
// IScreen
virtual void *getEventTarget() const = 0;
virtual bool getClipboard(ClipboardID id, IClipboard *) const = 0;
virtual void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const = 0;
virtual void getCursorPos(SInt32 &x, SInt32 &y) const = 0;
virtual void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const = 0;
virtual void getCursorPos(int32_t &x, int32_t &y) const = 0;
// IClient overrides
virtual void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) = 0;
virtual void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) = 0;
virtual bool leave() = 0;
virtual void setClipboard(ClipboardID, const IClipboard *) = 0;
virtual void grabClipboard(ClipboardID) = 0;
virtual void setClipboardDirty(ClipboardID, bool) = 0;
virtual void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &) = 0;
virtual void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &lang) = 0;
virtual void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &lang) = 0;
virtual void keyUp(KeyID, KeyModifierMask, KeyButton) = 0;
virtual void mouseDown(ButtonID) = 0;
virtual void mouseUp(ButtonID) = 0;
virtual void mouseMove(SInt32 xAbs, SInt32 yAbs) = 0;
virtual void mouseRelativeMove(SInt32 xRel, SInt32 yRel) = 0;
virtual void mouseWheel(SInt32 xDelta, SInt32 yDelta) = 0;
virtual void mouseMove(int32_t xAbs, int32_t yAbs) = 0;
virtual void mouseRelativeMove(int32_t xRel, int32_t yRel) = 0;
virtual void mouseWheel(int32_t xDelta, int32_t yDelta) = 0;
virtual void screensaver(bool activate) = 0;
virtual void resetOptions() = 0;
virtual void setOptions(const OptionsList &options) = 0;
@ -96,5 +96,5 @@ public:
private:
std::string m_name;
SInt32 m_x, m_y;
int32_t m_x, m_y;
};

14
src/lib/server/ClientProxy.h
View file

@ -65,23 +65,23 @@ public:
// IScreen
void *getEventTarget() const override;
bool getClipboard(ClipboardID id, IClipboard *) const override = 0;
void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const override = 0;
void getCursorPos(SInt32 &x, SInt32 &y) const override = 0;
void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override = 0;
void getCursorPos(int32_t &x, int32_t &y) const override = 0;
// IClient overrides
void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override = 0;
void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override = 0;
bool leave() override = 0;
void setClipboard(ClipboardID, const IClipboard *) override = 0;
void grabClipboard(ClipboardID) override = 0;
void setClipboardDirty(ClipboardID, bool) override = 0;
void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &) override = 0;
void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &lang) override = 0;
void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &lang) override = 0;
void keyUp(KeyID, KeyModifierMask, KeyButton) override = 0;
void mouseDown(ButtonID) override = 0;
void mouseUp(ButtonID) override = 0;
void mouseMove(SInt32 xAbs, SInt32 yAbs) override = 0;
void mouseRelativeMove(SInt32 xRel, SInt32 yRel) override = 0;
void mouseWheel(SInt32 xDelta, SInt32 yDelta) override = 0;
void mouseMove(int32_t xAbs, int32_t yAbs) override = 0;
void mouseRelativeMove(int32_t xRel, int32_t yRel) override = 0;
void mouseWheel(int32_t xDelta, int32_t yDelta) override = 0;
void screensaver(bool activate) override = 0;
void resetOptions() override = 0;
void setOptions(const OptionsList &options) override = 0;

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

@ -229,7 +229,7 @@ bool ClientProxy1_0::getClipboard(ClipboardID id, IClipboard *clipboard) const
return true;
}
void ClientProxy1_0::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
void ClientProxy1_0::getShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) const
{
x = m_info.m_x;
y = m_info.m_y;
@ -237,14 +237,14 @@ void ClientProxy1_0::getShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) const
h = m_info.m_h;
}
void ClientProxy1_0::getCursorPos(SInt32 &x, SInt32 &y) const
void ClientProxy1_0::getCursorPos(int32_t &x, int32_t &y) const
{
// note -- this returns the cursor pos from when we last got client info
x = m_info.m_mx;
y = m_info.m_my;
}
void ClientProxy1_0::enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool)
void ClientProxy1_0::enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool)
{
LOG((CLOG_DEBUG1 "send enter to \"%s\", %d,%d %d %04x", getName().c_str(), xAbs, yAbs, seqNum, mask));
ProtocolUtil::writef(getStream(), kMsgCEnter, xAbs, yAbs, seqNum, mask);
@ -284,7 +284,7 @@ void ClientProxy1_0::keyDown(KeyID key, KeyModifierMask mask, KeyButton, const s
ProtocolUtil::writef(getStream(), kMsgDKeyDown1_0, key, mask);
}
void ClientProxy1_0::keyRepeat(KeyID key, KeyModifierMask mask, SInt32 count, KeyButton, const std::string &)
void ClientProxy1_0::keyRepeat(KeyID key, KeyModifierMask mask, int32_t count, KeyButton, const std::string &)
{
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d", getName().c_str(), key, mask, count));
ProtocolUtil::writef(getStream(), kMsgDKeyRepeat1_0, key, mask, count);
@ -308,18 +308,18 @@ void ClientProxy1_0::mouseUp(ButtonID button)
ProtocolUtil::writef(getStream(), kMsgDMouseUp, button);
}
void ClientProxy1_0::mouseMove(SInt32 xAbs, SInt32 yAbs)
void ClientProxy1_0::mouseMove(int32_t xAbs, int32_t yAbs)
{
LOG((CLOG_DEBUG2 "send mouse move to \"%s\" %d,%d", getName().c_str(), xAbs, yAbs));
ProtocolUtil::writef(getStream(), kMsgDMouseMove, xAbs, yAbs);
}
void ClientProxy1_0::mouseRelativeMove(SInt32, SInt32)
void ClientProxy1_0::mouseRelativeMove(int32_t, int32_t)
{
// ignore -- not supported in protocol 1.0
}
void ClientProxy1_0::mouseWheel(SInt32, SInt32 yDelta)
void ClientProxy1_0::mouseWheel(int32_t, int32_t yDelta)
{
// clients prior to 1.3 only support the y axis
LOG((CLOG_DEBUG2 "send mouse wheel to \"%s\" %+d", getName().c_str(), yDelta));

14
src/lib/server/ClientProxy1_0.h
View file

@ -40,23 +40,23 @@ public:
// IScreen
bool getClipboard(ClipboardID id, IClipboard *) const override;
void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const override;
void getCursorPos(SInt32 &x, SInt32 &y) const override;
void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override;
void getCursorPos(int32_t &x, int32_t &y) const override;
// IClient overrides
void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override;
void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override;
bool leave() override;
void setClipboard(ClipboardID, const IClipboard *) override;
void grabClipboard(ClipboardID) override;
void setClipboardDirty(ClipboardID, bool) override;
void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &) override;
void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &) override;
void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &) override;
void keyUp(KeyID, KeyModifierMask, KeyButton) override;
void mouseDown(ButtonID) override;
void mouseUp(ButtonID) override;
void mouseMove(SInt32 xAbs, SInt32 yAbs) override;
void mouseRelativeMove(SInt32 xRel, SInt32 yRel) override;
void mouseWheel(SInt32 xDelta, SInt32 yDelta) override;
void mouseMove(int32_t xAbs, int32_t yAbs) override;
void mouseRelativeMove(int32_t xRel, int32_t yRel) override;
void mouseWheel(int32_t xDelta, int32_t yDelta) override;
void screensaver(bool activate) override;
void resetOptions() override;
void setOptions(const OptionsList &options) override;

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

@ -45,7 +45,9 @@ void ClientProxy1_1::keyDown(KeyID key, KeyModifierMask mask, KeyButton button,
ProtocolUtil::writef(getStream(), kMsgDKeyDown, key, mask, button);
}
void ClientProxy1_1::keyRepeat(KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang)
void ClientProxy1_1::keyRepeat(
KeyID key, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang
)
{
LOG(
(CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d, "

2
src/lib/server/ClientProxy1_1.h
View file

@ -29,6 +29,6 @@ public:
// IClient overrides
virtual void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &);
virtual void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &);
virtual void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &);
virtual void keyUp(KeyID, KeyModifierMask, KeyButton);
};

2
src/lib/server/ClientProxy1_2.cpp
View file

@ -36,7 +36,7 @@ ClientProxy1_2::~ClientProxy1_2()
// do nothing
}
void ClientProxy1_2::mouseRelativeMove(SInt32 xRel, SInt32 yRel)
void ClientProxy1_2::mouseRelativeMove(int32_t xRel, int32_t yRel)
{
LOG((CLOG_DEBUG2 "send mouse relative move to \"%s\" %d,%d", getName().c_str(), xRel, yRel));
ProtocolUtil::writef(getStream(), kMsgDMouseRelMove, xRel, yRel);

2
src/lib/server/ClientProxy1_2.h
View file

@ -30,5 +30,5 @@ public:
~ClientProxy1_2();
// IClient overrides
virtual void mouseRelativeMove(SInt32 xRel, SInt32 yRel);
virtual void mouseRelativeMove(int32_t xRel, int32_t yRel);
};

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

@ -45,7 +45,7 @@ ClientProxy1_3::~ClientProxy1_3()
removeHeartbeatTimer();
}
void ClientProxy1_3::mouseWheel(SInt32 xDelta, SInt32 yDelta)
void ClientProxy1_3::mouseWheel(int32_t xDelta, int32_t yDelta)
{
LOG((CLOG_DEBUG2 "send mouse wheel to \"%s\" %+d,%+d", getName().c_str(), xDelta, yDelta));
ProtocolUtil::writef(getStream(), kMsgDMouseWheel, xDelta, yDelta);

2
src/lib/server/ClientProxy1_3.h
View file

@ -33,7 +33,7 @@ public:
ClientProxy1_3 &operator=(ClientProxy1_3 &&) = delete;
// IClient overrides
virtual void mouseWheel(SInt32 xDelta, SInt32 yDelta);
virtual void mouseWheel(int32_t xDelta, int32_t yDelta);
void handleKeepAlive(const Event &, void *);

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

@ -47,7 +47,9 @@ void ClientProxy1_4::keyDown(KeyID key, KeyModifierMask mask, KeyButton button,
ClientProxy1_3::keyDown(key, mask, button, lang);
}
void ClientProxy1_4::keyRepeat(KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang)
void ClientProxy1_4::keyRepeat(
KeyID key, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang
)
{
ClientProxy1_3::keyRepeat(key, mask, count, button, lang);
}

2
src/lib/server/ClientProxy1_4.h
View file

@ -42,7 +42,7 @@ public:
// IClient overrides
virtual void keyDown(KeyID key, KeyModifierMask mask, KeyButton button, const std::string &);
virtual void keyRepeat(KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang);
virtual void keyRepeat(KeyID key, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang);
virtual void keyUp(KeyID key, KeyModifierMask mask, KeyButton button);
virtual void keepAlive();

2
src/lib/server/Config.cpp
View file

@ -1704,7 +1704,7 @@ std::ostream &operator<<(std::ostream &s, const Config &config)
// ConfigReadContext
//
ConfigReadContext::ConfigReadContext(std::istream &s, SInt32 firstLine) : m_stream(s), m_line(firstLine - 1)
ConfigReadContext::ConfigReadContext(std::istream &s, int32_t firstLine) : m_stream(s), m_line(firstLine - 1)
{
// do nothing
}

4
src/lib/server/Config.h
View file

@ -526,7 +526,7 @@ class ConfigReadContext
public:
using ArgList = std::vector<std::string>;
ConfigReadContext(std::istream &, SInt32 firstLine = 1);
ConfigReadContext(std::istream &, int32_t firstLine = 1);
~ConfigReadContext();
bool readLine(std::string &);
@ -562,7 +562,7 @@ private:
private:
std::istream &m_stream;
SInt32 m_line;
int32_t m_line;
};
//! Configuration stream read exception

18
src/lib/server/PrimaryClient.cpp
View file

@ -71,12 +71,12 @@ void PrimaryClient::fakeInputEnd()
}
}
SInt32 PrimaryClient::getJumpZoneSize() const
int32_t PrimaryClient::getJumpZoneSize() const
{
return m_screen->getJumpZoneSize();
}
void PrimaryClient::getCursorCenter(SInt32 &x, SInt32 &y) const
void PrimaryClient::getCursorCenter(int32_t &x, int32_t &y) const
{
m_screen->getCursorCenter(x, y);
}
@ -101,12 +101,12 @@ bool PrimaryClient::getClipboard(ClipboardID id, IClipboard *clipboard) const
return m_screen->getClipboard(id, clipboard);
}
void PrimaryClient::getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const
void PrimaryClient::getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const
{
m_screen->getShape(x, y, width, height);
}
void PrimaryClient::getCursorPos(SInt32 &x, SInt32 &y) const
void PrimaryClient::getCursorPos(int32_t &x, int32_t &y) const
{
m_screen->getCursorPos(x, y);
}
@ -121,7 +121,7 @@ void PrimaryClient::disable()
m_screen->disable();
}
void PrimaryClient::enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool screensaver)
void PrimaryClient::enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool screensaver)
{
m_screen->setSequenceNumber(seqNum);
if (!screensaver) {
@ -172,7 +172,7 @@ void PrimaryClient::keyDown(KeyID key, KeyModifierMask mask, KeyButton button, c
}
}
void PrimaryClient::keyRepeat(KeyID, KeyModifierMask, SInt32, KeyButton, const std::string &)
void PrimaryClient::keyRepeat(KeyID, KeyModifierMask, int32_t, KeyButton, const std::string &)
{
// ignore
}
@ -198,17 +198,17 @@ void PrimaryClient::mouseUp(ButtonID)
// ignore
}
void PrimaryClient::mouseMove(SInt32 x, SInt32 y)
void PrimaryClient::mouseMove(int32_t x, int32_t y)
{
m_screen->warpCursor(x, y);
}
void PrimaryClient::mouseRelativeMove(SInt32, SInt32)
void PrimaryClient::mouseRelativeMove(int32_t, int32_t)
{
// ignore
}
void PrimaryClient::mouseWheel(SInt32, SInt32)
void PrimaryClient::mouseWheel(int32_t, int32_t)
{
// ignore
}

20
src/lib/server/PrimaryClient.h
View file

@ -92,7 +92,7 @@ public:
Return the jump zone size, the size of the regions on the edges of
the screen that cause the cursor to jump to another screen.
*/
SInt32 getJumpZoneSize() const;
int32_t getJumpZoneSize() const;
//! Get cursor center position
/*!
@ -100,7 +100,7 @@ public:
cursor to compute cursor motion deltas and should be far from
the edges of the screen, typically the center.
*/
void getCursorCenter(SInt32 &x, SInt32 &y) const;
void getCursorCenter(int32_t &x, int32_t &y) const;
//! Get toggle key state
/*!
@ -123,23 +123,23 @@ public:
// IScreen overrides
void *getEventTarget() const override;
bool getClipboard(ClipboardID id, IClipboard *) const override;
void getShape(SInt32 &x, SInt32 &y, SInt32 &width, SInt32 &height) const override;
void getCursorPos(SInt32 &x, SInt32 &y) const override;
void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override;
void getCursorPos(int32_t &x, int32_t &y) const override;
// IClient overrides
void enter(SInt32 xAbs, SInt32 yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override;
void enter(int32_t xAbs, int32_t yAbs, UInt32 seqNum, KeyModifierMask mask, bool forScreensaver) override;
bool leave() override;
void setClipboard(ClipboardID, const IClipboard *) override;
void grabClipboard(ClipboardID) override;
void setClipboardDirty(ClipboardID, bool) override;
void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &) override;
void keyRepeat(KeyID, KeyModifierMask, SInt32 count, KeyButton, const std::string &) override;
void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &) override;
void keyUp(KeyID, KeyModifierMask, KeyButton) override;
void mouseDown(ButtonID) override;
void mouseUp(ButtonID) override;
void mouseMove(SInt32 xAbs, SInt32 yAbs) override;
void mouseRelativeMove(SInt32 xRel, SInt32 yRel) override;
void mouseWheel(SInt32 xDelta, SInt32 yDelta) override;
void mouseMove(int32_t xAbs, int32_t yAbs) override;
void mouseRelativeMove(int32_t xRel, int32_t yRel) override;
void mouseWheel(int32_t xDelta, int32_t yDelta) override;
void screensaver(bool activate) override;
void resetOptions() override;
void setOptions(const OptionsList &options) override;
@ -160,5 +160,5 @@ public:
private:
deskflow::Screen *m_screen;
bool m_clipboardDirty[kClipboardEnd];
SInt32 m_fakeInputCount;
int32_t m_fakeInputCount;
};

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

@ -355,7 +355,7 @@ std::string Server::protocolString() const
UInt32 Server::getNumClients() const
{
return (SInt32)m_clients.size();
return (int32_t)m_clients.size();
}
void Server::getClients(std::vector<std::string> &list) const
@ -422,7 +422,7 @@ bool Server::isLockedToScreen() const
return false;
}
SInt32 Server::getJumpZoneSize(BaseClientProxy *client) const
int32_t Server::getJumpZoneSize(BaseClientProxy *client) const
{
if (client == m_primaryClient) {
return m_primaryClient->getJumpZoneSize();
@ -431,11 +431,11 @@ SInt32 Server::getJumpZoneSize(BaseClientProxy *client) const
}
}
void Server::switchScreen(BaseClientProxy *dst, SInt32 x, SInt32 y, bool forScreensaver)
void Server::switchScreen(BaseClientProxy *dst, int32_t x, int32_t y, bool forScreensaver)
{
assert(dst != NULL);
SInt32 dx, dy, dw, dh;
int32_t dx, dy, dw, dh;
dst->getShape(dx, dy, dw, dh);
// any of these conditions seem to trigger when the portal permission dialog
@ -551,15 +551,15 @@ void Server::jumpToScreen(BaseClientProxy *newScreen)
m_active->setJumpCursorPos(m_x, m_y);
// get the last cursor position on the target screen
SInt32 x, y;
int32_t x, y;
newScreen->getJumpCursorPos(x, y);
switchScreen(newScreen, x, y, false);
}
float Server::mapToFraction(BaseClientProxy *client, EDirection dir, SInt32 x, SInt32 y) const
float Server::mapToFraction(BaseClientProxy *client, EDirection dir, int32_t x, int32_t y) const
{
SInt32 sx, sy, sw, sh;
int32_t sx, sy, sw, sh;
client->getShape(sx, sy, sw, sh);
switch (dir) {
case kLeft:
@ -577,19 +577,19 @@ float Server::mapToFraction(BaseClientProxy *client, EDirection dir, SInt32 x, S
return 0.0f;
}
void Server::mapToPixel(BaseClientProxy *client, EDirection dir, float f, SInt32 &x, SInt32 &y) const
void Server::mapToPixel(BaseClientProxy *client, EDirection dir, float f, int32_t &x, int32_t &y) const
{
SInt32 sx, sy, sw, sh;
int32_t sx, sy, sw, sh;
client->getShape(sx, sy, sw, sh);
switch (dir) {
case kLeft:
case kRight:
y = static_cast<SInt32>(f * sh) + sy;
y = static_cast<int32_t>(f * sh) + sy;
break;
case kTop:
case kBottom:
x = static_cast<SInt32>(f * sw) + sx;
x = static_cast<int32_t>(f * sw) + sx;
break;
case kNoDirection:
@ -605,7 +605,7 @@ bool Server::hasAnyNeighbor(BaseClientProxy *client, EDirection dir) const
return m_config->hasNeighbor(getName(client), dir);
}
BaseClientProxy *Server::getNeighbor(BaseClientProxy *src, EDirection dir, SInt32 &x, SInt32 &y) const
BaseClientProxy *Server::getNeighbor(BaseClientProxy *src, EDirection dir, int32_t &x, int32_t &y) const
{
// note -- must be locked on entry
@ -651,7 +651,7 @@ BaseClientProxy *Server::getNeighbor(BaseClientProxy *src, EDirection dir, SInt3
}
}
BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, SInt32 &x, SInt32 &y) const
BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, int32_t &x, int32_t &y) const
{
// note -- must be locked on entry
@ -664,7 +664,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide,
}
// get the source screen's size
SInt32 dx, dy, dw, dh;
int32_t dx, dy, dw, dh;
BaseClientProxy *lastGoodScreen = src;
lastGoodScreen->getShape(dx, dy, dw, dh);
@ -756,7 +756,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide,
return dst;
}
void Server::avoidJumpZone(BaseClientProxy *dst, EDirection dir, SInt32 &x, SInt32 &y) const
void Server::avoidJumpZone(BaseClientProxy *dst, EDirection dir, int32_t &x, int32_t &y) const
{
// we only need to avoid jump zones on the primary screen
if (dst != m_primaryClient) {
@ -764,10 +764,10 @@ void Server::avoidJumpZone(BaseClientProxy *dst, EDirection dir, SInt32 &x, SInt
}
const std::string dstName(getName(dst));
SInt32 dx, dy, dw, dh;
int32_t dx, dy, dw, dh;
dst->getShape(dx, dy, dw, dh);
float t = mapToFraction(dst, dir, x, y);
SInt32 z = getJumpZoneSize(dst);
int32_t z = getJumpZoneSize(dst);
// move in far enough to avoid the jump zone. if entering a side
// that doesn't have a neighbor (i.e. an asymmetrical side) then we
@ -799,7 +799,7 @@ void Server::avoidJumpZone(BaseClientProxy *dst, EDirection dir, SInt32 &x, SInt
}
bool Server::isSwitchOkay(
BaseClientProxy *newScreen, EDirection dir, SInt32 x, SInt32 y, SInt32 xActive, SInt32 yActive
BaseClientProxy *newScreen, EDirection dir, int32_t x, int32_t y, int32_t xActive, int32_t yActive
)
{
LOG((CLOG_DEBUG1 "try to leave \"%s\" on %s", getName(m_active).c_str(), Config::dirName(dir)));
@ -857,7 +857,7 @@ bool Server::isSwitchOkay(
Config::ScreenOptions::const_iterator i = options->find(kOptionScreenSwitchCorners);
UInt32 corners = static_cast<UInt32>(i->second);
i = options->find(kOptionScreenSwitchCornerSize);
SInt32 size = 0;
int32_t size = 0;
if (i != options->end()) {
size = i->second;
}
@ -892,7 +892,7 @@ bool Server::isSwitchOkay(
return !preventSwitch;
}
void Server::noSwitch(SInt32 x, SInt32 y)
void Server::noSwitch(int32_t x, int32_t y)
{
armSwitchTwoTap(x, y);
stopSwitchWait();
@ -916,7 +916,7 @@ void Server::startSwitchTwoTap()
LOG((CLOG_DEBUG1 "waiting for second tap"));
}
void Server::armSwitchTwoTap(SInt32 x, SInt32 y)
void Server::armSwitchTwoTap(int32_t x, int32_t y)
{
if (m_switchTwoTapEngaged) {
if (m_switchTwoTapTimer.getTime() > m_switchTwoTapDelay) {
@ -925,9 +925,9 @@ void Server::armSwitchTwoTap(SInt32 x, SInt32 y)
} else if (!m_switchTwoTapArmed) {
// still time for a double tap. see if we left the tap
// zone and, if so, arm the two tap.
SInt32 ax, ay, aw, ah;
int32_t ax, ay, aw, ah;
m_active->getShape(ax, ay, aw, ah);
SInt32 tapZone = m_primaryClient->getJumpZoneSize();
int32_t tapZone = m_primaryClient->getJumpZoneSize();
if (tapZone < m_switchTwoTapZone) {
tapZone = m_switchTwoTapZone;
}
@ -978,7 +978,7 @@ bool Server::shouldSwitchTwoTap() const
return (m_switchTwoTapArmed && m_switchTwoTapTimer.getTime() <= m_switchTwoTapDelay);
}
void Server::startSwitchWait(SInt32 x, SInt32 y)
void Server::startSwitchWait(int32_t x, int32_t y)
{
stopSwitchWait();
m_switchWaitX = x;
@ -1000,16 +1000,16 @@ bool Server::isSwitchWaitStarted() const
return (m_switchWaitTimer != NULL);
}
UInt32 Server::getCorner(BaseClientProxy *client, SInt32 x, SInt32 y, SInt32 size) const
UInt32 Server::getCorner(BaseClientProxy *client, int32_t x, int32_t y, int32_t size) const
{
assert(client != NULL);
// get client screen shape
SInt32 ax, ay, aw, ah;
int32_t ax, ay, aw, ah;
client->getShape(ax, ay, aw, ah);
// check for x,y on the left or right
SInt32 xSide;
int32_t xSide;
if (x <= ax) {
xSide = -1;
} else if (x >= ax + aw - 1) {
@ -1019,7 +1019,7 @@ UInt32 Server::getCorner(BaseClientProxy *client, SInt32 x, SInt32 y, SInt32 siz
}
// check for x,y on the top or bottom
SInt32 ySide;
int32_t ySide;
if (y <= ay) {
ySide = -1;
} else if (y >= ay + ah - 1) {
@ -1053,7 +1053,7 @@ void Server::stopRelativeMoves()
{
if (m_relativeMoves && m_active != m_primaryClient) {
// warp to the center of the active client so we know where we are
SInt32 ax, ay, aw, ah;
int32_t ax, ay, aw, ah;
m_active->getShape(ax, ay, aw, ah);
m_x = ax + (aw >> 1);
m_y = ay + (ah >> 1);
@ -1176,7 +1176,7 @@ void Server::handleShapeChanged(const Event &, void *vclient)
LOG((CLOG_DEBUG "screen \"%s\" shape changed", getName(client).c_str()));
// update jump coordinate
SInt32 x, y;
int32_t x, y;
client->getCursorPos(x, y);
client->setJumpCursorPos(x, y);
@ -1375,7 +1375,7 @@ void Server::handleSwitchInDirectionEvent(const Event &event, void *)
SwitchInDirectionInfo *info = static_cast<SwitchInDirectionInfo *>(event.getData());
// jump to screen in chosen direction from center of this screen
SInt32 x = m_x, y = m_y;
int32_t x = m_x, y = m_y;
BaseClientProxy *newScreen = getNeighbor(m_active, info->m_direction, x, y);
if (newScreen == NULL) {
LOG((CLOG_DEBUG1 "no neighbor %s", Config::dirName(info->m_direction)));
@ -1537,9 +1537,9 @@ void Server::onScreensaver(bool activated)
if (m_activeSaver != NULL && m_activeSaver != m_primaryClient) {
// check position
BaseClientProxy *screen = m_activeSaver;
SInt32 x, y, w, h;
int32_t x, y, w, h;
screen->getShape(x, y, w, h);
SInt32 zoneSize = getJumpZoneSize(screen);
int32_t zoneSize = getJumpZoneSize(screen);
if (m_xSaver < x + zoneSize) {
m_xSaver = x + zoneSize;
} else if (m_xSaver >= x + w - zoneSize) {
@ -1612,7 +1612,7 @@ void Server::onKeyUp(KeyID id, KeyModifierMask mask, KeyButton button, const cha
}
}
void Server::onKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button, const std::string &lang)
void Server::onKeyRepeat(KeyID id, KeyModifierMask mask, int32_t count, KeyButton button, const std::string &lang)
{
LOG(
(CLOG_DEBUG1 "onKeyRepeat id=%d mask=0x%04x count=%d button=0x%04x lang=\"%s\"", id, mask, count, button,
@ -1662,7 +1662,7 @@ void Server::onMouseUp(ButtonID id)
}
}
bool Server::onMouseMovePrimary(SInt32 x, SInt32 y)
bool Server::onMouseMovePrimary(int32_t x, int32_t y)
{
LOG((CLOG_DEBUG4 "onMouseMovePrimary %d,%d", x, y));
@ -1685,12 +1685,12 @@ bool Server::onMouseMovePrimary(SInt32 x, SInt32 y)
m_y = y;
// get screen shape
SInt32 ax, ay, aw, ah;
int32_t ax, ay, aw, ah;
m_active->getShape(ax, ay, aw, ah);
SInt32 zoneSize = getJumpZoneSize(m_active);
int32_t zoneSize = getJumpZoneSize(m_active);
// clamp position to screen
SInt32 xc = x, yc = y;
int32_t xc = x, yc = y;
if (xc < ax + zoneSize) {
xc = ax;
} else if (xc >= ax + aw - zoneSize) {
@ -1706,7 +1706,7 @@ bool Server::onMouseMovePrimary(SInt32 x, SInt32 y)
// when the cursor is in a corner, there may be a screen either
// horizontally or vertically. check both directions.
EDirection dirh = kNoDirection, dirv = kNoDirection;
SInt32 xh = x, yv = y;
int32_t xh = x, yv = y;
if (x < ax + zoneSize) {
xh -= zoneSize;
dirh = kLeft;
@ -1729,7 +1729,7 @@ bool Server::onMouseMovePrimary(SInt32 x, SInt32 y)
// check both horizontally and vertically
EDirection dirs[] = {dirh, dirv};
SInt32 xs[] = {xh, x}, ys[] = {y, yv};
int32_t xs[] = {xh, x}, ys[] = {y, yv};
for (int i = 0; i < 2; ++i) {
EDirection dir = dirs[i];
if (dir == kNoDirection) {
@ -1802,15 +1802,15 @@ void Server::sendDragInfo(BaseClientProxy *newScreen)
}
}
void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
void Server::onMouseMoveSecondary(int32_t dx, int32_t dy)
{
LOG((CLOG_DEBUG2 "onMouseMoveSecondary initial %+d,%+d", dx, dy));
const char *envVal = std::getenv("DESKFLOW_MOUSE_ADJUSTMENT");
if (envVal != nullptr) {
try {
double multiplier = std::stod(envVal); // Convert to double
SInt32 adjustedDx = static_cast<SInt32>(std::round(dx * multiplier)); // Apply multiplier and round
SInt32 adjustedDy = static_cast<SInt32>(std::round(dy * multiplier));
double multiplier = std::stod(envVal); // Convert to double
int32_t adjustedDx = static_cast<int32_t>(std::round(dx * multiplier)); // Apply multiplier and round
int32_t adjustedDy = static_cast<int32_t>(std::round(dy * multiplier));
LOG((CLOG_DEBUG2 "Adjusted to %+d,%+d using multiplier %.2f", adjustedDx, adjustedDy, multiplier));
dx = adjustedDx; // Update dx and dy to adjusted values
dy = adjustedDy;
@ -1842,8 +1842,8 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
}
// save old position
const SInt32 xOld = m_x;
const SInt32 yOld = m_y;
const int32_t xOld = m_x;
const int32_t yOld = m_y;
// save last delta
m_xDelta2 = m_xDelta;
@ -1858,7 +1858,7 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
m_y += dy;
// get screen shape
SInt32 ax, ay, aw, ah;
int32_t ax, ay, aw, ah;
m_active->getShape(ax, ay, aw, ah);
// find direction of neighbor and get the neighbor
@ -1866,7 +1866,7 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
BaseClientProxy *newScreen;
do {
// clamp position to screen
SInt32 xc = m_x, yc = m_y;
int32_t xc = m_x, yc = m_y;
if (xc < ax) {
xc = ax;
} else if (xc >= ax + aw) {
@ -1897,7 +1897,7 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
// then arm the double tap.
if (m_switchScreen != NULL) {
bool clearWait;
SInt32 zoneSize = m_primaryClient->getJumpZoneSize();
int32_t zoneSize = m_primaryClient->getJumpZoneSize();
switch (m_switchDir) {
case kLeft:
clearWait = (m_x >= ax + zoneSize);
@ -1945,8 +1945,8 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
m_sendFileThread.reset(nullptr);
}
SInt32 newX = m_x;
SInt32 newY = m_y;
int32_t newX = m_x;
int32_t newY = m_y;
// switch screens
switchScreen(newScreen, newX, newY, false);
@ -1977,7 +1977,7 @@ void Server::onMouseMoveSecondary(SInt32 dx, SInt32 dy)
}
}
void Server::onMouseWheel(SInt32 xDelta, SInt32 yDelta)
void Server::onMouseWheel(int32_t xDelta, int32_t yDelta)
{
LOG((CLOG_DEBUG1 "onMouseWheel %+d,%+d", xDelta, yDelta));
assert(m_active != NULL);
@ -2042,7 +2042,7 @@ bool Server::addClient(BaseClientProxy *client)
m_clients.insert(std::make_pair(name, client));
// initialize client data
SInt32 x, y;
int32_t x, y;
client->getCursorPos(x, y);
client->setJumpCursorPos(x, y);

44
src/lib/server/Server.h
View file

@ -254,21 +254,21 @@ private:
bool isLockedToScreen() const;
// returns the jump zone of the client
SInt32 getJumpZoneSize(BaseClientProxy *) const;
int32_t getJumpZoneSize(BaseClientProxy *) const;
// change the active screen
void switchScreen(BaseClientProxy *, SInt32 x, SInt32 y, bool forScreenSaver);
void switchScreen(BaseClientProxy *, int32_t x, int32_t y, bool forScreenSaver);
// jump to screen
void jumpToScreen(BaseClientProxy *);
// convert pixel position to fraction, using x or y depending on the
// direction.
float mapToFraction(BaseClientProxy *, EDirection, SInt32 x, SInt32 y) const;
float mapToFraction(BaseClientProxy *, EDirection, int32_t x, int32_t y) const;
// convert fraction to pixel position, writing only x or y depending
// on the direction.
void mapToPixel(BaseClientProxy *, EDirection, float f, SInt32 &x, SInt32 &y) const;
void mapToPixel(BaseClientProxy *, EDirection, float f, int32_t &x, int32_t &y) const;
// returns true if the client has a neighbor anywhere along the edge
// indicated by the direction.
@ -276,27 +276,27 @@ private:
// lookup neighboring screen, mapping the coordinate independent of
// the direction to the neighbor's coordinate space.
BaseClientProxy *getNeighbor(BaseClientProxy *, EDirection, SInt32 &x, SInt32 &y) const;
BaseClientProxy *getNeighbor(BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const;
// lookup neighboring screen. given a position relative to the
// source screen, find the screen we should move onto and where.
// if the position is sufficiently far from the source then we
// cross multiple screens. if there is no suitable screen then
// return NULL and x,y are not modified.
BaseClientProxy *mapToNeighbor(BaseClientProxy *, EDirection, SInt32 &x, SInt32 &y) const;
BaseClientProxy *mapToNeighbor(BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const;
// adjusts x and y or neither to avoid ending up in a jump zone
// after entering the client in the given direction.
void avoidJumpZone(BaseClientProxy *, EDirection, SInt32 &x, SInt32 &y) const;
void avoidJumpZone(BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const;
// test if a switch is permitted. this includes testing user
// options like switch delay and tracking any state required to
// implement them. returns true iff a switch is permitted.
bool isSwitchOkay(BaseClientProxy *dst, EDirection, SInt32 x, SInt32 y, SInt32 xActive, SInt32 yActive);
bool isSwitchOkay(BaseClientProxy *dst, EDirection, int32_t x, int32_t y, int32_t xActive, int32_t yActive);
// update switch state due to a mouse move at \p x, \p y that
// doesn't switch screens.
void noSwitch(SInt32 x, SInt32 y);
void noSwitch(int32_t x, int32_t y);
// stop switch timers
void stopSwitch();
@ -305,7 +305,7 @@ private:
void startSwitchTwoTap();
// arm the two tap switch timer if \p x, \p y is outside the tap zone
void armSwitchTwoTap(SInt32 x, SInt32 y);
void armSwitchTwoTap(int32_t x, int32_t y);
// stop the two tap switch timer
void stopSwitchTwoTap();
@ -317,7 +317,7 @@ private:
bool shouldSwitchTwoTap() const;
// start delay switch timer
void startSwitchWait(SInt32 x, SInt32 y);
void startSwitchWait(int32_t x, int32_t y);
// stop delay switch timer
void stopSwitchWait();
@ -327,7 +327,7 @@ private:
// returns the corner (EScreenSwitchCornerMasks) where x,y is on the
// given client. corners have the given size.
UInt32 getCorner(BaseClientProxy *, SInt32 x, SInt32 y, SInt32 size) const;
UInt32 getCorner(BaseClientProxy *, int32_t x, int32_t y, int32_t size) const;
// stop relative mouse moves
void stopRelativeMoves();
@ -369,12 +369,12 @@ private:
void onScreensaver(bool activated);
void onKeyDown(KeyID, KeyModifierMask, KeyButton, const std::string &, const char *screens);
void onKeyUp(KeyID, KeyModifierMask, KeyButton, const char *screens);
void onKeyRepeat(KeyID, KeyModifierMask, SInt32, KeyButton, const std::string &);
void onKeyRepeat(KeyID, KeyModifierMask, int32_t, KeyButton, const std::string &);
void onMouseDown(ButtonID);
void onMouseUp(ButtonID);
bool onMouseMovePrimary(SInt32 x, SInt32 y);
void onMouseMoveSecondary(SInt32 dx, SInt32 dy);
void onMouseWheel(SInt32 xDelta, SInt32 yDelta);
bool onMouseMovePrimary(int32_t x, int32_t y);
void onMouseMoveSecondary(int32_t dx, int32_t dy);
void onMouseWheel(int32_t xDelta, int32_t yDelta);
void onFileChunkSending(const void *data);
void onFileRecieveCompleted();
@ -453,14 +453,14 @@ private:
// current mouse position (in absolute screen coordinates) on
// whichever screen is active
SInt32 m_x, m_y;
int32_t m_x, m_y;
// last mouse deltas. this is needed to smooth out double tap
// on win32 which reports bogus mouse motion at the edge of
// the screen when using low level hooks, synthesizing motion
// in the opposite direction the mouse actually moved.
SInt32 m_xDelta, m_yDelta;
SInt32 m_xDelta2, m_yDelta2;
int32_t m_xDelta, m_yDelta;
int32_t m_xDelta2, m_yDelta2;
// current configuration
ServerConfig *m_config;
@ -473,7 +473,7 @@ private:
// state saved when screen saver activates
BaseClientProxy *m_activeSaver;
SInt32 m_xSaver, m_ySaver;
int32_t m_xSaver, m_ySaver;
// common state for screen switch tests. all tests are always
// trying to reach the same screen in the same direction.
@ -483,14 +483,14 @@ private:
// state for delayed screen switching
double m_switchWaitDelay;
EventQueueTimer *m_switchWaitTimer;
SInt32 m_switchWaitX, m_switchWaitY;
int32_t m_switchWaitX, m_switchWaitY;
// state for double-tap screen switching
double m_switchTwoTapDelay;
Stopwatch m_switchTwoTapTimer;
bool m_switchTwoTapEngaged;
bool m_switchTwoTapArmed;
SInt32 m_switchTwoTapZone;
int32_t m_switchTwoTapZone;
// modifiers needed before switching
bool m_switchNeedsShift;

8
src/test/integtests/net/NetworkTests.cpp
View file

@ -59,8 +59,8 @@ const uint16_t kMockDataChunkIncrement = 1024; // 1KB
const char *kMockFilename = "tmp/test/NetworkTests.mock";
const size_t kMockFileSize = 1024 * 1024 * 10; // 10MB
void getScreenShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h);
void getCursorPos(SInt32 &x, SInt32 &y);
void getScreenShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h);
void getCursorPos(int32_t &x, int32_t &y);
uint8_t *newMockData(size_t size);
void createFile(fstream &file, const char *filename, size_t size);
@ -517,14 +517,14 @@ void createFile(fstream &file, const char *filename, size_t size) {
delete[] buffer;
}
void getScreenShape(SInt32 &x, SInt32 &y, SInt32 &w, SInt32 &h) {
void getScreenShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) {
x = 0;
y = 0;
w = 1;
h = 1;
}
void getCursorPos(SInt32 &x, SInt32 &y) {
void getCursorPos(int32_t &x, int32_t &y) {
x = 0;
y = 0;
}

6
src/test/integtests/platform/XWindowsKeyStateTests.cpp
View file

@ -176,7 +176,7 @@ TEST_F(XWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero) {
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
SInt32 actual = keyState.pollActiveGroup();
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(0, actual);
}
@ -188,7 +188,7 @@ TEST_F(XWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup) {
keyState.group(3);
SInt32 actual = keyState.pollActiveGroup();
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(3, actual);
}
@ -206,7 +206,7 @@ TEST_F(XWindowsKeyStateTests, pollActiveGroup_xkb_areEqual) {
// compare pollActiveGroup() with XkbGetState()
if (XkbGetState(m_display, XkbUseCoreKbd, &state) == Success) {
SInt32 actual = keyState.pollActiveGroup();
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(state.group, actual);
} else {

2
src/test/mock/deskflow/MockKeyMap.h
View file

@ -31,7 +31,7 @@ public:
MOCK_METHOD(bool, isHalfDuplex, (KeyID, KeyButton), (const, override));
MOCK_METHOD(
const KeyMap::KeyItem *, mapKey,
(Keystrokes &, KeyID, SInt32, ModifierToKeys &, KeyModifierMask &, KeyModifierMask, bool, const std::string &),
(Keystrokes &, KeyID, int32_t, ModifierToKeys &, KeyModifierMask &, KeyModifierMask, bool, const std::string &),
(const, override)
);
};

4
src/test/mock/deskflow/MockKeyState.h
View file

@ -39,7 +39,7 @@ public:
{
}
MOCK_METHOD(SInt32, pollActiveGroup, (), (const, override));
MOCK_METHOD(int32_t, pollActiveGroup, (), (const, override));
MOCK_METHOD(KeyModifierMask, pollActiveModifiers, (), (const, override));
MOCK_METHOD(bool, fakeCtrlAltDel, (), (override));
MOCK_METHOD(void, getKeyMap, (deskflow::KeyMap &), (override));
@ -52,4 +52,4 @@ typedef ::testing::NiceMock<MockKeyState> KeyStateImpl;
using KeyID = UInt32;
typedef void (*ForeachKeyCallback)(KeyID, SInt32 group, deskflow::KeyMap::KeyItem &, void *userData);
typedef void (*ForeachKeyCallback)(KeyID, int32_t group, deskflow::KeyMap::KeyItem &, void *userData);

4
src/test/mock/deskflow/MockScreen.h
View file

@ -30,8 +30,8 @@ public:
{
}
MOCK_METHOD(void, disable, (), (override));
MOCK_METHOD(void, getShape, (SInt32 &, SInt32 &, SInt32 &, SInt32 &), (const, override));
MOCK_METHOD(void, getCursorPos, (SInt32 &, SInt32 &), (const, override));
MOCK_METHOD(void, getShape, (int32_t &, int32_t &, int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, getCursorPos, (int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, resetOptions, (), (override));
MOCK_METHOD(void, setOptions, (const OptionsList &), (override));
MOCK_METHOD(void, enable, (), (override));

4
src/test/mock/server/MockPrimaryClient.h
View file

@ -27,8 +27,8 @@ class MockPrimaryClient : public PrimaryClient
{
public:
MOCK_METHOD(void *, getEventTarget, (), (const, override));
MOCK_METHOD(void, getCursorPos, (SInt32 &, SInt32 &), (const, override));
MOCK_METHOD(void, setJumpCursorPos, (SInt32, SInt32), (const));
MOCK_METHOD(void, getCursorPos, (int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, setJumpCursorPos, (int32_t, int32_t), (const));
MOCK_METHOD(void, reconfigure, (UInt32), (override));
MOCK_METHOD(void, resetOptions, (), (override));
MOCK_METHOD(void, setOptions, (const OptionsList &), (override));

4
src/test/unittests/client/HelloBackTests.cpp
View file

@ -36,7 +36,7 @@ void intTo2ByteBuf(int16_t value, std::array<char, 2> &buf)
buf[1] = static_cast<char>(value & 0xFF); // LSB
}
void intTo4ByteBuf(SInt32 value, std::array<char, 4> &buf)
void intTo4ByteBuf(int32_t value, std::array<char, 4> &buf)
{
buf[0] = static_cast<char>((value >> 24) & 0xFF); // MSB
buf[1] = static_cast<char>((value >> 16) & 0xFF);
@ -99,7 +99,7 @@ void setupMockHelloBackWrite(
std::array<char, 4> nameLenBuf;
intTo2ByteBuf(majorVersion, majorBuf);
intTo2ByteBuf(minorVersion, minorBuf);
intTo4ByteBuf(static_cast<SInt32>(name.size()), nameLenBuf);
intTo4ByteBuf(static_cast<int32_t>(name.size()), nameLenBuf);
const auto versionIntSize = 4;
const auto clientNameIntSize = 4;

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

@ -35,7 +35,7 @@ void stubPollPressedKeys(IKeyState::KeyButtonSet &pressedKeys);
void assertMaskIsOne(ForeachKeyCallback cb, void *userData);
const deskflow::KeyMap::KeyItem *stubMapKey(
deskflow::KeyMap::Keystrokes &keys, KeyID id, SInt32 group, deskflow::KeyMap::ModifierToKeys &activeModifiers,
deskflow::KeyMap::Keystrokes &keys, KeyID id, int32_t group, deskflow::KeyMap::ModifierToKeys &activeModifiers,
KeyModifierMask &currentState, KeyModifierMask desiredMask, bool isAutoRepeat, const std::string &lang
);
@ -484,7 +484,7 @@ void assertMaskIsOne(ForeachKeyCallback cb, void *userData)
}
const deskflow::KeyMap::KeyItem *
stubMapKey(deskflow::KeyMap::Keystrokes &keys, KeyID, SInt32, deskflow::KeyMap::ModifierToKeys &, KeyModifierMask &, KeyModifierMask, bool, const std::string &)
stubMapKey(deskflow::KeyMap::Keystrokes &keys, KeyID, int32_t, deskflow::KeyMap::ModifierToKeys &, KeyModifierMask &, KeyModifierMask, bool, const std::string &)
{
keys.push_back(s_stubKeystroke);
return &s_stubKeyItem;