blob: ba0b0e9346ad8fd1ceaae0e7519bda35f1e398ef [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 Ossmanf741d342011-06-09 08:32:49 +0000231static const char * dotcursor_xpm[] = {
232 "5 5 2 1",
233 ". c #000000",
234 " c #FFFFFF",
235 " ",
236 " ... ",
237 " ... ",
238 " ... ",
239 " "};
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000240
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000241void Viewport::setCursor(int width, int height, const Point& hotspot,
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100242 const rdr::U8* data)
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000243{
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100244 int i;
245
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000246 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000247 if (!cursor->alloc_array)
248 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000249 delete cursor;
250 }
251
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100252 for (i = 0; i < width*height; i++)
253 if (data[i*4 + 3] != 0) break;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000254
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100255 if ((i == width*height) && dotWhenNoCursor) {
Pierre Ossmana51574a2011-06-09 08:39:35 +0000256 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000257
258 Fl_Pixmap pxm(dotcursor_xpm);
259 cursor = new Fl_RGB_Image(&pxm);
260 cursorHotspot.x = cursorHotspot.y = 2;
261 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000262 if ((width == 0) || (height == 0)) {
263 U8 *buffer = new U8[4];
264 memset(buffer, 0, 4);
265 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
266 cursorHotspot.x = cursorHotspot.y = 0;
267 } else {
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100268 U8 *buffer = new U8[width * height * 4];
269 memcpy(buffer, data, width * height * 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000270 cursor = new Fl_RGB_Image(buffer, width, height, 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000271 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000272 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000273 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000274
275 if (Fl::belowmouse() == this)
276 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000277}
278
279
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100280void Viewport::setLEDState(unsigned int state)
281{
282 Fl_Widget *focus;
283
284 vlog.debug("Got server LED state: 0x%08x", state);
285
286 focus = Fl::grab();
287 if (!focus)
288 focus = Fl::focus();
289 if (!focus)
290 return;
291
292 if (focus != this)
293 return;
294
295#if defined(WIN32)
296 INPUT input[6];
297 UINT count;
298 UINT ret;
299
300 memset(input, 0, sizeof(input));
301 count = 0;
302
303 if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
304 input[count].type = input[count+1].type = INPUT_KEYBOARD;
305 input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
306 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
307 input[count].ki.dwFlags = 0;
308 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
309 count += 2;
310 }
311
312 if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
313 input[count].type = input[count+1].type = INPUT_KEYBOARD;
314 input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
315 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
316 input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
317 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
318 count += 2;
319 }
320
321 if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
322 input[count].type = input[count+1].type = INPUT_KEYBOARD;
323 input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
324 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
325 input[count].ki.dwFlags = 0;
326 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
327 count += 2;
328 }
329
330 if (count == 0)
331 return;
332
333 ret = SendInput(count, input, sizeof(*input));
334 if (ret < count)
335 vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
336#elif defined(__APPLE__)
337 int ret;
338
339 ret = cocoa_set_caps_lock_state(state & ledCapsLock);
340 if (ret != 0) {
341 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
342 return;
343 }
344
345 ret = cocoa_set_num_lock_state(state & ledNumLock);
346 if (ret != 0) {
347 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
348 return;
349 }
350
351 // No support for Scroll Lock //
352
353#else
354 unsigned int affect, values;
355 unsigned int mask;
356
357 Bool ret;
358
359 affect = values = 0;
360
361 affect |= LockMask;
362 if (state & ledCapsLock)
363 values |= LockMask;
364
365 mask = getModifierMask(XK_Num_Lock);
366 affect |= mask;
367 if (state & ledNumLock)
368 values |= mask;
369
370 mask = getModifierMask(XK_Scroll_Lock);
371 affect |= mask;
372 if (state & ledScrollLock)
373 values |= mask;
374
375 ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
376 if (!ret)
377 vlog.error(_("Failed to update keyboard LED state"));
378#endif
379}
380
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100381void Viewport::pushLEDState()
382{
383 unsigned int state;
384
385 // Server support?
386 if (cc->cp.ledState() == ledUnknown)
387 return;
388
389 state = 0;
390
391#if defined(WIN32)
392 if (GetKeyState(VK_CAPITAL) & 0x1)
393 state |= ledCapsLock;
394 if (GetKeyState(VK_NUMLOCK) & 0x1)
395 state |= ledNumLock;
396 if (GetKeyState(VK_SCROLL) & 0x1)
397 state |= ledScrollLock;
398#elif defined(__APPLE__)
399 int ret;
400 bool on;
401
402 ret = cocoa_get_caps_lock_state(&on);
403 if (ret != 0) {
404 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
405 return;
406 }
407 if (on)
408 state |= ledCapsLock;
409
410 ret = cocoa_get_num_lock_state(&on);
411 if (ret != 0) {
412 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
413 return;
414 }
415 if (on)
416 state |= ledNumLock;
417
418 // No support for Scroll Lock //
419 state |= (cc->cp.ledState() & ledScrollLock);
420
421#else
422 unsigned int mask;
423
424 Status status;
425 XkbStateRec xkbState;
426
427 status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
428 if (status != Success) {
429 vlog.error(_("Failed to get keyboard LED state: %d"), status);
430 return;
431 }
432
433 if (xkbState.locked_mods & LockMask)
434 state |= ledCapsLock;
435
436 mask = getModifierMask(XK_Num_Lock);
437 if (xkbState.locked_mods & mask)
438 state |= ledNumLock;
439
440 mask = getModifierMask(XK_Scroll_Lock);
441 if (xkbState.locked_mods & mask)
442 state |= ledScrollLock;
443#endif
444
445 if ((state & ledCapsLock) != (cc->cp.ledState() & ledCapsLock)) {
446 vlog.debug("Inserting fake CapsLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200447 handleKeyPress(0x3a, XK_Caps_Lock);
448 handleKeyRelease(0x3a);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100449 }
450 if ((state & ledNumLock) != (cc->cp.ledState() & ledNumLock)) {
451 vlog.debug("Inserting fake NumLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200452 handleKeyPress(0x45, XK_Num_Lock);
453 handleKeyRelease(0x45);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100454 }
455 if ((state & ledScrollLock) != (cc->cp.ledState() & ledScrollLock)) {
456 vlog.debug("Inserting fake ScrollLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200457 handleKeyPress(0x46, XK_Scroll_Lock);
458 handleKeyRelease(0x46);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100459 }
460}
461
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100462
Pierre Ossman3d74d882017-01-02 19:49:52 +0100463void Viewport::draw(Surface* dst)
464{
465 int X, Y, W, H;
466
467 // Check what actually needs updating
468 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
469 if ((W == 0) || (H == 0))
470 return;
471
472 frameBuffer->draw(dst, X - x(), Y - y(), X, Y, W, H);
473}
474
475
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000476void Viewport::draw()
477{
478 int X, Y, W, H;
479
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000480 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000481 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000482 if ((W == 0) || (H == 0))
483 return;
484
Pierre Ossman132b3d02011-06-13 11:19:32 +0000485 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000486}
487
488
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000489void Viewport::resize(int x, int y, int w, int h)
490{
Pierre Ossman9f273e92015-11-09 16:34:54 +0100491 if ((w != frameBuffer->width()) || (h != frameBuffer->height())) {
492 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
493 frameBuffer->width(), frameBuffer->height(), w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000494
Pierre Ossman403ac272017-01-02 17:00:41 +0100495 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100496 assert(frameBuffer);
497 cc->setFramebuffer(frameBuffer);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000498 }
499
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000500 Fl_Widget::resize(x, y, w, h);
501}
502
503
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000504int Viewport::handle(int event)
505{
Pierre Ossman689c4582011-05-26 15:39:41 +0000506 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000507 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000508 int buttonMask, wheelMask;
509 DownMap::const_iterator iter;
510
511 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000512 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000513 buffer = new char[Fl::event_length() + 1];
514
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000515 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000516 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
517 Fl::event_length() + 1);
518 assert(ret < (Fl::event_length() + 1));
519
Pierre Ossmanfb450fb2015-03-03 16:34:56 +0100520 vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000521
522 try {
523 cc->writer()->clientCutText(buffer, ret);
524 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000525 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000526 exit_vncviewer(e.str());
527 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000528
529 delete [] buffer;
530
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000531 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000532
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000533 case FL_ENTER:
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000534 if (cursor)
535 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman56610fb2015-01-27 16:28:15 +0100536 // Yes, we would like some pointer events please!
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000537 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000538
539 case FL_LEAVE:
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000540 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossman164865a2011-11-10 13:30:39 +0000541 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000542 case FL_PUSH:
543 case FL_RELEASE:
544 case FL_DRAG:
545 case FL_MOVE:
546 case FL_MOUSEWHEEL:
547 buttonMask = 0;
548 if (Fl::event_button1())
549 buttonMask |= 1;
550 if (Fl::event_button2())
551 buttonMask |= 2;
552 if (Fl::event_button3())
553 buttonMask |= 4;
554
555 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000556 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000557 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000558 wheelMask |= 8;
559 if (Fl::event_dy() > 0)
560 wheelMask |= 16;
561 if (Fl::event_dx() < 0)
562 wheelMask |= 32;
563 if (Fl::event_dx() > 0)
564 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000565
566 // A quick press of the wheel "button", followed by a immediate
567 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000568 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000569 buttonMask | wheelMask);
570 }
571
Pierre Ossman6a464be2011-04-15 12:57:31 +0000572 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000573 return 1;
574
575 case FL_FOCUS:
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200576 Fl::disable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000577 // Yes, we would like some focus please!
578 return 1;
579
580 case FL_UNFOCUS:
581 // Release all keys that were pressed as that generally makes most
582 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000583 while (!downKeySym.empty())
Pierre Ossman25188c42014-07-21 16:30:08 +0200584 handleKeyRelease(downKeySym.begin()->first);
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200585 Fl::enable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000586 return 1;
587
588 case FL_KEYDOWN:
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000589 case FL_KEYUP:
Pierre Ossman56610fb2015-01-27 16:28:15 +0100590 // Just ignore these as keys were handled in the event handler
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000591 return 1;
592 }
593
594 return Fl_Widget::handle(event);
595}
596
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100597
598#if ! (defined(WIN32) || defined(__APPLE__))
599unsigned int Viewport::getModifierMask(unsigned int keysym)
600{
601 XkbDescPtr xkb;
602 unsigned int mask, keycode;
603 XkbAction *act;
604
605 mask = 0;
606
607 xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
608 if (xkb == NULL)
609 return 0;
610
611 for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
612 unsigned int state_out;
613 KeySym ks;
614
615 XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
616 if (ks == NoSymbol)
617 continue;
618
619 if (ks == keysym)
620 break;
621 }
622
623 // KeySym not mapped?
624 if (keycode > xkb->max_key_code)
625 goto out;
626
627 act = XkbKeyAction(xkb, keycode, 0);
628 if (act == NULL)
629 goto out;
630 if (act->type != XkbSA_LockMods)
631 goto out;
632
633 if (act->mods.flags & XkbSA_UseModMapMods)
634 mask = xkb->map->modmap[keycode];
635 else
636 mask = act->mods.mask;
637
638out:
639 XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
640
641 return mask;
642}
643#endif
644
645
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000646void Viewport::handleClipboardChange(int source, void *data)
647{
648 Viewport *self = (Viewport *)data;
649
650 assert(self);
651
Pierre Ossmana432b582017-01-02 15:16:58 +0100652 if (!sendClipboard)
653 return;
654
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100655#if !defined(WIN32) && !defined(__APPLE__)
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000656 if (!sendPrimary && (source == 0))
657 return;
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100658#endif
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000659
660 Fl::paste(*self, source);
661}
662
663
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000664void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
665{
666 if (!viewOnly) {
667 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000668 try {
669 cc->writer()->pointerEvent(pos, buttonMask);
670 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000671 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000672 exit_vncviewer(e.str());
673 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000674 } else {
675 if (!Fl::has_timeout(handlePointerTimeout, this))
676 Fl::add_timeout((double)pointerEventInterval/1000.0,
677 handlePointerTimeout, this);
678 }
679 lastPointerPos = pos;
680 lastButtonMask = buttonMask;
681 }
682}
683
684
685void Viewport::handlePointerTimeout(void *data)
686{
687 Viewport *self = (Viewport *)data;
688
689 assert(self);
690
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000691 try {
692 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
693 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000694 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000695 exit_vncviewer(e.str());
696 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000697}
698
699
Pierre Ossman25188c42014-07-21 16:30:08 +0200700void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym)
701{
702 static bool menuRecursion = false;
703
704 // Prevent recursion if the menu wants to send its own
705 // activation key.
706 if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) {
707 menuRecursion = true;
708 popupContextMenu();
709 menuRecursion = false;
710 return;
711 }
712
713 if (viewOnly)
714 return;
715
Pierre Ossman0c158662017-07-13 15:54:11 +0200716 if (keyCode == 0) {
717 vlog.error(_("No key code specified on key press"));
718 return;
719 }
720
Pierre Ossman25188c42014-07-21 16:30:08 +0200721#ifdef __APPLE__
722 // Alt on OS X behaves more like AltGr on other systems, and to get
723 // sane behaviour we should translate things in that manner for the
724 // remote VNC server. However that means we lose the ability to use
725 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
726 // left command key as an Alt replacement.
727 switch (keySym) {
728 case XK_Super_L:
729 keySym = XK_Alt_L;
730 break;
731 case XK_Super_R:
732 keySym = XK_Super_L;
733 break;
734 case XK_Alt_L:
Pierre Ossman38fcebb2014-08-21 13:44:28 +0200735 keySym = XK_Mode_switch;
736 break;
Pierre Ossman25188c42014-07-21 16:30:08 +0200737 case XK_Alt_R:
738 keySym = XK_ISO_Level3_Shift;
739 break;
740 }
741#endif
742
Pierre Ossman25188c42014-07-21 16:30:08 +0200743 // Because of the way keyboards work, we cannot expect to have the same
744 // symbol on release as when pressed. This breaks the VNC protocol however,
745 // so we need to keep track of what keysym a key _code_ generated on press
746 // and send the same on release.
747 downKeySym[keyCode] = keySym;
748
749#if defined(WIN32) || defined(__APPLE__)
750 vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
751#else
752 vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)",
753 keyCode, XKeysymToString(keySym), keySym);
754#endif
755
756 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200757 // Fake keycode?
758 if (keyCode > 0xff)
759 cc->writer()->keyEvent(keySym, 0, true);
760 else
761 cc->writer()->keyEvent(keySym, keyCode, true);
Pierre Ossman25188c42014-07-21 16:30:08 +0200762 } catch (rdr::Exception& e) {
763 vlog.error("%s", e.str());
764 exit_vncviewer(e.str());
765 }
Pierre Ossman25188c42014-07-21 16:30:08 +0200766}
767
768
769void Viewport::handleKeyRelease(int keyCode)
770{
771 DownMap::iterator iter;
772
773 if (viewOnly)
774 return;
775
776 iter = downKeySym.find(keyCode);
777 if (iter == downKeySym.end()) {
778 // These occur somewhat frequently so let's not spam them unless
779 // logging is turned up.
780 vlog.debug("Unexpected release of key code %d", keyCode);
781 return;
782 }
783
784#if defined(WIN32) || defined(__APPLE__)
785 vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second);
786#else
787 vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)",
788 keyCode, XKeysymToString(iter->second), iter->second);
789#endif
790
791 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200792 if (keyCode > 0xff)
793 cc->writer()->keyEvent(iter->second, 0, false);
794 else
795 cc->writer()->keyEvent(iter->second, keyCode, false);
Pierre Ossman25188c42014-07-21 16:30:08 +0200796 } catch (rdr::Exception& e) {
797 vlog.error("%s", e.str());
798 exit_vncviewer(e.str());
799 }
800
801 downKeySym.erase(iter);
802}
803
804
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200805int Viewport::handleSystemEvent(void *event, void *data)
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200806{
807 Viewport *self = (Viewport *)data;
808 Fl_Widget *focus;
809
810 assert(self);
811
812 focus = Fl::grab();
813 if (!focus)
814 focus = Fl::focus();
815 if (!focus)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200816 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200817
818 if (focus != self)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200819 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200820
821 assert(event);
822
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200823#if defined(WIN32)
824 MSG *msg = (MSG*)event;
825
826 if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
827 UINT vKey;
828 bool isExtended;
829 int keyCode;
830 rdr::U32 keySym;
831
832 vKey = msg->wParam;
833 isExtended = (msg->lParam & (1 << 24)) != 0;
834
835 keyCode = ((msg->lParam >> 16) & 0xff);
836
Pierre Ossman51249782018-03-08 14:05:39 +0100837 // Windows doesn't have a proper AltGr, but handles it using fake
838 // Ctrl+Alt. However the remote end might not be Windows, so we need
839 // to merge those in to a single AltGr event. We detect this case
840 // by seeing the two key events directly after each other with a very
841 // short time between them (<50ms).
842 if (self->altGrArmed) {
843 self->altGrArmed = false;
844 Fl::remove_timeout(handleAltGrTimeout);
845
846 if (isExtended && (keyCode == 0x38) && (vKey == VK_MENU) &&
847 ((msg->time - self->altGrCtrlTime) < 50)) {
848 // FIXME: We fail to detect this if either Ctrl key is
849 // first manually pressed as Windows then no longer
850 // sends the fake Ctrl down event. It does however
851 // happily send real Ctrl events even when AltGr
852 // is already down.
853 vlog.debug("Detected AltGr combination");
854 self->handleKeyPress(0xb8, XK_ISO_Level3_Shift);
855 return 1;
856 }
857
858 self->handleKeyPress(0x1d, XK_Control_L);
859 }
860
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100861 if (keyCode == SCAN_FAKE) {
862 vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
863 return 1;
864 }
865
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200866 // Windows sets the scan code to 0x00 for multimedia keys, so we
867 // have to do a reverse lookup based on the vKey.
868 if (keyCode == 0x00) {
869 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
870 if (keyCode == 0x00) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200871 if (isExtended)
872 vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
873 else
874 vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200875 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200876 }
877 }
878
Pierre Ossman0c158662017-07-13 15:54:11 +0200879 if (keyCode & ~0x7f) {
880 vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode);
881 return 1;
882 }
883
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200884 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200885 keyCode |= 0x80;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200886
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100887
888 // Fortunately RFB and Windows use the same scan code set (mostly),
889 // so there is no conversion needed
890 // (as long as we encode the extended keys with the high bit)
891
892 // However Pause sends a code that conflicts with NumLock, so use
893 // the code most RFB implementations use (part of the sequence for
894 // Ctrl+Pause, i.e. Break)
895 if (keyCode == 0x45)
896 keyCode = 0xc6;
897
898 // And NumLock incorrectly has the extended bit set
899 if (keyCode == 0xc5)
900 keyCode = 0x45;
901
902 // And Alt+PrintScreen (i.e. SysRq) sends a different code than
903 // PrintScreen
904 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200905 keyCode = 0x54;
Pierre Ossmana7d3dc72014-09-30 17:03:28 +0200906
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200907 keySym = win32_vkey_to_keysym(vKey, isExtended);
908 if (keySym == NoSymbol) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200909 if (isExtended)
910 vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
911 else
912 vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200913 }
914
Pierre Ossman30b3f922017-11-13 09:07:59 +0100915 // Windows sends the same vKey for both shifts, so we need to look
916 // at the scan code to tell them apart
917 if ((keySym == XK_Shift_L) && (keyCode == 0x36))
918 keySym = XK_Shift_R;
Pierre Ossman0c158662017-07-13 15:54:11 +0200919
Pierre Ossman51249782018-03-08 14:05:39 +0100920 // Possible start of AltGr sequence? (see above)
921 if ((keyCode == 0x1d) && (keySym == XK_Control_L)) {
922 self->altGrArmed = true;
923 self->altGrCtrlTime = msg->time;
924 Fl::add_timeout(0.1, handleAltGrTimeout, self);
925 return 1;
926 }
927
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200928 self->handleKeyPress(keyCode, keySym);
929
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200930 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200931 } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
932 UINT vKey;
933 bool isExtended;
934 int keyCode;
935
936 vKey = msg->wParam;
937 isExtended = (msg->lParam & (1 << 24)) != 0;
938
939 keyCode = ((msg->lParam >> 16) & 0xff);
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100940
Pierre Ossman51249782018-03-08 14:05:39 +0100941 // We can't get a release in the middle of an AltGr sequence, so
942 // abort that detection
943 if (self->altGrArmed) {
944 self->altGrArmed = false;
945 Fl::remove_timeout(handleAltGrTimeout);
946 self->handleKeyPress(0x1d, XK_Control_L);
947 }
948
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100949 if (keyCode == SCAN_FAKE) {
950 vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
951 return 1;
952 }
953
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200954 if (keyCode == 0x00)
955 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
956 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200957 keyCode |= 0x80;
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100958 if (keyCode == 0x45)
959 keyCode = 0xc6;
960 if (keyCode == 0xc5)
961 keyCode = 0x45;
962 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200963 keyCode = 0x54;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200964
965 self->handleKeyRelease(keyCode);
966
Pierre Ossman30b3f922017-11-13 09:07:59 +0100967 // Windows has a rather nasty bug where it won't send key release
968 // events for a Shift button if the other Shift is still pressed
969 if ((keyCode == 0x2a) || (keyCode == 0x36)) {
970 if (self->downKeySym.count(0x2a))
971 self->handleKeyRelease(0x2a);
972 if (self->downKeySym.count(0x36))
973 self->handleKeyRelease(0x36);
974 }
975
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200976 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200977 }
Pierre Ossman6b743d02014-07-21 16:48:43 +0200978#elif defined(__APPLE__)
979 if (cocoa_is_keyboard_event(event)) {
980 int keyCode;
981
982 keyCode = cocoa_event_keycode(event);
Pierre Ossman0c158662017-07-13 15:54:11 +0200983 if ((unsigned)keyCode >= code_map_osx_to_qnum_len)
984 keyCode = 0;
985 else
986 keyCode = code_map_osx_to_qnum[keyCode];
Pierre Ossman6b743d02014-07-21 16:48:43 +0200987
988 if (cocoa_is_key_press(event)) {
989 rdr::U32 keySym;
990
991 keySym = cocoa_event_keysym(event);
992 if (keySym == NoSymbol) {
993 vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
994 (int)keyCode);
Pierre Ossman6b743d02014-07-21 16:48:43 +0200995 }
996
997 self->handleKeyPress(keyCode, keySym);
998
999 // We don't get any release events for CapsLock, so we have to
1000 // send the release right away.
1001 if (keySym == XK_Caps_Lock)
1002 self->handleKeyRelease(keyCode);
1003 } else {
1004 self->handleKeyRelease(keyCode);
1005 }
1006
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001007 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +02001008 }
1009#else
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001010 XEvent *xevent = (XEvent*)event;
1011
1012 if (xevent->type == KeyPress) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001013 int keycode;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001014 char str;
1015 KeySym keysym;
1016
Pierre Ossman0c158662017-07-13 15:54:11 +02001017 keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1018
1019 // Generate a fake keycode just for tracking if we can't figure
1020 // out the proper one
1021 if (keycode == 0)
1022 keycode = 0x100 | xevent->xkey.keycode;
1023
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001024 XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
1025 if (keysym == NoSymbol) {
1026 vlog.error(_("No symbol for key code %d (in the current state)"),
1027 (int)xevent->xkey.keycode);
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001028 }
1029
1030 switch (keysym) {
1031 // For the first few years, there wasn't a good consensus on what the
1032 // Windows keys should be mapped to for X11. So we need to help out a
1033 // bit and map all variants to the same key...
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001034 case XK_Hyper_L:
1035 keysym = XK_Super_L;
1036 break;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001037 case XK_Hyper_R:
1038 keysym = XK_Super_R;
1039 break;
1040 // There has been several variants for Shift-Tab over the years.
1041 // RFB states that we should always send a normal tab.
1042 case XK_ISO_Left_Tab:
1043 keysym = XK_Tab;
1044 break;
1045 }
1046
Pierre Ossman0c158662017-07-13 15:54:11 +02001047 self->handleKeyPress(keycode, keysym);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001048 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001049 } else if (xevent->type == KeyRelease) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001050 int keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1051 if (keycode == 0)
1052 keycode = 0x100 | xevent->xkey.keycode;
1053 self->handleKeyRelease(keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001054 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001055 }
1056#endif
1057
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001058 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +02001059}
1060
Pierre Ossman51249782018-03-08 14:05:39 +01001061#ifdef WIN32
1062void Viewport::handleAltGrTimeout(void *data)
1063{
1064 Viewport *self = (Viewport *)data;
1065
1066 assert(self);
1067
1068 self->altGrArmed = false;
1069 self->handleKeyPress(0x1d, XK_Control_L);
1070}
1071#endif
1072
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001073void Viewport::initContextMenu()
1074{
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001075 contextMenu->clear();
1076
Pierre Ossmanff626f82015-09-23 16:39:54 +02001077 fltk_menu_add(contextMenu, p_("ContextMenu|", "E&xit viewer"),
1078 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001079
Pierre Ossmanff626f82015-09-23 16:39:54 +02001080 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"),
1081 0, NULL, (void*)ID_FULLSCREEN,
Pierre Ossman245c8022015-02-25 11:27:49 +01001082 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001083 fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"),
1084 0, NULL, (void*)ID_MINIMIZE, 0);
1085 fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"),
1086 0, NULL, (void*)ID_RESIZE,
Pierre Ossman245c8022015-02-25 11:27:49 +01001087 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
Pierre Ossman245c8022015-02-25 11:27:49 +01001088 FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001089
Pierre Ossmanff626f82015-09-23 16:39:54 +02001090 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"),
1091 0, NULL, (void*)ID_CTRL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001092 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001093 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"),
1094 0, NULL, (void*)ID_ALT,
Pierre Ossman245c8022015-02-25 11:27:49 +01001095 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001096
1097 if (menuKeySym) {
1098 char sendMenuKey[64];
Pierre Ossmanff626f82015-09-23 16:39:54 +02001099 snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey);
Pierre Ossman245c8022015-02-25 11:27:49 +01001100 fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
Pierre Ossman0c158662017-07-13 15:54:11 +02001101 fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001102 (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001103 }
1104
Pierre Ossmanff626f82015-09-23 16:39:54 +02001105 fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"),
1106 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001107
Pierre Ossmanff626f82015-09-23 16:39:54 +02001108 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"),
1109 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001110
Pierre Ossmanff626f82015-09-23 16:39:54 +02001111 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."),
1112 0, NULL, (void*)ID_OPTIONS, 0);
1113 fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."),
1114 0, NULL, (void*)ID_INFO, 0);
1115 fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."),
1116 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001117
Pierre Ossmanff626f82015-09-23 16:39:54 +02001118 fltk_menu_add(contextMenu, p_("ContextMenu|", "Dismiss &menu"),
1119 0, NULL, (void*)ID_DISMISS, 0);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001120}
1121
1122
1123void Viewport::popupContextMenu()
1124{
1125 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001126 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001127
Pierre Ossmanb3ff4372011-06-03 11:45:15 +00001128 // Make sure the menu is reset to its initial state between goes or
1129 // it will start up highlighting the previously selected entry.
1130 contextMenu->value(-1);
1131
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001132 // initialize context menu before display
1133 initContextMenu();
1134
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001135 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
1136 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001137 if (Fl::belowmouse() == this)
1138 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001139
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001140 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001141
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001142 // Back to our proper mouse pointer.
Pierre Ossmande1a3b92014-03-17 14:29:49 +01001143 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001144 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001145
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001146 if (m == NULL)
1147 return;
1148
1149 switch (m->argument()) {
1150 case ID_EXIT:
1151 exit_vncviewer();
1152 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +00001153 case ID_FULLSCREEN:
1154 if (window()->fullscreen_active())
1155 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +00001156 else
Pierre Ossmanaae38912012-07-13 11:22:55 +00001157 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +00001158 break;
Joel Teichroeba7494ac2015-07-13 14:46:22 -07001159 case ID_MINIMIZE:
1160 window()->iconize();
Joel Teichroeb1f9e45a2015-07-18 07:09:24 -07001161 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001162 case ID_RESIZE:
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001163 if (window()->fullscreen_active())
1164 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001165 window()->size(w(), h());
1166 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001167 case ID_CTRL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001168 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001169 handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001170 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001171 handleKeyRelease(0x1d);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001172 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001173 break;
1174 case ID_ALT:
Pierre Ossman25188c42014-07-21 16:30:08 +02001175 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001176 handleKeyPress(0x38, XK_Alt_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001177 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001178 handleKeyRelease(0x38);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001179 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001180 break;
1181 case ID_MENUKEY:
Pierre Ossman0c158662017-07-13 15:54:11 +02001182 handleKeyPress(menuKeyCode, menuKeySym);
1183 handleKeyRelease(menuKeyCode);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001184 break;
1185 case ID_CTRLALTDEL:
Pierre Ossman0c158662017-07-13 15:54:11 +02001186 handleKeyPress(0x1d, XK_Control_L);
1187 handleKeyPress(0x38, XK_Alt_L);
1188 handleKeyPress(0xd3, XK_Delete);
Pierre Ossman991b4fe2011-07-12 16:02:30 +00001189
Pierre Ossman0c158662017-07-13 15:54:11 +02001190 handleKeyRelease(0xd3);
1191 handleKeyRelease(0x38);
1192 handleKeyRelease(0x1d);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001193 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001194 case ID_REFRESH:
1195 cc->refreshFramebuffer();
1196 break;
Pierre Ossmand463b572011-05-16 12:04:43 +00001197 case ID_OPTIONS:
1198 OptionsDialog::showDialog();
1199 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001200 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001201 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
1202 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +00001203 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001204 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001205 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +00001206 case ID_ABOUT:
1207 about_vncviewer();
1208 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001209 case ID_DISMISS:
1210 // Don't need to do anything
1211 break;
1212 }
1213}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001214
1215
1216void Viewport::setMenuKey()
1217{
Pierre Ossman0c158662017-07-13 15:54:11 +02001218 getMenuKey(&menuKeyFLTK, &menuKeyCode, &menuKeySym);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001219}
1220
1221
1222void Viewport::handleOptions(void *data)
1223{
1224 Viewport *self = (Viewport*)data;
1225
1226 self->setMenuKey();
1227}