blob: d784a4210ee9bbf000ade85db1dae291796ab67a [file] [log] [blame]
Pierre Ossmand50b3d12011-04-15 07:46:56 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
2 * Copyright 2011 Pierre Ossman <ossman@cendio.se> for Cendio AB
3 *
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
33#define XK_MISCELLANY
34#define XK_XKB_KEYS
35#include <rfb/keysymdef.h>
36#endif
37
Pierre Ossmancb0cffe2011-05-20 14:55:10 +000038#ifndef XF86XK_ModeLock
39#include <rfb/XF86keysym.h>
40#endif
41
Pierre Ossmand50b3d12011-04-15 07:46:56 +000042#include "Viewport.h"
43#include "CConn.h"
Pierre Ossmand463b572011-05-16 12:04:43 +000044#include "OptionsDialog.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000045#include "i18n.h"
Pierre Ossmanc628ba42011-05-23 12:21:21 +000046#include "fltk_layout.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000047#include "parameters.h"
48#include "keysym2ucs.h"
Martin Koegler498ef462011-09-04 07:04:43 +000049#include "menukey.h"
Pierre Ossman39ceb502011-07-12 15:54:25 +000050#include "vncviewer.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000051
DRCb65bb932011-06-24 03:17:00 +000052#include <FL/fl_draw.H>
53#include <FL/fl_ask.H>
54
Pierre Ossman769963f2014-01-20 14:43:52 +010055#include <FL/Fl_Menu.H>
56#include <FL/Fl_Menu_Button.H>
57
DRCb65bb932011-06-24 03:17:00 +000058#ifdef WIN32
59#include "win32.h"
60#endif
61
Pierre Ossmand50b3d12011-04-15 07:46:56 +000062using namespace rfb;
Pierre Ossman835b4ef2011-06-08 17:02:36 +000063using namespace rdr;
Pierre Ossmand50b3d12011-04-15 07:46:56 +000064
Pierre Ossmand50b3d12011-04-15 07:46:56 +000065static rfb::LogWriter vlog("Viewport");
66
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000067// Menu constants
68
Pierre Ossman8dc8bca2012-07-04 11:37:10 +000069enum { ID_EXIT, ID_FULLSCREEN, ID_RESIZE,
70 ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
Pierre Ossman2eb1d112011-05-16 12:18:08 +000071 ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS };
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000072
Pierre Ossmand50b3d12011-04-15 07:46:56 +000073Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_)
74 : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL), pixelTrans(NULL),
Pierre Ossmanf3505452011-07-15 08:11:55 +000075 colourMapChange(false), lastPointerPos(0, 0), lastButtonMask(0),
Henrik Andersson3a848322011-09-14 08:33:15 +000076 cursor(NULL), menuCtrlKey(false), menuAltKey(false)
Pierre Ossmand50b3d12011-04-15 07:46:56 +000077{
Pierre Ossmanf8c5ef62011-05-13 12:47:54 +000078// FLTK STR #2599 must be fixed for proper dead keys support
79#ifdef HAVE_FLTK_DEAD_KEYS
80 set_simple_keyboard();
81#endif
82
Pierre Ossman4a6be4a2011-05-19 14:49:18 +000083// FLTK STR #2636 gives us the ability to monitor clipboard changes
84#ifdef HAVE_FLTK_CLIPBOARD
85 Fl::add_clipboard_notify(handleClipboardChange, this);
86#endif
87
Pierre Ossman132b3d02011-06-13 11:19:32 +000088 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +000089 assert(frameBuffer);
90
91 setServerPF(serverPF);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000092
93 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +000094 // Setting box type to FL_NO_BOX prevents it from trying to draw the
95 // button component (which we don't want)
96 contextMenu->box(FL_NO_BOX);
97
Pierre Ossmanb043ad12011-06-01 09:26:57 +000098 // The (invisible) button associated with this widget can mess with
99 // things like Fl_Scroll so we need to get rid of any parents.
100 // Unfortunately that's not possible because of STR #2654, but
101 // reparenting to the current window works for most cases.
102 window()->add(contextMenu);
103
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000104 setMenuKey();
105
106 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmande673132011-11-10 14:59:24 +0000107
108 // Send a fake pointer event so that the server will stop rendering
109 // a server-side cursor. Ideally we'd like to send the actual pointer
110 // position, but we can't really tell when the window manager is done
111 // placing us so we don't have a good time for that.
112 handlePointerEvent(Point(w/2, h/2), 0);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000113}
114
115
116Viewport::~Viewport()
117{
118 // Unregister all timeouts in case they get a change tro trigger
119 // again later when this object is already gone.
120 Fl::remove_timeout(handleUpdateTimeout, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000121 Fl::remove_timeout(handlePointerTimeout, this);
122
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000123#ifdef HAVE_FLTK_CLIPBOARD
124 Fl::remove_clipboard_notify(handleClipboardChange);
125#endif
126
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000127 OptionsDialog::removeCallback(handleOptions);
128
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000129 delete frameBuffer;
130
131 if (pixelTrans)
132 delete pixelTrans;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000133
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000134 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000135 if (!cursor->alloc_array)
136 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000137 delete cursor;
138 }
139
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000140 // FLTK automatically deletes all child widgets, so we shouldn't touch
141 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000142}
143
144
145void Viewport::setServerPF(const rfb::PixelFormat& pf)
146{
147 if (pixelTrans)
148 delete pixelTrans;
149 pixelTrans = NULL;
150
151 if (pf.equal(getPreferredPF()))
152 return;
153
154 pixelTrans = new PixelTransformer();
Pierre Ossmanf72eb6b2011-07-15 12:34:33 +0000155
156 // FIXME: This is an ugly (temporary) hack to get around a corner
157 // case during startup. The conversion routines cannot handle
158 // non-native source formats, and we can sometimes get that
159 // as the initial format. We will switch to a better format
160 // before getting any updates, but we need something for now.
161 // Our old client used something completely bogus and just
162 // hoped nothing would ever go wrong. We try to at least match
163 // the pixel size so that we don't get any memory access issues
164 // should a stray update appear.
165 static rdr::U32 endianTest = 1;
166 static bool nativeBigEndian = *(rdr::U8*)(&endianTest) != 1;
167 if ((pf.bpp > 8) && (pf.bigEndian != nativeBigEndian)) {
168 PixelFormat fake_pf(pf.bpp, pf.depth, nativeBigEndian, pf.trueColour,
169 pf.redMax, pf.greenMax, pf.blueMax,
170 pf.redShift, pf.greenShift, pf.blueShift);
171 pixelTrans->init(fake_pf, &colourMap, getPreferredPF());
172 return;
173 }
174
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000175 pixelTrans->init(pf, &colourMap, getPreferredPF());
176}
177
178
179const rfb::PixelFormat &Viewport::getPreferredPF()
180{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000181 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000182}
183
184
185// setColourMapEntries() changes some of the entries in the colourmap.
Pierre Ossmanf3505452011-07-15 08:11:55 +0000186// We don't actually act on these changes until we need to. This is
187// because recalculating the internal translation table can be expensive.
188// This also solves the issue of silly servers sending colour maps in
189// multiple pieces.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000190void Viewport::setColourMapEntries(int firstColour, int nColours,
191 rdr::U16* rgbs)
192{
193 for (int i = 0; i < nColours; i++)
194 colourMap.set(firstColour+i, rgbs[i*3], rgbs[i*3+1], rgbs[i*3+2]);
195
Pierre Ossmanf3505452011-07-15 08:11:55 +0000196 colourMapChange = true;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000197}
198
199
200// Copy the areas of the framebuffer that have been changed (damaged)
201// to the displayed window.
202
203void Viewport::updateWindow()
204{
205 Rect r;
206
207 Fl::remove_timeout(handleUpdateTimeout, this);
208
209 r = damage.get_bounding_rect();
Pierre Ossmana6e20772011-04-15 11:10:52 +0000210 Fl_Widget::damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height());
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000211
212 damage.clear();
213}
214
Pierre Ossmanf741d342011-06-09 08:32:49 +0000215#ifdef HAVE_FLTK_CURSOR
216static const char * dotcursor_xpm[] = {
217 "5 5 2 1",
218 ". c #000000",
219 " c #FFFFFF",
220 " ",
221 " ... ",
222 " ... ",
223 " ... ",
224 " "};
225#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000226
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000227void Viewport::setCursor(int width, int height, const Point& hotspot,
228 void* data, void* mask)
229{
230#ifdef HAVE_FLTK_CURSOR
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000231 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000232 if (!cursor->alloc_array)
233 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000234 delete cursor;
235 }
236
Pierre Ossmanf741d342011-06-09 08:32:49 +0000237 int mask_len = ((width+7)/8) * height;
238 int i;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000239
Pierre Ossmanf741d342011-06-09 08:32:49 +0000240 for (i = 0; i < mask_len; i++)
241 if (((rdr::U8*)mask)[i]) break;
242
Pierre Ossmana51574a2011-06-09 08:39:35 +0000243 if ((i == mask_len) && dotWhenNoCursor) {
244 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000245
246 Fl_Pixmap pxm(dotcursor_xpm);
247 cursor = new Fl_RGB_Image(&pxm);
248 cursorHotspot.x = cursorHotspot.y = 2;
249 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000250 if ((width == 0) || (height == 0)) {
251 U8 *buffer = new U8[4];
252 memset(buffer, 0, 4);
253 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
254 cursorHotspot.x = cursorHotspot.y = 0;
255 } else {
256 U8 *buffer = new U8[width*height*4];
257 U8 *i, *o, *m;
258 int m_width;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000259
Pierre Ossmand8f84872011-07-15 08:26:51 +0000260 const PixelFormat *pf;
261
262 if (pixelTrans)
263 pf = &pixelTrans->getInPF();
264 else
265 pf = &frameBuffer->getPF();
Pierre Ossmanf741d342011-06-09 08:32:49 +0000266
Pierre Ossman17a48f02011-06-09 08:42:04 +0000267 i = (U8*)data;
268 o = buffer;
269 m = (U8*)mask;
270 m_width = (width+7)/8;
271 for (int y = 0;y < height;y++) {
272 for (int x = 0;x < width;x++) {
Pierre Ossmand8f84872011-07-15 08:26:51 +0000273 pf->rgbFromBuffer(o, i, 1, &colourMap);
Pierre Ossmanf741d342011-06-09 08:32:49 +0000274
Pierre Ossman17a48f02011-06-09 08:42:04 +0000275 if (m[(m_width*y)+(x/8)] & 0x80>>(x%8))
276 o[3] = 255;
277 else
278 o[3] = 0;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000279
Pierre Ossman17a48f02011-06-09 08:42:04 +0000280 o += 4;
Pierre Ossmand8f84872011-07-15 08:26:51 +0000281 i += pf->bpp/8;
Pierre Ossman17a48f02011-06-09 08:42:04 +0000282 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000283 }
Pierre Ossman17a48f02011-06-09 08:42:04 +0000284
285 cursor = new Fl_RGB_Image(buffer, width, height, 4);
286
287 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000288 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000289 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000290
291 if (Fl::belowmouse() == this)
292 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
293#endif
294}
295
296
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000297void Viewport::draw()
298{
299 int X, Y, W, H;
300
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000301 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000302 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000303 if ((W == 0) || (H == 0))
304 return;
305
Pierre Ossman132b3d02011-06-13 11:19:32 +0000306 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000307}
308
309
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000310void Viewport::resize(int x, int y, int w, int h)
311{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000312 PlatformPixelBuffer* newBuffer;
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000313 rfb::Rect rect;
314
Pierre Ossman132b3d02011-06-13 11:19:32 +0000315 // FIXME: Resize should probably be a feature of the pixel buffer itself
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000316
317 if ((w == frameBuffer->width()) && (h == frameBuffer->height()))
318 goto end;
319
Pierre Ossmana23989b2012-07-04 11:10:46 +0000320 vlog.debug("Resizing framebuffer from %dx%d to %dx%d",
Pierre Ossman773125e2011-07-15 13:41:02 +0000321 frameBuffer->width(), frameBuffer->height(), w, h);
322
Pierre Ossman132b3d02011-06-13 11:19:32 +0000323 newBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000324 assert(newBuffer);
325
326 rect.setXYWH(0, 0,
327 __rfbmin(newBuffer->width(), frameBuffer->width()),
328 __rfbmin(newBuffer->height(), frameBuffer->height()));
329 newBuffer->imageRect(rect, frameBuffer->data, frameBuffer->getStride());
330
331 // Black out any new areas
332
333 if (newBuffer->width() > frameBuffer->width()) {
334 rect.setXYWH(frameBuffer->width(), 0,
335 newBuffer->width() - frameBuffer->width(),
336 newBuffer->height());
337 newBuffer->fillRect(rect, 0);
338 }
339
340 if (newBuffer->height() > frameBuffer->height()) {
341 rect.setXYWH(0, frameBuffer->height(),
342 newBuffer->width(),
343 newBuffer->height() - frameBuffer->height());
344 newBuffer->fillRect(rect, 0);
345 }
346
347 delete frameBuffer;
348 frameBuffer = newBuffer;
349
350end:
351 Fl_Widget::resize(x, y, w, h);
352}
353
354
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000355int Viewport::handle(int event)
356{
Pierre Ossman689c4582011-05-26 15:39:41 +0000357 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000358 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000359 int buttonMask, wheelMask;
360 DownMap::const_iterator iter;
361
362 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000363 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000364 buffer = new char[Fl::event_length() + 1];
365
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000366 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000367 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
368 Fl::event_length() + 1);
369 assert(ret < (Fl::event_length() + 1));
370
Pierre Ossman5803d3b2013-09-05 14:25:40 +0000371 vlog.debug("Sending clipboard data (%d bytes)", strlen(buffer));
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000372
373 try {
374 cc->writer()->clientCutText(buffer, ret);
375 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000376 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000377 exit_vncviewer(e.str());
378 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000379
380 delete [] buffer;
381
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000382 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000383
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000384 case FL_ENTER:
385 // Yes, we would like some pointer events please!
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000386#ifdef HAVE_FLTK_CURSOR
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000387 if (cursor)
388 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000389#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000390 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000391
392 case FL_LEAVE:
393#ifdef HAVE_FLTK_CURSOR
394 window()->cursor(FL_CURSOR_DEFAULT);
395#endif
Pierre Ossman164865a2011-11-10 13:30:39 +0000396 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000397 case FL_PUSH:
398 case FL_RELEASE:
399 case FL_DRAG:
400 case FL_MOVE:
401 case FL_MOUSEWHEEL:
402 buttonMask = 0;
403 if (Fl::event_button1())
404 buttonMask |= 1;
405 if (Fl::event_button2())
406 buttonMask |= 2;
407 if (Fl::event_button3())
408 buttonMask |= 4;
409
410 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000411 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000412 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000413 wheelMask |= 8;
414 if (Fl::event_dy() > 0)
415 wheelMask |= 16;
416 if (Fl::event_dx() < 0)
417 wheelMask |= 32;
418 if (Fl::event_dx() > 0)
419 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000420
421 // A quick press of the wheel "button", followed by a immediate
422 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000423 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000424 buttonMask | wheelMask);
425 }
426
Pierre Ossman6a464be2011-04-15 12:57:31 +0000427 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000428 return 1;
429
430 case FL_FOCUS:
431 // Yes, we would like some focus please!
432 return 1;
433
434 case FL_UNFOCUS:
435 // Release all keys that were pressed as that generally makes most
436 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000437 while (!downKeySym.empty())
438 handleKeyEvent(downKeySym.begin()->first, downKeySym.begin()->first,
439 "", false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000440 return 1;
441
442 case FL_KEYDOWN:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000443 if (menuKeyCode && (Fl::event_key() == menuKeyCode)) {
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000444 popupContextMenu();
445 return 1;
446 }
447
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000448 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
449 Fl::event_text(), true);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000450 return 1;
451
452 case FL_KEYUP:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000453 if (menuKeyCode && (Fl::event_key() == menuKeyCode))
454 return 1;
455
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000456 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
457 Fl::event_text(), false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000458 return 1;
459 }
460
461 return Fl_Widget::handle(event);
462}
463
464
465void Viewport::handleUpdateTimeout(void *data)
466{
467 Viewport *self = (Viewport *)data;
468
469 assert(self);
470
471 self->updateWindow();
472}
473
474
Pierre Ossmanf3505452011-07-15 08:11:55 +0000475void Viewport::commitColourMap()
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000476{
Pierre Ossmanf3505452011-07-15 08:11:55 +0000477 if (pixelTrans == NULL)
478 return;
479 if (!colourMapChange)
480 return;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000481
Pierre Ossmanf3505452011-07-15 08:11:55 +0000482 colourMapChange = false;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000483
Pierre Ossmanf3505452011-07-15 08:11:55 +0000484 pixelTrans->setColourMapEntries(0, 0);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000485}
486
487
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000488void Viewport::handleClipboardChange(int source, void *data)
489{
490 Viewport *self = (Viewport *)data;
491
492 assert(self);
493
494 if (!sendPrimary && (source == 0))
495 return;
496
497 Fl::paste(*self, source);
498}
499
500
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000501void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
502{
503 if (!viewOnly) {
504 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000505 try {
506 cc->writer()->pointerEvent(pos, buttonMask);
507 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000508 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000509 exit_vncviewer(e.str());
510 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000511 } else {
512 if (!Fl::has_timeout(handlePointerTimeout, this))
513 Fl::add_timeout((double)pointerEventInterval/1000.0,
514 handlePointerTimeout, this);
515 }
516 lastPointerPos = pos;
517 lastButtonMask = buttonMask;
518 }
519}
520
521
522void Viewport::handlePointerTimeout(void *data)
523{
524 Viewport *self = (Viewport *)data;
525
526 assert(self);
527
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000528 try {
529 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
530 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000531 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000532 exit_vncviewer(e.str());
533 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000534}
535
536
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000537rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *keyText)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000538{
539 unsigned ucs;
540
541 // First check for function keys
542 if ((keyCode > FL_F) && (keyCode <= FL_F_Last))
543 return XK_F1 + (keyCode - FL_F - 1);
544
545 // Numpad numbers
546 if ((keyCode >= (FL_KP + '0')) && (keyCode <= (FL_KP + '9')))
547 return XK_KP_0 + (keyCode - (FL_KP + '0'));
548
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000549 // FLTK does some special remapping of numpad keys when numlock is off
550 if ((origKeyCode >= FL_KP) && (origKeyCode <= FL_KP_Last)) {
551 switch (keyCode) {
552 case FL_F+1:
553 return XK_KP_F1;
554 case FL_F+2:
555 return XK_KP_F2;
556 case FL_F+3:
557 return XK_KP_F3;
558 case FL_F+4:
559 return XK_KP_F4;
560 case FL_Home:
561 return XK_KP_Home;
562 case FL_Left:
563 return XK_KP_Left;
564 case FL_Up:
565 return XK_KP_Up;
566 case FL_Right:
567 return XK_KP_Right;
568 case FL_Down:
569 return XK_KP_Down;
570 case FL_Page_Up:
571 return XK_KP_Page_Up;
572 case FL_Page_Down:
573 return XK_KP_Page_Down;
574 case FL_End:
575 return XK_KP_End;
576 case FL_Insert:
577 return XK_KP_Insert;
578 case FL_Delete:
579 return XK_KP_Delete;
580 }
581 }
582
Pierre Ossmanaa336be2011-07-14 13:35:48 +0000583#ifdef __APPLE__
584 // Alt on OS X behaves more like AltGr on other systems, and to get
585 // sane behaviour we should translate things in that manner for the
586 // remote VNC server. However that means we lose the ability to use
587 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
588 // left command key as an Alt replacement.
589 switch (keyCode) {
590 case FL_Meta_L:
591 return XK_Alt_L;
592 case FL_Meta_R:
593 return XK_Super_L;
594 case FL_Alt_L:
595 case FL_Alt_R:
596 return XK_ISO_Level3_Shift;
597 }
598#endif
599
Pierre Ossman159cb832013-05-29 12:33:59 +0000600#if defined(WIN32) || defined(__APPLE__)
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000601 // X11 fairly consistently uses XK_KP_Separator for comma and
Pierre Ossman159cb832013-05-29 12:33:59 +0000602 // XK_KP_Decimal for period. Windows and OS X are a different matter
603 // though.
604 //
605 // OS X will consistently generate the same key code no matter what
606 // layout is being used.
607 //
608 // Windows is terribly inconcistent, and is not something that's
609 // likely to change:
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000610 // http://blogs.msdn.com/michkap/archive/2006/09/13/752377.aspx
Pierre Ossman159cb832013-05-29 12:33:59 +0000611 //
612 // To get X11 behaviour, we instead look at the text generated by
613 // they key.
Pierre Ossman7e8ace12013-04-16 11:56:29 +0000614 if ((keyCode == (FL_KP + ',')) || (keyCode == (FL_KP + '.'))) {
615 switch (keyText[0]) {
616 case ',':
617 return XK_KP_Separator;
618 case '.':
619 return XK_KP_Decimal;
620 default:
621 vlog.error(_("Unknown decimal separator: '%s'"), keyText);
622 return XK_KP_Decimal;
623 }
624 }
625#endif
626
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000627 // Then other special keys
628 switch (keyCode) {
629 case FL_BackSpace:
630 return XK_BackSpace;
631 case FL_Tab:
632 return XK_Tab;
633 case FL_Enter:
634 return XK_Return;
635 case FL_Pause:
636 return XK_Pause;
637 case FL_Scroll_Lock:
638 return XK_Scroll_Lock;
639 case FL_Escape:
640 return XK_Escape;
641 case FL_Home:
642 return XK_Home;
643 case FL_Left:
644 return XK_Left;
645 case FL_Up:
646 return XK_Up;
647 case FL_Right:
648 return XK_Right;
649 case FL_Down:
650 return XK_Down;
651 case FL_Page_Up:
652 return XK_Page_Up;
653 case FL_Page_Down:
654 return XK_Page_Down;
655 case FL_End:
656 return XK_End;
657 case FL_Print:
658 return XK_Print;
659 case FL_Insert:
660 return XK_Insert;
661 case FL_Menu:
662 return XK_Menu;
663 case FL_Help:
664 return XK_Help;
665 case FL_Num_Lock:
666 return XK_Num_Lock;
667 case FL_Shift_L:
668 return XK_Shift_L;
669 case FL_Shift_R:
670 return XK_Shift_R;
671 case FL_Control_L:
672 return XK_Control_L;
673 case FL_Control_R:
674 return XK_Control_R;
675 case FL_Caps_Lock:
676 return XK_Caps_Lock;
677 case FL_Meta_L:
678 return XK_Super_L;
679 case FL_Meta_R:
680 return XK_Super_R;
681 case FL_Alt_L:
682 return XK_Alt_L;
683 case FL_Alt_R:
684 return XK_Alt_R;
685 case FL_Delete:
686 return XK_Delete;
687 case FL_KP_Enter:
688 return XK_KP_Enter;
689 case FL_KP + '=':
690 return XK_KP_Equal;
691 case FL_KP + '*':
692 return XK_KP_Multiply;
693 case FL_KP + '+':
694 return XK_KP_Add;
695 case FL_KP + ',':
696 return XK_KP_Separator;
697 case FL_KP + '-':
698 return XK_KP_Subtract;
699 case FL_KP + '.':
700 return XK_KP_Decimal;
701 case FL_KP + '/':
702 return XK_KP_Divide;
Pierre Ossmancb0cffe2011-05-20 14:55:10 +0000703#ifdef HAVE_FLTK_MEDIAKEYS
704 case FL_Volume_Down:
705 return XF86XK_AudioLowerVolume;
706 case FL_Volume_Mute:
707 return XF86XK_AudioMute;
708 case FL_Volume_Up:
709 return XF86XK_AudioRaiseVolume;
710 case FL_Media_Play:
711 return XF86XK_AudioPlay;
712 case FL_Media_Stop:
713 return XF86XK_AudioStop;
714 case FL_Media_Prev:
715 return XF86XK_AudioPrev;
716 case FL_Media_Next:
717 return XF86XK_AudioNext;
718 case FL_Home_Page:
719 return XF86XK_HomePage;
720 case FL_Mail:
721 return XF86XK_Mail;
722 case FL_Search:
723 return XF86XK_Search;
724 case FL_Back:
725 return XF86XK_Back;
726 case FL_Forward:
727 return XF86XK_Forward;
728 case FL_Stop:
729 return XF86XK_Stop;
730 case FL_Refresh:
731 return XF86XK_Refresh;
732 case FL_Sleep:
733 return XF86XK_Sleep;
734 case FL_Favorites:
735 return XF86XK_Favorites;
736#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000737 case XK_ISO_Level3_Shift:
738 // FLTK tends to let this one leak through on X11...
739 return XK_ISO_Level3_Shift;
Pierre Ossmana75f8f82011-04-29 11:12:02 +0000740 case XK_Multi_key:
741 // Same for this...
742 return XK_Multi_key;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000743 }
744
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000745 // Unknown special key?
746 if (keyText[0] == '\0') {
747 vlog.error(_("Unknown FLTK key code %d (0x%04x)"), keyCode, keyCode);
748 return XK_VoidSymbol;
749 }
750
751 // Look up the symbol the key produces and translate that from Unicode
752 // to a X11 keysym.
753 if (fl_utf_nb_char((const unsigned char*)keyText, strlen(keyText)) != 1) {
754 vlog.error(_("Multiple characters given for key code %d (0x%04x): '%s'"),
755 keyCode, keyCode, keyText);
756 return XK_VoidSymbol;
757 }
758
759 ucs = fl_utf8decode(keyText, NULL, NULL);
760 return ucs2keysym(ucs);
761}
762
763
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000764void Viewport::handleKeyEvent(int keyCode, int origKeyCode, const char *keyText, bool down)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000765{
766 rdr::U32 keySym;
767
768 if (viewOnly)
769 return;
770
771 // Because of the way keyboards work, we cannot expect to have the same
772 // symbol on release as when pressed. This breaks the VNC protocol however,
773 // so we need to keep track of what keysym a key _code_ generated on press
774 // and send the same on release.
775 if (!down) {
776 DownMap::iterator iter;
777
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000778 iter = downKeySym.find(origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000779 if (iter == downKeySym.end()) {
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000780 vlog.error(_("Unexpected release of FLTK key code %d (0x%04x)"),
781 origKeyCode, origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000782 return;
783 }
784
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000785 vlog.debug("Key released: 0x%04x => 0x%04x", origKeyCode, iter->second);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000786
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000787 try {
788 cc->writer()->keyEvent(iter->second, false);
789 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000790 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000791 exit_vncviewer(e.str());
792 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000793
794 downKeySym.erase(iter);
795
796 return;
797 }
798
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000799 keySym = translateKeyEvent(keyCode, origKeyCode, keyText);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000800 if (keySym == XK_VoidSymbol)
801 return;
802
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000803#ifdef WIN32
804 // Ugly hack alert!
805 //
806 // Windows doesn't have a proper AltGr, but handles it using fake
807 // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
808 // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
809 // get everything in the correct state. Cheat and temporarily release
810 // Ctrl and Alt whenever we get a key with a symbol.
811 bool need_cheat = true;
812
813 if (keyText[0] == '\0')
814 need_cheat = false;
815 else if ((downKeySym.find(FL_Control_L) == downKeySym.end()) &&
816 (downKeySym.find(FL_Control_R) == downKeySym.end()))
817 need_cheat = false;
818 else if ((downKeySym.find(FL_Alt_L) == downKeySym.end()) &&
819 (downKeySym.find(FL_Alt_R) == downKeySym.end()))
820 need_cheat = false;
821
822 if (need_cheat) {
823 vlog.debug("Faking release of AltGr (Ctrl+Alt)");
824 try {
825 if (downKeySym.find(FL_Control_L) != downKeySym.end())
826 cc->writer()->keyEvent(XK_Control_L, false);
827 if (downKeySym.find(FL_Control_R) != downKeySym.end())
828 cc->writer()->keyEvent(XK_Control_R, false);
829 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
830 cc->writer()->keyEvent(XK_Alt_L, false);
831 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
832 cc->writer()->keyEvent(XK_Alt_R, false);
833 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000834 vlog.error("%s", e.str());
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000835 exit_vncviewer(e.str());
836 }
837 }
838#endif
839
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000840 vlog.debug("Key pressed: 0x%04x (0x%04x) '%s' => 0x%04x",
841 origKeyCode, keyCode, keyText, keySym);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000842
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000843 downKeySym[origKeyCode] = keySym;
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000844
845 try {
846 cc->writer()->keyEvent(keySym, down);
847 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000848 vlog.error("%s", e.str());
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000849 exit_vncviewer(e.str());
850 }
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000851
852#ifdef WIN32
853 // Ugly hack continued...
854 if (need_cheat) {
855 vlog.debug("Restoring AltGr state");
856 try {
857 if (downKeySym.find(FL_Control_L) != downKeySym.end())
858 cc->writer()->keyEvent(XK_Control_L, true);
859 if (downKeySym.find(FL_Control_R) != downKeySym.end())
860 cc->writer()->keyEvent(XK_Control_R, true);
861 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
862 cc->writer()->keyEvent(XK_Alt_L, true);
863 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
864 cc->writer()->keyEvent(XK_Alt_R, true);
865 } catch (rdr::Exception& e) {
866 vlog.error(e.str());
867 exit_vncviewer(e.str());
868 }
869 }
870#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000871}
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000872
873
874void Viewport::initContextMenu()
875{
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000876 contextMenu->clear();
877
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000878 contextMenu->add(_("Exit viewer"), 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
879
Pierre Ossman4c613d32011-05-26 14:14:06 +0000880#ifdef HAVE_FLTK_FULLSCREEN
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000881 contextMenu->add(_("Full screen"), 0, NULL, (void*)ID_FULLSCREEN,
882 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossman4c613d32011-05-26 14:14:06 +0000883#endif
Pierre Ossman8dc8bca2012-07-04 11:37:10 +0000884 contextMenu->add(_("Resize window to session"), 0, NULL, (void*)ID_RESIZE,
885#ifdef HAVE_FLTK_FULLSCREEN
886 (window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
887#endif
888 FL_MENU_DIVIDER);
Pierre Ossman4c613d32011-05-26 14:14:06 +0000889
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000890 contextMenu->add(_("Ctrl"), 0, NULL, (void*)ID_CTRL,
891 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
892 contextMenu->add(_("Alt"), 0, NULL, (void*)ID_ALT,
893 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000894
895 if (menuKeyCode) {
896 char sendMenuKey[64];
897 snprintf(sendMenuKey, 64, _("Send %s"), (const char *)menuKey);
898 contextMenu->add(sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
899 contextMenu->add("Secret shortcut menu key", menuKeyCode, NULL, (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
900 }
901
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000902 contextMenu->add(_("Send Ctrl-Alt-Del"), 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
903
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000904 contextMenu->add(_("Refresh screen"), 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
905
Pierre Ossmand463b572011-05-16 12:04:43 +0000906 contextMenu->add(_("Options..."), 0, NULL, (void*)ID_OPTIONS, 0);
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000907 contextMenu->add(_("Connection info..."), 0, NULL, (void*)ID_INFO, 0);
Pierre Ossmanb8858222011-04-29 11:51:38 +0000908 contextMenu->add(_("About TigerVNC viewer..."), 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
909
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000910 contextMenu->add(_("Dismiss menu"), 0, NULL, (void*)ID_DISMISS, 0);
911}
912
913
914void Viewport::popupContextMenu()
915{
916 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000917 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000918
Pierre Ossmanb3ff4372011-06-03 11:45:15 +0000919 // Make sure the menu is reset to its initial state between goes or
920 // it will start up highlighting the previously selected entry.
921 contextMenu->value(-1);
922
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000923 // initialize context menu before display
924 initContextMenu();
925
Pierre Ossmanfd177f32012-01-05 12:37:04 +0000926 // Unfortunately FLTK doesn't reliably restore the mouse pointer for
927 // menus, so we have to help it out.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +0000928#ifdef HAVE_FLTK_CURSOR
929 if (Fl::belowmouse() == this)
930 window()->cursor(FL_CURSOR_DEFAULT);
931#endif
932
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000933 m = contextMenu->popup();
Pierre Ossmanbfbdb102012-01-05 12:32:03 +0000934
Pierre Ossmanfd177f32012-01-05 12:37:04 +0000935 // Back to our proper mouse pointer.
Pierre Ossmanbfbdb102012-01-05 12:32:03 +0000936#ifdef HAVE_FLTK_CURSOR
Pierre Ossmande1a3b92014-03-17 14:29:49 +0100937 if ((Fl::belowmouse() == this) && cursor)
Pierre Ossmanbfbdb102012-01-05 12:32:03 +0000938 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
939#endif
940
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000941 if (m == NULL)
942 return;
943
944 switch (m->argument()) {
945 case ID_EXIT:
946 exit_vncviewer();
947 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +0000948#ifdef HAVE_FLTK_FULLSCREEN
949 case ID_FULLSCREEN:
950 if (window()->fullscreen_active())
951 window()->fullscreen_off();
Pierre Ossman275284f2012-07-04 11:37:48 +0000952 else
Pierre Ossmanaae38912012-07-13 11:22:55 +0000953 ((DesktopWindow*)window())->fullscreen_on();
Pierre Ossman4c613d32011-05-26 14:14:06 +0000954 break;
955#endif
Pierre Ossman8dc8bca2012-07-04 11:37:10 +0000956 case ID_RESIZE:
957#ifdef HAVE_FLTK_FULLSCREEN
958 if (window()->fullscreen_active())
959 break;
960#endif
961 window()->size(w(), h());
962 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000963 case ID_CTRL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000964 handleKeyEvent(FL_Control_L, FL_Control_L, "", m->value());
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000965 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000966 break;
967 case ID_ALT:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000968 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", m->value());
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000969 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000970 break;
971 case ID_MENUKEY:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000972 handleKeyEvent(menuKeyCode, menuKeyCode, "", true);
973 handleKeyEvent(menuKeyCode, menuKeyCode, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000974 break;
975 case ID_CTRLALTDEL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000976 handleKeyEvent(FL_Control_L, FL_Control_L, "", true);
977 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", true);
978 handleKeyEvent(FL_Delete, FL_Delete, "", true);
979
980 handleKeyEvent(FL_Delete, FL_Delete, "", false);
981 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", false);
982 handleKeyEvent(FL_Control_L, FL_Control_L, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000983 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000984 case ID_REFRESH:
985 cc->refreshFramebuffer();
986 break;
Pierre Ossmand463b572011-05-16 12:04:43 +0000987 case ID_OPTIONS:
988 OptionsDialog::showDialog();
989 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000990 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000991 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
992 fl_message_title(_("VNC connection info"));
Pierre Ossmanf52740e2012-04-25 15:43:56 +0000993 fl_message("%s", buffer);
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000994 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000995 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +0000996 case ID_ABOUT:
997 about_vncviewer();
998 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000999 case ID_DISMISS:
1000 // Don't need to do anything
1001 break;
1002 }
1003}
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001004
1005
1006void Viewport::setMenuKey()
1007{
Martin Koegler498ef462011-09-04 07:04:43 +00001008 menuKeyCode = getMenuKeyCode();
Pierre Ossman4e7271e2011-05-24 12:47:12 +00001009}
1010
1011
1012void Viewport::handleOptions(void *data)
1013{
1014 Viewport *self = (Viewport*)data;
1015
1016 self->setMenuKey();
1017}