blob: 0936a632e9133c128250e349fb4a1c291b54dd0d [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
20#include <assert.h>
21#include <stdio.h>
22#include <string.h>
23
Pierre Ossmand50b3d12011-04-15 07:46:56 +000024#include <rfb/CMsgWriter.h>
25#include <rfb/LogWriter.h>
26
27// FLTK can pull in the X11 headers on some systems
28#ifndef XK_VoidSymbol
29#define XK_MISCELLANY
30#define XK_XKB_KEYS
31#include <rfb/keysymdef.h>
32#endif
33
Pierre Ossmancb0cffe2011-05-20 14:55:10 +000034#ifndef XF86XK_ModeLock
35#include <rfb/XF86keysym.h>
36#endif
37
Pierre Ossmand50b3d12011-04-15 07:46:56 +000038#include "Viewport.h"
39#include "CConn.h"
Pierre Ossmand463b572011-05-16 12:04:43 +000040#include "OptionsDialog.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000041#include "i18n.h"
Pierre Ossmanc628ba42011-05-23 12:21:21 +000042#include "fltk_layout.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000043#include "parameters.h"
44#include "keysym2ucs.h"
Pierre Ossman39ceb502011-07-12 15:54:25 +000045#include "vncviewer.h"
Pierre Ossmand50b3d12011-04-15 07:46:56 +000046
DRCb65bb932011-06-24 03:17:00 +000047#include <FL/fl_draw.H>
48#include <FL/fl_ask.H>
49
50#ifdef WIN32
51#include "win32.h"
52#endif
53
Pierre Ossmand50b3d12011-04-15 07:46:56 +000054using namespace rfb;
Pierre Ossman835b4ef2011-06-08 17:02:36 +000055using namespace rdr;
Pierre Ossmand50b3d12011-04-15 07:46:56 +000056
Pierre Ossmand50b3d12011-04-15 07:46:56 +000057static rfb::LogWriter vlog("Viewport");
58
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000059// Menu constants
60
Pierre Ossman4c613d32011-05-26 14:14:06 +000061enum { ID_EXIT, ID_FULLSCREEN, ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
Pierre Ossman2eb1d112011-05-16 12:18:08 +000062 ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS };
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000063
Pierre Ossmand50b3d12011-04-15 07:46:56 +000064Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_)
65 : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL), pixelTrans(NULL),
Pierre Ossmanf3505452011-07-15 08:11:55 +000066 colourMapChange(false), lastPointerPos(0, 0), lastButtonMask(0),
67 cursor(NULL)
Pierre Ossmand50b3d12011-04-15 07:46:56 +000068{
Pierre Ossmanf8c5ef62011-05-13 12:47:54 +000069// FLTK STR #2599 must be fixed for proper dead keys support
70#ifdef HAVE_FLTK_DEAD_KEYS
71 set_simple_keyboard();
72#endif
73
Pierre Ossman4a6be4a2011-05-19 14:49:18 +000074// FLTK STR #2636 gives us the ability to monitor clipboard changes
75#ifdef HAVE_FLTK_CLIPBOARD
76 Fl::add_clipboard_notify(handleClipboardChange, this);
77#endif
78
Pierre Ossman132b3d02011-06-13 11:19:32 +000079 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +000080 assert(frameBuffer);
81
82 setServerPF(serverPF);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000083
84 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +000085 // Setting box type to FL_NO_BOX prevents it from trying to draw the
86 // button component (which we don't want)
87 contextMenu->box(FL_NO_BOX);
88
Pierre Ossmanb043ad12011-06-01 09:26:57 +000089 // The (invisible) button associated with this widget can mess with
90 // things like Fl_Scroll so we need to get rid of any parents.
91 // Unfortunately that's not possible because of STR #2654, but
92 // reparenting to the current window works for most cases.
93 window()->add(contextMenu);
94
Pierre Ossman4e7271e2011-05-24 12:47:12 +000095 setMenuKey();
Peter Åstrand086359c2011-06-23 08:40:14 +000096 initContextMenu();
Pierre Ossman4e7271e2011-05-24 12:47:12 +000097
98 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +000099}
100
101
102Viewport::~Viewport()
103{
104 // Unregister all timeouts in case they get a change tro trigger
105 // again later when this object is already gone.
106 Fl::remove_timeout(handleUpdateTimeout, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000107 Fl::remove_timeout(handlePointerTimeout, this);
108
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000109#ifdef HAVE_FLTK_CLIPBOARD
110 Fl::remove_clipboard_notify(handleClipboardChange);
111#endif
112
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000113 OptionsDialog::removeCallback(handleOptions);
114
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000115 delete frameBuffer;
116
117 if (pixelTrans)
118 delete pixelTrans;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000119
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000120 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000121 if (!cursor->alloc_array)
122 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000123 delete cursor;
124 }
125
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000126 // FLTK automatically deletes all child widgets, so we shouldn't touch
127 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000128}
129
130
131void Viewport::setServerPF(const rfb::PixelFormat& pf)
132{
133 if (pixelTrans)
134 delete pixelTrans;
135 pixelTrans = NULL;
136
137 if (pf.equal(getPreferredPF()))
138 return;
139
140 pixelTrans = new PixelTransformer();
Pierre Ossmanf72eb6b2011-07-15 12:34:33 +0000141
142 // FIXME: This is an ugly (temporary) hack to get around a corner
143 // case during startup. The conversion routines cannot handle
144 // non-native source formats, and we can sometimes get that
145 // as the initial format. We will switch to a better format
146 // before getting any updates, but we need something for now.
147 // Our old client used something completely bogus and just
148 // hoped nothing would ever go wrong. We try to at least match
149 // the pixel size so that we don't get any memory access issues
150 // should a stray update appear.
151 static rdr::U32 endianTest = 1;
152 static bool nativeBigEndian = *(rdr::U8*)(&endianTest) != 1;
153 if ((pf.bpp > 8) && (pf.bigEndian != nativeBigEndian)) {
154 PixelFormat fake_pf(pf.bpp, pf.depth, nativeBigEndian, pf.trueColour,
155 pf.redMax, pf.greenMax, pf.blueMax,
156 pf.redShift, pf.greenShift, pf.blueShift);
157 pixelTrans->init(fake_pf, &colourMap, getPreferredPF());
158 return;
159 }
160
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000161 pixelTrans->init(pf, &colourMap, getPreferredPF());
162}
163
164
165const rfb::PixelFormat &Viewport::getPreferredPF()
166{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000167 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000168}
169
170
171// setColourMapEntries() changes some of the entries in the colourmap.
Pierre Ossmanf3505452011-07-15 08:11:55 +0000172// We don't actually act on these changes until we need to. This is
173// because recalculating the internal translation table can be expensive.
174// This also solves the issue of silly servers sending colour maps in
175// multiple pieces.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000176void Viewport::setColourMapEntries(int firstColour, int nColours,
177 rdr::U16* rgbs)
178{
179 for (int i = 0; i < nColours; i++)
180 colourMap.set(firstColour+i, rgbs[i*3], rgbs[i*3+1], rgbs[i*3+2]);
181
Pierre Ossmanf3505452011-07-15 08:11:55 +0000182 colourMapChange = true;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000183}
184
185
186// Copy the areas of the framebuffer that have been changed (damaged)
187// to the displayed window.
188
189void Viewport::updateWindow()
190{
191 Rect r;
192
193 Fl::remove_timeout(handleUpdateTimeout, this);
194
195 r = damage.get_bounding_rect();
Pierre Ossmana6e20772011-04-15 11:10:52 +0000196 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 +0000197
198 damage.clear();
199}
200
Pierre Ossmanf741d342011-06-09 08:32:49 +0000201#ifdef HAVE_FLTK_CURSOR
202static const char * dotcursor_xpm[] = {
203 "5 5 2 1",
204 ". c #000000",
205 " c #FFFFFF",
206 " ",
207 " ... ",
208 " ... ",
209 " ... ",
210 " "};
211#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000212
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000213void Viewport::setCursor(int width, int height, const Point& hotspot,
214 void* data, void* mask)
215{
216#ifdef HAVE_FLTK_CURSOR
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000217 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000218 if (!cursor->alloc_array)
219 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000220 delete cursor;
221 }
222
Pierre Ossmanf741d342011-06-09 08:32:49 +0000223 int mask_len = ((width+7)/8) * height;
224 int i;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000225
Pierre Ossmanf741d342011-06-09 08:32:49 +0000226 for (i = 0; i < mask_len; i++)
227 if (((rdr::U8*)mask)[i]) break;
228
Pierre Ossmana51574a2011-06-09 08:39:35 +0000229 if ((i == mask_len) && dotWhenNoCursor) {
230 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000231
232 Fl_Pixmap pxm(dotcursor_xpm);
233 cursor = new Fl_RGB_Image(&pxm);
234 cursorHotspot.x = cursorHotspot.y = 2;
235 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000236 if ((width == 0) || (height == 0)) {
237 U8 *buffer = new U8[4];
238 memset(buffer, 0, 4);
239 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
240 cursorHotspot.x = cursorHotspot.y = 0;
241 } else {
242 U8 *buffer = new U8[width*height*4];
243 U8 *i, *o, *m;
244 int m_width;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000245
Pierre Ossmand8f84872011-07-15 08:26:51 +0000246 const PixelFormat *pf;
247
248 if (pixelTrans)
249 pf = &pixelTrans->getInPF();
250 else
251 pf = &frameBuffer->getPF();
Pierre Ossmanf741d342011-06-09 08:32:49 +0000252
Pierre Ossman17a48f02011-06-09 08:42:04 +0000253 i = (U8*)data;
254 o = buffer;
255 m = (U8*)mask;
256 m_width = (width+7)/8;
257 for (int y = 0;y < height;y++) {
258 for (int x = 0;x < width;x++) {
Pierre Ossmand8f84872011-07-15 08:26:51 +0000259 pf->rgbFromBuffer(o, i, 1, &colourMap);
Pierre Ossmanf741d342011-06-09 08:32:49 +0000260
Pierre Ossman17a48f02011-06-09 08:42:04 +0000261 if (m[(m_width*y)+(x/8)] & 0x80>>(x%8))
262 o[3] = 255;
263 else
264 o[3] = 0;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000265
Pierre Ossman17a48f02011-06-09 08:42:04 +0000266 o += 4;
Pierre Ossmand8f84872011-07-15 08:26:51 +0000267 i += pf->bpp/8;
Pierre Ossman17a48f02011-06-09 08:42:04 +0000268 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000269 }
Pierre Ossman17a48f02011-06-09 08:42:04 +0000270
271 cursor = new Fl_RGB_Image(buffer, width, height, 4);
272
273 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000274 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000275 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000276
277 if (Fl::belowmouse() == this)
278 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
279#endif
280}
281
282
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000283void Viewport::draw()
284{
285 int X, Y, W, H;
286
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000287 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000288 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000289 if ((W == 0) || (H == 0))
290 return;
291
Pierre Ossman132b3d02011-06-13 11:19:32 +0000292 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000293}
294
295
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000296void Viewport::resize(int x, int y, int w, int h)
297{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000298 PlatformPixelBuffer* newBuffer;
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000299 rfb::Rect rect;
300
Pierre Ossman132b3d02011-06-13 11:19:32 +0000301 // FIXME: Resize should probably be a feature of the pixel buffer itself
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000302
303 if ((w == frameBuffer->width()) && (h == frameBuffer->height()))
304 goto end;
305
Pierre Ossman773125e2011-07-15 13:41:02 +0000306 vlog.debug("Resing framebuffer from %dx%d to %dx%d",
307 frameBuffer->width(), frameBuffer->height(), w, h);
308
Pierre Ossman132b3d02011-06-13 11:19:32 +0000309 newBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000310 assert(newBuffer);
311
312 rect.setXYWH(0, 0,
313 __rfbmin(newBuffer->width(), frameBuffer->width()),
314 __rfbmin(newBuffer->height(), frameBuffer->height()));
315 newBuffer->imageRect(rect, frameBuffer->data, frameBuffer->getStride());
316
317 // Black out any new areas
318
319 if (newBuffer->width() > frameBuffer->width()) {
320 rect.setXYWH(frameBuffer->width(), 0,
321 newBuffer->width() - frameBuffer->width(),
322 newBuffer->height());
323 newBuffer->fillRect(rect, 0);
324 }
325
326 if (newBuffer->height() > frameBuffer->height()) {
327 rect.setXYWH(0, frameBuffer->height(),
328 newBuffer->width(),
329 newBuffer->height() - frameBuffer->height());
330 newBuffer->fillRect(rect, 0);
331 }
332
333 delete frameBuffer;
334 frameBuffer = newBuffer;
335
336end:
337 Fl_Widget::resize(x, y, w, h);
338}
339
340
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000341int Viewport::handle(int event)
342{
Pierre Ossman689c4582011-05-26 15:39:41 +0000343 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000344 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000345 int buttonMask, wheelMask;
346 DownMap::const_iterator iter;
347
348 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000349 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000350 buffer = new char[Fl::event_length() + 1];
351
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000352 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000353 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
354 Fl::event_length() + 1);
355 assert(ret < (Fl::event_length() + 1));
356
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000357 vlog.debug("Sending clipboard data: '%s'", buffer);
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000358
359 try {
360 cc->writer()->clientCutText(buffer, ret);
361 } catch (rdr::Exception& e) {
362 vlog.error(e.str());
363 exit_vncviewer(e.str());
364 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000365
366 delete [] buffer;
367
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000368 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000369
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000370 case FL_ENTER:
371 // Yes, we would like some pointer events please!
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000372#ifdef HAVE_FLTK_CURSOR
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000373 if (cursor)
374 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000375#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000376 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000377
378 case FL_LEAVE:
379#ifdef HAVE_FLTK_CURSOR
380 window()->cursor(FL_CURSOR_DEFAULT);
381#endif
382 return 1;
383
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000384 case FL_PUSH:
385 case FL_RELEASE:
386 case FL_DRAG:
387 case FL_MOVE:
388 case FL_MOUSEWHEEL:
389 buttonMask = 0;
390 if (Fl::event_button1())
391 buttonMask |= 1;
392 if (Fl::event_button2())
393 buttonMask |= 2;
394 if (Fl::event_button3())
395 buttonMask |= 4;
396
397 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000398 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000399 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000400 wheelMask |= 8;
401 if (Fl::event_dy() > 0)
402 wheelMask |= 16;
403 if (Fl::event_dx() < 0)
404 wheelMask |= 32;
405 if (Fl::event_dx() > 0)
406 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000407
408 // A quick press of the wheel "button", followed by a immediate
409 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000410 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000411 buttonMask | wheelMask);
412 }
413
Pierre Ossman6a464be2011-04-15 12:57:31 +0000414 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000415 return 1;
416
417 case FL_FOCUS:
418 // Yes, we would like some focus please!
419 return 1;
420
421 case FL_UNFOCUS:
422 // Release all keys that were pressed as that generally makes most
423 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000424 while (!downKeySym.empty())
425 handleKeyEvent(downKeySym.begin()->first, downKeySym.begin()->first,
426 "", false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000427 return 1;
428
429 case FL_KEYDOWN:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000430 if (menuKeyCode && (Fl::event_key() == menuKeyCode)) {
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000431 popupContextMenu();
432 return 1;
433 }
434
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000435 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
436 Fl::event_text(), true);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000437 return 1;
438
439 case FL_KEYUP:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000440 if (menuKeyCode && (Fl::event_key() == menuKeyCode))
441 return 1;
442
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000443 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
444 Fl::event_text(), false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000445 return 1;
446 }
447
448 return Fl_Widget::handle(event);
449}
450
451
452void Viewport::handleUpdateTimeout(void *data)
453{
454 Viewport *self = (Viewport *)data;
455
456 assert(self);
457
458 self->updateWindow();
459}
460
461
Pierre Ossmanf3505452011-07-15 08:11:55 +0000462void Viewport::commitColourMap()
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000463{
Pierre Ossmanf3505452011-07-15 08:11:55 +0000464 if (pixelTrans == NULL)
465 return;
466 if (!colourMapChange)
467 return;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000468
Pierre Ossmanf3505452011-07-15 08:11:55 +0000469 colourMapChange = false;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000470
Pierre Ossmanf3505452011-07-15 08:11:55 +0000471 pixelTrans->setColourMapEntries(0, 0);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000472}
473
474
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000475void Viewport::handleClipboardChange(int source, void *data)
476{
477 Viewport *self = (Viewport *)data;
478
479 assert(self);
480
481 if (!sendPrimary && (source == 0))
482 return;
483
484 Fl::paste(*self, source);
485}
486
487
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000488void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
489{
490 if (!viewOnly) {
491 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000492 try {
493 cc->writer()->pointerEvent(pos, buttonMask);
494 } catch (rdr::Exception& e) {
495 vlog.error(e.str());
496 exit_vncviewer(e.str());
497 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000498 } else {
499 if (!Fl::has_timeout(handlePointerTimeout, this))
500 Fl::add_timeout((double)pointerEventInterval/1000.0,
501 handlePointerTimeout, this);
502 }
503 lastPointerPos = pos;
504 lastButtonMask = buttonMask;
505 }
506}
507
508
509void Viewport::handlePointerTimeout(void *data)
510{
511 Viewport *self = (Viewport *)data;
512
513 assert(self);
514
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000515 try {
516 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
517 } catch (rdr::Exception& e) {
518 vlog.error(e.str());
519 exit_vncviewer(e.str());
520 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000521}
522
523
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000524rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *keyText)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000525{
526 unsigned ucs;
527
528 // First check for function keys
529 if ((keyCode > FL_F) && (keyCode <= FL_F_Last))
530 return XK_F1 + (keyCode - FL_F - 1);
531
532 // Numpad numbers
533 if ((keyCode >= (FL_KP + '0')) && (keyCode <= (FL_KP + '9')))
534 return XK_KP_0 + (keyCode - (FL_KP + '0'));
535
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000536 // FLTK does some special remapping of numpad keys when numlock is off
537 if ((origKeyCode >= FL_KP) && (origKeyCode <= FL_KP_Last)) {
538 switch (keyCode) {
539 case FL_F+1:
540 return XK_KP_F1;
541 case FL_F+2:
542 return XK_KP_F2;
543 case FL_F+3:
544 return XK_KP_F3;
545 case FL_F+4:
546 return XK_KP_F4;
547 case FL_Home:
548 return XK_KP_Home;
549 case FL_Left:
550 return XK_KP_Left;
551 case FL_Up:
552 return XK_KP_Up;
553 case FL_Right:
554 return XK_KP_Right;
555 case FL_Down:
556 return XK_KP_Down;
557 case FL_Page_Up:
558 return XK_KP_Page_Up;
559 case FL_Page_Down:
560 return XK_KP_Page_Down;
561 case FL_End:
562 return XK_KP_End;
563 case FL_Insert:
564 return XK_KP_Insert;
565 case FL_Delete:
566 return XK_KP_Delete;
567 }
568 }
569
Pierre Ossmanaa336be2011-07-14 13:35:48 +0000570#ifdef __APPLE__
571 // Alt on OS X behaves more like AltGr on other systems, and to get
572 // sane behaviour we should translate things in that manner for the
573 // remote VNC server. However that means we lose the ability to use
574 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
575 // left command key as an Alt replacement.
576 switch (keyCode) {
577 case FL_Meta_L:
578 return XK_Alt_L;
579 case FL_Meta_R:
580 return XK_Super_L;
581 case FL_Alt_L:
582 case FL_Alt_R:
583 return XK_ISO_Level3_Shift;
584 }
585#endif
586
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000587 // Then other special keys
588 switch (keyCode) {
589 case FL_BackSpace:
590 return XK_BackSpace;
591 case FL_Tab:
592 return XK_Tab;
593 case FL_Enter:
594 return XK_Return;
595 case FL_Pause:
596 return XK_Pause;
597 case FL_Scroll_Lock:
598 return XK_Scroll_Lock;
599 case FL_Escape:
600 return XK_Escape;
601 case FL_Home:
602 return XK_Home;
603 case FL_Left:
604 return XK_Left;
605 case FL_Up:
606 return XK_Up;
607 case FL_Right:
608 return XK_Right;
609 case FL_Down:
610 return XK_Down;
611 case FL_Page_Up:
612 return XK_Page_Up;
613 case FL_Page_Down:
614 return XK_Page_Down;
615 case FL_End:
616 return XK_End;
617 case FL_Print:
618 return XK_Print;
619 case FL_Insert:
620 return XK_Insert;
621 case FL_Menu:
622 return XK_Menu;
623 case FL_Help:
624 return XK_Help;
625 case FL_Num_Lock:
626 return XK_Num_Lock;
627 case FL_Shift_L:
628 return XK_Shift_L;
629 case FL_Shift_R:
630 return XK_Shift_R;
631 case FL_Control_L:
632 return XK_Control_L;
633 case FL_Control_R:
634 return XK_Control_R;
635 case FL_Caps_Lock:
636 return XK_Caps_Lock;
637 case FL_Meta_L:
638 return XK_Super_L;
639 case FL_Meta_R:
640 return XK_Super_R;
641 case FL_Alt_L:
642 return XK_Alt_L;
643 case FL_Alt_R:
644 return XK_Alt_R;
645 case FL_Delete:
646 return XK_Delete;
647 case FL_KP_Enter:
648 return XK_KP_Enter;
649 case FL_KP + '=':
650 return XK_KP_Equal;
651 case FL_KP + '*':
652 return XK_KP_Multiply;
653 case FL_KP + '+':
654 return XK_KP_Add;
655 case FL_KP + ',':
656 return XK_KP_Separator;
657 case FL_KP + '-':
658 return XK_KP_Subtract;
659 case FL_KP + '.':
660 return XK_KP_Decimal;
661 case FL_KP + '/':
662 return XK_KP_Divide;
Pierre Ossmancb0cffe2011-05-20 14:55:10 +0000663#ifdef HAVE_FLTK_MEDIAKEYS
664 case FL_Volume_Down:
665 return XF86XK_AudioLowerVolume;
666 case FL_Volume_Mute:
667 return XF86XK_AudioMute;
668 case FL_Volume_Up:
669 return XF86XK_AudioRaiseVolume;
670 case FL_Media_Play:
671 return XF86XK_AudioPlay;
672 case FL_Media_Stop:
673 return XF86XK_AudioStop;
674 case FL_Media_Prev:
675 return XF86XK_AudioPrev;
676 case FL_Media_Next:
677 return XF86XK_AudioNext;
678 case FL_Home_Page:
679 return XF86XK_HomePage;
680 case FL_Mail:
681 return XF86XK_Mail;
682 case FL_Search:
683 return XF86XK_Search;
684 case FL_Back:
685 return XF86XK_Back;
686 case FL_Forward:
687 return XF86XK_Forward;
688 case FL_Stop:
689 return XF86XK_Stop;
690 case FL_Refresh:
691 return XF86XK_Refresh;
692 case FL_Sleep:
693 return XF86XK_Sleep;
694 case FL_Favorites:
695 return XF86XK_Favorites;
696#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000697 case XK_ISO_Level3_Shift:
698 // FLTK tends to let this one leak through on X11...
699 return XK_ISO_Level3_Shift;
Pierre Ossmana75f8f82011-04-29 11:12:02 +0000700 case XK_Multi_key:
701 // Same for this...
702 return XK_Multi_key;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000703 }
704
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000705 // Unknown special key?
706 if (keyText[0] == '\0') {
707 vlog.error(_("Unknown FLTK key code %d (0x%04x)"), keyCode, keyCode);
708 return XK_VoidSymbol;
709 }
710
711 // Look up the symbol the key produces and translate that from Unicode
712 // to a X11 keysym.
713 if (fl_utf_nb_char((const unsigned char*)keyText, strlen(keyText)) != 1) {
714 vlog.error(_("Multiple characters given for key code %d (0x%04x): '%s'"),
715 keyCode, keyCode, keyText);
716 return XK_VoidSymbol;
717 }
718
719 ucs = fl_utf8decode(keyText, NULL, NULL);
720 return ucs2keysym(ucs);
721}
722
723
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000724void Viewport::handleKeyEvent(int keyCode, int origKeyCode, const char *keyText, bool down)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000725{
726 rdr::U32 keySym;
727
728 if (viewOnly)
729 return;
730
731 // Because of the way keyboards work, we cannot expect to have the same
732 // symbol on release as when pressed. This breaks the VNC protocol however,
733 // so we need to keep track of what keysym a key _code_ generated on press
734 // and send the same on release.
735 if (!down) {
736 DownMap::iterator iter;
737
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000738 iter = downKeySym.find(origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000739 if (iter == downKeySym.end()) {
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000740 vlog.error(_("Unexpected release of FLTK key code %d (0x%04x)"),
741 origKeyCode, origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000742 return;
743 }
744
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000745 vlog.debug("Key released: 0x%04x => 0x%04x", origKeyCode, iter->second);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000746
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000747 try {
748 cc->writer()->keyEvent(iter->second, false);
749 } catch (rdr::Exception& e) {
750 vlog.error(e.str());
751 exit_vncviewer(e.str());
752 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000753
754 downKeySym.erase(iter);
755
756 return;
757 }
758
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000759 keySym = translateKeyEvent(keyCode, origKeyCode, keyText);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000760 if (keySym == XK_VoidSymbol)
761 return;
762
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000763#ifdef WIN32
764 // Ugly hack alert!
765 //
766 // Windows doesn't have a proper AltGr, but handles it using fake
767 // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
768 // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
769 // get everything in the correct state. Cheat and temporarily release
770 // Ctrl and Alt whenever we get a key with a symbol.
771 bool need_cheat = true;
772
773 if (keyText[0] == '\0')
774 need_cheat = false;
775 else if ((downKeySym.find(FL_Control_L) == downKeySym.end()) &&
776 (downKeySym.find(FL_Control_R) == downKeySym.end()))
777 need_cheat = false;
778 else if ((downKeySym.find(FL_Alt_L) == downKeySym.end()) &&
779 (downKeySym.find(FL_Alt_R) == downKeySym.end()))
780 need_cheat = false;
781
782 if (need_cheat) {
783 vlog.debug("Faking release of AltGr (Ctrl+Alt)");
784 try {
785 if (downKeySym.find(FL_Control_L) != downKeySym.end())
786 cc->writer()->keyEvent(XK_Control_L, false);
787 if (downKeySym.find(FL_Control_R) != downKeySym.end())
788 cc->writer()->keyEvent(XK_Control_R, false);
789 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
790 cc->writer()->keyEvent(XK_Alt_L, false);
791 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
792 cc->writer()->keyEvent(XK_Alt_R, false);
793 } catch (rdr::Exception& e) {
794 vlog.error(e.str());
795 exit_vncviewer(e.str());
796 }
797 }
798#endif
799
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000800 vlog.debug("Key pressed: 0x%04x (0x%04x) '%s' => 0x%04x",
801 origKeyCode, keyCode, keyText, keySym);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000802
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000803 downKeySym[origKeyCode] = keySym;
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000804
805 try {
806 cc->writer()->keyEvent(keySym, down);
807 } catch (rdr::Exception& e) {
808 vlog.error(e.str());
809 exit_vncviewer(e.str());
810 }
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000811
812#ifdef WIN32
813 // Ugly hack continued...
814 if (need_cheat) {
815 vlog.debug("Restoring AltGr state");
816 try {
817 if (downKeySym.find(FL_Control_L) != downKeySym.end())
818 cc->writer()->keyEvent(XK_Control_L, true);
819 if (downKeySym.find(FL_Control_R) != downKeySym.end())
820 cc->writer()->keyEvent(XK_Control_R, true);
821 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
822 cc->writer()->keyEvent(XK_Alt_L, true);
823 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
824 cc->writer()->keyEvent(XK_Alt_R, true);
825 } catch (rdr::Exception& e) {
826 vlog.error(e.str());
827 exit_vncviewer(e.str());
828 }
829 }
830#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000831}
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000832
833
834void Viewport::initContextMenu()
835{
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000836 contextMenu->clear();
837
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000838 contextMenu->add(_("Exit viewer"), 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
839
Pierre Ossman4c613d32011-05-26 14:14:06 +0000840#ifdef HAVE_FLTK_FULLSCREEN
841 contextMenu->add(_("Full screen"), 0, NULL, (void*)ID_FULLSCREEN, FL_MENU_DIVIDER);
842#endif
843
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000844 contextMenu->add(_("Ctrl"), 0, NULL, (void*)ID_CTRL, FL_MENU_TOGGLE);
845 contextMenu->add(_("Alt"), 0, NULL, (void*)ID_ALT, FL_MENU_TOGGLE);
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000846
847 if (menuKeyCode) {
848 char sendMenuKey[64];
849 snprintf(sendMenuKey, 64, _("Send %s"), (const char *)menuKey);
850 contextMenu->add(sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
851 contextMenu->add("Secret shortcut menu key", menuKeyCode, NULL, (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
852 }
853
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000854 contextMenu->add(_("Send Ctrl-Alt-Del"), 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
855
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000856 contextMenu->add(_("Refresh screen"), 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
857
Pierre Ossmand463b572011-05-16 12:04:43 +0000858 contextMenu->add(_("Options..."), 0, NULL, (void*)ID_OPTIONS, 0);
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000859 contextMenu->add(_("Connection info..."), 0, NULL, (void*)ID_INFO, 0);
Pierre Ossmanb8858222011-04-29 11:51:38 +0000860 contextMenu->add(_("About TigerVNC viewer..."), 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
861
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000862 contextMenu->add(_("Dismiss menu"), 0, NULL, (void*)ID_DISMISS, 0);
863}
864
865
866void Viewport::popupContextMenu()
867{
868 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000869 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000870
Pierre Ossmanb3ff4372011-06-03 11:45:15 +0000871 // Make sure the menu is reset to its initial state between goes or
872 // it will start up highlighting the previously selected entry.
873 contextMenu->value(-1);
874
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000875 m = contextMenu->popup();
876 if (m == NULL)
877 return;
878
879 switch (m->argument()) {
880 case ID_EXIT:
881 exit_vncviewer();
882 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +0000883#ifdef HAVE_FLTK_FULLSCREEN
884 case ID_FULLSCREEN:
885 if (window()->fullscreen_active())
886 window()->fullscreen_off();
Peter Åstrand17067b12011-07-18 07:45:14 +0000887 else {
888 // See comment in DesktopWindow::handleOptions
889 window()->size_range(100, 100, 0, 0);
Pierre Ossman4c613d32011-05-26 14:14:06 +0000890 window()->fullscreen();
Peter Åstrand17067b12011-07-18 07:45:14 +0000891 }
Pierre Ossman4c613d32011-05-26 14:14:06 +0000892 break;
893#endif
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000894 case ID_CTRL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000895 handleKeyEvent(FL_Control_L, FL_Control_L, "", m->value());
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000896 break;
897 case ID_ALT:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000898 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", m->value());
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000899 break;
900 case ID_MENUKEY:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000901 handleKeyEvent(menuKeyCode, menuKeyCode, "", true);
902 handleKeyEvent(menuKeyCode, menuKeyCode, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000903 break;
904 case ID_CTRLALTDEL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000905 handleKeyEvent(FL_Control_L, FL_Control_L, "", true);
906 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", true);
907 handleKeyEvent(FL_Delete, FL_Delete, "", true);
908
909 handleKeyEvent(FL_Delete, FL_Delete, "", false);
910 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", false);
911 handleKeyEvent(FL_Control_L, FL_Control_L, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000912 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000913 case ID_REFRESH:
914 cc->refreshFramebuffer();
915 break;
Pierre Ossmand463b572011-05-16 12:04:43 +0000916 case ID_OPTIONS:
917 OptionsDialog::showDialog();
918 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000919 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000920 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
921 fl_message_title(_("VNC connection info"));
922 fl_message(buffer);
923 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000924 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +0000925 case ID_ABOUT:
926 about_vncviewer();
927 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000928 case ID_DISMISS:
929 // Don't need to do anything
930 break;
931 }
932}
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000933
934
935void Viewport::setMenuKey()
936{
937 const char *menuKeyStr;
938
939 menuKeyCode = 0;
940
941 menuKeyStr = menuKey;
942 if (menuKeyStr[0] == 'F') {
943 int num = atoi(menuKeyStr + 1);
944 if ((num >= 1) && (num <= 12))
945 menuKeyCode = FL_F + num;
946 }
947
948 // Need to repopulate the context menu as it contains references to
949 // the menu key
950 initContextMenu();
951}
952
953
954void Viewport::handleOptions(void *data)
955{
956 Viewport *self = (Viewport*)data;
957
958 self->setMenuKey();
959}