blob: 7af19aa7df0955a0b77c276ac186146f4a3f62ca [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 Ossmanb1cd6ca2015-03-03 16:37:43 +0100118 menuCtrlKey(false), menuAltKey(false), cursor(NULL)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000119{
Pierre Ossman0c158662017-07-13 15:54:11 +0200120#if !defined(WIN32) && !defined(__APPLE__)
121 XkbDescPtr xkb;
122 Status status;
123
124 xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd);
125 if (!xkb)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200126 throw rfb::Exception("XkbGetMap");
Pierre Ossman0c158662017-07-13 15:54:11 +0200127
128 status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb);
129 if (status != Success)
Pierre Ossman87b9d5f2017-09-18 16:07:12 +0200130 throw rfb::Exception("XkbGetNames");
Pierre Ossman0c158662017-07-13 15:54:11 +0200131
132 memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum));
133 for (KeyCode keycode = xkb->min_key_code;
134 keycode < xkb->max_key_code;
135 keycode++) {
136 const char *keyname = xkb->names->keys[keycode].name;
137 unsigned short rfbcode;
138
139 if (keyname[0] == '\0')
140 continue;
141
142 rfbcode = 0;
143 for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) {
144 if (strncmp(code_map_xkb_to_qnum[i].from,
145 keyname, XkbKeyNameLength) == 0) {
146 rfbcode = code_map_xkb_to_qnum[i].to;
147 break;
148 }
149 }
150 if (rfbcode != 0)
151 code_map_keycode_to_qnum[keycode] = rfbcode;
152 else
153 vlog.debug("No key mapping for key %.4s", keyname);
154 }
155
156 XkbFreeKeyboard(xkb, 0, True);
157#endif
158
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000159 Fl::add_clipboard_notify(handleClipboardChange, this);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000160
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200161 // We need to intercept keyboard events early
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200162 Fl::add_system_handler(handleSystemEvent, this);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200163
Pierre Ossman403ac272017-01-02 17:00:41 +0100164 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000165 assert(frameBuffer);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100166 cc->setFramebuffer(frameBuffer);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000167
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000168 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +0000169 // Setting box type to FL_NO_BOX prevents it from trying to draw the
170 // button component (which we don't want)
171 contextMenu->box(FL_NO_BOX);
172
Pierre Ossmanb043ad12011-06-01 09:26:57 +0000173 // The (invisible) button associated with this widget can mess with
174 // things like Fl_Scroll so we need to get rid of any parents.
175 // Unfortunately that's not possible because of STR #2654, but
176 // reparenting to the current window works for most cases.
177 window()->add(contextMenu);
178
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000179 setMenuKey();
180
181 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000182}
183
184
185Viewport::~Viewport()
186{
187 // Unregister all timeouts in case they get a change tro trigger
188 // again later when this object is already gone.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000189 Fl::remove_timeout(handlePointerTimeout, this);
190
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200191 Fl::remove_system_handler(handleSystemEvent);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200192
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000193 Fl::remove_clipboard_notify(handleClipboardChange);
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000194
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000195 OptionsDialog::removeCallback(handleOptions);
196
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000197 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000198 if (!cursor->alloc_array)
199 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000200 delete cursor;
201 }
202
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000203 // FLTK automatically deletes all child widgets, so we shouldn't touch
204 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000205}
206
207
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000208const rfb::PixelFormat &Viewport::getPreferredPF()
209{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000210 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000211}
212
213
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000214// Copy the areas of the framebuffer that have been changed (damaged)
215// to the displayed window.
216
217void Viewport::updateWindow()
218{
219 Rect r;
220
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200221 r = frameBuffer->getDamage();
222 damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000223}
224
Pierre Ossmanf741d342011-06-09 08:32:49 +0000225static const char * dotcursor_xpm[] = {
226 "5 5 2 1",
227 ". c #000000",
228 " c #FFFFFF",
229 " ",
230 " ... ",
231 " ... ",
232 " ... ",
233 " "};
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000234
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000235void Viewport::setCursor(int width, int height, const Point& hotspot,
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100236 const rdr::U8* data)
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000237{
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100238 int i;
239
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000240 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000241 if (!cursor->alloc_array)
242 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000243 delete cursor;
244 }
245
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100246 for (i = 0; i < width*height; i++)
247 if (data[i*4 + 3] != 0) break;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000248
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100249 if ((i == width*height) && dotWhenNoCursor) {
Pierre Ossmana51574a2011-06-09 08:39:35 +0000250 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000251
252 Fl_Pixmap pxm(dotcursor_xpm);
253 cursor = new Fl_RGB_Image(&pxm);
254 cursorHotspot.x = cursorHotspot.y = 2;
255 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000256 if ((width == 0) || (height == 0)) {
257 U8 *buffer = new U8[4];
258 memset(buffer, 0, 4);
259 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
260 cursorHotspot.x = cursorHotspot.y = 0;
261 } else {
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100262 U8 *buffer = new U8[width * height * 4];
263 memcpy(buffer, data, width * height * 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000264 cursor = new Fl_RGB_Image(buffer, width, height, 4);
Pierre Ossman17a48f02011-06-09 08:42:04 +0000265 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000266 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000267 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000268
269 if (Fl::belowmouse() == this)
270 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000271}
272
273
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100274void Viewport::setLEDState(unsigned int state)
275{
276 Fl_Widget *focus;
277
278 vlog.debug("Got server LED state: 0x%08x", state);
279
280 focus = Fl::grab();
281 if (!focus)
282 focus = Fl::focus();
283 if (!focus)
284 return;
285
286 if (focus != this)
287 return;
288
289#if defined(WIN32)
290 INPUT input[6];
291 UINT count;
292 UINT ret;
293
294 memset(input, 0, sizeof(input));
295 count = 0;
296
297 if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
298 input[count].type = input[count+1].type = INPUT_KEYBOARD;
299 input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
300 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
301 input[count].ki.dwFlags = 0;
302 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
303 count += 2;
304 }
305
306 if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
307 input[count].type = input[count+1].type = INPUT_KEYBOARD;
308 input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
309 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
310 input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
311 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
312 count += 2;
313 }
314
315 if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
316 input[count].type = input[count+1].type = INPUT_KEYBOARD;
317 input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
318 input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
319 input[count].ki.dwFlags = 0;
320 input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
321 count += 2;
322 }
323
324 if (count == 0)
325 return;
326
327 ret = SendInput(count, input, sizeof(*input));
328 if (ret < count)
329 vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
330#elif defined(__APPLE__)
331 int ret;
332
333 ret = cocoa_set_caps_lock_state(state & ledCapsLock);
334 if (ret != 0) {
335 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
336 return;
337 }
338
339 ret = cocoa_set_num_lock_state(state & ledNumLock);
340 if (ret != 0) {
341 vlog.error(_("Failed to update keyboard LED state: %d"), ret);
342 return;
343 }
344
345 // No support for Scroll Lock //
346
347#else
348 unsigned int affect, values;
349 unsigned int mask;
350
351 Bool ret;
352
353 affect = values = 0;
354
355 affect |= LockMask;
356 if (state & ledCapsLock)
357 values |= LockMask;
358
359 mask = getModifierMask(XK_Num_Lock);
360 affect |= mask;
361 if (state & ledNumLock)
362 values |= mask;
363
364 mask = getModifierMask(XK_Scroll_Lock);
365 affect |= mask;
366 if (state & ledScrollLock)
367 values |= mask;
368
369 ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
370 if (!ret)
371 vlog.error(_("Failed to update keyboard LED state"));
372#endif
373}
374
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100375void Viewport::pushLEDState()
376{
377 unsigned int state;
378
379 // Server support?
380 if (cc->cp.ledState() == ledUnknown)
381 return;
382
383 state = 0;
384
385#if defined(WIN32)
386 if (GetKeyState(VK_CAPITAL) & 0x1)
387 state |= ledCapsLock;
388 if (GetKeyState(VK_NUMLOCK) & 0x1)
389 state |= ledNumLock;
390 if (GetKeyState(VK_SCROLL) & 0x1)
391 state |= ledScrollLock;
392#elif defined(__APPLE__)
393 int ret;
394 bool on;
395
396 ret = cocoa_get_caps_lock_state(&on);
397 if (ret != 0) {
398 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
399 return;
400 }
401 if (on)
402 state |= ledCapsLock;
403
404 ret = cocoa_get_num_lock_state(&on);
405 if (ret != 0) {
406 vlog.error(_("Failed to get keyboard LED state: %d"), ret);
407 return;
408 }
409 if (on)
410 state |= ledNumLock;
411
412 // No support for Scroll Lock //
413 state |= (cc->cp.ledState() & ledScrollLock);
414
415#else
416 unsigned int mask;
417
418 Status status;
419 XkbStateRec xkbState;
420
421 status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
422 if (status != Success) {
423 vlog.error(_("Failed to get keyboard LED state: %d"), status);
424 return;
425 }
426
427 if (xkbState.locked_mods & LockMask)
428 state |= ledCapsLock;
429
430 mask = getModifierMask(XK_Num_Lock);
431 if (xkbState.locked_mods & mask)
432 state |= ledNumLock;
433
434 mask = getModifierMask(XK_Scroll_Lock);
435 if (xkbState.locked_mods & mask)
436 state |= ledScrollLock;
437#endif
438
439 if ((state & ledCapsLock) != (cc->cp.ledState() & ledCapsLock)) {
440 vlog.debug("Inserting fake CapsLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200441 handleKeyPress(0x3a, XK_Caps_Lock);
442 handleKeyRelease(0x3a);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100443 }
444 if ((state & ledNumLock) != (cc->cp.ledState() & ledNumLock)) {
445 vlog.debug("Inserting fake NumLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200446 handleKeyPress(0x45, XK_Num_Lock);
447 handleKeyRelease(0x45);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100448 }
449 if ((state & ledScrollLock) != (cc->cp.ledState() & ledScrollLock)) {
450 vlog.debug("Inserting fake ScrollLock to get in sync with server");
Pierre Ossman0c158662017-07-13 15:54:11 +0200451 handleKeyPress(0x46, XK_Scroll_Lock);
452 handleKeyRelease(0x46);
Pierre Ossman1668cfa2016-12-10 17:13:40 +0100453 }
454}
455
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100456
Pierre Ossman3d74d882017-01-02 19:49:52 +0100457void Viewport::draw(Surface* dst)
458{
459 int X, Y, W, H;
460
461 // Check what actually needs updating
462 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
463 if ((W == 0) || (H == 0))
464 return;
465
466 frameBuffer->draw(dst, X - x(), Y - y(), X, Y, W, H);
467}
468
469
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000470void Viewport::draw()
471{
472 int X, Y, W, H;
473
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000474 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000475 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000476 if ((W == 0) || (H == 0))
477 return;
478
Pierre Ossman132b3d02011-06-13 11:19:32 +0000479 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000480}
481
482
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000483void Viewport::resize(int x, int y, int w, int h)
484{
Pierre Ossman9f273e92015-11-09 16:34:54 +0100485 if ((w != frameBuffer->width()) || (h != frameBuffer->height())) {
486 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
487 frameBuffer->width(), frameBuffer->height(), w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000488
Pierre Ossman403ac272017-01-02 17:00:41 +0100489 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossman9f273e92015-11-09 16:34:54 +0100490 assert(frameBuffer);
491 cc->setFramebuffer(frameBuffer);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000492 }
493
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000494 Fl_Widget::resize(x, y, w, h);
495}
496
497
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000498int Viewport::handle(int event)
499{
Pierre Ossman689c4582011-05-26 15:39:41 +0000500 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000501 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000502 int buttonMask, wheelMask;
503 DownMap::const_iterator iter;
504
505 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000506 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000507 buffer = new char[Fl::event_length() + 1];
508
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000509 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000510 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
511 Fl::event_length() + 1);
512 assert(ret < (Fl::event_length() + 1));
513
Pierre Ossmanfb450fb2015-03-03 16:34:56 +0100514 vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000515
516 try {
517 cc->writer()->clientCutText(buffer, ret);
518 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000519 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000520 exit_vncviewer(e.str());
521 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000522
523 delete [] buffer;
524
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000525 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000526
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000527 case FL_ENTER:
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000528 if (cursor)
529 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman56610fb2015-01-27 16:28:15 +0100530 // Yes, we would like some pointer events please!
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000531 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000532
533 case FL_LEAVE:
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000534 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossman164865a2011-11-10 13:30:39 +0000535 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000536 case FL_PUSH:
537 case FL_RELEASE:
538 case FL_DRAG:
539 case FL_MOVE:
540 case FL_MOUSEWHEEL:
541 buttonMask = 0;
542 if (Fl::event_button1())
543 buttonMask |= 1;
544 if (Fl::event_button2())
545 buttonMask |= 2;
546 if (Fl::event_button3())
547 buttonMask |= 4;
548
549 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000550 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000551 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000552 wheelMask |= 8;
553 if (Fl::event_dy() > 0)
554 wheelMask |= 16;
555 if (Fl::event_dx() < 0)
556 wheelMask |= 32;
557 if (Fl::event_dx() > 0)
558 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000559
560 // A quick press of the wheel "button", followed by a immediate
561 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000562 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000563 buttonMask | wheelMask);
564 }
565
Pierre Ossman6a464be2011-04-15 12:57:31 +0000566 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000567 return 1;
568
569 case FL_FOCUS:
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200570 Fl::disable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000571 // Yes, we would like some focus please!
572 return 1;
573
574 case FL_UNFOCUS:
575 // Release all keys that were pressed as that generally makes most
576 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000577 while (!downKeySym.empty())
Pierre Ossman25188c42014-07-21 16:30:08 +0200578 handleKeyRelease(downKeySym.begin()->first);
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200579 Fl::enable_im();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000580 return 1;
581
582 case FL_KEYDOWN:
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000583 case FL_KEYUP:
Pierre Ossman56610fb2015-01-27 16:28:15 +0100584 // Just ignore these as keys were handled in the event handler
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000585 return 1;
586 }
587
588 return Fl_Widget::handle(event);
589}
590
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100591
592#if ! (defined(WIN32) || defined(__APPLE__))
593unsigned int Viewport::getModifierMask(unsigned int keysym)
594{
595 XkbDescPtr xkb;
596 unsigned int mask, keycode;
597 XkbAction *act;
598
599 mask = 0;
600
601 xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
602 if (xkb == NULL)
603 return 0;
604
605 for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
606 unsigned int state_out;
607 KeySym ks;
608
609 XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
610 if (ks == NoSymbol)
611 continue;
612
613 if (ks == keysym)
614 break;
615 }
616
617 // KeySym not mapped?
618 if (keycode > xkb->max_key_code)
619 goto out;
620
621 act = XkbKeyAction(xkb, keycode, 0);
622 if (act == NULL)
623 goto out;
624 if (act->type != XkbSA_LockMods)
625 goto out;
626
627 if (act->mods.flags & XkbSA_UseModMapMods)
628 mask = xkb->map->modmap[keycode];
629 else
630 mask = act->mods.mask;
631
632out:
633 XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
634
635 return mask;
636}
637#endif
638
639
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000640void Viewport::handleClipboardChange(int source, void *data)
641{
642 Viewport *self = (Viewport *)data;
643
644 assert(self);
645
Pierre Ossmana432b582017-01-02 15:16:58 +0100646 if (!sendClipboard)
647 return;
648
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100649#if !defined(WIN32) && !defined(__APPLE__)
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000650 if (!sendPrimary && (source == 0))
651 return;
Pierre Ossmanf7fef922015-12-10 21:24:08 +0100652#endif
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000653
654 Fl::paste(*self, source);
655}
656
657
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000658void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
659{
660 if (!viewOnly) {
661 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000662 try {
663 cc->writer()->pointerEvent(pos, buttonMask);
664 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000665 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000666 exit_vncviewer(e.str());
667 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000668 } else {
669 if (!Fl::has_timeout(handlePointerTimeout, this))
670 Fl::add_timeout((double)pointerEventInterval/1000.0,
671 handlePointerTimeout, this);
672 }
673 lastPointerPos = pos;
674 lastButtonMask = buttonMask;
675 }
676}
677
678
679void Viewport::handlePointerTimeout(void *data)
680{
681 Viewport *self = (Viewport *)data;
682
683 assert(self);
684
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000685 try {
686 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
687 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000688 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000689 exit_vncviewer(e.str());
690 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000691}
692
693
Pierre Ossman25188c42014-07-21 16:30:08 +0200694void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym)
695{
696 static bool menuRecursion = false;
697
698 // Prevent recursion if the menu wants to send its own
699 // activation key.
700 if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) {
701 menuRecursion = true;
702 popupContextMenu();
703 menuRecursion = false;
704 return;
705 }
706
707 if (viewOnly)
708 return;
709
Pierre Ossman0c158662017-07-13 15:54:11 +0200710 if (keyCode == 0) {
711 vlog.error(_("No key code specified on key press"));
712 return;
713 }
714
Pierre Ossman25188c42014-07-21 16:30:08 +0200715#ifdef __APPLE__
716 // Alt on OS X behaves more like AltGr on other systems, and to get
717 // sane behaviour we should translate things in that manner for the
718 // remote VNC server. However that means we lose the ability to use
719 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
720 // left command key as an Alt replacement.
721 switch (keySym) {
722 case XK_Super_L:
723 keySym = XK_Alt_L;
724 break;
725 case XK_Super_R:
726 keySym = XK_Super_L;
727 break;
728 case XK_Alt_L:
Pierre Ossman38fcebb2014-08-21 13:44:28 +0200729 keySym = XK_Mode_switch;
730 break;
Pierre Ossman25188c42014-07-21 16:30:08 +0200731 case XK_Alt_R:
732 keySym = XK_ISO_Level3_Shift;
733 break;
734 }
735#endif
736
737#ifdef WIN32
738 // Ugly hack alert!
739 //
740 // Windows doesn't have a proper AltGr, but handles it using fake
741 // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
742 // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
743 // get everything in the correct state. Cheat and temporarily release
744 // Ctrl and Alt when we send some other symbol.
Pierre Ossman0c158662017-07-13 15:54:11 +0200745 if (downKeySym.count(0x1d) && downKeySym.count(0xb8)) {
Pierre Ossman25188c42014-07-21 16:30:08 +0200746 vlog.debug("Faking release of AltGr (Ctrl_L+Alt_R)");
747 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200748 cc->writer()->keyEvent(downKeySym[0x1d], 0x1d, false);
749 cc->writer()->keyEvent(downKeySym[0xb8], 0xb8, false);
Pierre Ossman25188c42014-07-21 16:30:08 +0200750 } catch (rdr::Exception& e) {
751 vlog.error("%s", e.str());
752 exit_vncviewer(e.str());
753 }
754 }
755#endif
756
757 // Because of the way keyboards work, we cannot expect to have the same
758 // symbol on release as when pressed. This breaks the VNC protocol however,
759 // so we need to keep track of what keysym a key _code_ generated on press
760 // and send the same on release.
761 downKeySym[keyCode] = keySym;
762
763#if defined(WIN32) || defined(__APPLE__)
764 vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
765#else
766 vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)",
767 keyCode, XKeysymToString(keySym), keySym);
768#endif
769
770 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200771 // Fake keycode?
772 if (keyCode > 0xff)
773 cc->writer()->keyEvent(keySym, 0, true);
774 else
775 cc->writer()->keyEvent(keySym, keyCode, true);
Pierre Ossman25188c42014-07-21 16:30:08 +0200776 } catch (rdr::Exception& e) {
777 vlog.error("%s", e.str());
778 exit_vncviewer(e.str());
779 }
780
781#ifdef WIN32
782 // Ugly hack continued...
Pierre Ossman0c158662017-07-13 15:54:11 +0200783 if (downKeySym.count(0x1d) && downKeySym.count(0xb8)) {
Pierre Ossman25188c42014-07-21 16:30:08 +0200784 vlog.debug("Restoring AltGr state");
785 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200786 cc->writer()->keyEvent(downKeySym[0x1d], 0x1d, true);
787 cc->writer()->keyEvent(downKeySym[0xb8], 0xb8, true);
Pierre Ossman25188c42014-07-21 16:30:08 +0200788 } catch (rdr::Exception& e) {
789 vlog.error("%s", e.str());
790 exit_vncviewer(e.str());
791 }
792 }
793#endif
794}
795
796
797void Viewport::handleKeyRelease(int keyCode)
798{
799 DownMap::iterator iter;
800
801 if (viewOnly)
802 return;
803
804 iter = downKeySym.find(keyCode);
805 if (iter == downKeySym.end()) {
806 // These occur somewhat frequently so let's not spam them unless
807 // logging is turned up.
808 vlog.debug("Unexpected release of key code %d", keyCode);
809 return;
810 }
811
812#if defined(WIN32) || defined(__APPLE__)
813 vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second);
814#else
815 vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)",
816 keyCode, XKeysymToString(iter->second), iter->second);
817#endif
818
819 try {
Pierre Ossman0c158662017-07-13 15:54:11 +0200820 if (keyCode > 0xff)
821 cc->writer()->keyEvent(iter->second, 0, false);
822 else
823 cc->writer()->keyEvent(iter->second, keyCode, false);
Pierre Ossman25188c42014-07-21 16:30:08 +0200824 } catch (rdr::Exception& e) {
825 vlog.error("%s", e.str());
826 exit_vncviewer(e.str());
827 }
828
829 downKeySym.erase(iter);
830}
831
832
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200833int Viewport::handleSystemEvent(void *event, void *data)
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200834{
835 Viewport *self = (Viewport *)data;
836 Fl_Widget *focus;
837
838 assert(self);
839
840 focus = Fl::grab();
841 if (!focus)
842 focus = Fl::focus();
843 if (!focus)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200844 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200845
846 if (focus != self)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200847 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200848
849 assert(event);
850
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200851#if defined(WIN32)
852 MSG *msg = (MSG*)event;
853
854 if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
855 UINT vKey;
856 bool isExtended;
857 int keyCode;
858 rdr::U32 keySym;
859
860 vKey = msg->wParam;
861 isExtended = (msg->lParam & (1 << 24)) != 0;
862
863 keyCode = ((msg->lParam >> 16) & 0xff);
864
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100865 if (keyCode == SCAN_FAKE) {
866 vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
867 return 1;
868 }
869
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200870 // Windows sets the scan code to 0x00 for multimedia keys, so we
871 // have to do a reverse lookup based on the vKey.
872 if (keyCode == 0x00) {
873 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
874 if (keyCode == 0x00) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200875 if (isExtended)
876 vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
877 else
878 vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200879 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200880 }
881 }
882
Pierre Ossman0c158662017-07-13 15:54:11 +0200883 if (keyCode & ~0x7f) {
884 vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode);
885 return 1;
886 }
887
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200888 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200889 keyCode |= 0x80;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200890
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100891
892 // Fortunately RFB and Windows use the same scan code set (mostly),
893 // so there is no conversion needed
894 // (as long as we encode the extended keys with the high bit)
895
896 // However Pause sends a code that conflicts with NumLock, so use
897 // the code most RFB implementations use (part of the sequence for
898 // Ctrl+Pause, i.e. Break)
899 if (keyCode == 0x45)
900 keyCode = 0xc6;
901
902 // And NumLock incorrectly has the extended bit set
903 if (keyCode == 0xc5)
904 keyCode = 0x45;
905
906 // And Alt+PrintScreen (i.e. SysRq) sends a different code than
907 // PrintScreen
908 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200909 keyCode = 0x54;
Pierre Ossmana7d3dc72014-09-30 17:03:28 +0200910
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200911 keySym = win32_vkey_to_keysym(vKey, isExtended);
912 if (keySym == NoSymbol) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200913 if (isExtended)
914 vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
915 else
916 vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200917 }
918
Pierre Ossman30b3f922017-11-13 09:07:59 +0100919 // Windows sends the same vKey for both shifts, so we need to look
920 // at the scan code to tell them apart
921 if ((keySym == XK_Shift_L) && (keyCode == 0x36))
922 keySym = XK_Shift_R;
Pierre Ossman0c158662017-07-13 15:54:11 +0200923
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200924 self->handleKeyPress(keyCode, keySym);
925
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200926 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200927 } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
928 UINT vKey;
929 bool isExtended;
930 int keyCode;
931
932 vKey = msg->wParam;
933 isExtended = (msg->lParam & (1 << 24)) != 0;
934
935 keyCode = ((msg->lParam >> 16) & 0xff);
Pierre Ossman2fa63f82016-12-05 15:26:21 +0100936
937 if (keyCode == SCAN_FAKE) {
938 vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
939 return 1;
940 }
941
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200942 if (keyCode == 0x00)
943 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
944 if (isExtended)
Pierre Ossman0c158662017-07-13 15:54:11 +0200945 keyCode |= 0x80;
Pierre Ossmanf73214c2017-11-13 09:06:03 +0100946 if (keyCode == 0x45)
947 keyCode = 0xc6;
948 if (keyCode == 0xc5)
949 keyCode = 0x45;
950 if (keyCode == 0xb7)
Pierre Ossman0c158662017-07-13 15:54:11 +0200951 keyCode = 0x54;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200952
953 self->handleKeyRelease(keyCode);
954
Pierre Ossman30b3f922017-11-13 09:07:59 +0100955 // Windows has a rather nasty bug where it won't send key release
956 // events for a Shift button if the other Shift is still pressed
957 if ((keyCode == 0x2a) || (keyCode == 0x36)) {
958 if (self->downKeySym.count(0x2a))
959 self->handleKeyRelease(0x2a);
960 if (self->downKeySym.count(0x36))
961 self->handleKeyRelease(0x36);
962 }
963
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200964 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200965 }
Pierre Ossman6b743d02014-07-21 16:48:43 +0200966#elif defined(__APPLE__)
967 if (cocoa_is_keyboard_event(event)) {
968 int keyCode;
969
970 keyCode = cocoa_event_keycode(event);
Pierre Ossman0c158662017-07-13 15:54:11 +0200971 if ((unsigned)keyCode >= code_map_osx_to_qnum_len)
972 keyCode = 0;
973 else
974 keyCode = code_map_osx_to_qnum[keyCode];
Pierre Ossman6b743d02014-07-21 16:48:43 +0200975
976 if (cocoa_is_key_press(event)) {
977 rdr::U32 keySym;
978
979 keySym = cocoa_event_keysym(event);
980 if (keySym == NoSymbol) {
981 vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
982 (int)keyCode);
Pierre Ossman6b743d02014-07-21 16:48:43 +0200983 }
984
985 self->handleKeyPress(keyCode, keySym);
986
987 // We don't get any release events for CapsLock, so we have to
988 // send the release right away.
989 if (keySym == XK_Caps_Lock)
990 self->handleKeyRelease(keyCode);
991 } else {
992 self->handleKeyRelease(keyCode);
993 }
994
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200995 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +0200996 }
997#else
Pierre Ossman6b9622d2014-07-21 16:42:12 +0200998 XEvent *xevent = (XEvent*)event;
999
1000 if (xevent->type == KeyPress) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001001 int keycode;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001002 char str;
1003 KeySym keysym;
1004
Pierre Ossman0c158662017-07-13 15:54:11 +02001005 keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1006
1007 // Generate a fake keycode just for tracking if we can't figure
1008 // out the proper one
1009 if (keycode == 0)
1010 keycode = 0x100 | xevent->xkey.keycode;
1011
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001012 XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
1013 if (keysym == NoSymbol) {
1014 vlog.error(_("No symbol for key code %d (in the current state)"),
1015 (int)xevent->xkey.keycode);
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001016 }
1017
1018 switch (keysym) {
1019 // For the first few years, there wasn't a good consensus on what the
1020 // Windows keys should be mapped to for X11. So we need to help out a
1021 // bit and map all variants to the same key...
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001022 case XK_Hyper_L:
1023 keysym = XK_Super_L;
1024 break;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001025 case XK_Hyper_R:
1026 keysym = XK_Super_R;
1027 break;
1028 // There has been several variants for Shift-Tab over the years.
1029 // RFB states that we should always send a normal tab.
1030 case XK_ISO_Left_Tab:
1031 keysym = XK_Tab;
1032 break;
1033 }
1034
Pierre Ossman0c158662017-07-13 15:54:11 +02001035 self->handleKeyPress(keycode, keysym);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001036 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001037 } else if (xevent->type == KeyRelease) {
Pierre Ossman0c158662017-07-13 15:54:11 +02001038 int keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
1039 if (keycode == 0)
1040 keycode = 0x100 | xevent->xkey.keycode;
1041 self->handleKeyRelease(keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001042 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +02001043 }
1044#endif
1045
Pierre Ossman64ff1ca2014-09-11 10:48:29 +02001046 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +02001047}
1048
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001049void Viewport::initContextMenu()
1050{
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001051 contextMenu->clear();
1052
Pierre Ossmanff626f82015-09-23 16:39:54 +02001053 fltk_menu_add(contextMenu, p_("ContextMenu|", "E&xit viewer"),
1054 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001055
Pierre Ossmanff626f82015-09-23 16:39:54 +02001056 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"),
1057 0, NULL, (void*)ID_FULLSCREEN,
Pierre Ossman245c8022015-02-25 11:27:49 +01001058 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001059 fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"),
1060 0, NULL, (void*)ID_MINIMIZE, 0);
1061 fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"),
1062 0, NULL, (void*)ID_RESIZE,
Pierre Ossman245c8022015-02-25 11:27:49 +01001063 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
Pierre Ossman245c8022015-02-25 11:27:49 +01001064 FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001065
Pierre Ossmanff626f82015-09-23 16:39:54 +02001066 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"),
1067 0, NULL, (void*)ID_CTRL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001068 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
Pierre Ossmanff626f82015-09-23 16:39:54 +02001069 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"),
1070 0, NULL, (void*)ID_ALT,
Pierre Ossman245c8022015-02-25 11:27:49 +01001071 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001072
1073 if (menuKeySym) {
1074 char sendMenuKey[64];
Pierre Ossmanff626f82015-09-23 16:39:54 +02001075 snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey);
Pierre Ossman245c8022015-02-25 11:27:49 +01001076 fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
Pierre Ossman0c158662017-07-13 15:54:11 +02001077 fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL,
Pierre Ossman245c8022015-02-25 11:27:49 +01001078 (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001079 }
1080
Pierre Ossmanff626f82015-09-23 16:39:54 +02001081 fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"),
1082 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001083
Pierre Ossmanff626f82015-09-23 16:39:54 +02001084 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"),
1085 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001086
Pierre Ossmanff626f82015-09-23 16:39:54 +02001087 fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."),
1088 0, NULL, (void*)ID_OPTIONS, 0);
1089 fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."),
1090 0, NULL, (void*)ID_INFO, 0);
1091 fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."),
1092 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
Pierre Ossmanb5b0ea52015-02-25 10:35:03 +01001093
Pierre Ossmanff626f82015-09-23 16:39:54 +02001094 fltk_menu_add(contextMenu, p_("ContextMenu|", "Dismiss &menu"),
1095 0, NULL, (void*)ID_DISMISS, 0);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001096}
1097
1098
1099void Viewport::popupContextMenu()
1100{
1101 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001102 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001103
Pierre Ossmanb3ff4372011-06-03 11:45:15 +00001104 // Make sure the menu is reset to its initial state between goes or
1105 // it will start up highlighting the previously selected entry.
1106 contextMenu->value(-1);
1107
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001108 // initialize context menu before display
1109 initContextMenu();
1110
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001111 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
1112 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001113 if (Fl::belowmouse() == this)
1114 window()->cursor(FL_CURSOR_DEFAULT);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001115
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001116 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001117
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001118 // Back to our proper mouse pointer.
Pierre Ossmande1a3b92014-03-17 14:29:49 +01001119 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001120 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001121
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001122 if (m == NULL)
1123 return;
1124
1125 switch (m->argument()) {
1126 case ID_EXIT:
1127 exit_vncviewer();
1128 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +00001129 case ID_FULLSCREEN:
1130 if (window()->fullscreen_active())
1131 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +00001132 else
Pierre Ossmanaae38912012-07-13 11:22:55 +00001133 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +00001134 break;
Joel Teichroeba7494ac2015-07-13 14:46:22 -07001135 case ID_MINIMIZE:
1136 window()->iconize();
Joel Teichroeb1f9e45a2015-07-18 07:09:24 -07001137 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001138 case ID_RESIZE:
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001139 if (window()->fullscreen_active())
1140 break;
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001141 window()->size(w(), h());
1142 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001143 case ID_CTRL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001144 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001145 handleKeyPress(0x1d, XK_Control_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001146 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001147 handleKeyRelease(0x1d);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001148 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001149 break;
1150 case ID_ALT:
Pierre Ossman25188c42014-07-21 16:30:08 +02001151 if (m->value())
Pierre Ossman0c158662017-07-13 15:54:11 +02001152 handleKeyPress(0x38, XK_Alt_L);
Pierre Ossman25188c42014-07-21 16:30:08 +02001153 else
Pierre Ossman0c158662017-07-13 15:54:11 +02001154 handleKeyRelease(0x38);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001155 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001156 break;
1157 case ID_MENUKEY:
Pierre Ossman0c158662017-07-13 15:54:11 +02001158 handleKeyPress(menuKeyCode, menuKeySym);
1159 handleKeyRelease(menuKeyCode);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001160 break;
1161 case ID_CTRLALTDEL:
Pierre Ossman0c158662017-07-13 15:54:11 +02001162 handleKeyPress(0x1d, XK_Control_L);
1163 handleKeyPress(0x38, XK_Alt_L);
1164 handleKeyPress(0xd3, XK_Delete);
Pierre Ossman991b4fe2011-07-12 16:02:30 +00001165
Pierre Ossman0c158662017-07-13 15:54:11 +02001166 handleKeyRelease(0xd3);
1167 handleKeyRelease(0x38);
1168 handleKeyRelease(0x1d);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001169 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001170 case ID_REFRESH:
1171 cc->refreshFramebuffer();
1172 break;
Pierre Ossmand463b572011-05-16 12:04:43 +00001173 case ID_OPTIONS:
1174 OptionsDialog::showDialog();
1175 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001176 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001177 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
1178 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +00001179 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001180 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001181 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +00001182 case ID_ABOUT:
1183 about_vncviewer();
1184 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001185 case ID_DISMISS:
1186 // Don't need to do anything
1187 break;
1188 }
1189}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001190
1191
1192void Viewport::setMenuKey()
1193{
Pierre Ossman0c158662017-07-13 15:54:11 +02001194 getMenuKey(&menuKeyFLTK, &menuKeyCode, &menuKeySym);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001195}
1196
1197
1198void Viewport::handleOptions(void *data)
1199{
1200 Viewport *self = (Viewport*)data;
1201
1202 self->setMenuKey();
1203}