FreeRDP
Loading...
Searching...
No Matches
xf_keyboard.c
1
20#include <freerdp/config.h>
21
22#include <ctype.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <stdint.h>
27
28#include <winpr/crt.h>
29#include <winpr/path.h>
30#include <winpr/assert.h>
31#include <winpr/cast.h>
32#include <winpr/collections.h>
33
34#include <freerdp/utils/string.h>
35
36#include <X11/Xlib.h>
37#include <X11/Xutil.h>
38#include <X11/keysym.h>
39#include <X11/XKBlib.h>
40
41#include <freerdp/locale/keyboard.h>
42#include <freerdp/locale/locale.h>
43
44#include "xf_event.h"
45
46#include "xf_keyboard.h"
47
48#include "xf_utils.h"
49#include "keyboard_x11.h"
50
51#include <freerdp/log.h>
52#define TAG CLIENT_TAG("x11")
53
54typedef struct
55{
56 BOOL Shift;
57 BOOL LeftShift;
58 BOOL RightShift;
59 BOOL Alt;
60 BOOL LeftAlt;
61 BOOL RightAlt;
62 BOOL Ctrl;
63 BOOL LeftCtrl;
64 BOOL RightCtrl;
65 BOOL Super;
66 BOOL LeftSuper;
67 BOOL RightSuper;
68} XF_MODIFIER_KEYS;
69
70struct x11_key_scancode_t
71{
72 const char* name;
73 DWORD sc;
74};
75
76static const struct x11_key_scancode_t XKB_KEY_NAME_SCANCODE_TABLE[] = {
77 { "", RDP_SCANCODE_UNKNOWN }, /* 008: [(null)] */
78 { "ESC", RDP_SCANCODE_ESCAPE }, /* 009: ESC [Escape] */
79 { "AE01", RDP_SCANCODE_KEY_1 }, /* 010: AE01 [1] */
80 { "AE02", RDP_SCANCODE_KEY_2 }, /* 011: AE02 [2] */
81 { "AE03", RDP_SCANCODE_KEY_3 }, /* 012: AE03 [3] */
82 { "AE04", RDP_SCANCODE_KEY_4 }, /* 013: AE04 [4] */
83 { "AE05", RDP_SCANCODE_KEY_5 }, /* 014: AE05 [5] */
84 { "AE06", RDP_SCANCODE_KEY_6 }, /* 015: AE06 [6] */
85 { "AE07", RDP_SCANCODE_KEY_7 }, /* 016: AE07 [7] */
86 { "AE08", RDP_SCANCODE_KEY_8 }, /* 017: AE08 [8] */
87 { "AE09", RDP_SCANCODE_KEY_9 }, /* 018: AE09 [9] */
88 { "AE10", RDP_SCANCODE_KEY_0 }, /* 019: AE10 [0] */
89 { "AE11", RDP_SCANCODE_OEM_MINUS }, /* 020: AE11 [minus] */
90 { "AE12", RDP_SCANCODE_OEM_PLUS }, /* 021: AE12 [equal] */
91 { "BKSP", RDP_SCANCODE_BACKSPACE }, /* 022: BKSP [BackSpace] */
92 { "TAB", RDP_SCANCODE_TAB }, /* 023: TAB [Tab] */
93 { "AD01", RDP_SCANCODE_KEY_Q }, /* 024: AD01 [q] */
94 { "AD02", RDP_SCANCODE_KEY_W }, /* 025: AD02 [w] */
95 { "AD03", RDP_SCANCODE_KEY_E }, /* 026: AD03 [e] */
96 { "AD04", RDP_SCANCODE_KEY_R }, /* 027: AD04 [r] */
97 { "AD05", RDP_SCANCODE_KEY_T }, /* 028: AD05 [t] */
98 { "AD06", RDP_SCANCODE_KEY_Y }, /* 029: AD06 [y] */
99 { "AD07", RDP_SCANCODE_KEY_U }, /* 030: AD07 [u] */
100 { "AD08", RDP_SCANCODE_KEY_I }, /* 031: AD08 [i] */
101 { "AD09", RDP_SCANCODE_KEY_O }, /* 032: AD09 [o] */
102 { "AD10", RDP_SCANCODE_KEY_P }, /* 033: AD10 [p] */
103 { "AD11", RDP_SCANCODE_OEM_4 }, /* 034: AD11 [bracketleft] */
104 { "AD12", RDP_SCANCODE_OEM_6 }, /* 035: AD12 [bracketright] */
105 { "RTRN", RDP_SCANCODE_RETURN }, /* 036: RTRN [Return] */
106 { "LCTL", RDP_SCANCODE_LCONTROL }, /* 037: LCTL [Control_L] */
107 { "AC01", RDP_SCANCODE_KEY_A }, /* 038: AC01 [a] */
108 { "AC02", RDP_SCANCODE_KEY_S }, /* 039: AC02 [s] */
109 { "AC03", RDP_SCANCODE_KEY_D }, /* 040: AC03 [d] */
110 { "AC04", RDP_SCANCODE_KEY_F }, /* 041: AC04 [f] */
111 { "AC05", RDP_SCANCODE_KEY_G }, /* 042: AC05 [g] */
112 { "AC06", RDP_SCANCODE_KEY_H }, /* 043: AC06 [h] */
113 { "AC07", RDP_SCANCODE_KEY_J }, /* 044: AC07 [j] */
114 { "AC08", RDP_SCANCODE_KEY_K }, /* 045: AC08 [k] */
115 { "AC09", RDP_SCANCODE_KEY_L }, /* 046: AC09 [l] */
116 { "AC10", RDP_SCANCODE_OEM_1 }, /* 047: AC10 [semicolon] */
117 { "AC11", RDP_SCANCODE_OEM_7 }, /* 048: AC11 [dead_acute] */
118 { "TLDE", RDP_SCANCODE_OEM_3 }, /* 049: TLDE [dead_grave] */
119 { "LFSH", RDP_SCANCODE_LSHIFT }, /* 050: LFSH [Shift_L] */
120 { "BKSL", RDP_SCANCODE_OEM_5 }, /* 051: BKSL [backslash] */
121 { "AB01", RDP_SCANCODE_KEY_Z }, /* 052: AB01 [z] */
122 { "AB02", RDP_SCANCODE_KEY_X }, /* 053: AB02 [x] */
123 { "AB03", RDP_SCANCODE_KEY_C }, /* 054: AB03 [c] */
124 { "AB04", RDP_SCANCODE_KEY_V }, /* 055: AB04 [v] */
125 { "AB05", RDP_SCANCODE_KEY_B }, /* 056: AB05 [b] */
126 { "AB06", RDP_SCANCODE_KEY_N }, /* 057: AB06 [n] */
127 { "AB07", RDP_SCANCODE_KEY_M }, /* 058: AB07 [m] */
128 { "AB08", RDP_SCANCODE_OEM_COMMA }, /* 059: AB08 [comma] */
129 { "AB09", RDP_SCANCODE_OEM_PERIOD }, /* 060: AB09 [period] */
130 { "AB10", RDP_SCANCODE_OEM_2 }, /* 061: AB10 [slash] */
131 { "RTSH", RDP_SCANCODE_RSHIFT }, /* 062: RTSH [Shift_R] */
132 { "KPMU", RDP_SCANCODE_MULTIPLY }, /* 063: KPMU [KP_Multiply] */
133 { "LALT", RDP_SCANCODE_LMENU }, /* 064: LALT [Alt_L] */
134 { "SPCE", RDP_SCANCODE_SPACE }, /* 065: SPCE [space] */
135 { "CAPS", RDP_SCANCODE_CAPSLOCK }, /* 066: CAPS [Caps_Lock] */
136 { "FK01", RDP_SCANCODE_F1 }, /* 067: FK01 [F1] */
137 { "FK02", RDP_SCANCODE_F2 }, /* 068: FK02 [F2] */
138 { "FK03", RDP_SCANCODE_F3 }, /* 069: FK03 [F3] */
139 { "FK04", RDP_SCANCODE_F4 }, /* 070: FK04 [F4] */
140 { "FK05", RDP_SCANCODE_F5 }, /* 071: FK05 [F5] */
141 { "FK06", RDP_SCANCODE_F6 }, /* 072: FK06 [F6] */
142 { "FK07", RDP_SCANCODE_F7 }, /* 073: FK07 [F7] */
143 { "FK08", RDP_SCANCODE_F8 }, /* 074: FK08 [F8] */
144 { "FK09", RDP_SCANCODE_F9 }, /* 075: FK09 [F9] */
145 { "FK10", RDP_SCANCODE_F10 }, /* 076: FK10 [F10] */
146 { "NMLK", RDP_SCANCODE_NUMLOCK }, /* 077: NMLK [Num_Lock] */
147 { "SCLK", RDP_SCANCODE_SCROLLLOCK }, /* 078: SCLK [Multi_key] */
148 { "KP7", RDP_SCANCODE_NUMPAD7 }, /* 079: KP7 [KP_Home] */
149 { "KP8", RDP_SCANCODE_NUMPAD8 }, /* 080: KP8 [KP_Up] */
150 { "KP9", RDP_SCANCODE_NUMPAD9 }, /* 081: KP9 [KP_Prior] */
151 { "KPSU", RDP_SCANCODE_SUBTRACT }, /* 082: KPSU [KP_Subtract] */
152 { "KP4", RDP_SCANCODE_NUMPAD4 }, /* 083: KP4 [KP_Left] */
153 { "KP5", RDP_SCANCODE_NUMPAD5 }, /* 084: KP5 [KP_Begin] */
154 { "KP6", RDP_SCANCODE_NUMPAD6 }, /* 085: KP6 [KP_Right] */
155 { "KPAD", RDP_SCANCODE_ADD }, /* 086: KPAD [KP_Add] */
156 { "KP1", RDP_SCANCODE_NUMPAD1 }, /* 087: KP1 [KP_End] */
157 { "KP2", RDP_SCANCODE_NUMPAD2 }, /* 088: KP2 [KP_Down] */
158 { "KP3", RDP_SCANCODE_NUMPAD3 }, /* 089: KP3 [KP_Next] */
159 { "KP0", RDP_SCANCODE_NUMPAD0 }, /* 090: KP0 [KP_Insert] */
160 { "KPDL", RDP_SCANCODE_DECIMAL }, /* 091: KPDL [KP_Delete] */
161 { "LVL3", RDP_SCANCODE_RMENU }, /* 092: LVL3 [ISO_Level3_Shift] */
162 { "", RDP_SCANCODE_UNKNOWN }, /* 093: [(null)] */
163 { "LSGT", RDP_SCANCODE_OEM_102 }, /* 094: LSGT [backslash] */
164 { "FK11", RDP_SCANCODE_F11 }, /* 095: FK11 [F11] */
165 { "FK12", RDP_SCANCODE_F12 }, /* 096: FK12 [F12] */
166 { "AB11", RDP_SCANCODE_ABNT_C1 }, /* 097: AB11 [(null)] */
167 { "KATA", RDP_SCANCODE_KANA_HANGUL }, /* 098: KATA [Katakana] */
168 { "HIRA", RDP_SCANCODE_HIRAGANA }, /* 099: HIRA [Hiragana] */
169 { "HENK", RDP_SCANCODE_CONVERT_JP }, /* 100: HENK [Henkan_Mode] */
170 { "HKTG", RDP_SCANCODE_HIRAGANA }, /* 101: HKTG [Hiragana_Katakana] */
171 { "MUHE", RDP_SCANCODE_NONCONVERT_JP }, /* 102: MUHE [Muhenkan] */
172 { "JPCM", RDP_SCANCODE_UNKNOWN }, /* 103: JPCM [(null)] */
173 { "KPEN", RDP_SCANCODE_RETURN_KP }, /* 104: KPEN [KP_Enter] */
174 { "RCTL", RDP_SCANCODE_RCONTROL }, /* 105: RCTL [Control_R] */
175 { "KPDV", RDP_SCANCODE_DIVIDE }, /* 106: KPDV [KP_Divide] */
176 { "PRSC", RDP_SCANCODE_PRINTSCREEN }, /* 107: PRSC [Print] */
177 { "RALT", RDP_SCANCODE_RMENU }, /* 108: RALT [ISO_Level3_Shift] */
178 { "LNFD", RDP_SCANCODE_UNKNOWN }, /* 109: LNFD [Linefeed] */
179 { "HOME", RDP_SCANCODE_HOME }, /* 110: HOME [Home] */
180 { "UP", RDP_SCANCODE_UP }, /* 111: UP [Up] */
181 { "PGUP", RDP_SCANCODE_PRIOR }, /* 112: PGUP [Prior] */
182 { "LEFT", RDP_SCANCODE_LEFT }, /* 113: LEFT [Left] */
183 { "RGHT", RDP_SCANCODE_RIGHT }, /* 114: RGHT [Right] */
184 { "END", RDP_SCANCODE_END }, /* 115: END [End] */
185 { "DOWN", RDP_SCANCODE_DOWN }, /* 116: DOWN [Down] */
186 { "PGDN", RDP_SCANCODE_NEXT }, /* 117: PGDN [Next] */
187 { "INS", RDP_SCANCODE_INSERT }, /* 118: INS [Insert] */
188 { "DELE", RDP_SCANCODE_DELETE }, /* 119: DELE [Delete] */
189 { "I120", RDP_SCANCODE_UNKNOWN }, /* 120: I120 [(null)] */
190 { "MUTE", RDP_SCANCODE_VOLUME_MUTE }, /* 121: MUTE [XF86AudioMute] */
191 { "VOL-", RDP_SCANCODE_VOLUME_DOWN }, /* 122: VOL- [XF86AudioLowerVolume] */
192 { "VOL+", RDP_SCANCODE_VOLUME_UP }, /* 123: VOL+ [XF86AudioRaiseVolume] */
193 { "POWR", RDP_SCANCODE_UNKNOWN }, /* 124: POWR [XF86PowerOff] */
194 { "KPEQ", RDP_SCANCODE_UNKNOWN }, /* 125: KPEQ [KP_Equal] */
195 { "I126", RDP_SCANCODE_UNKNOWN }, /* 126: I126 [plusminus] */
196 { "PAUS", RDP_SCANCODE_PAUSE }, /* 127: PAUS [Pause] */
197 { "I128", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 128: I128 [XF86LaunchA] */
198 { "I129", RDP_SCANCODE_ABNT_C2 }, /* 129: I129 [KP_Decimal] */
199 { "HNGL", RDP_SCANCODE_HANGUL }, /* 130: HNGL [Hangul] */
200 { "HJCV", RDP_SCANCODE_HANJA }, /* 131: HJCV [Hangul_Hanja] */
201 { "AE13", RDP_SCANCODE_BACKSLASH_JP }, /* 132: AE13 [(null)] */
202 { "LWIN", RDP_SCANCODE_LWIN }, /* 133: LWIN [Super_L] */
203 { "RWIN", RDP_SCANCODE_RWIN }, /* 134: RWIN [Super_R] */
204 { "COMP", RDP_SCANCODE_APPS }, /* 135: COMP [Menu] */
205 { "STOP", RDP_SCANCODE_BROWSER_STOP }, /* 136: STOP [Cancel] */
206 { "AGAI" /* codespell:ignore */, RDP_SCANCODE_UNKNOWN },
207 /* 137: AGAI [Redo] */ /* codespell:ignore */
208 { "PROP", RDP_SCANCODE_UNKNOWN }, /* 138: PROP [SunProps] */
209 { "UNDO", RDP_SCANCODE_UNKNOWN }, /* 139: UNDO [Undo] */
210 { "FRNT", RDP_SCANCODE_UNKNOWN }, /* 140: FRNT [SunFront] */
211 { "COPY", RDP_SCANCODE_UNKNOWN }, /* 141: COPY [XF86Copy] */
212 { "OPEN", RDP_SCANCODE_UNKNOWN }, /* 142: OPEN [XF86Open] */
213 { "PAST", RDP_SCANCODE_UNKNOWN }, /* 143: PAST [XF86Paste] */
214 { "FIND", RDP_SCANCODE_UNKNOWN }, /* 144: FIND [Find] */
215 { "CUT", RDP_SCANCODE_UNKNOWN }, /* 145: CUT [XF86Cut] */
216 { "HELP", RDP_SCANCODE_HELP }, /* 146: HELP [Help] */
217 { "I147", RDP_SCANCODE_UNKNOWN }, /* 147: I147 [XF86MenuKB] */
218 { "I148", RDP_SCANCODE_UNKNOWN }, /* 148: I148 [XF86Calculator] */
219 { "I149", RDP_SCANCODE_UNKNOWN }, /* 149: I149 [(null)] */
220 { "I150", RDP_SCANCODE_SLEEP }, /* 150: I150 [XF86Sleep] */
221 { "I151", RDP_SCANCODE_UNKNOWN }, /* 151: I151 [XF86WakeUp] */
222 { "I152", RDP_SCANCODE_UNKNOWN }, /* 152: I152 [XF86Explorer] */
223 { "I153", RDP_SCANCODE_UNKNOWN }, /* 153: I153 [XF86Send] */
224 { "I154", RDP_SCANCODE_UNKNOWN }, /* 154: I154 [(null)] */
225 { "I155", RDP_SCANCODE_UNKNOWN }, /* 155: I155 [XF86Xfer] */
226 { "I156", RDP_SCANCODE_LAUNCH_APP1 }, /* 156: I156 [XF86Launch1] */
227 { "I157", RDP_SCANCODE_LAUNCH_APP2 }, /* 157: I157 [XF86Launch2] */
228 { "I158", RDP_SCANCODE_BROWSER_HOME }, /* 158: I158 [XF86WWW] */
229 { "I159", RDP_SCANCODE_UNKNOWN }, /* 159: I159 [XF86DOS] */
230 { "I160", RDP_SCANCODE_UNKNOWN }, /* 160: I160 [XF86ScreenSaver] */
231 { "I161", RDP_SCANCODE_UNKNOWN }, /* 161: I161 [XF86RotateWindows] */
232 { "I162", RDP_SCANCODE_UNKNOWN }, /* 162: I162 [XF86TaskPane] */
233 { "I163", RDP_SCANCODE_LAUNCH_MAIL }, /* 163: I163 [XF86Mail] */
234 { "I164", RDP_SCANCODE_BROWSER_FAVORITES }, /* 164: I164 [XF86Favorites] */
235 { "I165", RDP_SCANCODE_UNKNOWN }, /* 165: I165 [XF86MyComputer] */
236 { "I166", RDP_SCANCODE_BROWSER_BACK }, /* 166: I166 [XF86Back] */
237 { "I167", RDP_SCANCODE_BROWSER_FORWARD }, /* 167: I167 [XF86Forward] */
238 { "I168", RDP_SCANCODE_UNKNOWN }, /* 168: I168 [(null)] */
239 { "I169", RDP_SCANCODE_UNKNOWN }, /* 169: I169 [XF86Eject] */
240 { "I170", RDP_SCANCODE_UNKNOWN }, /* 170: I170 [XF86Eject] */
241 { "I171", RDP_SCANCODE_MEDIA_NEXT_TRACK }, /* 171: I171 [XF86AudioNext] */
242 { "I172", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 172: I172 [XF86AudioPlay] */
243 { "I173", RDP_SCANCODE_MEDIA_PREV_TRACK }, /* 173: I173 [XF86AudioPrev] */
244 { "I174", RDP_SCANCODE_MEDIA_STOP }, /* 174: I174 [XF86AudioStop] */
245 { "I175", RDP_SCANCODE_UNKNOWN }, /* 175: I175 [XF86AudioRecord] */
246 { "I176", RDP_SCANCODE_UNKNOWN }, /* 176: I176 [XF86AudioRewind] */
247 { "I177", RDP_SCANCODE_UNKNOWN }, /* 177: I177 [XF86Phone] */
248 { "I178", RDP_SCANCODE_UNKNOWN }, /* 178: I178 [(null)] */
249 { "I179", RDP_SCANCODE_UNKNOWN }, /* 179: I179 [XF86Tools] */
250 { "I180", RDP_SCANCODE_BROWSER_HOME }, /* 180: I180 [XF86HomePage] */
251 { "I181", RDP_SCANCODE_BROWSER_REFRESH }, /* 181: I181 [XF86Reload] */
252 { "I182", RDP_SCANCODE_UNKNOWN }, /* 182: I182 [XF86Close] */
253 { "I183", RDP_SCANCODE_UNKNOWN }, /* 183: I183 [(null)] */
254 { "I184", RDP_SCANCODE_UNKNOWN }, /* 184: I184 [(null)] */
255 { "I185", RDP_SCANCODE_UNKNOWN }, /* 185: I185 [XF86ScrollUp] */
256 { "I186", RDP_SCANCODE_UNKNOWN }, /* 186: I186 [XF86ScrollDown] */
257 { "I187", RDP_SCANCODE_UNKNOWN }, /* 187: I187 [parenleft] */
258 { "I188", RDP_SCANCODE_UNKNOWN }, /* 188: I188 [parenright] */
259 { "I189", RDP_SCANCODE_UNKNOWN }, /* 189: I189 [XF86New] */
260 { "I190", RDP_SCANCODE_UNKNOWN }, /* 190: I190 [Redo] */
261 { "FK13", RDP_SCANCODE_F13 }, /* 191: FK13 [XF86Tools] */
262 { "FK14", RDP_SCANCODE_F14 }, /* 192: FK14 [XF86Launch5] */
263 { "FK15", RDP_SCANCODE_F15 }, /* 193: FK15 [XF86Launch6] */
264 { "FK16", RDP_SCANCODE_F16 }, /* 194: FK16 [XF86Launch7] */
265 { "FK17", RDP_SCANCODE_F17 }, /* 195: FK17 [XF86Launch8] */
266 { "FK18", RDP_SCANCODE_F18 }, /* 196: FK18 [XF86Launch9] */
267 { "FK19", RDP_SCANCODE_F19 }, /* 197: FK19 [(null)] */
268 { "FK20", RDP_SCANCODE_F20 }, /* 198: FK20 [XF86AudioMicMute] */
269 { "FK21", RDP_SCANCODE_F21 }, /* 199: FK21 [XF86TouchpadToggle] */
270 { "FK22", RDP_SCANCODE_F22 }, /* 200: FK22 [XF86TouchpadOn] */
271 { "FK23", RDP_SCANCODE_F23 }, /* 201: FK23 [XF86TouchpadOff] */
272 { "FK24", RDP_SCANCODE_F24 }, /* 202: FK24 [(null)] */
273 { "LVL5", RDP_SCANCODE_UNKNOWN }, /* 203: LVL5 [ISO_Level5_Shift] */
274 { "ALT", RDP_SCANCODE_LMENU }, /* 204: ALT [(null)] */
275 { "META", RDP_SCANCODE_LMENU }, /* 205: META [(null)] */
276 { "SUPR", RDP_SCANCODE_LWIN }, /* 206: SUPR [(null)] */
277 { "HYPR", RDP_SCANCODE_LWIN }, /* 207: HYPR [(null)] */
278 { "I208", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 208: I208 [XF86AudioPlay] */
279 { "I209", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 209: I209 [XF86AudioPause] */
280 { "I210", RDP_SCANCODE_UNKNOWN }, /* 210: I210 [XF86Launch3] */
281 { "I211", RDP_SCANCODE_UNKNOWN }, /* 211: I211 [XF86Launch4] */
282 { "I212", RDP_SCANCODE_UNKNOWN }, /* 212: I212 [XF86LaunchB] */
283 { "I213", RDP_SCANCODE_UNKNOWN }, /* 213: I213 [XF86Suspend] */
284 { "I214", RDP_SCANCODE_UNKNOWN }, /* 214: I214 [XF86Close] */
285 { "I215", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 215: I215 [XF86AudioPlay] */
286 { "I216", RDP_SCANCODE_MEDIA_NEXT_TRACK }, /* 216: I216 [XF86AudioForward] */
287 { "I217", RDP_SCANCODE_UNKNOWN }, /* 217: I217 [(null)] */
288 { "I218", RDP_SCANCODE_UNKNOWN }, /* 218: I218 [Print] */
289 { "I219", RDP_SCANCODE_UNKNOWN }, /* 219: I219 [(null)] */
290 { "I220", RDP_SCANCODE_UNKNOWN }, /* 220: I220 [XF86WebCam] */
291 { "I221", RDP_SCANCODE_UNKNOWN }, /* 221: I221 [XF86AudioPreset] */
292 { "I222", RDP_SCANCODE_UNKNOWN }, /* 222: I222 [(null)] */
293 { "I223", RDP_SCANCODE_LAUNCH_MAIL }, /* 223: I223 [XF86Mail] */
294 { "I224", RDP_SCANCODE_UNKNOWN }, /* 224: I224 [XF86Messenger] */
295 { "I225", RDP_SCANCODE_BROWSER_SEARCH }, /* 225: I225 [XF86Search] */
296 { "I226", RDP_SCANCODE_UNKNOWN }, /* 226: I226 [XF86Go] */
297 { "I227", RDP_SCANCODE_UNKNOWN }, /* 227: I227 [XF86Finance] */
298 { "I228", RDP_SCANCODE_UNKNOWN }, /* 228: I228 [XF86Game] */
299 { "I229", RDP_SCANCODE_UNKNOWN }, /* 229: I229 [XF86Shop] */
300 { "I230", RDP_SCANCODE_UNKNOWN }, /* 230: I230 [(null)] */
301 { "I231", RDP_SCANCODE_UNKNOWN }, /* 231: I231 [Cancel] */
302 { "I232", RDP_SCANCODE_UNKNOWN }, /* 232: I232 [XF86MonBrightnessDown] */
303 { "I233", RDP_SCANCODE_UNKNOWN }, /* 233: I233 [XF86MonBrightnessUp] */
304 { "I234", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 234: I234 [XF86AudioMedia] */
305 { "I235", RDP_SCANCODE_UNKNOWN }, /* 235: I235 [XF86Display] */
306 { "I236", RDP_SCANCODE_UNKNOWN }, /* 236: I236 [XF86KbdLightOnOff] */
307 { "I237", RDP_SCANCODE_UNKNOWN }, /* 237: I237 [XF86KbdBrightnessDown] */
308 { "I238", RDP_SCANCODE_UNKNOWN }, /* 238: I238 [XF86KbdBrightnessUp] */
309 { "I239", RDP_SCANCODE_UNKNOWN }, /* 239: I239 [XF86Send] */
310 { "I240", RDP_SCANCODE_UNKNOWN }, /* 240: I240 [XF86Reply] */
311 { "I241", RDP_SCANCODE_UNKNOWN }, /* 241: I241 [XF86MailForward] */
312 { "I242", RDP_SCANCODE_UNKNOWN }, /* 242: I242 [XF86Save] */
313 { "I243", RDP_SCANCODE_UNKNOWN }, /* 243: I243 [XF86Documents] */
314 { "I244", RDP_SCANCODE_UNKNOWN }, /* 244: I244 [XF86Battery] */
315 { "I245", RDP_SCANCODE_UNKNOWN }, /* 245: I245 [XF86Bluetooth] */
316 { "I246", RDP_SCANCODE_UNKNOWN }, /* 246: I246 [XF86WLAN] */
317 { "I247", RDP_SCANCODE_UNKNOWN }, /* 247: I247 [XF86UWB] */
318 { "I248", RDP_SCANCODE_UNKNOWN }, /* 248: I248 [(null)] */
319 { "I249", RDP_SCANCODE_UNKNOWN }, /* 249: I249 [XF86Next_VMode] */
320 { "I250", RDP_SCANCODE_UNKNOWN }, /* 250: I250 [XF86Prev_VMode] */
321 { "I251", RDP_SCANCODE_UNKNOWN }, /* 251: I251 [XF86MonBrightnessCycle] */
322 { "I252", RDP_SCANCODE_UNKNOWN }, /* 252: I252 [XF86BrightnessAuto] */
323 { "I253", RDP_SCANCODE_UNKNOWN }, /* 253: I253 [XF86DisplayOff] */
324 { "I254", RDP_SCANCODE_UNKNOWN }, /* 254: I254 [XF86WWAN] */
325 { "I255", RDP_SCANCODE_UNKNOWN } /* 255: I255 [XF86RFKill] */
326};
327
328static UINT32 xf_keyboard_get_toggle_keys_state(xfContext* xfc);
329static BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym);
330static void xf_keyboard_handle_special_keys_release(xfContext* xfc, KeySym keysym);
331
332static void xf_keyboard_modifier_map_free(xfContext* xfc)
333{
334 WINPR_ASSERT(xfc);
335 if (xfc->modifierMap)
336 {
337 XFreeModifiermap(xfc->modifierMap);
338 xfc->modifierMap = NULL;
339 }
340}
341
342BOOL xf_keyboard_update_modifier_map(xfContext* xfc)
343{
344 WINPR_ASSERT(xfc);
345 xf_keyboard_modifier_map_free(xfc);
346 xfc->modifierMap = XGetModifierMapping(xfc->display);
347 return xfc->modifierMap != NULL;
348}
349
350static void xf_keyboard_send_key(xfContext* xfc, BOOL down, BOOL repeat, const XKeyEvent* ev);
351
352static BOOL xf_sync_kbd_state(xfContext* xfc)
353{
354 const UINT32 syncFlags = xf_keyboard_get_toggle_keys_state(xfc);
355
356 WINPR_ASSERT(xfc);
357 return freerdp_input_send_synchronize_event(xfc->common.context.input, syncFlags);
358}
359
360static void xf_keyboard_clear(xfContext* xfc)
361{
362 WINPR_ASSERT(xfc);
363 ZeroMemory(xfc->KeyboardState, sizeof(xfc->KeyboardState));
364}
365
366static BOOL xf_action_script_append(xfContext* xfc, const char* buffer, size_t size,
367 WINPR_ATTR_UNUSED void* user, const char* what, const char* arg)
368{
369 WINPR_ASSERT(xfc);
370 WINPR_UNUSED(what);
371 WINPR_UNUSED(arg);
372
373 if (!buffer || (size == 0))
374 return TRUE;
375 return ArrayList_Append(xfc->keyCombinations, buffer);
376}
377
378static void xf_keyboard_action_script_free(xfContext* xfc)
379{
380 xf_event_action_script_free(xfc);
381
382 if (xfc->keyCombinations)
383 {
384 ArrayList_Free(xfc->keyCombinations);
385 xfc->keyCombinations = NULL;
386 xfc->actionScriptExists = FALSE;
387 }
388}
389
390BOOL xf_keyboard_action_script_init(xfContext* xfc)
391{
392 WINPR_ASSERT(xfc);
393
394 xf_keyboard_action_script_free(xfc);
395 xfc->keyCombinations = ArrayList_New(TRUE);
396
397 if (!xfc->keyCombinations)
398 return FALSE;
399
400 wObject* obj = ArrayList_Object(xfc->keyCombinations);
401 WINPR_ASSERT(obj);
402 obj->fnObjectNew = winpr_ObjectStringClone;
403 obj->fnObjectFree = winpr_ObjectStringFree;
404
405 if (!run_action_script(xfc, "key", NULL, xf_action_script_append, NULL))
406 return FALSE;
407
408 return xf_event_action_script_init(xfc);
409}
410
411static int xkb_cmp(const void* pva, const void* pvb)
412{
413 const struct x11_key_scancode_t* a = pva;
414 const struct x11_key_scancode_t* b = pvb;
415
416 if (!a && !b)
417 return 0;
418 if (!a)
419 return 1;
420 if (!b)
421 return -1;
422 return strcmp(a->name, b->name);
423}
424
425static BOOL try_add(xfContext* xfc, size_t offset, const char* xkb_keyname)
426{
427 WINPR_ASSERT(xfc);
428
429 static BOOL initialized = FALSE;
430 static struct x11_key_scancode_t copy[ARRAYSIZE(XKB_KEY_NAME_SCANCODE_TABLE)] = { 0 };
431 if (!initialized)
432 {
433 // TODO: Here we can do some magic:
434 // depending on input keyboard type use different mapping! (e.g. IBM, Apple, ...)
435 memcpy(copy, XKB_KEY_NAME_SCANCODE_TABLE, sizeof(copy));
436 qsort(copy, ARRAYSIZE(copy), sizeof(struct x11_key_scancode_t), xkb_cmp);
437 initialized = TRUE;
438 }
439
440 struct x11_key_scancode_t key = { .name = xkb_keyname,
441 .sc = WINPR_ASSERTING_INT_CAST(uint32_t, offset) };
442
443 struct x11_key_scancode_t* found =
444 bsearch(&key, copy, ARRAYSIZE(copy), sizeof(struct x11_key_scancode_t), xkb_cmp);
445 if (found)
446 {
447 WLog_Print(xfc->log, WLOG_DEBUG,
448 "%4s: keycode: 0x%02" PRIuz " -> rdp scancode: 0x%08" PRIx32 "", xkb_keyname,
449 offset, found->sc);
450 xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[offset] = found->sc;
451 return TRUE;
452 }
453
454 return FALSE;
455}
456
457static int load_map_from_xkbfile(xfContext* xfc)
458{
459 WINPR_ASSERT(xfc);
460 int status = -1;
461
462 if (!xfc->display)
463 return -2;
464
465 XkbDescPtr xkb = XkbGetMap(xfc->display, 0, XkbUseCoreKbd);
466 if (!xkb)
467 {
468 WLog_Print(xfc->log, WLOG_WARN, "XkbGetMap() == NULL");
469 return -3;
470 }
471
472 const int rc = XkbGetNames(xfc->display, XkbKeyNamesMask, xkb);
473 if (rc != Success)
474 {
475 char buffer[64] = { 0 };
476 WLog_Print(xfc->log, WLOG_WARN, "XkbGetNames() != Success: [%s]",
477 x11_error_to_string(xfc, rc, buffer, sizeof(buffer)));
478 }
479 else
480 {
481 char xkb_keyname[XkbKeyNameLength + 1] = { 42, 42, 42, 42,
482 0 }; /* end-of-string at index 5 */
483
484 WLog_Print(xfc->log, WLOG_TRACE, "XkbGetNames() == Success, min=%" PRIu8 ", max=%" PRIu8,
485 xkb->min_key_code, xkb->max_key_code);
486 for (size_t i = xkb->min_key_code; i < xkb->max_key_code; i++)
487 {
488 BOOL found = FALSE;
489 strncpy(xkb_keyname, xkb->names->keys[i].name, XkbKeyNameLength);
490
491 WLog_Print(xfc->log, WLOG_TRACE, "KeyCode %" PRIuz " -> %s", i, xkb_keyname);
492 if (strnlen(xkb_keyname, ARRAYSIZE(xkb_keyname)) >= 1)
493 found = try_add(xfc, i, xkb_keyname);
494
495 if (!found)
496 {
497#if defined(__APPLE__)
498 const DWORD vkcode =
499 GetVirtualKeyCodeFromKeycode((UINT32)i - 8u, WINPR_KEYCODE_TYPE_APPLE);
500 xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[i] =
501 GetVirtualScanCodeFromVirtualKeyCode(vkcode, WINPR_KBD_TYPE_IBM_ENHANCED);
502 found = TRUE;
503#endif
504 }
505 if (!found)
506 {
507 WLog_Print(xfc->log, WLOG_WARN,
508 "%4s: keycode: 0x%02" PRIx32 " -> no RDP scancode found", xkb_keyname,
509 WINPR_ASSERTING_INT_CAST(UINT32, i));
510 }
511 else
512 status = 0;
513 }
514 }
515
516 XkbFreeKeyboard(xkb, 0, 1);
517
518 return status;
519}
520
521BOOL xf_keyboard_init(xfContext* xfc)
522{
523 rdpSettings* settings = NULL;
524
525 WINPR_ASSERT(xfc);
526
527 settings = xfc->common.context.settings;
528 WINPR_ASSERT(settings);
529
530 xf_keyboard_clear(xfc);
531
532 /* Layout detection algorithm:
533 *
534 * 1. If one was supplied, use that one
535 * 2. Try to determine current X11 keyboard layout
536 * 3. Try to determine default layout for current system language
537 * 4. Fall back to ENGLISH_UNITED_STATES
538 */
539 UINT32 KeyboardLayout = freerdp_settings_get_uint32(settings, FreeRDP_KeyboardLayout);
540 if (KeyboardLayout == 0)
541 {
542 xf_detect_keyboard_layout_from_xkb(xfc->log, &KeyboardLayout);
543 if (KeyboardLayout == 0)
544 freerdp_detect_keyboard_layout_from_system_locale(&KeyboardLayout);
545 if (KeyboardLayout == 0)
546 KeyboardLayout = ENGLISH_UNITED_STATES;
547 if (!freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, KeyboardLayout))
548 return FALSE;
549 }
550
551 const int rc = load_map_from_xkbfile(xfc);
552 if (rc != 0)
553 return FALSE;
554
555 return xf_keyboard_update_modifier_map(xfc);
556}
557
558void xf_keyboard_free(xfContext* xfc)
559{
560 xf_keyboard_modifier_map_free(xfc);
561 xf_keyboard_action_script_free(xfc);
562}
563
564void xf_keyboard_key_press(xfContext* xfc, const XKeyEvent* event, KeySym keysym)
565{
566 BOOL last = 0;
567
568 WINPR_ASSERT(xfc);
569 WINPR_ASSERT(event);
570 WINPR_ASSERT(event->keycode < ARRAYSIZE(xfc->KeyboardState));
571
572 last = xfc->KeyboardState[event->keycode];
573 xfc->KeyboardState[event->keycode] = TRUE;
574
575 if (xf_keyboard_handle_special_keys(xfc, keysym))
576 return;
577
578 xf_keyboard_send_key(xfc, TRUE, last, event);
579}
580
581void xf_keyboard_key_release(xfContext* xfc, const XKeyEvent* event, KeySym keysym)
582{
583 WINPR_ASSERT(xfc);
584 WINPR_ASSERT(event);
585 WINPR_ASSERT(event->keycode < ARRAYSIZE(xfc->KeyboardState));
586
587 BOOL last = xfc->KeyboardState[event->keycode];
588 xfc->KeyboardState[event->keycode] = FALSE;
589 xf_keyboard_handle_special_keys_release(xfc, keysym);
590 xf_keyboard_send_key(xfc, FALSE, last, event);
591}
592
593static DWORD get_rdp_scancode_from_x11_keycode(xfContext* xfc, DWORD keycode)
594{
595 WINPR_ASSERT(xfc);
596 if (keycode >= ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE))
597 {
598 WLog_ERR(TAG, "KeyCode %" PRIu32 " exceeds allowed value range [0,%" PRIuz "]", keycode,
599 ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE));
600 return 0;
601 }
602
603 const DWORD scancode = xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[keycode];
604 const DWORD remapped = freerdp_keyboard_remap_key(xfc->remap_table, scancode);
605
606#if defined(WITH_DEBUG_KBD)
607 {
608 const BOOL ex = RDP_SCANCODE_EXTENDED(scancode);
609 const DWORD sc = RDP_SCANCODE_CODE(scancode);
610 WLog_DBG(TAG, "x11 keycode: %02" PRIX32 " -> rdp code: [%04" PRIx16 "] %02" PRIX8 "%s",
611 keycode, scancode, sc, ex ? " extended" : "");
612 }
613#endif
614
615 if (remapped != 0)
616 {
617#if defined(WITH_DEBUG_KBD)
618 {
619 const BOOL ex = RDP_SCANCODE_EXTENDED(remapped);
620 const DWORD sc = RDP_SCANCODE_CODE(remapped);
621 WLog_DBG(TAG,
622 "x11 keycode: %02" PRIX32 " -> remapped rdp code: [%04" PRIx16 "] %02" PRIX8
623 "%s",
624 keycode, remapped, sc, ex ? " extended" : "");
625 }
626#endif
627 return remapped;
628 }
629
630 return scancode;
631}
632
633void xf_keyboard_release_all_keypress(xfContext* xfc)
634{
635 WINPR_ASSERT(xfc);
636
637 WINPR_STATIC_ASSERT(ARRAYSIZE(xfc->KeyboardState) <= UINT32_MAX);
638 for (size_t keycode = 0; keycode < ARRAYSIZE(xfc->KeyboardState); keycode++)
639 {
640 if (xfc->KeyboardState[keycode])
641 {
642 const DWORD rdp_scancode =
643 get_rdp_scancode_from_x11_keycode(xfc, WINPR_ASSERTING_INT_CAST(UINT32, keycode));
644
645 // release tab before releasing the windows key.
646 // this stops the start menu from opening on unfocus event.
647 if (rdp_scancode == RDP_SCANCODE_LWIN)
648 freerdp_input_send_keyboard_event_ex(xfc->common.context.input, FALSE, FALSE,
649 RDP_SCANCODE_TAB);
650
651 freerdp_input_send_keyboard_event_ex(xfc->common.context.input, FALSE, FALSE,
652 rdp_scancode);
653 xfc->KeyboardState[keycode] = FALSE;
654 }
655 }
656 xf_sync_kbd_state(xfc);
657}
658
659static BOOL xf_keyboard_key_pressed(xfContext* xfc, KeySym keysym)
660{
661 KeyCode keycode = XKeysymToKeycode(xfc->display, keysym);
662 WINPR_ASSERT(keycode < ARRAYSIZE(xfc->KeyboardState));
663 return xfc->KeyboardState[keycode];
664}
665
666void xf_keyboard_send_key(xfContext* xfc, BOOL down, BOOL repeat, const XKeyEvent* event)
667{
668 WINPR_ASSERT(xfc);
669 WINPR_ASSERT(event);
670
671 rdpInput* input = xfc->common.context.input;
672 WINPR_ASSERT(input);
673
674 const DWORD rdp_scancode = get_rdp_scancode_from_x11_keycode(xfc, event->keycode);
675 if (rdp_scancode == RDP_SCANCODE_PAUSE && !xf_keyboard_key_pressed(xfc, XK_Control_L) &&
676 !xf_keyboard_key_pressed(xfc, XK_Control_R))
677 {
678 /* Pause without Ctrl has to be sent as a series of keycodes
679 * in a single input PDU. Pause only happens on "press";
680 * no code is sent on "release".
681 */
682 if (down)
683 {
684 (void)freerdp_input_send_keyboard_pause_event(input);
685 }
686 }
687 else
688 {
689 if (freerdp_settings_get_bool(xfc->common.context.settings, FreeRDP_UnicodeInput))
690 {
691 wchar_t buffer[32] = { 0 };
692 int xwc = -1;
693
694 switch (rdp_scancode)
695 {
696 case RDP_SCANCODE_RETURN:
697 break;
698 default:
699 {
700 XIM xim = XOpenIM(xfc->display, 0, 0, 0);
701 if (!xim)
702 {
703 WLog_WARN(TAG, "Failed to XOpenIM");
704 }
705 else
706 {
707 XIC xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
708 NULL);
709 if (!xic)
710 {
711 WLog_WARN(TAG, "XCreateIC failed");
712 }
713 else
714 {
715 KeySym ignore = { 0 };
716 Status return_status = 0;
717 XKeyEvent ev = *event;
718 ev.type = KeyPress;
719 xwc = XwcLookupString(xic, &ev, buffer, ARRAYSIZE(buffer), &ignore,
720 &return_status);
721 XDestroyIC(xic);
722 }
723 XCloseIM(xim);
724 }
725 }
726 break;
727 }
728
729 if (xwc < 1)
730 {
731 if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
732 WLog_ERR(TAG, "Unknown key with X keycode 0x%02" PRIx8 "", event->keycode);
733 else
734 (void)freerdp_input_send_keyboard_event_ex(input, down, repeat, rdp_scancode);
735 }
736 else
737 {
738 char str[3 * ARRAYSIZE(buffer)] = { 0 };
739 // NOLINTNEXTLINE(concurrency-mt-unsafe)
740 const size_t rc = wcstombs(str, buffer, ARRAYSIZE(buffer));
741
742 WCHAR wbuffer[ARRAYSIZE(buffer)] = { 0 };
743 (void)ConvertUtf8ToWChar(str, wbuffer, rc);
744 (void)freerdp_input_send_unicode_keyboard_event(input, down ? 0 : KBD_FLAGS_RELEASE,
745 wbuffer[0]);
746 }
747 }
748 else if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
749 WLog_ERR(TAG, "Unknown key with X keycode 0x%02" PRIx8 "", event->keycode);
750 else
751 (void)freerdp_input_send_keyboard_event_ex(input, down, repeat, rdp_scancode);
752 }
753}
754
755static int xf_keyboard_read_keyboard_state(xfContext* xfc)
756{
757 int dummy = 0;
758 Window wdummy = 0;
759 UINT32 state = 0;
760
761 if (!xfc->remote_app && xfc->window)
762 {
763 XQueryPointer(xfc->display, xfc->window->handle, &wdummy, &wdummy, &dummy, &dummy, &dummy,
764 &dummy, &state);
765 }
766 else
767 {
768 XQueryPointer(xfc->display, DefaultRootWindow(xfc->display), &wdummy, &wdummy, &dummy,
769 &dummy, &dummy, &dummy, &state);
770 }
771
772 return WINPR_ASSERTING_INT_CAST(int, state);
773}
774
775static int xf_keyboard_get_keymask(xfContext* xfc, KeySym keysym)
776{
777 int keysymMask = 0;
778 KeyCode keycode = XKeysymToKeycode(xfc->display, keysym);
779
780 if (keycode == NoSymbol)
781 return 0;
782
783 WINPR_ASSERT(xfc->modifierMap);
784 for (int modifierpos = 0; modifierpos < 8; modifierpos++)
785 {
786 int offset = xfc->modifierMap->max_keypermod * modifierpos;
787
788 for (int key = 0; key < xfc->modifierMap->max_keypermod; key++)
789 {
790 if (xfc->modifierMap->modifiermap[offset + key] == keycode)
791 {
792 keysymMask |= 1 << modifierpos;
793 }
794 }
795 }
796
797 return keysymMask;
798}
799
800static BOOL xf_keyboard_get_key_state(xfContext* xfc, int state, KeySym keysym)
801{
802 int keysymMask = xf_keyboard_get_keymask(xfc, keysym);
803
804 if (!keysymMask)
805 return FALSE;
806
807 return (state & keysymMask) ? TRUE : FALSE;
808}
809
810static BOOL xf_keyboard_set_key_state(xfContext* xfc, BOOL on, KeySym keysym)
811{
812 if (!xfc->xkbAvailable)
813 return FALSE;
814
815 const int keysymMask = xf_keyboard_get_keymask(xfc, keysym);
816
817 if (!keysymMask)
818 {
819 return FALSE;
820 }
821
822 return XkbLockModifiers(xfc->display, XkbUseCoreKbd,
823 WINPR_ASSERTING_INT_CAST(uint32_t, keysymMask),
824 on ? WINPR_ASSERTING_INT_CAST(uint32_t, keysymMask) : 0);
825}
826
827UINT32 xf_keyboard_get_toggle_keys_state(xfContext* xfc)
828{
829 UINT32 toggleKeysState = 0;
830 const int state = xf_keyboard_read_keyboard_state(xfc);
831
832 if (xf_keyboard_get_key_state(xfc, state, XK_Scroll_Lock))
833 toggleKeysState |= KBD_SYNC_SCROLL_LOCK;
834
835 if (xf_keyboard_get_key_state(xfc, state, XK_Num_Lock))
836 toggleKeysState |= KBD_SYNC_NUM_LOCK;
837
838 if (xf_keyboard_get_key_state(xfc, state, XK_Caps_Lock))
839 toggleKeysState |= KBD_SYNC_CAPS_LOCK;
840
841 if (xf_keyboard_get_key_state(xfc, state, XK_Kana_Lock))
842 toggleKeysState |= KBD_SYNC_KANA_LOCK;
843
844 return toggleKeysState;
845}
846
847static void xk_keyboard_update_modifier_keys(xfContext* xfc)
848{
849 const KeySym keysyms[] = { XK_Shift_L, XK_Shift_R, XK_Alt_L, XK_Alt_R,
850 XK_Control_L, XK_Control_R, XK_Super_L, XK_Super_R };
851
852 xf_keyboard_clear(xfc);
853
854 const int state = xf_keyboard_read_keyboard_state(xfc);
855
856 for (size_t i = 0; i < ARRAYSIZE(keysyms); i++)
857 {
858 if (xf_keyboard_get_key_state(xfc, state, keysyms[i]))
859 {
860 const KeyCode keycode = XKeysymToKeycode(xfc->display, keysyms[i]);
861 WINPR_ASSERT(keycode < ARRAYSIZE(xfc->KeyboardState));
862 xfc->KeyboardState[keycode] = TRUE;
863 }
864 }
865}
866
867void xf_keyboard_focus_in(xfContext* xfc)
868{
869 UINT32 state = 0;
870 Window w = None;
871 int d = 0;
872 int x = 0;
873 int y = 0;
874
875 WINPR_ASSERT(xfc);
876 if (!xfc->display || !xfc->window)
877 return;
878
879 rdpInput* input = xfc->common.context.input;
880 WINPR_ASSERT(input);
881
882 const UINT32 syncFlags = xf_keyboard_get_toggle_keys_state(xfc);
883 freerdp_input_send_focus_in_event(input, WINPR_ASSERTING_INT_CAST(UINT16, syncFlags));
884 xk_keyboard_update_modifier_keys(xfc);
885
886 /* finish with a mouse pointer position like mstsc.exe if required */
887
888 if (xfc->remote_app || !xfc->window)
889 return;
890
891 if (XQueryPointer(xfc->display, xfc->window->handle, &w, &w, &d, &d, &x, &y, &state))
892 {
893 if ((x >= 0) && (x < xfc->window->width) && (y >= 0) && (y < xfc->window->height))
894 {
895 xf_event_adjust_coordinates(xfc, &x, &y);
896 freerdp_client_send_button_event(&xfc->common, FALSE, PTR_FLAGS_MOVE, x, y);
897 }
898 }
899}
900
901static BOOL action_script_run(xfContext* xfc, const char* buffer, size_t size, void* user,
902 const char* what, const char* arg)
903{
904 WINPR_UNUSED(xfc);
905 WINPR_UNUSED(what);
906 WINPR_UNUSED(arg);
907 WINPR_ASSERT(user);
908 int* pstatus = user;
909
910 if (size == 0)
911 {
912 WLog_WARN(TAG, "ActionScript key: script did not return data");
913 return FALSE;
914 }
915
916 if (strcmp(buffer, "key-local") == 0)
917 *pstatus = 0;
918 else if (winpr_PathFileExists(buffer))
919 {
920 FILE* fp = popen(buffer, "w");
921 if (!fp)
922 {
923 WLog_ERR(TAG, "Failed to execute '%s'", buffer);
924 return FALSE;
925 }
926
927 *pstatus = pclose(fp);
928 if (*pstatus < 0)
929 {
930 WLog_ERR(TAG, "Command '%s' returned %d", buffer, *pstatus);
931 return FALSE;
932 }
933 }
934 else
935 {
936 WLog_WARN(TAG, "ActionScript key: no such file '%s'", buffer);
937 return FALSE;
938 }
939 return TRUE;
940}
941
942static int xf_keyboard_execute_action_script(xfContext* xfc, XF_MODIFIER_KEYS* mod, KeySym keysym)
943{
944 int status = 1;
945 BOOL match = FALSE;
946 char command[2048] = { 0 };
947 char combination[1024] = { 0 };
948
949 if (!xfc->actionScriptExists)
950 return 1;
951
952 if ((keysym == XK_Shift_L) || (keysym == XK_Shift_R) || (keysym == XK_Alt_L) ||
953 (keysym == XK_Alt_R) || (keysym == XK_Control_L) || (keysym == XK_Control_R))
954 {
955 return 1;
956 }
957
958 const char* keyStr = XKeysymToString(keysym);
959
960 if (keyStr == 0)
961 {
962 return 1;
963 }
964
965 if (mod->Shift)
966 winpr_str_append("Shift", combination, sizeof(combination), "+");
967
968 if (mod->Ctrl)
969 winpr_str_append("Ctrl", combination, sizeof(combination), "+");
970
971 if (mod->Alt)
972 winpr_str_append("Alt", combination, sizeof(combination), "+");
973
974 if (mod->Super)
975 winpr_str_append("Super", combination, sizeof(combination), "+");
976
977 winpr_str_append(keyStr, combination, sizeof(combination), "+");
978
979 for (size_t i = 0; i < strnlen(combination, sizeof(combination)); i++)
980 combination[i] = WINPR_ASSERTING_INT_CAST(char, tolower(combination[i]));
981
982 const size_t count = ArrayList_Count(xfc->keyCombinations);
983
984 for (size_t index = 0; index < count; index++)
985 {
986 const char* keyCombination = (const char*)ArrayList_GetItem(xfc->keyCombinations, index);
987
988 if (_stricmp(keyCombination, combination) == 0)
989 {
990 match = TRUE;
991 break;
992 }
993 }
994
995 if (!match)
996 return 1;
997
998 (void)sprintf_s(command, sizeof(command), "key %s", combination);
999 if (!run_action_script(xfc, command, NULL, action_script_run, &status))
1000 return -1;
1001
1002 return status;
1003}
1004
1005static int xk_keyboard_get_modifier_keys(xfContext* xfc, XF_MODIFIER_KEYS* mod)
1006{
1007 mod->LeftShift = xf_keyboard_key_pressed(xfc, XK_Shift_L);
1008 mod->RightShift = xf_keyboard_key_pressed(xfc, XK_Shift_R);
1009 mod->Shift = mod->LeftShift || mod->RightShift;
1010 mod->LeftAlt = xf_keyboard_key_pressed(xfc, XK_Alt_L);
1011 mod->RightAlt = xf_keyboard_key_pressed(xfc, XK_Alt_R);
1012 mod->Alt = mod->LeftAlt || mod->RightAlt;
1013 mod->LeftCtrl = xf_keyboard_key_pressed(xfc, XK_Control_L);
1014 mod->RightCtrl = xf_keyboard_key_pressed(xfc, XK_Control_R);
1015 mod->Ctrl = mod->LeftCtrl || mod->RightCtrl;
1016 mod->LeftSuper = xf_keyboard_key_pressed(xfc, XK_Super_L);
1017 mod->RightSuper = xf_keyboard_key_pressed(xfc, XK_Super_R);
1018 mod->Super = mod->LeftSuper || mod->RightSuper;
1019 return 0;
1020}
1021
1022BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym)
1023{
1024 XF_MODIFIER_KEYS mod = { 0 };
1025 xk_keyboard_get_modifier_keys(xfc, &mod);
1026
1027 // remember state of RightCtrl to ungrab keyboard if next action is release of RightCtrl
1028 // do not return anything such that the key could be used by client if ungrab is not the goal
1029 if (keysym == XK_Control_R)
1030 {
1031 if (mod.RightCtrl && !xfc->wasRightCtrlAlreadyPressed)
1032 {
1033 // Right Ctrl is pressed, getting ready to ungrab
1034 xfc->ungrabKeyboardWithRightCtrl = TRUE;
1035 xfc->wasRightCtrlAlreadyPressed = TRUE;
1036 }
1037 }
1038 else
1039 {
1040 // some other key has been pressed, abort ungrabbing
1041 if (xfc->ungrabKeyboardWithRightCtrl)
1042 xfc->ungrabKeyboardWithRightCtrl = FALSE;
1043 }
1044
1045 const int rc = xf_keyboard_execute_action_script(xfc, &mod, keysym);
1046 if (rc < 0)
1047 return FALSE;
1048 if (rc == 0)
1049 return TRUE;
1050
1051 if (!xfc->remote_app && xfc->fullscreen_toggle)
1052 {
1053 switch (keysym)
1054 {
1055 case XK_Return:
1056 if (mod.Ctrl && mod.Alt)
1057 {
1058 /* Ctrl-Alt-Enter: toggle full screen */
1059 WLog_INFO(TAG, "<ctrl>+<alt>+<enter> pressed, toggling fullscreen state...");
1060 xf_sync_kbd_state(xfc);
1061 xf_toggle_fullscreen(xfc);
1062 return TRUE;
1063 }
1064 break;
1065 default:
1066 break;
1067 }
1068 }
1069
1070 if (mod.Ctrl && mod.Alt)
1071 {
1072 switch (keysym)
1073 {
1074 case XK_m:
1075 case XK_M:
1076 WLog_INFO(TAG, "<ctrl>+<alt>+m pressed, minimizing RDP session...");
1077 xf_sync_kbd_state(xfc);
1078 xf_minimize(xfc);
1079 return TRUE;
1080 case XK_c:
1081 case XK_C:
1082 /* Ctrl-Alt-C: toggle control */
1083 WLog_INFO(TAG, "<ctrl>+<alt>+c pressed, toggle encomps control...");
1084 if (freerdp_client_encomsp_toggle_control(xfc->common.encomsp))
1085 return TRUE;
1086 break;
1087 case XK_d:
1088 case XK_D:
1089 /* <ctrl>+<alt>+d: disconnect session */
1090 WLog_INFO(TAG, "<ctrl>+<alt>+d pressed, terminating RDP session...");
1091 xf_sync_kbd_state(xfc);
1092 return freerdp_abort_connect_context(&xfc->common.context);
1093
1094 default:
1095 break;
1096 }
1097 }
1098
1099#if 0 /* set to 1 to enable multi touch gesture simulation via keyboard */
1100#ifdef WITH_XRENDER
1101
1102 if (!xfc->remote_app && freerdp_settings_get_bool(xfc->common.context.settings, FreeRDP_MultiTouchGestures))
1103 {
1104 rdpContext* ctx = &xfc->common.context;
1105
1106 if (mod.Ctrl && mod.Alt)
1107 {
1108 int pdx = 0;
1109 int pdy = 0;
1110 int zdx = 0;
1111 int zdy = 0;
1112
1113 switch (keysym)
1114 {
1115 case XK_0: /* Ctrl-Alt-0: Reset scaling and panning */{
1116 const UINT32 sessionWidth = freerdp_settings_get_uint32(xfc->common.context.settings, FreeRDP_DesktopWidth);
1117 const UINT32 sessionHeight = freerdp_settings_get_uint32(xfc->common.context.settings, FreeRDP_DesktopHeight);
1118
1119 xfc->scaledWidth = sessionWidth;
1120 xfc->scaledHeight = sessionHeight;
1121 xfc->offset_x = 0;
1122 xfc->offset_y = 0;
1123
1124 if (!xfc->fullscreen && (sessionWidth != xfc->window->width ||
1125 sessionHeight != xfc->window->height))
1126 {
1127 xf_ResizeDesktopWindow(xfc, xfc->window, sessionWidth, sessionHeight);
1128 }
1129
1130 xf_draw_screen(xfc, 0, 0, sessionWidth, sessionHeight);
1131 return TRUE;
1132}
1133
1134 case XK_1: /* Ctrl-Alt-1: Zoom in */
1135 zdx = zdy = 10;
1136 break;
1137
1138 case XK_2: /* Ctrl-Alt-2: Zoom out */
1139 zdx = zdy = -10;
1140 break;
1141
1142 case XK_3: /* Ctrl-Alt-3: Pan left */
1143 pdx = -10;
1144 break;
1145
1146 case XK_4: /* Ctrl-Alt-4: Pan right */
1147 pdx = 10;
1148 break;
1149
1150 case XK_5: /* Ctrl-Alt-5: Pan up */
1151 pdy = -10;
1152 break;
1153
1154 case XK_6: /* Ctrl-Alt-6: Pan up */
1155 pdy = 10;
1156 break;
1157 }
1158
1159 if (pdx != 0 || pdy != 0)
1160 {
1161 PanningChangeEventArgs e;
1162 EventArgsInit(&e, "xfreerdp");
1163 e.dx = pdx;
1164 e.dy = pdy;
1165 PubSub_OnPanningChange(ctx->pubSub, xfc, &e);
1166 return TRUE;
1167 }
1168
1169 if (zdx != 0 || zdy != 0)
1170 {
1171 ZoomingChangeEventArgs e;
1172 EventArgsInit(&e, "xfreerdp");
1173 e.dx = zdx;
1174 e.dy = zdy;
1175 PubSub_OnZoomingChange(ctx->pubSub, xfc, &e);
1176 return TRUE;
1177 }
1178 }
1179 }
1180
1181#endif /* WITH_XRENDER defined */
1182#endif /* pinch/zoom/pan simulation */
1183 return FALSE;
1184}
1185
1186void xf_keyboard_handle_special_keys_release(xfContext* xfc, KeySym keysym)
1187{
1188 if (keysym != XK_Control_R)
1189 return;
1190
1191 xfc->wasRightCtrlAlreadyPressed = FALSE;
1192
1193 if (!xfc->ungrabKeyboardWithRightCtrl)
1194 return;
1195
1196 // all requirements for ungrab are fulfilled, ungrabbing now
1197 XF_MODIFIER_KEYS mod = { 0 };
1198 xk_keyboard_get_modifier_keys(xfc, &mod);
1199
1200 if (!mod.RightCtrl)
1201 {
1202 if (!xfc->fullscreen)
1203 {
1204 xf_sync_kbd_state(xfc);
1205 freerdp_client_encomsp_toggle_control(xfc->common.encomsp);
1206 }
1207
1208 xfc->mouse_active = FALSE;
1209 xf_ungrab(xfc);
1210 }
1211
1212 // ungrabbed
1213 xfc->ungrabKeyboardWithRightCtrl = FALSE;
1214}
1215
1216BOOL xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
1217{
1218 xfContext* xfc = (xfContext*)context;
1219 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_SCROLL_LOCK, XK_Scroll_Lock);
1220 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_NUM_LOCK, XK_Num_Lock);
1221 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_CAPS_LOCK, XK_Caps_Lock);
1222 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_KANA_LOCK, XK_Kana_Lock);
1223 return TRUE;
1224}
1225
1226BOOL xf_keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
1227 UINT32 imeConvMode)
1228{
1229 if (!context)
1230 return FALSE;
1231
1232 WLog_WARN(TAG,
1233 "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
1234 ", imeConvMode=%08" PRIx32 ") ignored",
1235 imeId, imeState, imeConvMode);
1236 return TRUE;
1237}
1238
1239BOOL xf_ungrab(xfContext* xfc)
1240{
1241 WINPR_ASSERT(xfc);
1242 XUngrabKeyboard(xfc->display, CurrentTime);
1243 XUngrabPointer(xfc->display, CurrentTime);
1244 xfc->common.mouse_grabbed = FALSE;
1245 return TRUE;
1246}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:57