blob: 4e0044c9855c948ce290eb18112e803632b4b85e [file] [log] [blame]
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
Pierre Ossmanff9eb5a2014-01-30 17:47:31 +01002 * Copyright 2011-2014 Pierre Ossman for Cendio AB
Pierre Ossmand50b3d12011-04-15 07:46:56 +00003 *
4 * This is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this software; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17 * USA.
18 */
19
Peter Åstrandc359f362011-08-23 12:04:46 +000020#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
Pierre Ossmand50b3d12011-04-15 07:46:56 +000024#include <assert.h>
25#include <stdio.h>
26#include <string.h>
27
Pierre Ossmand50b3d12011-04-15 07:46:56 +000028#include <rfb/CMsgWriter.h>
29#include <rfb/LogWriter.h>
Pierre Ossmand1a853b2014-10-10 13:37:35 +020030#include <rfb/Exception.h>
Pierre Ossman2fa63f82016-12-05 15:26:21 +010031#include <rfb/ledStates.h>
Pierre Ossmand50b3d12011-04-15 07:46:56 +000032
33// FLTK can pull in the X11 headers on some systems
34#ifndef XK_VoidSymbol
Pierre Ossman13a809a2014-08-22 15:09:54 +020035#define XK_LATIN1
Pierre Ossmand50b3d12011-04-15 07:46:56 +000036#define XK_MISCELLANY
37#define XK_XKB_KEYS
38#include <rfb/keysymdef.h>
39#endif
40
Pierre Ossmancb0cffe2011-05-20 14:55:10 +000041#ifndef XF86XK_ModeLock
42#include <rfb/XF86keysym.h>
43#endif
44
Pierre Ossman2fa63f82016-12-05 15:26:21 +010045#if ! (defined(WIN32) || defined(__APPLE__))
46#include <X11/XKBlib.h>
47#endif
48
Pierre Ossman7b8bff62014-07-21 16:17:23 +020049#ifndef NoSymbol
50#define NoSymbol 0
51#endif
52
Pierre Ossman2e9684f2014-07-21 16:46:22 +020053// Missing in at least some versions of MinGW
54#ifndef MAPVK_VK_TO_VSC
55#define MAPVK_VK_TO_VSC 0
56#endif
57
Pierre Ossmand50b3d12011-04-15 07:46:56 +000058#include "Viewport.h"
59#include "CConn.h"
Pierre Ossmand463b572011-05-16 12:04:43 +000060#include "OptionsDialog.h"
Pierre Ossman947b48d2014-01-27 16:52:35 +010061#include "DesktopWindow.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000062#include "i18n.h"
Pierre Ossmanc628ba42011-05-23 12:21:21 +000063#include "fltk_layout.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000064#include "parameters.h"
65#include "keysym2ucs.h"
Martin Koegler498ef462011-09-04 07:04:43 +000066#include "menukey.h"
Pierre Ossman39ceb502011-07-12 15:54:25 +000067#include "vncviewer.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000068
Pierre Ossmanac13abe2014-02-07 14:46:26 +010069#include "PlatformPixelBuffer.h"
Pierre Ossman947b48d2014-01-27 16:52:35 +010070
DRCb65bb932011-06-24 03:17:00 +000071#include <FL/fl_draw.H>
72#include <FL/fl_ask.H>
73
Pierre Ossman769963f2014-01-20 14:43:52 +010074#include <FL/Fl_Menu.H>
75#include <FL/Fl_Menu_Button.H>
76
Pierre Ossman0c158662017-07-13 15:54:11 +020077#if !defined(WIN32) && !defined(__APPLE__)
78#include <X11/XKBlib.h>
79extern const struct _code_map_xkb_to_qnum {
80 const char * from;
81 const unsigned short to;
82} code_map_xkb_to_qnum[];
83extern const unsigned int code_map_xkb_to_qnum_len;
84
85static int code_map_keycode_to_qnum[256];
86#endif
87
Pierre Ossman6b743d02014-07-21 16:48:43 +020088#ifdef __APPLE__
89#include "cocoa.h"
Pierre Ossman0c158662017-07-13 15:54:11 +020090extern const unsigned short code_map_osx_to_qnum[];
91extern const unsigned int code_map_osx_to_qnum_len;
Pierre Ossman6b743d02014-07-21 16:48:43 +020092#endif
93
DRCb65bb932011-06-24 03:17:00 +000094#ifdef WIN32
95#include "win32.h"
96#endif
97
Pierre Ossman6b743d02014-07-21 16:48:43 +020098
Pierre Ossmand50b3d12011-04-15 07:46:56 +000099using namespace rfb;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000100using namespace rdr;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000101
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000102static rfb::LogWriter vlog("Viewport");
103
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000104// Menu constants
105
Joel Teichroeba7494ac2015-07-13 14:46:22 -0700106enum { ID_EXIT, ID_FULLSCREEN, ID_MINIMIZE, ID_RESIZE,
Pierre Ossman8dc8bca2012-07-04 11:37:10 +0000107 ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000108 ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS };
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000109
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100110// Used to detect fake input (0xaa is not a real key)
111#ifdef WIN32
112static const WORD SCAN_FAKE = 0xaa;
113#endif
114
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000115Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_)
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200116 : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL),
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100117 lastPointerPos(0, 0), lastButtonMask(0),
Pierre Ossman51249782018-03-08 14:05:39 +0100118#ifdef WIN32
119 altGrArmed(false),
120#endif
Pierre Ossman609a9c82018-06-07 09:16:02 +0200121 firstLEDState(true),
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200122 pendingServerCutText(NULL), pendingClientCutText(NULL),
Pierre Ossmanb1cd6ca2015-03-03 16:37:43 +0100123 menuCtrlKey(false), menuAltKey(false), cursor(NULL)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000124{
Pierre Ossman0c158662017-07-13 15:54:11 +0200125#if !defined(WIN32) && !defined(__APPLE__)
126 XkbDescPtr xkb;
127 Status status;
128
129 xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd);
130 if (!xkb)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200131 throw rfb::Exception("XkbGetMap");
Pierre Ossman0c158662017-07-13 15:54:11 +0200132
133 status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb);
134 if (status != Success)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200135 throw rfb::Exception("XkbGetNames");
Pierre Ossman0c158662017-07-13 15:54:11 +0200136
137 memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum));
138 for (KeyCode keycode = xkb->min_key_code;
139 keycode < xkb->max_key_code;
140 keycode++) {
141 const char *keyname = xkb->names->keys[keycode].name;
142 unsigned short rfbcode;
143
144 if (keyname[0] == '\0')
145 continue;
146
147 rfbcode = 0;
148 for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) {
149 if (strncmp(code_map_xkb_to_qnum[i].from,
150 keyname, XkbKeyNameLength) == 0) {
151 rfbcode = code_map_xkb_to_qnum[i].to;
152 break;
153 }
154 }
155 if (rfbcode != 0)
156 code_map_keycode_to_qnum[keycode] = rfbcode;
157 else
158 vlog.debug("No key mapping for key %.4s", keyname);
159 }
160
161 XkbFreeKeyboard(xkb, 0, True);
162#endif
163
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000164 Fl::add_clipboard_notify(handleClipboardChange, this);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000165
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200166 // We need to intercept keyboard events early
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200167 Fl::add_system_handler(handleSystemEvent, this);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200168
Pierre Ossman403ac272017-01-02 17:00:41 +0100169 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000170 assert(frameBuffer);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100171 cc->setFramebuffer(frameBuffer);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000172
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000173 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +0000174 // Setting box type to FL_NO_BOX prevents it from trying to draw the
175 // button component (which we don't want)
176 contextMenu->box(FL_NO_BOX);
177
Pierre Ossmanb043ad12011-06-01 09:26:57 +0000178 // The (invisible) button associated with this widget can mess with
179 // things like Fl_Scroll so we need to get rid of any parents.
180 // Unfortunately that's not possible because of STR #2654, but
181 // reparenting to the current window works for most cases.
182 window()->add(contextMenu);
183
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000184 setMenuKey();
185
186 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000187}
188
189
190Viewport::~Viewport()
191{
192 // Unregister all timeouts in case they get a change tro trigger
193 // again later when this object is already gone.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000194 Fl::remove_timeout(handlePointerTimeout, this);
Pierre Ossman51249782018-03-08 14:05:39 +0100195#ifdef WIN32
196 Fl::remove_timeout(handleAltGrTimeout, this);
197#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000198
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200199 Fl::remove_system_handler(handleSystemEvent);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200200
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000201 Fl::remove_clipboard_notify(handleClipboardChange);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000202
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000203 OptionsDialog::removeCallback(handleOptions);
204
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000205 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000206 if (!cursor->alloc_array)
207 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000208 delete cursor;
209 }
210
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200211 clearPendingClipboard();
212
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000213 // FLTK automatically deletes all child widgets, so we shouldn't touch
214 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000215}
216
217
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000218const rfb::PixelFormat &Viewport::getPreferredPF()
219{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000220 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000221}
222
223
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000224// Copy the areas of the framebuffer that have been changed (damaged)
225// to the displayed window.
226
227void Viewport::updateWindow()
228{
229 Rect r;
230
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200231 r = frameBuffer->getDamage();
232 damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000233}
234
Pierre Ossman4c204232018-03-26 13:32:49 +0200235void Viewport::serverCutText(const char* str, rdr::U32 len)
236{
237 char *buffer;
238 int size, ret;
239
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200240 clearPendingClipboard();
241
Pierre Ossman4c204232018-03-26 13:32:49 +0200242 if (!acceptClipboard)
243 return;
244
245 size = fl_utf8froma(NULL, 0, str, len);
246 if (size <= 0)
247 return;
248
249 size++;
250
251 buffer = new char[size];
252
253 ret = fl_utf8froma(buffer, size, str, len);
254 assert(ret < size);
255
256 vlog.debug("Got clipboard data (%d bytes)", (int)strlen(buffer));
257
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200258 if (!hasFocus()) {
259 pendingServerCutText = buffer;
260 return;
261 }
262
Pierre Ossman4c204232018-03-26 13:32:49 +0200263 // RFB doesn't have separate selection and clipboard concepts, so we
264 // dump the data into both variants.
265 if (setPrimary)
266 Fl::copy(buffer, ret, 0);
267 Fl::copy(buffer, ret, 1);
268
269 delete [] buffer;
270}
271
Pierre Ossmanf741d342011-06-09 08:32:49 +0000272static const char * dotcursor_xpm[] = {
273 "5 5 2 1",
274 ". c #000000",
275 " c #FFFFFF",
276 " ",
277 " ... ",
278 " ... ",
279 " ... ",
280 " "};
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000281
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000282void Viewport::setCursor(int width, int height, const Point& hotspot,
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100283 const rdr::U8* data)
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000284{
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100285 int i;
286
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000287 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000288 if (!cursor->alloc_array)
289 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000290 delete cursor;
291 }
292
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100293 for (i = 0; i < width*height; i++)
294 if (data[i*4 + 3] != 0) break;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000295
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100296 if ((i == width*height) && dotWhenNoCursor) {
Pierre Ossmana51574a2011-06-09 08:39:35 +0000297 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000298
299 Fl_Pixmap pxm(dotcursor_xpm);
300 cursor = new Fl_RGB_Image(&pxm);
301 cursorHotspot.x = cursorHotspot.y = 2;
302 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000303 if ((width == 0) || (height == 0)) {
304 U8 *buffer = new U8[4];
305 memset(buffer, 0, 4);
306 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
307 cursorHotspot.x = cursorHotspot.y = 0;
308 } else {
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100309 U8 *buffer = new U8[width * height * 4];
310 memcpy(buffer, data, width * height * 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000311 cursor = new Fl_RGB_Image(buffer, width, height, 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000312 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000313 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000314 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000315
316 if (Fl::belowmouse() == this)
317 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000318}
319
320
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100321void Viewport::setLEDState(unsigned int state)
322{
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100323 vlog.debug("Got server LED state: 0x%08x", state);
324
Pierre Ossman609a9c82018-06-07 09:16:02 +0200325 // The first message is just considered to be the server announcing
Pierre Ossman20634392019-02-28 10:57:40 +0100326 // support for this extension. We will push our state to sync up the
327 // server when we get focus. If we already have focus we need to push
328 // it here though.
Pierre Ossman609a9c82018-06-07 09:16:02 +0200329 if (firstLEDState) {
330 firstLEDState = false;
Pierre Ossman20634392019-02-28 10:57:40 +0100331 if (hasFocus())
332 pushLEDState();
Pierre Ossman609a9c82018-06-07 09:16:02 +0200333 return;
334 }
335
Pierre Ossman9a747322018-03-26 14:16:43 +0200336 if (!hasFocus())
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100337 return;
338
339#if defined(WIN32)
340 INPUT input[6];
341 UINT count;
342 UINT ret;
343
344 memset(input, 0, sizeof(input));
345 count = 0;
346
347 if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
348 input[count].type = input[count+1].type = INPUT_KEYBOARD;
349 input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
350 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
351 input[count].ki.dwFlags = 0;
352 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
353 count += 2;
354 }
355
356 if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
357 input[count].type = input[count+1].type = INPUT_KEYBOARD;
358 input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
359 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
360 input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
361 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
362 count += 2;
363 }
364
365 if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
366 input[count].type = input[count+1].type = INPUT_KEYBOARD;
367 input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
368 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
369 input[count].ki.dwFlags = 0;
370 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
371 count += 2;
372 }
373
374 if (count == 0)
375 return;
376
377 ret = SendInput(count, input, sizeof(*input));
378 if (ret < count)
379 vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
380#elif defined(__APPLE__)
381 int ret;
382
383 ret = cocoa_set_caps_lock_state(state & ledCapsLock);
384 if (ret != 0) {
385 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
386 return;
387 }
388
389 ret = cocoa_set_num_lock_state(state & ledNumLock);
390 if (ret != 0) {
391 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
392 return;
393 }
394
395 // No support for Scroll Lock //
396
397#else
398 unsigned int affect, values;
399 unsigned int mask;
400
401 Bool ret;
402
403 affect = values = 0;
404
405 affect |= LockMask;
406 if (state & ledCapsLock)
407 values |= LockMask;
408
409 mask = getModifierMask(XK_Num_Lock);
410 affect |= mask;
411 if (state & ledNumLock)
412 values |= mask;
413
414 mask = getModifierMask(XK_Scroll_Lock);
415 affect |= mask;
416 if (state & ledScrollLock)
417 values |= mask;
418
419 ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
420 if (!ret)
421 vlog.error(_("Failed to update keyboard LED state"));
422#endif
423}
424
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100425void Viewport::pushLEDState()
426{
427 unsigned int state;
428
429 // Server support?
Pierre Ossmanb14a6bc2018-06-18 15:44:26 +0200430 if (cc->server.ledState() == ledUnknown)
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100431 return;
432
433 state = 0;
434
435#if defined(WIN32)
436 if (GetKeyState(VK_CAPITAL) & 0x1)
437 state |= ledCapsLock;
438 if (GetKeyState(VK_NUMLOCK) & 0x1)
439 state |= ledNumLock;
440 if (GetKeyState(VK_SCROLL) & 0x1)
441 state |= ledScrollLock;
442#elif defined(__APPLE__)
443 int ret;
444 bool on;
445
446 ret = cocoa_get_caps_lock_state(&on);
447 if (ret != 0) {
448 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
449 return;
450 }
451 if (on)
452 state |= ledCapsLock;
453
454 ret = cocoa_get_num_lock_state(&on);
455 if (ret != 0) {
456 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
457 return;
458 }
459 if (on)
460 state |= ledNumLock;
461
462 // No support for Scroll Lock //
Pierre Ossmanb14a6bc2018-06-18 15:44:26 +0200463 state |= (cc->server.ledState() & ledScrollLock);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100464
465#else
466 unsigned int mask;
467
468 Status status;
469 XkbStateRec xkbState;
470
471 status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
472 if (status != Success) {
473 vlog.error(_("Failed to get keyboard LED state: %d"), status);
474 return;
475 }
476
477 if (xkbState.locked_mods & LockMask)
478 state |= ledCapsLock;
479
480 mask = getModifierMask(XK_Num_Lock);
481 if (xkbState.locked_mods & mask)
482 state |= ledNumLock;
483
484 mask = getModifierMask(XK_Scroll_Lock);
485 if (xkbState.locked_mods & mask)
486 state |= ledScrollLock;
487#endif
488
Pierre Ossmanb14a6bc2018-06-18 15:44:26 +0200489 if ((state & ledCapsLock) != (cc->server.ledState() & ledCapsLock)) {
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100490 vlog.debug("Inserting fake CapsLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200491 handleKeyPress(0x3a, XK_Caps_Lock);
492 handleKeyRelease(0x3a);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100493 }
Pierre Ossmanb14a6bc2018-06-18 15:44:26 +0200494 if ((state & ledNumLock) != (cc->server.ledState() & ledNumLock)) {
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100495 vlog.debug("Inserting fake NumLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200496 handleKeyPress(0x45, XK_Num_Lock);
497 handleKeyRelease(0x45);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100498 }
Pierre Ossmanb14a6bc2018-06-18 15:44:26 +0200499 if ((state & ledScrollLock) != (cc->server.ledState() & ledScrollLock)) {
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100500 vlog.debug("Inserting fake ScrollLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200501 handleKeyPress(0x46, XK_Scroll_Lock);
502 handleKeyRelease(0x46);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100503 }
504}
505
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100506
Pierre Ossman3d74d882017-01-02 19:49:52 +0100507void Viewport::draw(Surface* dst)
508{
509 int X, Y, W, H;
510
511 // Check what actually needs updating
512 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
513 if ((W == 0) || (H == 0))
514 return;
515
516 frameBuffer->draw(dst, X - x(), Y - y(), X, Y, W, H);
517}
518
519
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000520void Viewport::draw()
521{
522 int X, Y, W, H;
523
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000524 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000525 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000526 if ((W == 0) || (H == 0))
527 return;
528
Pierre Ossman132b3d02011-06-13 11:19:32 +0000529 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000530}
531
532
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000533void Viewport::resize(int x, int y, int w, int h)
534{
Pierre Ossman9f273e92015-11-09 16:34:54 +0100535 if ((w != frameBuffer->width()) || (h != frameBuffer->height())) {
536 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
537 frameBuffer->width(), frameBuffer->height(), w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000538
Pierre Ossman403ac272017-01-02 17:00:41 +0100539 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100540 assert(frameBuffer);
541 cc->setFramebuffer(frameBuffer);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000542 }
543
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000544 Fl_Widget::resize(x, y, w, h);
545}
546
547
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000548int Viewport::handle(int event)
549{
Pierre Ossman689c4582011-05-26 15:39:41 +0000550 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000551 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000552 int buttonMask, wheelMask;
553 DownMap::const_iterator iter;
554
555 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000556 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000557 buffer = new char[Fl::event_length() + 1];
558
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200559 clearPendingClipboard();
560
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000561 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000562 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
563 Fl::event_length() + 1);
564 assert(ret < (Fl::event_length() + 1));
565
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200566 if (!hasFocus()) {
567 pendingClientCutText = buffer;
568 return 1;
569 }
570
Pierre Ossmanfb450fb2015-03-03 16:34:56 +0100571 vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000572
573 try {
Pierre Ossman59da99f2016-02-05 10:43:12 +0100574 cc->writer()->writeClientCutText(buffer, ret);
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000575 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000576 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000577 exit_vncviewer(e.str());
578 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000579
580 delete [] buffer;
581
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000582 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000583
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000584 case FL_ENTER:
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000585 if (cursor)
586 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman56610fb2015-01-27 16:28:15 +0100587 // Yes, we would like some pointer events please!
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000588 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000589
590 case FL_LEAVE:
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000591 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossmanbe882932018-07-31 16:06:59 +0200592 // We want a last move event to help trigger edge stuff
593 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), 0);
594 return 1;
595
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000596 case FL_PUSH:
597 case FL_RELEASE:
598 case FL_DRAG:
599 case FL_MOVE:
600 case FL_MOUSEWHEEL:
601 buttonMask = 0;
602 if (Fl::event_button1())
603 buttonMask |= 1;
604 if (Fl::event_button2())
605 buttonMask |= 2;
606 if (Fl::event_button3())
607 buttonMask |= 4;
608
609 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000610 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000611 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000612 wheelMask |= 8;
613 if (Fl::event_dy() > 0)
614 wheelMask |= 16;
615 if (Fl::event_dx() < 0)
616 wheelMask |= 32;
617 if (Fl::event_dx() > 0)
618 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000619
620 // A quick press of the wheel "button", followed by a immediate
621 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000622 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000623 buttonMask | wheelMask);
624 }
625
Pierre Ossman6a464be2011-04-15 12:57:31 +0000626 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000627 return 1;
628
629 case FL_FOCUS:
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200630 Fl::disable_im();
Pierre Ossman78236292018-03-26 14:15:40 +0200631
Pierre Ossmane370e1c2018-07-11 13:05:11 +0200632 flushPendingClipboard();
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200633
Pierre Ossmane370e1c2018-07-11 13:05:11 +0200634 // We may have gotten our lock keys out of sync with the server
635 // whilst we didn't have focus. Try to sort this out.
636 pushLEDState();
Pierre Ossman78236292018-03-26 14:15:40 +0200637
Dominique Martinet9f831802018-07-08 02:15:43 +0900638 // Resend Ctrl/Alt if needed
639 if (menuCtrlKey)
640 handleKeyPress(0x1d, XK_Control_L);
641 if (menuAltKey)
642 handleKeyPress(0x38, XK_Alt_L);
643
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000644 // Yes, we would like some focus please!
645 return 1;
646
647 case FL_UNFOCUS:
648 // Release all keys that were pressed as that generally makes most
649 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000650 while (!downKeySym.empty())
Pierre Ossman25188c42014-07-21 16:30:08 +0200651 handleKeyRelease(downKeySym.begin()->first);
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200652 Fl::enable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000653 return 1;
654
655 case FL_KEYDOWN:
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000656 case FL_KEYUP:
Pierre Ossman56610fb2015-01-27 16:28:15 +0100657 // Just ignore these as keys were handled in the event handler
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000658 return 1;
659 }
660
661 return Fl_Widget::handle(event);
662}
663
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100664
Pierre Ossman9a747322018-03-26 14:16:43 +0200665bool Viewport::hasFocus()
666{
667 Fl_Widget* focus;
668
669 focus = Fl::grab();
670 if (!focus)
671 focus = Fl::focus();
672
673 return focus == this;
674}
675
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100676#if ! (defined(WIN32) || defined(__APPLE__))
677unsigned int Viewport::getModifierMask(unsigned int keysym)
678{
679 XkbDescPtr xkb;
680 unsigned int mask, keycode;
681 XkbAction *act;
682
683 mask = 0;
684
685 xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
686 if (xkb == NULL)
687 return 0;
688
689 for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
690 unsigned int state_out;
691 KeySym ks;
692
693 XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
694 if (ks == NoSymbol)
695 continue;
696
697 if (ks == keysym)
698 break;
699 }
700
701 // KeySym not mapped?
702 if (keycode > xkb->max_key_code)
703 goto out;
704
705 act = XkbKeyAction(xkb, keycode, 0);
706 if (act == NULL)
707 goto out;
708 if (act->type != XkbSA_LockMods)
709 goto out;
710
711 if (act->mods.flags & XkbSA_UseModMapMods)
712 mask = xkb->map->modmap[keycode];
713 else
714 mask = act->mods.mask;
715
716out:
717 XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
718
719 return mask;
720}
721#endif
722
723
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000724void Viewport::handleClipboardChange(int source, void *data)
725{
726 Viewport *self = (Viewport *)data;
727
728 assert(self);
729
Pierre Ossmana432b582017-01-02 15:16:58 +0100730 if (!sendClipboard)
731 return;
732
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100733#if !defined(WIN32) && !defined(__APPLE__)
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000734 if (!sendPrimary && (source == 0))
735 return;
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100736#endif
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000737
738 Fl::paste(*self, source);
739}
740
741
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200742void Viewport::clearPendingClipboard()
743{
744 delete [] pendingServerCutText;
745 pendingServerCutText = NULL;
746 delete [] pendingClientCutText;
747 pendingClientCutText = NULL;
748}
749
750
751void Viewport::flushPendingClipboard()
752{
753 if (pendingServerCutText) {
754 size_t len = strlen(pendingServerCutText);
755 if (setPrimary)
756 Fl::copy(pendingServerCutText, len, 0);
757 Fl::copy(pendingServerCutText, len, 1);
758 }
759 if (pendingClientCutText) {
760 size_t len = strlen(pendingClientCutText);
761 vlog.debug("Sending pending clipboard data (%d bytes)", (int)len);
Pierre Ossmane370e1c2018-07-11 13:05:11 +0200762 try {
763 cc->writer()->writeClientCutText(pendingClientCutText, len);
764 } catch (rdr::Exception& e) {
765 vlog.error("%s", e.str());
766 exit_vncviewer(e.str());
767 }
Pierre Ossmanbe6909b2018-03-26 14:17:04 +0200768 }
769
770 clearPendingClipboard();
771}
772
773
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000774void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
775{
776 if (!viewOnly) {
777 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000778 try {
Pierre Ossman59da99f2016-02-05 10:43:12 +0100779 cc->writer()->writePointerEvent(pos, buttonMask);
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000780 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000781 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000782 exit_vncviewer(e.str());
783 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000784 } else {
785 if (!Fl::has_timeout(handlePointerTimeout, this))
786 Fl::add_timeout((double)pointerEventInterval/1000.0,
787 handlePointerTimeout, this);
788 }
789 lastPointerPos = pos;
790 lastButtonMask = buttonMask;
791 }
792}
793
794
795void Viewport::handlePointerTimeout(void *data)
796{
797 Viewport *self = (Viewport *)data;
798
799 assert(self);
800
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000801 try {
Pierre Ossman59da99f2016-02-05 10:43:12 +0100802 self->cc->writer()->writePointerEvent(self->lastPointerPos,
803 self->lastButtonMask);
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000804 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000805 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000806 exit_vncviewer(e.str());
807 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000808}
809
810
Pierre Ossman25188c42014-07-21 16:30:08 +0200811void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym)
812{
813 static bool menuRecursion = false;
814
815 // Prevent recursion if the menu wants to send its own
816 // activation key.
817 if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) {
818 menuRecursion = true;
819 popupContextMenu();
820 menuRecursion = false;
821 return;
822 }
823
824 if (viewOnly)
825 return;
826
Pierre Ossman0c158662017-07-13 15:54:11 +0200827 if (keyCode == 0) {
828 vlog.error(_("No key code specified on key press"));
829 return;
830 }
831
Pierre Ossman25188c42014-07-21 16:30:08 +0200832#ifdef __APPLE__
833 // Alt on OS X behaves more like AltGr on other systems, and to get
834 // sane behaviour we should translate things in that manner for the
835 // remote VNC server. However that means we lose the ability to use
836 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
837 // left command key as an Alt replacement.
838 switch (keySym) {
839 case XK_Super_L:
840 keySym = XK_Alt_L;
841 break;
842 case XK_Super_R:
843 keySym = XK_Super_L;
844 break;
845 case XK_Alt_L:
Pierre Ossman38fcebb2014-08-21 13:44:28 +0200846 keySym = XK_Mode_switch;
847 break;
Pierre Ossman25188c42014-07-21 16:30:08 +0200848 case XK_Alt_R:
849 keySym = XK_ISO_Level3_Shift;
850 break;
851 }
852#endif
853
Pierre Ossman25188c42014-07-21 16:30:08 +0200854 // Because of the way keyboards work, we cannot expect to have the same
855 // symbol on release as when pressed. This breaks the VNC protocol however,
856 // so we need to keep track of what keysym a key _code_ generated on press
857 // and send the same on release.
858 downKeySym[keyCode] = keySym;
859
860#if defined(WIN32) || defined(__APPLE__)
861 vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
862#else
863 vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)",
864 keyCode, XKeysymToString(keySym), keySym);
865#endif
866
867 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200868 // Fake keycode?
869 if (keyCode > 0xff)
Pierre Ossman59da99f2016-02-05 10:43:12 +0100870 cc->writer()->writeKeyEvent(keySym, 0, true);
Pierre Ossman0c158662017-07-13 15:54:11 +0200871 else
Pierre Ossman59da99f2016-02-05 10:43:12 +0100872 cc->writer()->writeKeyEvent(keySym, keyCode, true);
Pierre Ossman25188c42014-07-21 16:30:08 +0200873 } catch (rdr::Exception& e) {
874 vlog.error("%s", e.str());
875 exit_vncviewer(e.str());
876 }
Pierre Ossman25188c42014-07-21 16:30:08 +0200877}
878
879
880void Viewport::handleKeyRelease(int keyCode)
881{
882 DownMap::iterator iter;
883
884 if (viewOnly)
885 return;
886
887 iter = downKeySym.find(keyCode);
888 if (iter == downKeySym.end()) {
889 // These occur somewhat frequently so let's not spam them unless
890 // logging is turned up.
891 vlog.debug("Unexpected release of key code %d", keyCode);
892 return;
893 }
894
895#if defined(WIN32) || defined(__APPLE__)
896 vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second);
897#else
898 vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)",
899 keyCode, XKeysymToString(iter->second), iter->second);
900#endif
901
902 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200903 if (keyCode > 0xff)
Pierre Ossman59da99f2016-02-05 10:43:12 +0100904 cc->writer()->writeKeyEvent(iter->second, 0, false);
Pierre Ossman0c158662017-07-13 15:54:11 +0200905 else
Pierre Ossman59da99f2016-02-05 10:43:12 +0100906 cc->writer()->writeKeyEvent(iter->second, keyCode, false);
Pierre Ossman25188c42014-07-21 16:30:08 +0200907 } catch (rdr::Exception& e) {
908 vlog.error("%s", e.str());
909 exit_vncviewer(e.str());
910 }
911
912 downKeySym.erase(iter);
913}
914
915
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200916int Viewport::handleSystemEvent(void *event, void *data)
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200917{
918 Viewport *self = (Viewport *)data;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200919
920 assert(self);
921
Pierre Ossman9a747322018-03-26 14:16:43 +0200922 if (!self->hasFocus())
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200923 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200924
925 assert(event);
926
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200927#if defined(WIN32)
928 MSG *msg = (MSG*)event;
929
930 if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
931 UINT vKey;
932 bool isExtended;
933 int keyCode;
934 rdr::U32 keySym;
935
936 vKey = msg->wParam;
937 isExtended = (msg->lParam & (1 << 24)) != 0;
938
939 keyCode = ((msg->lParam >> 16) & 0xff);
940
Pierre Ossman42d0f5d2018-11-06 17:31:11 +0100941 // Windows' touch keyboard doesn't set a scan code for the Alt
942 // portion of the AltGr sequence, so we need to help it out
943 if (!isExtended && (keyCode == 0x00) && (vKey == VK_MENU)) {
944 isExtended = true;
945 keyCode = 0x38;
946 }
947
Pierre Ossman51249782018-03-08 14:05:39 +0100948 // Windows doesn't have a proper AltGr, but handles it using fake
949 // Ctrl+Alt. However the remote end might not be Windows, so we need
950 // to merge those in to a single AltGr event. We detect this case
951 // by seeing the two key events directly after each other with a very
Pierre Ossman69428fe2018-03-08 17:24:54 +0100952 // short time between them (<50ms) and supress the Ctrl event.
Pierre Ossman51249782018-03-08 14:05:39 +0100953 if (self->altGrArmed) {
954 self->altGrArmed = false;
955 Fl::remove_timeout(handleAltGrTimeout);
956
957 if (isExtended && (keyCode == 0x38) && (vKey == VK_MENU) &&
958 ((msg->time - self->altGrCtrlTime) < 50)) {
Pierre Ossman69428fe2018-03-08 17:24:54 +0100959 // Alt seen, so this is an AltGr sequence
960 } else {
961 // Not Alt, so fire the queued up Ctrl event
962 self->handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman51249782018-03-08 14:05:39 +0100963 }
Pierre Ossman51249782018-03-08 14:05:39 +0100964 }
965
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100966 if (keyCode == SCAN_FAKE) {
967 vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
968 return 1;
969 }
970
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200971 // Windows sets the scan code to 0x00 for multimedia keys, so we
972 // have to do a reverse lookup based on the vKey.
973 if (keyCode == 0x00) {
974 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
975 if (keyCode == 0x00) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200976 if (isExtended)
977 vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
978 else
979 vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200980 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200981 }
982 }
983
Pierre Ossman0c158662017-07-13 15:54:11 +0200984 if (keyCode & ~0x7f) {
985 vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode);
986 return 1;
987 }
988
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200989 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200990 keyCode |= 0x80;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200991
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100992
993 // Fortunately RFB and Windows use the same scan code set (mostly),
994 // so there is no conversion needed
995 // (as long as we encode the extended keys with the high bit)
996
997 // However Pause sends a code that conflicts with NumLock, so use
998 // the code most RFB implementations use (part of the sequence for
999 // Ctrl+Pause, i.e. Break)
1000 if (keyCode == 0x45)
1001 keyCode = 0xc6;
1002
1003 // And NumLock incorrectly has the extended bit set
1004 if (keyCode == 0xc5)
1005 keyCode = 0x45;
1006
1007 // And Alt+PrintScreen (i.e. SysRq) sends a different code than
1008 // PrintScreen
1009 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +02001010 keyCode = 0x54;
Pierre Ossmana7d3dc72014-09-30 17:03:28 +02001011
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001012 keySym = win32_vkey_to_keysym(vKey, isExtended);
1013 if (keySym == NoSymbol) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +02001014 if (isExtended)
1015 vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
1016 else
1017 vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001018 }
1019
Pierre Ossman30b3f922017-11-13 09:07:59 +01001020 // Windows sends the same vKey for both shifts, so we need to look
1021 // at the scan code to tell them apart
1022 if ((keySym == XK_Shift_L) && (keyCode == 0x36))
1023 keySym = XK_Shift_R;
Pierre Ossman0c158662017-07-13 15:54:11 +02001024
Pierre Ossman69428fe2018-03-08 17:24:54 +01001025 // AltGr handling (see above)
1026 if (win32_has_altgr()) {
1027 if ((keyCode == 0xb8) && (keySym == XK_Alt_R))
1028 keySym = XK_ISO_Level3_Shift;
1029
1030 // Possible start of AltGr sequence?
1031 if ((keyCode == 0x1d) && (keySym == XK_Control_L)) {
1032 self->altGrArmed = true;
1033 self->altGrCtrlTime = msg->time;
1034 Fl::add_timeout(0.1, handleAltGrTimeout, self);
1035 return 1;
1036 }
Pierre Ossman51249782018-03-08 14:05:39 +01001037 }
1038
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001039 self->handleKeyPress(keyCode, keySym);
1040
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001041 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001042 } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
1043 UINT vKey;
1044 bool isExtended;
1045 int keyCode;
1046
1047 vKey = msg->wParam;
1048 isExtended = (msg->lParam & (1 << 24)) != 0;
1049
1050 keyCode = ((msg->lParam >> 16) & 0xff);
Pierre Ossman2fa63f82016-12-05 15:26:21 +01001051
Pierre Ossman42d0f5d2018-11-06 17:31:11 +01001052 // Touch keyboard AltGr (see above)
1053 if (!isExtended && (keyCode == 0x00) && (vKey == VK_MENU)) {
1054 isExtended = true;
1055 keyCode = 0x38;
1056 }
1057
Pierre Ossman51249782018-03-08 14:05:39 +01001058 // We can't get a release in the middle of an AltGr sequence, so
1059 // abort that detection
1060 if (self->altGrArmed) {
1061 self->altGrArmed = false;
1062 Fl::remove_timeout(handleAltGrTimeout);
1063 self->handleKeyPress(0x1d, XK_Control_L);
1064 }
1065
Pierre Ossman2fa63f82016-12-05 15:26:21 +01001066 if (keyCode == SCAN_FAKE) {
1067 vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
1068 return 1;
1069 }
1070
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001071 if (keyCode == 0x00)
1072 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
1073 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +02001074 keyCode |= 0x80;
Pierre Ossmanf73214c2017-11-13 09:06:03 +01001075 if (keyCode == 0x45)
1076 keyCode = 0xc6;
1077 if (keyCode == 0xc5)
1078 keyCode = 0x45;
1079 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +02001080 keyCode = 0x54;
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001081
1082 self->handleKeyRelease(keyCode);
1083
Pierre Ossman30b3f922017-11-13 09:07:59 +01001084 // Windows has a rather nasty bug where it won't send key release
1085 // events for a Shift button if the other Shift is still pressed
1086 if ((keyCode == 0x2a) || (keyCode == 0x36)) {
1087 if (self->downKeySym.count(0x2a))
1088 self->handleKeyRelease(0x2a);
1089 if (self->downKeySym.count(0x36))
1090 self->handleKeyRelease(0x36);
1091 }
1092
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001093 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001094 }
Pierre Ossman6b743d02014-07-21 16:48:43 +02001095#elif defined(__APPLE__)
1096 if (cocoa_is_keyboard_event(event)) {
1097 int keyCode;
1098
1099 keyCode = cocoa_event_keycode(event);
Pierre Ossman0c158662017-07-13 15:54:11 +02001100 if ((unsigned)keyCode >= code_map_osx_to_qnum_len)
1101 keyCode = 0;
1102 else
1103 keyCode = code_map_osx_to_qnum[keyCode];
Pierre Ossman6b743d02014-07-21 16:48:43 +02001104
1105 if (cocoa_is_key_press(event)) {
1106 rdr::U32 keySym;
1107
1108 keySym = cocoa_event_keysym(event);
1109 if (keySym == NoSymbol) {
1110 vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
1111 (int)keyCode);
Pierre Ossman6b743d02014-07-21 16:48:43 +02001112 }
1113
1114 self->handleKeyPress(keyCode, keySym);
1115
1116 // We don't get any release events for CapsLock, so we have to
1117 // send the release right away.
1118 if (keySym == XK_Caps_Lock)
1119 self->handleKeyRelease(keyCode);
1120 } else {
1121 self->handleKeyRelease(keyCode);
1122 }
1123
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001124 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +02001125 }
1126#else
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001127 XEvent *xevent = (XEvent*)event;
1128
1129 if (xevent->type == KeyPress) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001130 int keycode;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001131 char str;
1132 KeySym keysym;
1133
Pierre Ossman0c158662017-07-13 15:54:11 +02001134 keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1135
1136 // Generate a fake keycode just for tracking if we can't figure
1137 // out the proper one
1138 if (keycode == 0)
1139 keycode = 0x100 | xevent->xkey.keycode;
1140
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001141 XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
1142 if (keysym == NoSymbol) {
1143 vlog.error(_("No symbol for key code %d (in the current state)"),
1144 (int)xevent->xkey.keycode);
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001145 }
1146
1147 switch (keysym) {
1148 // For the first few years, there wasn't a good consensus on what the
1149 // Windows keys should be mapped to for X11. So we need to help out a
1150 // bit and map all variants to the same key...
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001151 case XK_Hyper_L:
1152 keysym = XK_Super_L;
1153 break;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001154 case XK_Hyper_R:
1155 keysym = XK_Super_R;
1156 break;
1157 // There has been several variants for Shift-Tab over the years.
1158 // RFB states that we should always send a normal tab.
1159 case XK_ISO_Left_Tab:
1160 keysym = XK_Tab;
1161 break;
1162 }
1163
Pierre Ossman0c158662017-07-13 15:54:11 +02001164 self->handleKeyPress(keycode, keysym);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001165 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001166 } else if (xevent->type == KeyRelease) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001167 int keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1168 if (keycode == 0)
1169 keycode = 0x100 | xevent->xkey.keycode;
1170 self->handleKeyRelease(keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001171 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001172 }
1173#endif
1174
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001175 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +02001176}
1177
Pierre Ossman51249782018-03-08 14:05:39 +01001178#ifdef WIN32
1179void Viewport::handleAltGrTimeout(void *data)
1180{
1181 Viewport *self = (Viewport *)data;
1182
1183 assert(self);
1184
1185 self->altGrArmed = false;
1186 self->handleKeyPress(0x1d, XK_Control_L);
1187}
1188#endif
1189
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001190void Viewport::initContextMenu()
1191{
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001192 contextMenu->clear();
1193
Pierre Ossmanff626f82015-09-23 16:39:54 +02001194 fltk_menu_add(contextMenu, p_("ContextMenu|", "E&xit viewer"),
1195 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001196
Pierre Ossmanff626f82015-09-23 16:39:54 +02001197 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"),
1198 0, NULL, (void*)ID_FULLSCREEN,
Pierre Ossman245c8022015-02-25 11:27:49 +01001199 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001200 fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"),
1201 0, NULL, (void*)ID_MINIMIZE, 0);
1202 fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"),
1203 0, NULL, (void*)ID_RESIZE,
Pierre Ossman245c8022015-02-25 11:27:49 +01001204 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
Pierre Ossman245c8022015-02-25 11:27:49 +01001205 FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001206
Pierre Ossmanff626f82015-09-23 16:39:54 +02001207 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"),
1208 0, NULL, (void*)ID_CTRL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001209 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001210 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"),
1211 0, NULL, (void*)ID_ALT,
Pierre Ossman245c8022015-02-25 11:27:49 +01001212 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001213
1214 if (menuKeySym) {
1215 char sendMenuKey[64];
Pierre Ossmanff626f82015-09-23 16:39:54 +02001216 snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey);
Pierre Ossman245c8022015-02-25 11:27:49 +01001217 fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
Pierre Ossman0c158662017-07-13 15:54:11 +02001218 fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001219 (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001220 }
1221
Pierre Ossmanff626f82015-09-23 16:39:54 +02001222 fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"),
1223 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001224
Pierre Ossmanff626f82015-09-23 16:39:54 +02001225 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"),
1226 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001227
Pierre Ossmanff626f82015-09-23 16:39:54 +02001228 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."),
1229 0, NULL, (void*)ID_OPTIONS, 0);
1230 fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."),
1231 0, NULL, (void*)ID_INFO, 0);
1232 fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."),
1233 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001234
Pierre Ossmanff626f82015-09-23 16:39:54 +02001235 fltk_menu_add(contextMenu, p_("ContextMenu|", "Dismiss &menu"),
1236 0, NULL, (void*)ID_DISMISS, 0);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001237}
1238
1239
1240void Viewport::popupContextMenu()
1241{
1242 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001243 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001244
Pierre Ossmanb3ff4372011-06-03 11:45:15 +00001245 // Make sure the menu is reset to its initial state between goes or
1246 // it will start up highlighting the previously selected entry.
1247 contextMenu->value(-1);
1248
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001249 // initialize context menu before display
1250 initContextMenu();
1251
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001252 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
1253 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001254 if (Fl::belowmouse() == this)
1255 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001256
Pierre Ossman78236292018-03-26 14:15:40 +02001257 // FLTK also doesn't switch focus properly for menus
1258 handle(FL_UNFOCUS);
1259
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001260 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001261
Pierre Ossman78236292018-03-26 14:15:40 +02001262 handle(FL_FOCUS);
1263
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001264 // Back to our proper mouse pointer.
Pierre Ossmande1a3b92014-03-17 14:29:49 +01001265 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001266 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001267
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001268 if (m == NULL)
1269 return;
1270
1271 switch (m->argument()) {
1272 case ID_EXIT:
1273 exit_vncviewer();
1274 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +00001275 case ID_FULLSCREEN:
1276 if (window()->fullscreen_active())
1277 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +00001278 else
Pierre Ossmanaae38912012-07-13 11:22:55 +00001279 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +00001280 break;
Joel Teichroeba7494ac2015-07-13 14:46:22 -07001281 case ID_MINIMIZE:
1282 window()->iconize();
Joel Teichroeb1f9e45a2015-07-18 07:09:24 -07001283 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001284 case ID_RESIZE:
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001285 if (window()->fullscreen_active())
1286 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001287 window()->size(w(), h());
1288 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001289 case ID_CTRL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001290 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001291 handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001292 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001293 handleKeyRelease(0x1d);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001294 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001295 break;
1296 case ID_ALT:
Pierre Ossman25188c42014-07-21 16:30:08 +02001297 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001298 handleKeyPress(0x38, XK_Alt_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001299 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001300 handleKeyRelease(0x38);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001301 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001302 break;
1303 case ID_MENUKEY:
Pierre Ossman0c158662017-07-13 15:54:11 +02001304 handleKeyPress(menuKeyCode, menuKeySym);
1305 handleKeyRelease(menuKeyCode);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001306 break;
1307 case ID_CTRLALTDEL:
Pierre Ossman0c158662017-07-13 15:54:11 +02001308 handleKeyPress(0x1d, XK_Control_L);
1309 handleKeyPress(0x38, XK_Alt_L);
1310 handleKeyPress(0xd3, XK_Delete);
Pierre Ossman991b4fe2011-07-12 16:02:30 +00001311
Pierre Ossman0c158662017-07-13 15:54:11 +02001312 handleKeyRelease(0xd3);
1313 handleKeyRelease(0x38);
1314 handleKeyRelease(0x1d);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001315 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001316 case ID_REFRESH:
1317 cc->refreshFramebuffer();
1318 break;
Pierre Ossmand463b572011-05-16 12:04:43 +00001319 case ID_OPTIONS:
1320 OptionsDialog::showDialog();
1321 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001322 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001323 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
1324 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +00001325 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001326 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001327 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +00001328 case ID_ABOUT:
1329 about_vncviewer();
1330 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001331 case ID_DISMISS:
1332 // Don't need to do anything
1333 break;
1334 }
1335}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001336
1337
1338void Viewport::setMenuKey()
1339{
Pierre Ossman0c158662017-07-13 15:54:11 +02001340 getMenuKey(&menuKeyFLTK, &menuKeyCode, &menuKeySym);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001341}
1342
1343
1344void Viewport::handleOptions(void *data)
1345{
1346 Viewport *self = (Viewport*)data;
1347
1348 self->setMenuKey();
1349}