blob: 887195ddf82b0abca8bcfc519e7d558450d7a49c [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>
30
31// FLTK can pull in the X11 headers on some systems
32#ifndef XK_VoidSymbol
Pierre Ossman13a809a2014-08-22 15:09:54 +020033#define XK_LATIN1
Pierre Ossmand50b3d12011-04-15 07:46:56 +000034#define XK_MISCELLANY
35#define XK_XKB_KEYS
36#include <rfb/keysymdef.h>
37#endif
38
Pierre Ossmancb0cffe2011-05-20 14:55:10 +000039#ifndef XF86XK_ModeLock
40#include <rfb/XF86keysym.h>
41#endif
42
Pierre Ossman7b8bff62014-07-21 16:17:23 +020043#ifndef NoSymbol
44#define NoSymbol 0
45#endif
46
Pierre Ossman2e9684f2014-07-21 16:46:22 +020047// Missing in at least some versions of MinGW
48#ifndef MAPVK_VK_TO_VSC
49#define MAPVK_VK_TO_VSC 0
50#endif
51
Pierre Ossmand50b3d12011-04-15 07:46:56 +000052#include "Viewport.h"
53#include "CConn.h"
Pierre Ossmand463b572011-05-16 12:04:43 +000054#include "OptionsDialog.h"
Pierre Ossman947b48d2014-01-27 16:52:35 +010055#include "DesktopWindow.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000056#include "i18n.h"
Pierre Ossmanc628ba42011-05-23 12:21:21 +000057#include "fltk_layout.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000058#include "parameters.h"
59#include "keysym2ucs.h"
Martin Koegler498ef462011-09-04 07:04:43 +000060#include "menukey.h"
Pierre Ossman39ceb502011-07-12 15:54:25 +000061#include "vncviewer.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000062
Pierre Ossmanac13abe2014-02-07 14:46:26 +010063#include "PlatformPixelBuffer.h"
64#include "FLTKPixelBuffer.h"
65
Pierre Ossman947b48d2014-01-27 16:52:35 +010066#if defined(WIN32)
67#include "Win32PixelBuffer.h"
68#elif defined(__APPLE__)
69#include "OSXPixelBuffer.h"
70#else
71#include "X11PixelBuffer.h"
72#endif
73
DRCb65bb932011-06-24 03:17:00 +000074#include <FL/fl_draw.H>
75#include <FL/fl_ask.H>
76
Pierre Ossman769963f2014-01-20 14:43:52 +010077#include <FL/Fl_Menu.H>
78#include <FL/Fl_Menu_Button.H>
79
Pierre Ossman6b743d02014-07-21 16:48:43 +020080#ifdef __APPLE__
81#include "cocoa.h"
82#endif
83
DRCb65bb932011-06-24 03:17:00 +000084#ifdef WIN32
85#include "win32.h"
86#endif
87
Pierre Ossman6b743d02014-07-21 16:48:43 +020088
Pierre Ossmand50b3d12011-04-15 07:46:56 +000089using namespace rfb;
Pierre Ossman835b4ef2011-06-08 17:02:36 +000090using namespace rdr;
Pierre Ossmand50b3d12011-04-15 07:46:56 +000091
Pierre Ossmand50b3d12011-04-15 07:46:56 +000092static rfb::LogWriter vlog("Viewport");
93
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000094// Menu constants
95
Pierre Ossman8dc8bca2012-07-04 11:37:10 +000096enum { ID_EXIT, ID_FULLSCREEN, ID_RESIZE,
97 ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
Pierre Ossman2eb1d112011-05-16 12:18:08 +000098 ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS };
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000099
Pierre Ossman25188c42014-07-21 16:30:08 +0200100// Fake key presses use this value and above
101static const int fakeKeyBase = 0x200;
102
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000103Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_)
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200104 : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL),
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100105 lastPointerPos(0, 0), lastButtonMask(0),
Henrik Andersson3a848322011-09-14 08:33:15 +0000106 cursor(NULL), menuCtrlKey(false), menuAltKey(false)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000107{
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000108// FLTK STR #2636 gives us the ability to monitor clipboard changes
109#ifdef HAVE_FLTK_CLIPBOARD
110 Fl::add_clipboard_notify(handleClipboardChange, this);
111#endif
112
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200113#ifdef HAVE_FLTK_XHANDLERS
114 // We need to intercept keyboard events early
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200115 Fl::add_system_handler(handleSystemEvent, this);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200116#endif
117
Pierre Ossmanac13abe2014-02-07 14:46:26 +0100118 frameBuffer = createFramebuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000119 assert(frameBuffer);
120
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000121 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +0000122 // Setting box type to FL_NO_BOX prevents it from trying to draw the
123 // button component (which we don't want)
124 contextMenu->box(FL_NO_BOX);
125
Pierre Ossmanb043ad12011-06-01 09:26:57 +0000126 // The (invisible) button associated with this widget can mess with
127 // things like Fl_Scroll so we need to get rid of any parents.
128 // Unfortunately that's not possible because of STR #2654, but
129 // reparenting to the current window works for most cases.
130 window()->add(contextMenu);
131
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000132 setMenuKey();
133
134 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmande673132011-11-10 14:59:24 +0000135
136 // Send a fake pointer event so that the server will stop rendering
137 // a server-side cursor. Ideally we'd like to send the actual pointer
138 // position, but we can't really tell when the window manager is done
139 // placing us so we don't have a good time for that.
140 handlePointerEvent(Point(w/2, h/2), 0);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000141}
142
143
144Viewport::~Viewport()
145{
146 // Unregister all timeouts in case they get a change tro trigger
147 // again later when this object is already gone.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000148 Fl::remove_timeout(handlePointerTimeout, this);
149
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200150#ifdef HAVE_FLTK_XHANDLERS
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200151 Fl::remove_system_handler(handleSystemEvent);
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200152#endif
153
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000154#ifdef HAVE_FLTK_CLIPBOARD
155 Fl::remove_clipboard_notify(handleClipboardChange);
156#endif
157
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000158 OptionsDialog::removeCallback(handleOptions);
159
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000160 delete frameBuffer;
161
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000162 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000163 if (!cursor->alloc_array)
164 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000165 delete cursor;
166 }
167
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000168 // FLTK automatically deletes all child widgets, so we shouldn't touch
169 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000170}
171
172
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000173const rfb::PixelFormat &Viewport::getPreferredPF()
174{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000175 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000176}
177
178
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000179// Copy the areas of the framebuffer that have been changed (damaged)
180// to the displayed window.
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200181// FIXME: Make sure this gets called on slow updates
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000182
183void Viewport::updateWindow()
184{
185 Rect r;
186
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200187 r = frameBuffer->getDamage();
188 damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000189}
190
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200191rfb::ModifiablePixelBuffer* Viewport::getFramebuffer(void)
192{
193 return frameBuffer;
Pierre Ossman947b48d2014-01-27 16:52:35 +0100194}
195
Pierre Ossmanf741d342011-06-09 08:32:49 +0000196#ifdef HAVE_FLTK_CURSOR
197static const char * dotcursor_xpm[] = {
198 "5 5 2 1",
199 ". c #000000",
200 " c #FFFFFF",
201 " ",
202 " ... ",
203 " ... ",
204 " ... ",
205 " "};
206#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000207
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000208void Viewport::setCursor(int width, int height, const Point& hotspot,
209 void* data, void* mask)
210{
211#ifdef HAVE_FLTK_CURSOR
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000212 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000213 if (!cursor->alloc_array)
214 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000215 delete cursor;
216 }
217
Pierre Ossmanf741d342011-06-09 08:32:49 +0000218 int mask_len = ((width+7)/8) * height;
219 int i;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000220
Pierre Ossmanf741d342011-06-09 08:32:49 +0000221 for (i = 0; i < mask_len; i++)
222 if (((rdr::U8*)mask)[i]) break;
223
Pierre Ossmana51574a2011-06-09 08:39:35 +0000224 if ((i == mask_len) && dotWhenNoCursor) {
225 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000226
227 Fl_Pixmap pxm(dotcursor_xpm);
228 cursor = new Fl_RGB_Image(&pxm);
229 cursorHotspot.x = cursorHotspot.y = 2;
230 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000231 if ((width == 0) || (height == 0)) {
232 U8 *buffer = new U8[4];
233 memset(buffer, 0, 4);
234 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
235 cursorHotspot.x = cursorHotspot.y = 0;
236 } else {
237 U8 *buffer = new U8[width*height*4];
238 U8 *i, *o, *m;
239 int m_width;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000240
Pierre Ossmand8f84872011-07-15 08:26:51 +0000241 const PixelFormat *pf;
242
Pierre Ossman0c9bd4b2014-07-09 16:44:11 +0200243 pf = &cc->cp.pf();
Pierre Ossmanf741d342011-06-09 08:32:49 +0000244
Pierre Ossman17a48f02011-06-09 08:42:04 +0000245 i = (U8*)data;
246 o = buffer;
247 m = (U8*)mask;
248 m_width = (width+7)/8;
249 for (int y = 0;y < height;y++) {
250 for (int x = 0;x < width;x++) {
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100251 pf->rgbFromBuffer(o, i, 1);
Pierre Ossmanf741d342011-06-09 08:32:49 +0000252
Pierre Ossman17a48f02011-06-09 08:42:04 +0000253 if (m[(m_width*y)+(x/8)] & 0x80>>(x%8))
254 o[3] = 255;
255 else
256 o[3] = 0;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000257
Pierre Ossman17a48f02011-06-09 08:42:04 +0000258 o += 4;
Pierre Ossmand8f84872011-07-15 08:26:51 +0000259 i += pf->bpp/8;
Pierre Ossman17a48f02011-06-09 08:42:04 +0000260 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000261 }
Pierre Ossman17a48f02011-06-09 08:42:04 +0000262
263 cursor = new Fl_RGB_Image(buffer, width, height, 4);
264
265 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);
271#endif
272}
273
274
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000275void Viewport::draw()
276{
277 int X, Y, W, H;
278
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000279 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000280 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000281 if ((W == 0) || (H == 0))
282 return;
283
Pierre Ossman132b3d02011-06-13 11:19:32 +0000284 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000285}
286
287
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000288void Viewport::resize(int x, int y, int w, int h)
289{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000290 PlatformPixelBuffer* newBuffer;
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000291 rfb::Rect rect;
292
Pierre Ossmanff9eb5a2014-01-30 17:47:31 +0100293 const rdr::U8* data;
294 int stride;
295
Pierre Ossman132b3d02011-06-13 11:19:32 +0000296 // FIXME: Resize should probably be a feature of the pixel buffer itself
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000297
298 if ((w == frameBuffer->width()) && (h == frameBuffer->height()))
299 goto end;
300
Pierre Ossmana23989b2012-07-04 11:10:46 +0000301 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
Pierre Ossman773125e2011-07-15 13:41:02 +0000302 frameBuffer->width(), frameBuffer->height(), w, h);
303
Pierre Ossmanac13abe2014-02-07 14:46:26 +0100304 newBuffer = createFramebuffer(w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000305 assert(newBuffer);
306
307 rect.setXYWH(0, 0,
308 __rfbmin(newBuffer->width(), frameBuffer->width()),
309 __rfbmin(newBuffer->height(), frameBuffer->height()));
Pierre Ossmanff9eb5a2014-01-30 17:47:31 +0100310 data = frameBuffer->getBuffer(frameBuffer->getRect(), &stride);
311 newBuffer->imageRect(rect, data, stride);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000312
313 // Black out any new areas
314
315 if (newBuffer->width() > frameBuffer->width()) {
316 rect.setXYWH(frameBuffer->width(), 0,
317 newBuffer->width() - frameBuffer->width(),
318 newBuffer->height());
319 newBuffer->fillRect(rect, 0);
320 }
321
322 if (newBuffer->height() > frameBuffer->height()) {
323 rect.setXYWH(0, frameBuffer->height(),
324 newBuffer->width(),
325 newBuffer->height() - frameBuffer->height());
326 newBuffer->fillRect(rect, 0);
327 }
328
329 delete frameBuffer;
330 frameBuffer = newBuffer;
331
332end:
333 Fl_Widget::resize(x, y, w, h);
334}
335
336
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000337int Viewport::handle(int event)
338{
Pierre Ossman689c4582011-05-26 15:39:41 +0000339 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000340 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000341 int buttonMask, wheelMask;
342 DownMap::const_iterator iter;
343
344 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000345 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000346 buffer = new char[Fl::event_length() + 1];
347
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000348 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000349 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
350 Fl::event_length() + 1);
351 assert(ret < (Fl::event_length() + 1));
352
Pierre Ossman5803d3b2013-09-05 14:25:40 +0000353 vlog.debug("Sending clipboard data (%d bytes)", strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000354
355 try {
356 cc->writer()->clientCutText(buffer, ret);
357 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000358 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000359 exit_vncviewer(e.str());
360 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000361
362 delete [] buffer;
363
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000364 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000365
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000366 case FL_ENTER:
367 // Yes, we would like some pointer events please!
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000368#ifdef HAVE_FLTK_CURSOR
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000369 if (cursor)
370 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000371#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000372 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000373
374 case FL_LEAVE:
375#ifdef HAVE_FLTK_CURSOR
376 window()->cursor(FL_CURSOR_DEFAULT);
377#endif
Pierre Ossman164865a2011-11-10 13:30:39 +0000378 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000379 case FL_PUSH:
380 case FL_RELEASE:
381 case FL_DRAG:
382 case FL_MOVE:
383 case FL_MOUSEWHEEL:
384 buttonMask = 0;
385 if (Fl::event_button1())
386 buttonMask |= 1;
387 if (Fl::event_button2())
388 buttonMask |= 2;
389 if (Fl::event_button3())
390 buttonMask |= 4;
391
392 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000393 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000394 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000395 wheelMask |= 8;
396 if (Fl::event_dy() > 0)
397 wheelMask |= 16;
398 if (Fl::event_dx() < 0)
399 wheelMask |= 32;
400 if (Fl::event_dx() > 0)
401 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000402
403 // A quick press of the wheel "button", followed by a immediate
404 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000405 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000406 buttonMask | wheelMask);
407 }
408
Pierre Ossman6a464be2011-04-15 12:57:31 +0000409 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000410 return 1;
411
412 case FL_FOCUS:
Pierre Ossman6d66d6d2014-09-11 10:46:12 +0200413#ifdef HAVE_FLTK_IM
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200414 Fl::disable_im();
Pierre Ossman6d66d6d2014-09-11 10:46:12 +0200415#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000416 // Yes, we would like some focus please!
417 return 1;
418
419 case FL_UNFOCUS:
420 // Release all keys that were pressed as that generally makes most
421 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000422 while (!downKeySym.empty())
Pierre Ossman25188c42014-07-21 16:30:08 +0200423 handleKeyRelease(downKeySym.begin()->first);
Pierre Ossman6d66d6d2014-09-11 10:46:12 +0200424#ifdef HAVE_FLTK_IM
Pierre Ossman48ef54d2014-08-19 14:08:04 +0200425 Fl::enable_im();
Pierre Ossman6d66d6d2014-09-11 10:46:12 +0200426#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000427 return 1;
428
429 case FL_KEYDOWN:
Pierre Ossman25188c42014-07-21 16:30:08 +0200430 handleFLTKKeyPress();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000431 return 1;
432
433 case FL_KEYUP:
Pierre Ossman25188c42014-07-21 16:30:08 +0200434 handleKeyRelease(Fl::event_original_key());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000435 return 1;
436 }
437
438 return Fl_Widget::handle(event);
439}
440
441
Pierre Ossmanac13abe2014-02-07 14:46:26 +0100442PlatformPixelBuffer* Viewport::createFramebuffer(int w, int h)
443{
444 PlatformPixelBuffer *fb;
445
446 try {
447#if defined(WIN32)
448 fb = new Win32PixelBuffer(w, h);
449#elif defined(__APPLE__)
450 fb = new OSXPixelBuffer(w, h);
451#else
452 fb = new X11PixelBuffer(w, h);
453#endif
454 } catch (rdr::Exception& e) {
455 fb = new FLTKPixelBuffer(w, h);
456 }
457
458 return fb;
459}
460
461
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000462void Viewport::handleClipboardChange(int source, void *data)
463{
464 Viewport *self = (Viewport *)data;
465
466 assert(self);
467
468 if (!sendPrimary && (source == 0))
469 return;
470
471 Fl::paste(*self, source);
472}
473
474
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000475void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
476{
477 if (!viewOnly) {
478 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000479 try {
480 cc->writer()->pointerEvent(pos, buttonMask);
481 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000482 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000483 exit_vncviewer(e.str());
484 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000485 } else {
486 if (!Fl::has_timeout(handlePointerTimeout, this))
487 Fl::add_timeout((double)pointerEventInterval/1000.0,
488 handlePointerTimeout, this);
489 }
490 lastPointerPos = pos;
491 lastButtonMask = buttonMask;
492 }
493}
494
495
496void Viewport::handlePointerTimeout(void *data)
497{
498 Viewport *self = (Viewport *)data;
499
500 assert(self);
501
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000502 try {
503 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
504 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000505 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000506 exit_vncviewer(e.str());
507 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000508}
509
510
Pierre Ossman25188c42014-07-21 16:30:08 +0200511void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym)
512{
513 static bool menuRecursion = false;
514
515 // Prevent recursion if the menu wants to send its own
516 // activation key.
517 if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) {
518 menuRecursion = true;
519 popupContextMenu();
520 menuRecursion = false;
521 return;
522 }
523
524 if (viewOnly)
525 return;
526
527#ifdef __APPLE__
528 // Alt on OS X behaves more like AltGr on other systems, and to get
529 // sane behaviour we should translate things in that manner for the
530 // remote VNC server. However that means we lose the ability to use
531 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
532 // left command key as an Alt replacement.
533 switch (keySym) {
534 case XK_Super_L:
535 keySym = XK_Alt_L;
536 break;
537 case XK_Super_R:
538 keySym = XK_Super_L;
539 break;
540 case XK_Alt_L:
Pierre Ossman38fcebb2014-08-21 13:44:28 +0200541 keySym = XK_Mode_switch;
542 break;
Pierre Ossman25188c42014-07-21 16:30:08 +0200543 case XK_Alt_R:
544 keySym = XK_ISO_Level3_Shift;
545 break;
546 }
547#endif
548
549#ifdef WIN32
550 // Ugly hack alert!
551 //
552 // Windows doesn't have a proper AltGr, but handles it using fake
553 // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
554 // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
555 // get everything in the correct state. Cheat and temporarily release
556 // Ctrl and Alt when we send some other symbol.
557 bool ctrlPressed, altPressed;
558 DownMap::iterator iter;
559
560 ctrlPressed = false;
561 altPressed = false;
562 for (iter = downKeySym.begin();iter != downKeySym.end();++iter) {
563 if (iter->second == XK_Control_L)
564 ctrlPressed = true;
565 else if (iter->second == XK_Alt_R)
566 altPressed = true;
567 }
568
569 if (ctrlPressed && altPressed) {
570 vlog.debug("Faking release of AltGr (Ctrl_L+Alt_R)");
571 try {
572 cc->writer()->keyEvent(XK_Control_L, false);
573 cc->writer()->keyEvent(XK_Alt_R, false);
574 } catch (rdr::Exception& e) {
575 vlog.error("%s", e.str());
576 exit_vncviewer(e.str());
577 }
578 }
579#endif
580
581 // Because of the way keyboards work, we cannot expect to have the same
582 // symbol on release as when pressed. This breaks the VNC protocol however,
583 // so we need to keep track of what keysym a key _code_ generated on press
584 // and send the same on release.
585 downKeySym[keyCode] = keySym;
586
587#if defined(WIN32) || defined(__APPLE__)
588 vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
589#else
590 vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)",
591 keyCode, XKeysymToString(keySym), keySym);
592#endif
593
594 try {
595 cc->writer()->keyEvent(keySym, true);
596 } catch (rdr::Exception& e) {
597 vlog.error("%s", e.str());
598 exit_vncviewer(e.str());
599 }
600
601#ifdef WIN32
602 // Ugly hack continued...
603 if (ctrlPressed && altPressed) {
604 vlog.debug("Restoring AltGr state");
605 try {
606 cc->writer()->keyEvent(XK_Control_L, true);
607 cc->writer()->keyEvent(XK_Alt_R, true);
608 } catch (rdr::Exception& e) {
609 vlog.error("%s", e.str());
610 exit_vncviewer(e.str());
611 }
612 }
613#endif
614}
615
616
617void Viewport::handleKeyRelease(int keyCode)
618{
619 DownMap::iterator iter;
620
621 if (viewOnly)
622 return;
623
624 iter = downKeySym.find(keyCode);
625 if (iter == downKeySym.end()) {
626 // These occur somewhat frequently so let's not spam them unless
627 // logging is turned up.
628 vlog.debug("Unexpected release of key code %d", keyCode);
629 return;
630 }
631
632#if defined(WIN32) || defined(__APPLE__)
633 vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second);
634#else
635 vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)",
636 keyCode, XKeysymToString(iter->second), iter->second);
637#endif
638
639 try {
640 cc->writer()->keyEvent(iter->second, false);
641 } catch (rdr::Exception& e) {
642 vlog.error("%s", e.str());
643 exit_vncviewer(e.str());
644 }
645
646 downKeySym.erase(iter);
647}
648
649
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200650int Viewport::handleSystemEvent(void *event, void *data)
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200651{
652 Viewport *self = (Viewport *)data;
653 Fl_Widget *focus;
654
655 assert(self);
656
657 focus = Fl::grab();
658 if (!focus)
659 focus = Fl::focus();
660 if (!focus)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200661 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200662
663 if (focus != self)
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200664 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200665
666 assert(event);
667
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200668#if defined(WIN32)
669 MSG *msg = (MSG*)event;
670
671 if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
672 UINT vKey;
673 bool isExtended;
674 int keyCode;
675 rdr::U32 keySym;
676
677 vKey = msg->wParam;
678 isExtended = (msg->lParam & (1 << 24)) != 0;
679
680 keyCode = ((msg->lParam >> 16) & 0xff);
681
682 // Windows sets the scan code to 0x00 for multimedia keys, so we
683 // have to do a reverse lookup based on the vKey.
684 if (keyCode == 0x00) {
685 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
686 if (keyCode == 0x00) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200687 if (isExtended)
688 vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
689 else
690 vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200691 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200692 }
693 }
694
695 if (isExtended)
696 keyCode |= 0x100;
697
698 keySym = win32_vkey_to_keysym(vKey, isExtended);
699 if (keySym == NoSymbol) {
Pierre Ossmanf05f3552014-09-22 12:19:52 +0200700 if (isExtended)
701 vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
702 else
703 vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200704 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200705 }
706
707 self->handleKeyPress(keyCode, keySym);
708
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200709 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200710 } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
711 UINT vKey;
712 bool isExtended;
713 int keyCode;
714
715 vKey = msg->wParam;
716 isExtended = (msg->lParam & (1 << 24)) != 0;
717
718 keyCode = ((msg->lParam >> 16) & 0xff);
719 if (keyCode == 0x00)
720 keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
721 if (isExtended)
722 keyCode |= 0x100;
723
724 self->handleKeyRelease(keyCode);
725
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200726 return 1;
Pierre Ossman2e9684f2014-07-21 16:46:22 +0200727 }
Pierre Ossman6b743d02014-07-21 16:48:43 +0200728#elif defined(__APPLE__)
729 if (cocoa_is_keyboard_event(event)) {
730 int keyCode;
731
732 keyCode = cocoa_event_keycode(event);
733
734 if (cocoa_is_key_press(event)) {
735 rdr::U32 keySym;
736
737 keySym = cocoa_event_keysym(event);
738 if (keySym == NoSymbol) {
739 vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
740 (int)keyCode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200741 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +0200742 }
743
744 self->handleKeyPress(keyCode, keySym);
745
746 // We don't get any release events for CapsLock, so we have to
747 // send the release right away.
748 if (keySym == XK_Caps_Lock)
749 self->handleKeyRelease(keyCode);
750 } else {
751 self->handleKeyRelease(keyCode);
752 }
753
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200754 return 1;
Pierre Ossman6b743d02014-07-21 16:48:43 +0200755 }
756#else
Pierre Ossman6b9622d2014-07-21 16:42:12 +0200757 XEvent *xevent = (XEvent*)event;
758
759 if (xevent->type == KeyPress) {
760 char str;
761 KeySym keysym;
762
763 XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
764 if (keysym == NoSymbol) {
765 vlog.error(_("No symbol for key code %d (in the current state)"),
766 (int)xevent->xkey.keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200767 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +0200768 }
769
770 switch (keysym) {
771 // For the first few years, there wasn't a good consensus on what the
772 // Windows keys should be mapped to for X11. So we need to help out a
773 // bit and map all variants to the same key...
774 case XK_Meta_L:
775 case XK_Hyper_L:
776 keysym = XK_Super_L;
777 break;
778 case XK_Meta_R:
779 case XK_Hyper_R:
780 keysym = XK_Super_R;
781 break;
782 // There has been several variants for Shift-Tab over the years.
783 // RFB states that we should always send a normal tab.
784 case XK_ISO_Left_Tab:
785 keysym = XK_Tab;
786 break;
787 }
788
789 self->handleKeyPress(xevent->xkey.keycode, keysym);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200790 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +0200791 } else if (xevent->type == KeyRelease) {
792 self->handleKeyRelease(xevent->xkey.keycode);
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200793 return 1;
Pierre Ossman6b9622d2014-07-21 16:42:12 +0200794 }
795#endif
796
Pierre Ossman64ff1ca2014-09-11 10:48:29 +0200797 return 0;
Pierre Ossman4f3ac692014-08-22 15:10:22 +0200798}
799
800
Pierre Ossman25188c42014-07-21 16:30:08 +0200801rdr::U32 Viewport::translateKeyEvent(void)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000802{
803 unsigned ucs;
Pierre Ossman25188c42014-07-21 16:30:08 +0200804 int keyCode, origKeyCode;
805 const char *keyText;
806 int keyTextLen;
807
808 keyCode = Fl::event_key();
809 origKeyCode = Fl::event_original_key();
810 keyText = Fl::event_text();
811 keyTextLen = Fl::event_length();
812
813 vlog.debug("FLTK key %d (%d) '%s'[%d]", origKeyCode, keyCode, keyText, keyTextLen);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000814
815 // First check for function keys
816 if ((keyCode > FL_F) && (keyCode <= FL_F_Last))
817 return XK_F1 + (keyCode - FL_F - 1);
818
819 // Numpad numbers
820 if ((keyCode >= (FL_KP + '0')) && (keyCode <= (FL_KP + '9')))
821 return XK_KP_0 + (keyCode - (FL_KP + '0'));
822
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000823 // FLTK does some special remapping of numpad keys when numlock is off
824 if ((origKeyCode >= FL_KP) && (origKeyCode <= FL_KP_Last)) {
825 switch (keyCode) {
826 case FL_F+1:
827 return XK_KP_F1;
828 case FL_F+2:
829 return XK_KP_F2;
830 case FL_F+3:
831 return XK_KP_F3;
832 case FL_F+4:
833 return XK_KP_F4;
834 case FL_Home:
835 return XK_KP_Home;
836 case FL_Left:
837 return XK_KP_Left;
838 case FL_Up:
839 return XK_KP_Up;
840 case FL_Right:
841 return XK_KP_Right;
842 case FL_Down:
843 return XK_KP_Down;
844 case FL_Page_Up:
845 return XK_KP_Page_Up;
846 case FL_Page_Down:
847 return XK_KP_Page_Down;
848 case FL_End:
849 return XK_KP_End;
850 case FL_Insert:
851 return XK_KP_Insert;
852 case FL_Delete:
853 return XK_KP_Delete;
854 }
855 }
856
Pierre Ossman159cb832013-05-29 12:33:59 +0000857#if defined(WIN32) || defined(__APPLE__)
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000858 // X11 fairly consistently uses XK_KP_Separator for comma and
Pierre Ossman159cb832013-05-29 12:33:59 +0000859 // XK_KP_Decimal for period. Windows and OS X are a different matter
860 // though.
861 //
862 // OS X will consistently generate the same key code no matter what
863 // layout is being used.
864 //
865 // Windows is terribly inconcistent, and is not something that's
866 // likely to change:
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000867 // http://blogs.msdn.com/michkap/archive/2006/09/13/752377.aspx
Pierre Ossman159cb832013-05-29 12:33:59 +0000868 //
869 // To get X11 behaviour, we instead look at the text generated by
870 // they key.
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000871 if ((keyCode == (FL_KP + ',')) || (keyCode == (FL_KP + '.'))) {
872 switch (keyText[0]) {
873 case ',':
874 return XK_KP_Separator;
875 case '.':
876 return XK_KP_Decimal;
877 default:
878 vlog.error(_("Unknown decimal separator: '%s'"), keyText);
879 return XK_KP_Decimal;
880 }
881 }
882#endif
883
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000884 // Then other special keys
885 switch (keyCode) {
886 case FL_BackSpace:
887 return XK_BackSpace;
888 case FL_Tab:
889 return XK_Tab;
890 case FL_Enter:
891 return XK_Return;
892 case FL_Pause:
893 return XK_Pause;
894 case FL_Scroll_Lock:
895 return XK_Scroll_Lock;
896 case FL_Escape:
897 return XK_Escape;
898 case FL_Home:
899 return XK_Home;
900 case FL_Left:
901 return XK_Left;
902 case FL_Up:
903 return XK_Up;
904 case FL_Right:
905 return XK_Right;
906 case FL_Down:
907 return XK_Down;
908 case FL_Page_Up:
909 return XK_Page_Up;
910 case FL_Page_Down:
911 return XK_Page_Down;
912 case FL_End:
913 return XK_End;
914 case FL_Print:
915 return XK_Print;
916 case FL_Insert:
917 return XK_Insert;
918 case FL_Menu:
919 return XK_Menu;
920 case FL_Help:
921 return XK_Help;
922 case FL_Num_Lock:
923 return XK_Num_Lock;
924 case FL_Shift_L:
925 return XK_Shift_L;
926 case FL_Shift_R:
927 return XK_Shift_R;
928 case FL_Control_L:
929 return XK_Control_L;
930 case FL_Control_R:
931 return XK_Control_R;
932 case FL_Caps_Lock:
933 return XK_Caps_Lock;
934 case FL_Meta_L:
935 return XK_Super_L;
936 case FL_Meta_R:
937 return XK_Super_R;
938 case FL_Alt_L:
939 return XK_Alt_L;
940 case FL_Alt_R:
941 return XK_Alt_R;
942 case FL_Delete:
943 return XK_Delete;
944 case FL_KP_Enter:
945 return XK_KP_Enter;
946 case FL_KP + '=':
947 return XK_KP_Equal;
948 case FL_KP + '*':
949 return XK_KP_Multiply;
950 case FL_KP + '+':
951 return XK_KP_Add;
952 case FL_KP + ',':
953 return XK_KP_Separator;
954 case FL_KP + '-':
955 return XK_KP_Subtract;
956 case FL_KP + '.':
957 return XK_KP_Decimal;
958 case FL_KP + '/':
959 return XK_KP_Divide;
Pierre Ossmancb0cffe2011-05-20 14:55:10 +0000960#ifdef HAVE_FLTK_MEDIAKEYS
961 case FL_Volume_Down:
962 return XF86XK_AudioLowerVolume;
963 case FL_Volume_Mute:
964 return XF86XK_AudioMute;
965 case FL_Volume_Up:
966 return XF86XK_AudioRaiseVolume;
967 case FL_Media_Play:
968 return XF86XK_AudioPlay;
969 case FL_Media_Stop:
970 return XF86XK_AudioStop;
971 case FL_Media_Prev:
972 return XF86XK_AudioPrev;
973 case FL_Media_Next:
974 return XF86XK_AudioNext;
975 case FL_Home_Page:
976 return XF86XK_HomePage;
977 case FL_Mail:
978 return XF86XK_Mail;
979 case FL_Search:
980 return XF86XK_Search;
981 case FL_Back:
982 return XF86XK_Back;
983 case FL_Forward:
984 return XF86XK_Forward;
985 case FL_Stop:
986 return XF86XK_Stop;
987 case FL_Refresh:
988 return XF86XK_Refresh;
989 case FL_Sleep:
990 return XF86XK_Sleep;
991 case FL_Favorites:
992 return XF86XK_Favorites;
993#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000994 case XK_ISO_Level3_Shift:
995 // FLTK tends to let this one leak through on X11...
996 return XK_ISO_Level3_Shift;
Pierre Ossmana75f8f82011-04-29 11:12:02 +0000997 case XK_Multi_key:
998 // Same for this...
999 return XK_Multi_key;
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001000 }
1001
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001002 // Unknown special key?
Pierre Ossman13a809a2014-08-22 15:09:54 +02001003 if (keyTextLen == 0) {
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001004 vlog.error(_("Unknown FLTK key code %d (0x%04x)"), keyCode, keyCode);
Pierre Ossman7b8bff62014-07-21 16:17:23 +02001005 return NoSymbol;
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001006 }
1007
Pierre Ossman13a809a2014-08-22 15:09:54 +02001008 // Control character?
1009 if ((keyTextLen == 1) && ((keyText[0] < 0x20) | (keyText[0] == 0x7f))) {
1010 if (keyText[0] == 0x00)
1011 return XK_2;
1012 else if (keyText[0] < 0x1b) {
1013 if (!!Fl::event_state(FL_SHIFT) != !!Fl::event_state(FL_CAPS_LOCK))
1014 return keyText[0] + XK_A - 0x01;
1015 else
1016 return keyText[0] + XK_a - 0x01;
1017 } else if (keyText[0] < 0x20)
1018 return keyText[0] + XK_3 - 0x1b;
1019 else
1020 return XK_8;
1021 }
1022
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001023 // Look up the symbol the key produces and translate that from Unicode
1024 // to a X11 keysym.
1025 if (fl_utf_nb_char((const unsigned char*)keyText, strlen(keyText)) != 1) {
1026 vlog.error(_("Multiple characters given for key code %d (0x%04x): '%s'"),
1027 keyCode, keyCode, keyText);
Pierre Ossman7b8bff62014-07-21 16:17:23 +02001028 return NoSymbol;
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001029 }
1030
1031 ucs = fl_utf8decode(keyText, NULL, NULL);
1032 return ucs2keysym(ucs);
1033}
1034
1035
Pierre Ossman25188c42014-07-21 16:30:08 +02001036void Viewport::handleFLTKKeyPress(void)
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001037{
1038 rdr::U32 keySym;
1039
Pierre Ossmana83c88d2014-08-19 14:06:53 +02001040#ifdef HAVE_FLTK_XHANDLERS
1041 return;
1042#endif
1043
Pierre Ossman25188c42014-07-21 16:30:08 +02001044 keySym = translateKeyEvent();
Pierre Ossman7b8bff62014-07-21 16:17:23 +02001045 if (keySym == NoSymbol)
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001046 return;
1047
Pierre Ossman25188c42014-07-21 16:30:08 +02001048 handleKeyPress(Fl::event_original_key(), keySym);
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001049}
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001050
1051
1052void Viewport::initContextMenu()
1053{
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001054 contextMenu->clear();
1055
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001056 contextMenu->add(_("Exit viewer"), 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
1057
Pierre Ossman4c613d32011-05-26 14:14:06 +00001058#ifdef HAVE_FLTK_FULLSCREEN
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001059 contextMenu->add(_("Full screen"), 0, NULL, (void*)ID_FULLSCREEN,
1060 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossman4c613d32011-05-26 14:14:06 +00001061#endif
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001062 contextMenu->add(_("Resize window to session"), 0, NULL, (void*)ID_RESIZE,
1063#ifdef HAVE_FLTK_FULLSCREEN
1064 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
1065#endif
1066 FL_MENU_DIVIDER);
Pierre Ossman4c613d32011-05-26 14:14:06 +00001067
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001068 contextMenu->add(_("Ctrl"), 0, NULL, (void*)ID_CTRL,
1069 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
1070 contextMenu->add(_("Alt"), 0, NULL, (void*)ID_ALT,
1071 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001072
Pierre Ossman25188c42014-07-21 16:30:08 +02001073 if (menuKeySym) {
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001074 char sendMenuKey[64];
1075 snprintf(sendMenuKey, 64, _("Send %s"), (const char *)menuKey);
1076 contextMenu->add(sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
1077 contextMenu->add("Secret shortcut menu key", menuKeyCode, NULL, (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
1078 }
1079
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001080 contextMenu->add(_("Send Ctrl-Alt-Del"), 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
1081
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001082 contextMenu->add(_("Refresh screen"), 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
1083
Pierre Ossmand463b572011-05-16 12:04:43 +00001084 contextMenu->add(_("Options..."), 0, NULL, (void*)ID_OPTIONS, 0);
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001085 contextMenu->add(_("Connection info..."), 0, NULL, (void*)ID_INFO, 0);
Pierre Ossmanb8858222011-04-29 11:51:38 +00001086 contextMenu->add(_("About TigerVNC viewer..."), 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
1087
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001088 contextMenu->add(_("Dismiss menu"), 0, NULL, (void*)ID_DISMISS, 0);
1089}
1090
1091
1092void Viewport::popupContextMenu()
1093{
1094 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001095 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001096
Pierre Ossmanb3ff4372011-06-03 11:45:15 +00001097 // Make sure the menu is reset to its initial state between goes or
1098 // it will start up highlighting the previously selected entry.
1099 contextMenu->value(-1);
1100
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001101 // initialize context menu before display
1102 initContextMenu();
1103
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001104 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
1105 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001106#ifdef HAVE_FLTK_CURSOR
1107 if (Fl::belowmouse() == this)
1108 window()->cursor(FL_CURSOR_DEFAULT);
1109#endif
1110
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001111 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001112
Pierre Ossmanfd177f32012-01-05 12:37:04 +00001113 // Back to our proper mouse pointer.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001114#ifdef HAVE_FLTK_CURSOR
Pierre Ossmande1a3b92014-03-17 14:29:49 +01001115 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +00001116 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
1117#endif
1118
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001119 if (m == NULL)
1120 return;
1121
1122 switch (m->argument()) {
1123 case ID_EXIT:
1124 exit_vncviewer();
1125 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +00001126#ifdef HAVE_FLTK_FULLSCREEN
1127 case ID_FULLSCREEN:
1128 if (window()->fullscreen_active())
1129 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +00001130 else
Pierre Ossmanaae38912012-07-13 11:22:55 +00001131 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +00001132 break;
1133#endif
Pierre Ossman8dc8bca2012-07-04 11:37:10 +00001134 case ID_RESIZE:
1135#ifdef HAVE_FLTK_FULLSCREEN
1136 if (window()->fullscreen_active())
1137 break;
1138#endif
1139 window()->size(w(), h());
1140 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001141 case ID_CTRL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001142 if (m->value())
1143 handleKeyPress(fakeKeyBase + 0, XK_Control_L);
1144 else
1145 handleKeyRelease(fakeKeyBase + 0);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001146 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001147 break;
1148 case ID_ALT:
Pierre Ossman25188c42014-07-21 16:30:08 +02001149 if (m->value())
1150 handleKeyPress(fakeKeyBase + 1, XK_Alt_L);
1151 else
1152 handleKeyRelease(fakeKeyBase + 1);
Henrik Anderssonabd70ce2011-09-14 06:31:06 +00001153 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001154 break;
1155 case ID_MENUKEY:
Pierre Ossman25188c42014-07-21 16:30:08 +02001156 handleKeyPress(fakeKeyBase + 2, menuKeySym);
1157 handleKeyRelease(fakeKeyBase + 2);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001158 break;
1159 case ID_CTRLALTDEL:
Pierre Ossman25188c42014-07-21 16:30:08 +02001160 handleKeyPress(fakeKeyBase + 3, XK_Control_L);
1161 handleKeyPress(fakeKeyBase + 4, XK_Alt_L);
1162 handleKeyPress(fakeKeyBase + 5, XK_Delete);
Pierre Ossman991b4fe2011-07-12 16:02:30 +00001163
Pierre Ossman25188c42014-07-21 16:30:08 +02001164 handleKeyRelease(fakeKeyBase + 5);
1165 handleKeyRelease(fakeKeyBase + 4);
1166 handleKeyRelease(fakeKeyBase + 3);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001167 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +00001168 case ID_REFRESH:
1169 cc->refreshFramebuffer();
1170 break;
Pierre Ossmand463b572011-05-16 12:04:43 +00001171 case ID_OPTIONS:
1172 OptionsDialog::showDialog();
1173 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001174 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001175 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
1176 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +00001177 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +00001178 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +00001179 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +00001180 case ID_ABOUT:
1181 about_vncviewer();
1182 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +00001183 case ID_DISMISS:
1184 // Don't need to do anything
1185 break;
1186 }
1187}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001188
1189
1190void Viewport::setMenuKey()
1191{
Pierre Ossman25188c42014-07-21 16:30:08 +02001192 getMenuKey(&menuKeyCode, &menuKeySym);
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001193}
1194
1195
1196void Viewport::handleOptions(void *data)
1197{
1198 Viewport *self = (Viewport*)data;
1199
1200 self->setMenuKey();
1201}