1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/*
* barrier -- mouse and keyboard sharing utility
* Copyright (C) 2012-2016 Symless Ltd.
* Copyright (C) 2003 Chris Schoeneman
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* found in the file LICENSE that should have accompanied this file.
*
* This package is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "barrier/key_types.h"
#include "base/Event.h"
#include "base/String.h"
#include "base/IEventQueue.h"
#include "base/EventTypes.h"
#include "common/stdset.h"
#include "common/IInterface.h"
//! Key state interface
/*!
This interface provides access to set and query the keyboard state and
to synthesize key events.
*/
class IKeyState : public IInterface {
public:
IKeyState(IEventQueue* events);
enum {
kNumButtons = 0x200
};
//! Key event data
class KeyInfo {
public:
static KeyInfo* alloc(KeyID, KeyModifierMask, KeyButton, SInt32 count);
static KeyInfo* alloc(KeyID, KeyModifierMask, KeyButton, SInt32 count,
const std::set<String>& destinations);
static KeyInfo* alloc(const KeyInfo&);
static bool isDefault(const char* screens);
static bool contains(const char* screens, const String& name);
static bool equal(const KeyInfo*, const KeyInfo*);
static String join(const std::set<String>& destinations);
static void split(const char* screens, std::set<String>&);
public:
KeyID m_key;
KeyModifierMask m_mask;
KeyButton m_button;
SInt32 m_count;
char* m_screens;
char m_screensBuffer[1];
};
typedef std::set<KeyButton> KeyButtonSet;
//! @name manipulators
//@{
//! Update the keyboard map
/*!
Causes the key state to get updated to reflect the current keyboard
mapping.
*/
virtual void updateKeyMap() = 0;
//! Update the key state
/*!
Causes the key state to get updated to reflect the physical keyboard
state.
*/
virtual void updateKeyState() = 0;
//! Set half-duplex mask
/*!
Sets which modifier toggle keys are half-duplex. A half-duplex
toggle key doesn't report a key release when toggled on and
doesn't report a key press when toggled off.
*/
virtual void setHalfDuplexMask(KeyModifierMask) = 0;
//! Fake a key press
/*!
Synthesizes a key press event and updates the key state.
*/
virtual void fakeKeyDown(KeyID id, KeyModifierMask mask,
KeyButton button) = 0;
//! Fake a key repeat
/*!
Synthesizes a key repeat event and updates the key state.
*/
virtual bool fakeKeyRepeat(KeyID id, KeyModifierMask mask,
SInt32 count, KeyButton button) = 0;
//! Fake a key release
/*!
Synthesizes a key release event and updates the key state.
*/
virtual bool fakeKeyUp(KeyButton button) = 0;
//! Fake key releases for all fake pressed keys
/*!
Synthesizes a key release event for every key that is synthetically
pressed and updates the key state.
*/
virtual void fakeAllKeysUp() = 0;
//! Fake ctrl+alt+del
/*!
Synthesize a press of ctrl+alt+del. Return true if processing is
complete and false if normal key processing should continue.
*/
virtual bool fakeCtrlAltDel() = 0;
//! Fake a media key
/*!
Synthesizes a media key down and up. Only Mac would implement this by
use cocoa appkit framework.
*/
virtual bool fakeMediaKey(KeyID id) = 0;
//@}
//! @name accessors
//@{
//! Test if key is pressed
/*!
Returns true iff the given key is down. Half-duplex toggles
always return false.
*/
virtual bool isKeyDown(KeyButton) const = 0;
//! Get the active modifiers
/*!
Returns the modifiers that are currently active according to our
shadowed state.
*/
virtual KeyModifierMask
getActiveModifiers() const = 0;
//! Get the active modifiers from OS
/*!
Returns the modifiers that are currently active according to the
operating system.
*/
virtual KeyModifierMask
pollActiveModifiers() const = 0;
//! Get the active keyboard layout from OS
/*!
Returns the active keyboard layout according to the operating system.
*/
virtual SInt32 pollActiveGroup() const = 0;
//! Get the keys currently pressed from OS
/*!
Adds any keys that are currently pressed according to the operating
system to \p pressedKeys.
*/
virtual void pollPressedKeys(KeyButtonSet& pressedKeys) const = 0;
//@}
};
|
