blob: 3b56fce558d42d9be4bd70365e09c2779ba34897 [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 Ossmanb1cd6ca2015-03-03 16:37:43 +0100121 menuCtrlKey(false), menuAltKey(false), cursor(NULL)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000122{
Pierre Ossman0c158662017-07-13 15:54:11 +0200123#if !defined(WIN32) && !defined(__APPLE__)
124 XkbDescPtr xkb;
125 Status status;
126
127 xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd);
128 if (!xkb)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200129 throw rfb::Exception("XkbGetMap");
Pierre Ossman0c158662017-07-13 15:54:11 +0200130
131 status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb);
132 if (status != Success)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200133 throw rfb::Exception("XkbGetNames");
Pierre Ossman0c158662017-07-13 15:54:11 +0200134
135 memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum));
136 for (KeyCode keycode = xkb->min_key_code;
137 keycode < xkb->max_key_code;
138 keycode++) {
139 const char *keyname = xkb->names->keys[keycode].name;
140 unsigned short rfbcode;
141
142 if (keyname[0] == '\0')
143 continue;
144
145 rfbcode = 0;
146 for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) {
147 if (strncmp(code_map_xkb_to_qnum[i].from,
148 keyname, XkbKeyNameLength) == 0) {
149 rfbcode = code_map_xkb_to_qnum[i].to;
150 break;
151 }
152 }
153 if (rfbcode != 0)
154 code_map_keycode_to_qnum[keycode] = rfbcode;
155 else
156 vlog.debug("No key mapping for key %.4s", keyname);
157 }
158
159 XkbFreeKeyboard(xkb, 0, True);
160#endif
161
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000162 Fl::add_clipboard_notify(handleClipboardChange, this);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000163
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200164 // We need to intercept keyboard events early
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200165 Fl::add_system_handler(handleSystemEvent, this);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200166
Pierre Ossman403ac272017-01-02 17:00:41 +0100167 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000168 assert(frameBuffer);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100169 cc->setFramebuffer(frameBuffer);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000170
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000171 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +0000172 // Setting box type to FL_NO_BOX prevents it from trying to draw the
173 // button component (which we don't want)
174 contextMenu->box(FL_NO_BOX);
175
Pierre Ossmanb043ad12011-06-01 09:26:57 +0000176 // The (invisible) button associated with this widget can mess with
177 // things like Fl_Scroll so we need to get rid of any parents.
178 // Unfortunately that's not possible because of STR #2654, but
179 // reparenting to the current window works for most cases.
180 window()->add(contextMenu);
181
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000182 setMenuKey();
183
184 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000185}
186
187
188Viewport::~Viewport()
189{
190 // Unregister all timeouts in case they get a change tro trigger
191 // again later when this object is already gone.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000192 Fl::remove_timeout(handlePointerTimeout, this);
Pierre Ossman51249782018-03-08 14:05:39 +0100193#ifdef WIN32
194 Fl::remove_timeout(handleAltGrTimeout, this);
195#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000196
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200197 Fl::remove_system_handler(handleSystemEvent);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200198
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000199 Fl::remove_clipboard_notify(handleClipboardChange);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000200
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000201 OptionsDialog::removeCallback(handleOptions);
202
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000203 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000204 if (!cursor->alloc_array)
205 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000206 delete cursor;
207 }
208
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000209 // FLTK automatically deletes all child widgets, so we shouldn't touch
210 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000211}
212
213
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000214const rfb::PixelFormat &Viewport::getPreferredPF()
215{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000216 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000217}
218
219
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000220// Copy the areas of the framebuffer that have been changed (damaged)
221// to the displayed window.
222
223void Viewport::updateWindow()
224{
225 Rect r;
226
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200227 r = frameBuffer->getDamage();
228 damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000229}
230
Pierre Ossman4c204232018-03-26 13:32:49 +0200231void Viewport::serverCutText(const char* str, rdr::U32 len)
232{
233 char *buffer;
234 int size, ret;
235
236 if (!acceptClipboard)
237 return;
238
239 size = fl_utf8froma(NULL, 0, str, len);
240 if (size <= 0)
241 return;
242
243 size++;
244
245 buffer = new char[size];
246
247 ret = fl_utf8froma(buffer, size, str, len);
248 assert(ret < size);
249
250 vlog.debug("Got clipboard data (%d bytes)", (int)strlen(buffer));
251
252 // RFB doesn't have separate selection and clipboard concepts, so we
253 // dump the data into both variants.
254 if (setPrimary)
255 Fl::copy(buffer, ret, 0);
256 Fl::copy(buffer, ret, 1);
257
258 delete [] buffer;
259}
260
Pierre Ossmanf741d342011-06-09 08:32:49 +0000261static const char * dotcursor_xpm[] = {
262 "5 5 2 1",
263 ". c #000000",
264 " c #FFFFFF",
265 " ",
266 " ... ",
267 " ... ",
268 " ... ",
269 " "};
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000270
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000271void Viewport::setCursor(int width, int height, const Point& hotspot,
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100272 const rdr::U8* data)
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000273{
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100274 int i;
275
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000276 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000277 if (!cursor->alloc_array)
278 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000279 delete cursor;
280 }
281
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100282 for (i = 0; i < width*height; i++)
283 if (data[i*4 + 3] != 0) break;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000284
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100285 if ((i == width*height) && dotWhenNoCursor) {
Pierre Ossmana51574a2011-06-09 08:39:35 +0000286 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000287
288 Fl_Pixmap pxm(dotcursor_xpm);
289 cursor = new Fl_RGB_Image(&pxm);
290 cursorHotspot.x = cursorHotspot.y = 2;
291 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000292 if ((width == 0) || (height == 0)) {
293 U8 *buffer = new U8[4];
294 memset(buffer, 0, 4);
295 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
296 cursorHotspot.x = cursorHotspot.y = 0;
297 } else {
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100298 U8 *buffer = new U8[width * height * 4];
299 memcpy(buffer, data, width * height * 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000300 cursor = new Fl_RGB_Image(buffer, width, height, 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000301 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000302 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000303 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000304
305 if (Fl::belowmouse() == this)
306 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000307}
308
309
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100310void Viewport::setLEDState(unsigned int state)
311{
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100312 vlog.debug("Got server LED state: 0x%08x", state);
313
Pierre Ossman9a747322018-03-26 14:16:43 +0200314 if (!hasFocus())
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100315 return;
316
317#if defined(WIN32)
318 INPUT input[6];
319 UINT count;
320 UINT ret;
321
322 memset(input, 0, sizeof(input));
323 count = 0;
324
325 if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
326 input[count].type = input[count+1].type = INPUT_KEYBOARD;
327 input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
328 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
329 input[count].ki.dwFlags = 0;
330 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
331 count += 2;
332 }
333
334 if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
335 input[count].type = input[count+1].type = INPUT_KEYBOARD;
336 input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
337 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
338 input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
339 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
340 count += 2;
341 }
342
343 if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
344 input[count].type = input[count+1].type = INPUT_KEYBOARD;
345 input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
346 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
347 input[count].ki.dwFlags = 0;
348 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
349 count += 2;
350 }
351
352 if (count == 0)
353 return;
354
355 ret = SendInput(count, input, sizeof(*input));
356 if (ret < count)
357 vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
358#elif defined(__APPLE__)
359 int ret;
360
361 ret = cocoa_set_caps_lock_state(state & ledCapsLock);
362 if (ret != 0) {
363 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
364 return;
365 }
366
367 ret = cocoa_set_num_lock_state(state & ledNumLock);
368 if (ret != 0) {
369 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
370 return;
371 }
372
373 // No support for Scroll Lock //
374
375#else
376 unsigned int affect, values;
377 unsigned int mask;
378
379 Bool ret;
380
381 affect = values = 0;
382
383 affect |= LockMask;
384 if (state & ledCapsLock)
385 values |= LockMask;
386
387 mask = getModifierMask(XK_Num_Lock);
388 affect |= mask;
389 if (state & ledNumLock)
390 values |= mask;
391
392 mask = getModifierMask(XK_Scroll_Lock);
393 affect |= mask;
394 if (state & ledScrollLock)
395 values |= mask;
396
397 ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
398 if (!ret)
399 vlog.error(_("Failed to update keyboard LED state"));
400#endif
401}
402
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100403void Viewport::pushLEDState()
404{
405 unsigned int state;
406
407 // Server support?
408 if (cc->cp.ledState() == ledUnknown)
409 return;
410
411 state = 0;
412
413#if defined(WIN32)
414 if (GetKeyState(VK_CAPITAL) & 0x1)
415 state |= ledCapsLock;
416 if (GetKeyState(VK_NUMLOCK) & 0x1)
417 state |= ledNumLock;
418 if (GetKeyState(VK_SCROLL) & 0x1)
419 state |= ledScrollLock;
420#elif defined(__APPLE__)
421 int ret;
422 bool on;
423
424 ret = cocoa_get_caps_lock_state(&on);
425 if (ret != 0) {
426 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
427 return;
428 }
429 if (on)
430 state |= ledCapsLock;
431
432 ret = cocoa_get_num_lock_state(&on);
433 if (ret != 0) {
434 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
435 return;
436 }
437 if (on)
438 state |= ledNumLock;
439
440 // No support for Scroll Lock //
441 state |= (cc->cp.ledState() & ledScrollLock);
442
443#else
444 unsigned int mask;
445
446 Status status;
447 XkbStateRec xkbState;
448
449 status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
450 if (status != Success) {
451 vlog.error(_("Failed to get keyboard LED state: %d"), status);
452 return;
453 }
454
455 if (xkbState.locked_mods & LockMask)
456 state |= ledCapsLock;
457
458 mask = getModifierMask(XK_Num_Lock);
459 if (xkbState.locked_mods & mask)
460 state |= ledNumLock;
461
462 mask = getModifierMask(XK_Scroll_Lock);
463 if (xkbState.locked_mods & mask)
464 state |= ledScrollLock;
465#endif
466
467 if ((state & ledCapsLock) != (cc->cp.ledState() & ledCapsLock)) {
468 vlog.debug("Inserting fake CapsLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200469 handleKeyPress(0x3a, XK_Caps_Lock);
470 handleKeyRelease(0x3a);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100471 }
472 if ((state & ledNumLock) != (cc->cp.ledState() & ledNumLock)) {
473 vlog.debug("Inserting fake NumLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200474 handleKeyPress(0x45, XK_Num_Lock);
475 handleKeyRelease(0x45);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100476 }
477 if ((state & ledScrollLock) != (cc->cp.ledState() & ledScrollLock)) {
478 vlog.debug("Inserting fake ScrollLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200479 handleKeyPress(0x46, XK_Scroll_Lock);
480 handleKeyRelease(0x46);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100481 }
482}
483
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100484
Pierre Ossman3d74d882017-01-02 19:49:52 +0100485void Viewport::draw(Surface* dst)
486{
487 int X, Y, W, H;
488
489 // Check what actually needs updating
490 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
491 if ((W == 0) || (H == 0))
492 return;
493
494 frameBuffer->draw(dst, X - x(), Y - y(), X, Y, W, H);
495}
496
497
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000498void Viewport::draw()
499{
500 int X, Y, W, H;
501
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000502 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000503 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000504 if ((W == 0) || (H == 0))
505 return;
506
Pierre Ossman132b3d02011-06-13 11:19:32 +0000507 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000508}
509
510
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000511void Viewport::resize(int x, int y, int w, int h)
512{
Pierre Ossman9f273e92015-11-09 16:34:54 +0100513 if ((w != frameBuffer->width()) || (h != frameBuffer->height())) {
514 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
515 frameBuffer->width(), frameBuffer->height(), w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000516
Pierre Ossman403ac272017-01-02 17:00:41 +0100517 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100518 assert(frameBuffer);
519 cc->setFramebuffer(frameBuffer);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000520 }
521
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000522 Fl_Widget::resize(x, y, w, h);
523}
524
525
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000526int Viewport::handle(int event)
527{
Pierre Ossman689c4582011-05-26 15:39:41 +0000528 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000529 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000530 int buttonMask, wheelMask;
531 DownMap::const_iterator iter;
532
533 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000534 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000535 buffer = new char[Fl::event_length() + 1];
536
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000537 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000538 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
539 Fl::event_length() + 1);
540 assert(ret < (Fl::event_length() + 1));
541
Pierre Ossmanfb450fb2015-03-03 16:34:56 +0100542 vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000543
544 try {
545 cc->writer()->clientCutText(buffer, ret);
546 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000547 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000548 exit_vncviewer(e.str());
549 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000550
551 delete [] buffer;
552
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000553 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000554
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000555 case FL_ENTER:
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000556 if (cursor)
557 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman56610fb2015-01-27 16:28:15 +0100558 // Yes, we would like some pointer events please!
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000559 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000560
561 case FL_LEAVE:
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000562 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossman164865a2011-11-10 13:30:39 +0000563 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000564 case FL_PUSH:
565 case FL_RELEASE:
566 case FL_DRAG:
567 case FL_MOVE:
568 case FL_MOUSEWHEEL:
569 buttonMask = 0;
570 if (Fl::event_button1())
571 buttonMask |= 1;
572 if (Fl::event_button2())
573 buttonMask |= 2;
574 if (Fl::event_button3())
575 buttonMask |= 4;
576
577 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000578 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000579 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000580 wheelMask |= 8;
581 if (Fl::event_dy() > 0)
582 wheelMask |= 16;
583 if (Fl::event_dx() < 0)
584 wheelMask |= 32;
585 if (Fl::event_dx() > 0)
586 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000587
588 // A quick press of the wheel "button", followed by a immediate
589 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000590 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000591 buttonMask | wheelMask);
592 }
593
Pierre Ossman6a464be2011-04-15 12:57:31 +0000594 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000595 return 1;
596
597 case FL_FOCUS:
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200598 Fl::disable_im();
Pierre Ossman78236292018-03-26 14:15:40 +0200599
600 try {
601 // We may have gotten our lock keys out of sync with the server
602 // whilst we didn't have focus. Try to sort this out.
603 pushLEDState();
604 } catch (rdr::Exception& e) {
605 vlog.error("%s", e.str());
606 exit_vncviewer(e.str());
607 }
608
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000609 // Yes, we would like some focus please!
610 return 1;
611
612 case FL_UNFOCUS:
613 // Release all keys that were pressed as that generally makes most
614 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000615 while (!downKeySym.empty())
Pierre Ossman25188c42014-07-21 16:30:08 +0200616 handleKeyRelease(downKeySym.begin()->first);
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200617 Fl::enable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000618 return 1;
619
620 case FL_KEYDOWN:
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000621 case FL_KEYUP:
Pierre Ossman56610fb2015-01-27 16:28:15 +0100622 // Just ignore these as keys were handled in the event handler
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000623 return 1;
624 }
625
626 return Fl_Widget::handle(event);
627}
628
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100629
Pierre Ossman9a747322018-03-26 14:16:43 +0200630bool Viewport::hasFocus()
631{
632 Fl_Widget* focus;
633
634 focus = Fl::grab();
635 if (!focus)
636 focus = Fl::focus();
637
638 return focus == this;
639}
640
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100641#if ! (defined(WIN32) || defined(__APPLE__))
642unsigned int Viewport::getModifierMask(unsigned int keysym)
643{
644 XkbDescPtr xkb;
645 unsigned int mask, keycode;
646 XkbAction *act;
647
648 mask = 0;
649
650 xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
651 if (xkb == NULL)
652 return 0;
653
654 for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
655 unsigned int state_out;
656 KeySym ks;
657
658 XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
659 if (ks == NoSymbol)
660 continue;
661
662 if (ks == keysym)
663 break;
664 }
665
666 // KeySym not mapped?
667 if (keycode > xkb->max_key_code)
668 goto out;
669
670 act = XkbKeyAction(xkb, keycode, 0);
671 if (act == NULL)
672 goto out;
673 if (act->type != XkbSA_LockMods)
674 goto out;
675
676 if (act->mods.flags & XkbSA_UseModMapMods)
677 mask = xkb->map->modmap[keycode];
678 else
679 mask = act->mods.mask;
680
681out:
682 XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
683
684 return mask;
685}
686#endif
687
688
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000689void Viewport::handleClipboardChange(int source, void *data)
690{
691 Viewport *self = (Viewport *)data;
692
693 assert(self);
694
Pierre Ossmana432b582017-01-02 15:16:58 +0100695 if (!sendClipboard)
696 return;
697
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100698#if !defined(WIN32) && !defined(__APPLE__)
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000699 if (!sendPrimary && (source == 0))
700 return;
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100701#endif
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000702
703 Fl::paste(*self, source);
704}
705
706
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000707void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
708{
709 if (!viewOnly) {
710 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000711 try {
712 cc->writer()->pointerEvent(pos, buttonMask);
713 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000714 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000715 exit_vncviewer(e.str());
716 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000717 } else {
718 if (!Fl::has_timeout(handlePointerTimeout, this))
719 Fl::add_timeout((double)pointerEventInterval/1000.0,
720 handlePointerTimeout, this);
721 }
722 lastPointerPos = pos;
723 lastButtonMask = buttonMask;
724 }
725}
726
727
728void Viewport::handlePointerTimeout(void *data)
729{
730 Viewport *self = (Viewport *)data;
731
732 assert(self);
733
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000734 try {
735 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
736 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000737 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000738 exit_vncviewer(e.str());
739 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000740}
741
742
Pierre Ossman25188c42014-07-21 16:30:08 +0200743void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym)
744{
745 static bool menuRecursion = false;
746
747 // Prevent recursion if the menu wants to send its own
748 // activation key.
749 if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) {
750 menuRecursion = true;
751 popupContextMenu();
752 menuRecursion = false;
753 return;
754 }
755
756 if (viewOnly)
757 return;
758
Pierre Ossman0c158662017-07-13 15:54:11 +0200759 if (keyCode == 0) {
760 vlog.error(_("No key code specified on key press"));
761 return;
762 }
763
Pierre Ossman25188c42014-07-21 16:30:08 +0200764#ifdef __APPLE__
765 // Alt on OS X behaves more like AltGr on other systems, and to get
766 // sane behaviour we should translate things in that manner for the
767 // remote VNC server. However that means we lose the ability to use
768 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
769 // left command key as an Alt replacement.
770 switch (keySym) {
771 case XK_Super_L:
772 keySym = XK_Alt_L;
773 break;
774 case XK_Super_R:
775 keySym = XK_Super_L;
776 break;
777 case XK_Alt_L:
Pierre Ossman38fcebb2014-08-21 13:44:28 +0200778 keySym = XK_Mode_switch;
779 break;
Pierre Ossman25188c42014-07-21 16:30:08 +0200780 case XK_Alt_R:
781 keySym = XK_ISO_Level3_Shift;
782 break;
783 }
784#endif
785
Pierre Ossman25188c42014-07-21 16:30:08 +0200786 // Because of the way keyboards work, we cannot expect to have the same
787 // symbol on release as when pressed. This breaks the VNC protocol however,
788 // so we need to keep track of what keysym a key _code_ generated on press
789 // and send the same on release.
790 downKeySym[keyCode] = keySym;
791
792#if defined(WIN32) || defined(__APPLE__)
793 vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
794#else
795 vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)",
796 keyCode, XKeysymToString(keySym), keySym);
797#endif
798
799 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200800 // Fake keycode?
801 if (keyCode > 0xff)
802 cc->writer()->keyEvent(keySym, 0, true);
803 else
804 cc->writer()->keyEvent(keySym, keyCode, true);
Pierre Ossman25188c42014-07-21 16:30:08 +0200805 } catch (rdr::Exception& e) {
806 vlog.error("%s", e.str());
807 exit_vncviewer(e.str());
808 }
Pierre Ossman25188c42014-07-21 16:30:08 +0200809}
810
811
812void Viewport::handleKeyRelease(int keyCode)
813{
814 DownMap::iterator iter;
815
816 if (viewOnly)
817 return;
818
819 iter = downKeySym.find(keyCode);
820 if (iter == downKeySym.end()) {
821 // These occur somewhat frequently so let's not spam them unless
822 // logging is turned up.
823 vlog.debug("Unexpected release of key code %d", keyCode);
824 return;
825 }
826
827#if defined(WIN32) || defined(__APPLE__)
828 vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second);
829#else
830 vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)",
831 keyCode, XKeysymToString(iter->second), iter->second);
832#endif
833
834 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200835 if (keyCode > 0xff)
836 cc->writer()->keyEvent(iter->second, 0, false);
837 else
838 cc->writer()->keyEvent(iter->second, keyCode, false);
Pierre Ossman25188c42014-07-21 16:30:08 +0200839 } catch (rdr::Exception& e) {
840 vlog.error("%s", e.str());
841 exit_vncviewer(e.str());
842 }
843
844 downKeySym.erase(iter);
845}
846
847
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200848int Viewport::handleSystemEvent(void *event, void *data)
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200849{
850 Viewport *self = (Viewport *)data;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200851
852 assert(self);
853
Pierre Ossman9a747322018-03-26 14:16:43 +0200854 if (!self->hasFocus())
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200855 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200856
857 assert(event);
858
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200859#if defined(WIN32)
860 MSG *msg = (MSG*)event;
861
862 if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
863 UINT vKey;
864 bool isExtended;
865 int keyCode;
866 rdr::U32 keySym;
867
868 vKey = msg->wParam;
869 isExtended = (msg->lParam & (1 << 24)) != 0;
870
871 keyCode = ((msg->lParam >> 16) & 0xff);
872
Pierre Ossman51249782018-03-08 14:05:39 +0100873 // Windows doesn't have a proper AltGr, but handles it using fake
874 // Ctrl+Alt. However the remote end might not be Windows, so we need
875 // to merge those in to a single AltGr event. We detect this case
876 // by seeing the two key events directly after each other with a very
Pierre Ossman69428fe2018-03-08 17:24:54 +0100877 // short time between them (<50ms) and supress the Ctrl event.
Pierre Ossman51249782018-03-08 14:05:39 +0100878 if (self->altGrArmed) {
879 self->altGrArmed = false;
880 Fl::remove_timeout(handleAltGrTimeout);
881
882 if (isExtended && (keyCode == 0x38) && (vKey == VK_MENU) &&
883 ((msg->time - self->altGrCtrlTime) < 50)) {
Pierre Ossman69428fe2018-03-08 17:24:54 +0100884 // Alt seen, so this is an AltGr sequence
885 } else {
886 // Not Alt, so fire the queued up Ctrl event
887 self->handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman51249782018-03-08 14:05:39 +0100888 }
Pierre Ossman51249782018-03-08 14:05:39 +0100889 }
890
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100891 if (keyCode == SCAN_FAKE) {
892 vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
893 return 1;
894 }
895
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200896 // Windows sets the scan code to 0x00 for multimedia keys, so we
897 // have to do a reverse lookup based on the vKey.
898 if (keyCode == 0x00) {
899 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
900 if (keyCode == 0x00) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200901 if (isExtended)
902 vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
903 else
904 vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200905 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200906 }
907 }
908
Pierre Ossman0c158662017-07-13 15:54:11 +0200909 if (keyCode & ~0x7f) {
910 vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode);
911 return 1;
912 }
913
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200914 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200915 keyCode |= 0x80;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200916
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100917
918 // Fortunately RFB and Windows use the same scan code set (mostly),
919 // so there is no conversion needed
920 // (as long as we encode the extended keys with the high bit)
921
922 // However Pause sends a code that conflicts with NumLock, so use
923 // the code most RFB implementations use (part of the sequence for
924 // Ctrl+Pause, i.e. Break)
925 if (keyCode == 0x45)
926 keyCode = 0xc6;
927
928 // And NumLock incorrectly has the extended bit set
929 if (keyCode == 0xc5)
930 keyCode = 0x45;
931
932 // And Alt+PrintScreen (i.e. SysRq) sends a different code than
933 // PrintScreen
934 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200935 keyCode = 0x54;
Pierre Ossmana7d3dc72014-09-30 17:03:28 +0200936
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200937 keySym = win32_vkey_to_keysym(vKey, isExtended);
938 if (keySym == NoSymbol) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200939 if (isExtended)
940 vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
941 else
942 vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200943 }
944
Pierre Ossman30b3f922017-11-13 09:07:59 +0100945 // Windows sends the same vKey for both shifts, so we need to look
946 // at the scan code to tell them apart
947 if ((keySym == XK_Shift_L) && (keyCode == 0x36))
948 keySym = XK_Shift_R;
Pierre Ossman0c158662017-07-13 15:54:11 +0200949
Pierre Ossman69428fe2018-03-08 17:24:54 +0100950 // AltGr handling (see above)
951 if (win32_has_altgr()) {
952 if ((keyCode == 0xb8) && (keySym == XK_Alt_R))
953 keySym = XK_ISO_Level3_Shift;
954
955 // Possible start of AltGr sequence?
956 if ((keyCode == 0x1d) && (keySym == XK_Control_L)) {
957 self->altGrArmed = true;
958 self->altGrCtrlTime = msg->time;
959 Fl::add_timeout(0.1, handleAltGrTimeout, self);
960 return 1;
961 }
Pierre Ossman51249782018-03-08 14:05:39 +0100962 }
963
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200964 self->handleKeyPress(keyCode, keySym);
965
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200966 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200967 } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
968 UINT vKey;
969 bool isExtended;
970 int keyCode;
971
972 vKey = msg->wParam;
973 isExtended = (msg->lParam & (1 << 24)) != 0;
974
975 keyCode = ((msg->lParam >> 16) & 0xff);
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100976
Pierre Ossman51249782018-03-08 14:05:39 +0100977 // We can't get a release in the middle of an AltGr sequence, so
978 // abort that detection
979 if (self->altGrArmed) {
980 self->altGrArmed = false;
981 Fl::remove_timeout(handleAltGrTimeout);
982 self->handleKeyPress(0x1d, XK_Control_L);
983 }
984
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100985 if (keyCode == SCAN_FAKE) {
986 vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
987 return 1;
988 }
989
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200990 if (keyCode == 0x00)
991 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
992 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200993 keyCode |= 0x80;
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100994 if (keyCode == 0x45)
995 keyCode = 0xc6;
996 if (keyCode == 0xc5)
997 keyCode = 0x45;
998 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200999 keyCode = 0x54;
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001000
1001 self->handleKeyRelease(keyCode);
1002
Pierre Ossman30b3f922017-11-13 09:07:59 +01001003 // Windows has a rather nasty bug where it won't send key release
1004 // events for a Shift button if the other Shift is still pressed
1005 if ((keyCode == 0x2a) || (keyCode == 0x36)) {
1006 if (self->downKeySym.count(0x2a))
1007 self->handleKeyRelease(0x2a);
1008 if (self->downKeySym.count(0x36))
1009 self->handleKeyRelease(0x36);
1010 }
1011
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001012 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +02001013 }
Pierre Ossman6b743d02014-07-21 16:48:43 +02001014#elif defined(__APPLE__)
1015 if (cocoa_is_keyboard_event(event)) {
1016 int keyCode;
1017
1018 keyCode = cocoa_event_keycode(event);
Pierre Ossman0c158662017-07-13 15:54:11 +02001019 if ((unsigned)keyCode >= code_map_osx_to_qnum_len)
1020 keyCode = 0;
1021 else
1022 keyCode = code_map_osx_to_qnum[keyCode];
Pierre Ossman6b743d02014-07-21 16:48:43 +02001023
1024 if (cocoa_is_key_press(event)) {
1025 rdr::U32 keySym;
1026
1027 keySym = cocoa_event_keysym(event);
1028 if (keySym == NoSymbol) {
1029 vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
1030 (int)keyCode);
Pierre Ossman6b743d02014-07-21 16:48:43 +02001031 }
1032
1033 self->handleKeyPress(keyCode, keySym);
1034
1035 // We don't get any release events for CapsLock, so we have to
1036 // send the release right away.
1037 if (keySym == XK_Caps_Lock)
1038 self->handleKeyRelease(keyCode);
1039 } else {
1040 self->handleKeyRelease(keyCode);
1041 }
1042
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001043 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +02001044 }
1045#else
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001046 XEvent *xevent = (XEvent*)event;
1047
1048 if (xevent->type == KeyPress) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001049 int keycode;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001050 char str;
1051 KeySym keysym;
1052
Pierre Ossman0c158662017-07-13 15:54:11 +02001053 keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1054
1055 // Generate a fake keycode just for tracking if we can't figure
1056 // out the proper one
1057 if (keycode == 0)
1058 keycode = 0x100 | xevent->xkey.keycode;
1059
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001060 XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
1061 if (keysym == NoSymbol) {
1062 vlog.error(_("No symbol for key code %d (in the current state)"),
1063 (int)xevent->xkey.keycode);
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001064 }
1065
1066 switch (keysym) {
1067 // For the first few years, there wasn't a good consensus on what the
1068 // Windows keys should be mapped to for X11. So we need to help out a
1069 // bit and map all variants to the same key...
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001070 case XK_Hyper_L:
1071 keysym = XK_Super_L;
1072 break;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001073 case XK_Hyper_R:
1074 keysym = XK_Super_R;
1075 break;
1076 // There has been several variants for Shift-Tab over the years.
1077 // RFB states that we should always send a normal tab.
1078 case XK_ISO_Left_Tab:
1079 keysym = XK_Tab;
1080 break;
1081 }
1082
Pierre Ossman0c158662017-07-13 15:54:11 +02001083 self->handleKeyPress(keycode, keysym);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001084 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001085 } else if (xevent->type == KeyRelease) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001086 int keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1087 if (keycode == 0)
1088 keycode = 0x100 | xevent->xkey.keycode;
1089 self->handleKeyRelease(keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001090 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001091 }
1092#endif
1093
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001094 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +02001095}
1096
Pierre Ossman51249782018-03-08 14:05:39 +01001097#ifdef WIN32
1098void Viewport::handleAltGrTimeout(void *data)
1099{
1100 Viewport *self = (Viewport *)data;
1101
1102 assert(self);
1103
1104 self->altGrArmed = false;
1105 self->handleKeyPress(0x1d, XK_Control_L);
1106}
1107#endif
1108
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001109void Viewport::initContextMenu()
1110{
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001111 contextMenu->clear();
1112
Pierre Ossmanff626f82015-09-23 16:39:54 +02001113 fltk_menu_add(contextMenu, p_("ContextMenu|", "E&xit viewer"),
1114 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001115
Pierre Ossmanff626f82015-09-23 16:39:54 +02001116 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"),
1117 0, NULL, (void*)ID_FULLSCREEN,
Pierre Ossman245c8022015-02-25 11:27:49 +01001118 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001119 fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"),
1120 0, NULL, (void*)ID_MINIMIZE, 0);
1121 fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"),
1122 0, NULL, (void*)ID_RESIZE,
Pierre Ossman245c8022015-02-25 11:27:49 +01001123 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
Pierre Ossman245c8022015-02-25 11:27:49 +01001124 FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001125
Pierre Ossmanff626f82015-09-23 16:39:54 +02001126 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"),
1127 0, NULL, (void*)ID_CTRL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001128 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001129 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"),
1130 0, NULL, (void*)ID_ALT,
Pierre Ossman245c8022015-02-25 11:27:49 +01001131 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001132
1133 if (menuKeySym) {
1134 char sendMenuKey[64];
Pierre Ossmanff626f82015-09-23 16:39:54 +02001135 snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey);
Pierre Ossman245c8022015-02-25 11:27:49 +01001136 fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
Pierre Ossman0c158662017-07-13 15:54:11 +02001137 fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001138 (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001139 }
1140
Pierre Ossmanff626f82015-09-23 16:39:54 +02001141 fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"),
1142 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001143
Pierre Ossmanff626f82015-09-23 16:39:54 +02001144 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"),
1145 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001146
Pierre Ossmanff626f82015-09-23 16:39:54 +02001147 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."),
1148 0, NULL, (void*)ID_OPTIONS, 0);
1149 fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."),
1150 0, NULL, (void*)ID_INFO, 0);
1151 fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."),
1152 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001153
Pierre Ossmanff626f82015-09-23 16:39:54 +02001154 fltk_menu_add(contextMenu, p_("ContextMenu|", "Dismiss &menu"),
1155 0, NULL, (void*)ID_DISMISS, 0);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001156}
1157
1158
1159void Viewport::popupContextMenu()
1160{
1161 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001162 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001163
Pierre Ossmanb3ff4372011-06-03 11:45:15 +00001164 // Make sure the menu is reset to its initial state between goes or
1165 // it will start up highlighting the previously selected entry.
1166 contextMenu->value(-1);
1167
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001168 // initialize context menu before display
1169 initContextMenu();
1170
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001171 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
1172 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001173 if (Fl::belowmouse() == this)
1174 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001175
Pierre Ossman78236292018-03-26 14:15:40 +02001176 // FLTK also doesn't switch focus properly for menus
1177 handle(FL_UNFOCUS);
1178
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001179 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001180
Pierre Ossman78236292018-03-26 14:15:40 +02001181 handle(FL_FOCUS);
1182
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001183 // Back to our proper mouse pointer.
Pierre Ossmande1a3b92014-03-17 14:29:49 +01001184 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001185 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001186
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001187 if (m == NULL)
1188 return;
1189
1190 switch (m->argument()) {
1191 case ID_EXIT:
1192 exit_vncviewer();
1193 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +00001194 case ID_FULLSCREEN:
1195 if (window()->fullscreen_active())
1196 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +00001197 else
Pierre Ossmanaae38912012-07-13 11:22:55 +00001198 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +00001199 break;
Joel Teichroeba7494ac2015-07-13 14:46:22 -07001200 case ID_MINIMIZE:
1201 window()->iconize();
Joel Teichroeb1f9e45a2015-07-18 07:09:24 -07001202 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001203 case ID_RESIZE:
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001204 if (window()->fullscreen_active())
1205 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001206 window()->size(w(), h());
1207 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001208 case ID_CTRL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001209 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001210 handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001211 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001212 handleKeyRelease(0x1d);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001213 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001214 break;
1215 case ID_ALT:
Pierre Ossman25188c42014-07-21 16:30:08 +02001216 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001217 handleKeyPress(0x38, XK_Alt_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001218 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001219 handleKeyRelease(0x38);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001220 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001221 break;
1222 case ID_MENUKEY:
Pierre Ossman0c158662017-07-13 15:54:11 +02001223 handleKeyPress(menuKeyCode, menuKeySym);
1224 handleKeyRelease(menuKeyCode);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001225 break;
1226 case ID_CTRLALTDEL:
Pierre Ossman0c158662017-07-13 15:54:11 +02001227 handleKeyPress(0x1d, XK_Control_L);
1228 handleKeyPress(0x38, XK_Alt_L);
1229 handleKeyPress(0xd3, XK_Delete);
Pierre Ossman991b4fe2011-07-12 16:02:30 +00001230
Pierre Ossman0c158662017-07-13 15:54:11 +02001231 handleKeyRelease(0xd3);
1232 handleKeyRelease(0x38);
1233 handleKeyRelease(0x1d);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001234 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001235 case ID_REFRESH:
1236 cc->refreshFramebuffer();
1237 break;
Pierre Ossmand463b572011-05-16 12:04:43 +00001238 case ID_OPTIONS:
1239 OptionsDialog::showDialog();
1240 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001241 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001242 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
1243 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +00001244 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001245 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001246 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +00001247 case ID_ABOUT:
1248 about_vncviewer();
1249 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001250 case ID_DISMISS:
1251 // Don't need to do anything
1252 break;
1253 }
1254}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001255
1256
1257void Viewport::setMenuKey()
1258{
Pierre Ossman0c158662017-07-13 15:54:11 +02001259 getMenuKey(&menuKeyFLTK, &menuKeyCode, &menuKeySym);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001260}
1261
1262
1263void Viewport::handleOptions(void *data)
1264{
1265 Viewport *self = (Viewport*)data;
1266
1267 self->setMenuKey();
1268}