blob: 0de1b8b1035b13a44318e0144915143ea99e39a1 [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
55#ifdef WIN32
56#include "win32.h"
57#endif
58
Pierre Ossmand50b3d12011-04-15 07:46:56 +000059using namespace rfb;
Pierre Ossman835b4ef2011-06-08 17:02:36 +000060using namespace rdr;
Pierre Ossmand50b3d12011-04-15 07:46:56 +000061
Pierre Ossmand50b3d12011-04-15 07:46:56 +000062static rfb::LogWriter vlog("Viewport");
63
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000064// Menu constants
65
Pierre Ossman4c613d32011-05-26 14:14:06 +000066enum { ID_EXIT, ID_FULLSCREEN, ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
Pierre Ossman2eb1d112011-05-16 12:18:08 +000067 ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS };
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000068
Pierre Ossmand50b3d12011-04-15 07:46:56 +000069Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_)
70 : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL), pixelTrans(NULL),
Pierre Ossmanf3505452011-07-15 08:11:55 +000071 colourMapChange(false), lastPointerPos(0, 0), lastButtonMask(0),
Henrik Andersson3a848322011-09-14 08:33:15 +000072 cursor(NULL), menuCtrlKey(false), menuAltKey(false)
Pierre Ossmand50b3d12011-04-15 07:46:56 +000073{
Pierre Ossmanf8c5ef62011-05-13 12:47:54 +000074// FLTK STR #2599 must be fixed for proper dead keys support
75#ifdef HAVE_FLTK_DEAD_KEYS
76 set_simple_keyboard();
77#endif
78
Pierre Ossman4a6be4a2011-05-19 14:49:18 +000079// FLTK STR #2636 gives us the ability to monitor clipboard changes
80#ifdef HAVE_FLTK_CLIPBOARD
81 Fl::add_clipboard_notify(handleClipboardChange, this);
82#endif
83
Pierre Ossman132b3d02011-06-13 11:19:32 +000084 frameBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmand50b3d12011-04-15 07:46:56 +000085 assert(frameBuffer);
86
87 setServerPF(serverPF);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +000088
89 contextMenu = new Fl_Menu_Button(0, 0, 0, 0);
Pierre Ossmanad9d1ae2011-05-26 14:16:02 +000090 // Setting box type to FL_NO_BOX prevents it from trying to draw the
91 // button component (which we don't want)
92 contextMenu->box(FL_NO_BOX);
93
Pierre Ossmanb043ad12011-06-01 09:26:57 +000094 // The (invisible) button associated with this widget can mess with
95 // things like Fl_Scroll so we need to get rid of any parents.
96 // Unfortunately that's not possible because of STR #2654, but
97 // reparenting to the current window works for most cases.
98 window()->add(contextMenu);
99
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000100 setMenuKey();
101
102 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000103}
104
105
106Viewport::~Viewport()
107{
108 // Unregister all timeouts in case they get a change tro trigger
109 // again later when this object is already gone.
110 Fl::remove_timeout(handleUpdateTimeout, this);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000111 Fl::remove_timeout(handlePointerTimeout, this);
112
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000113#ifdef HAVE_FLTK_CLIPBOARD
114 Fl::remove_clipboard_notify(handleClipboardChange);
115#endif
116
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000117 OptionsDialog::removeCallback(handleOptions);
118
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000119 delete frameBuffer;
120
121 if (pixelTrans)
122 delete pixelTrans;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000123
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000124 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000125 if (!cursor->alloc_array)
126 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000127 delete cursor;
128 }
129
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000130 // FLTK automatically deletes all child widgets, so we shouldn't touch
131 // them ourselves here
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000132}
133
134
135void Viewport::setServerPF(const rfb::PixelFormat& pf)
136{
137 if (pixelTrans)
138 delete pixelTrans;
139 pixelTrans = NULL;
140
141 if (pf.equal(getPreferredPF()))
142 return;
143
144 pixelTrans = new PixelTransformer();
Pierre Ossmanf72eb6b2011-07-15 12:34:33 +0000145
146 // FIXME: This is an ugly (temporary) hack to get around a corner
147 // case during startup. The conversion routines cannot handle
148 // non-native source formats, and we can sometimes get that
149 // as the initial format. We will switch to a better format
150 // before getting any updates, but we need something for now.
151 // Our old client used something completely bogus and just
152 // hoped nothing would ever go wrong. We try to at least match
153 // the pixel size so that we don't get any memory access issues
154 // should a stray update appear.
155 static rdr::U32 endianTest = 1;
156 static bool nativeBigEndian = *(rdr::U8*)(&endianTest) != 1;
157 if ((pf.bpp > 8) && (pf.bigEndian != nativeBigEndian)) {
158 PixelFormat fake_pf(pf.bpp, pf.depth, nativeBigEndian, pf.trueColour,
159 pf.redMax, pf.greenMax, pf.blueMax,
160 pf.redShift, pf.greenShift, pf.blueShift);
161 pixelTrans->init(fake_pf, &colourMap, getPreferredPF());
162 return;
163 }
164
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000165 pixelTrans->init(pf, &colourMap, getPreferredPF());
166}
167
168
169const rfb::PixelFormat &Viewport::getPreferredPF()
170{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000171 return frameBuffer->getPF();
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000172}
173
174
175// setColourMapEntries() changes some of the entries in the colourmap.
Pierre Ossmanf3505452011-07-15 08:11:55 +0000176// We don't actually act on these changes until we need to. This is
177// because recalculating the internal translation table can be expensive.
178// This also solves the issue of silly servers sending colour maps in
179// multiple pieces.
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000180void Viewport::setColourMapEntries(int firstColour, int nColours,
181 rdr::U16* rgbs)
182{
183 for (int i = 0; i < nColours; i++)
184 colourMap.set(firstColour+i, rgbs[i*3], rgbs[i*3+1], rgbs[i*3+2]);
185
Pierre Ossmanf3505452011-07-15 08:11:55 +0000186 colourMapChange = true;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000187}
188
189
190// Copy the areas of the framebuffer that have been changed (damaged)
191// to the displayed window.
192
193void Viewport::updateWindow()
194{
195 Rect r;
196
197 Fl::remove_timeout(handleUpdateTimeout, this);
198
199 r = damage.get_bounding_rect();
Pierre Ossmana6e20772011-04-15 11:10:52 +0000200 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 +0000201
202 damage.clear();
203}
204
Pierre Ossmanf741d342011-06-09 08:32:49 +0000205#ifdef HAVE_FLTK_CURSOR
206static const char * dotcursor_xpm[] = {
207 "5 5 2 1",
208 ". c #000000",
209 " c #FFFFFF",
210 " ",
211 " ... ",
212 " ... ",
213 " ... ",
214 " "};
215#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000216
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000217void Viewport::setCursor(int width, int height, const Point& hotspot,
218 void* data, void* mask)
219{
220#ifdef HAVE_FLTK_CURSOR
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000221 if (cursor) {
Pierre Ossmanf741d342011-06-09 08:32:49 +0000222 if (!cursor->alloc_array)
223 delete [] cursor->array;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000224 delete cursor;
225 }
226
Pierre Ossmanf741d342011-06-09 08:32:49 +0000227 int mask_len = ((width+7)/8) * height;
228 int i;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000229
Pierre Ossmanf741d342011-06-09 08:32:49 +0000230 for (i = 0; i < mask_len; i++)
231 if (((rdr::U8*)mask)[i]) break;
232
Pierre Ossmana51574a2011-06-09 08:39:35 +0000233 if ((i == mask_len) && dotWhenNoCursor) {
234 vlog.debug("cursor is empty - using dot");
Pierre Ossmanf741d342011-06-09 08:32:49 +0000235
236 Fl_Pixmap pxm(dotcursor_xpm);
237 cursor = new Fl_RGB_Image(&pxm);
238 cursorHotspot.x = cursorHotspot.y = 2;
239 } else {
Pierre Ossman17a48f02011-06-09 08:42:04 +0000240 if ((width == 0) || (height == 0)) {
241 U8 *buffer = new U8[4];
242 memset(buffer, 0, 4);
243 cursor = new Fl_RGB_Image(buffer, 1, 1, 4);
244 cursorHotspot.x = cursorHotspot.y = 0;
245 } else {
246 U8 *buffer = new U8[width*height*4];
247 U8 *i, *o, *m;
248 int m_width;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000249
Pierre Ossmand8f84872011-07-15 08:26:51 +0000250 const PixelFormat *pf;
251
252 if (pixelTrans)
253 pf = &pixelTrans->getInPF();
254 else
255 pf = &frameBuffer->getPF();
Pierre Ossmanf741d342011-06-09 08:32:49 +0000256
Pierre Ossman17a48f02011-06-09 08:42:04 +0000257 i = (U8*)data;
258 o = buffer;
259 m = (U8*)mask;
260 m_width = (width+7)/8;
261 for (int y = 0;y < height;y++) {
262 for (int x = 0;x < width;x++) {
Pierre Ossmand8f84872011-07-15 08:26:51 +0000263 pf->rgbFromBuffer(o, i, 1, &colourMap);
Pierre Ossmanf741d342011-06-09 08:32:49 +0000264
Pierre Ossman17a48f02011-06-09 08:42:04 +0000265 if (m[(m_width*y)+(x/8)] & 0x80>>(x%8))
266 o[3] = 255;
267 else
268 o[3] = 0;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000269
Pierre Ossman17a48f02011-06-09 08:42:04 +0000270 o += 4;
Pierre Ossmand8f84872011-07-15 08:26:51 +0000271 i += pf->bpp/8;
Pierre Ossman17a48f02011-06-09 08:42:04 +0000272 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000273 }
Pierre Ossman17a48f02011-06-09 08:42:04 +0000274
275 cursor = new Fl_RGB_Image(buffer, width, height, 4);
276
277 cursorHotspot = hotspot;
Pierre Ossmanf741d342011-06-09 08:32:49 +0000278 }
Pierre Ossmanf741d342011-06-09 08:32:49 +0000279 }
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000280
281 if (Fl::belowmouse() == this)
282 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
283#endif
284}
285
286
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000287void Viewport::draw()
288{
289 int X, Y, W, H;
290
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000291 // Check what actually needs updating
Pierre Ossmana6e20772011-04-15 11:10:52 +0000292 fl_clip_box(x(), y(), w(), h(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000293 if ((W == 0) || (H == 0))
294 return;
295
Pierre Ossman132b3d02011-06-13 11:19:32 +0000296 frameBuffer->draw(X - x(), Y - y(), X, Y, W, H);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000297}
298
299
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000300void Viewport::resize(int x, int y, int w, int h)
301{
Pierre Ossman132b3d02011-06-13 11:19:32 +0000302 PlatformPixelBuffer* newBuffer;
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000303 rfb::Rect rect;
304
Pierre Ossman132b3d02011-06-13 11:19:32 +0000305 // FIXME: Resize should probably be a feature of the pixel buffer itself
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000306
307 if ((w == frameBuffer->width()) && (h == frameBuffer->height()))
308 goto end;
309
Pierre Ossman773125e2011-07-15 13:41:02 +0000310 vlog.debug("Resing framebuffer from %dx%d to %dx%d",
311 frameBuffer->width(), frameBuffer->height(), w, h);
312
Pierre Ossman132b3d02011-06-13 11:19:32 +0000313 newBuffer = new PlatformPixelBuffer(w, h);
Pierre Ossmane00f0aa2011-06-01 09:31:53 +0000314 assert(newBuffer);
315
316 rect.setXYWH(0, 0,
317 __rfbmin(newBuffer->width(), frameBuffer->width()),
318 __rfbmin(newBuffer->height(), frameBuffer->height()));
319 newBuffer->imageRect(rect, frameBuffer->data, frameBuffer->getStride());
320
321 // Black out any new areas
322
323 if (newBuffer->width() > frameBuffer->width()) {
324 rect.setXYWH(frameBuffer->width(), 0,
325 newBuffer->width() - frameBuffer->width(),
326 newBuffer->height());
327 newBuffer->fillRect(rect, 0);
328 }
329
330 if (newBuffer->height() > frameBuffer->height()) {
331 rect.setXYWH(0, frameBuffer->height(),
332 newBuffer->width(),
333 newBuffer->height() - frameBuffer->height());
334 newBuffer->fillRect(rect, 0);
335 }
336
337 delete frameBuffer;
338 frameBuffer = newBuffer;
339
340end:
341 Fl_Widget::resize(x, y, w, h);
342}
343
344
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000345int Viewport::handle(int event)
346{
Pierre Ossman689c4582011-05-26 15:39:41 +0000347 char *buffer;
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000348 int ret;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000349 int buttonMask, wheelMask;
350 DownMap::const_iterator iter;
351
352 switch (event) {
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000353 case FL_PASTE:
Pierre Ossman689c4582011-05-26 15:39:41 +0000354 buffer = new char[Fl::event_length() + 1];
355
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000356 // This is documented as to ASCII, but actually does to 8859-1
Pierre Ossman689c4582011-05-26 15:39:41 +0000357 ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer,
358 Fl::event_length() + 1);
359 assert(ret < (Fl::event_length() + 1));
360
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000361 vlog.debug("Sending clipboard data: '%s'", buffer);
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000362
363 try {
364 cc->writer()->clientCutText(buffer, ret);
365 } catch (rdr::Exception& e) {
366 vlog.error(e.str());
367 exit_vncviewer(e.str());
368 }
Pierre Ossman689c4582011-05-26 15:39:41 +0000369
370 delete [] buffer;
371
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000372 return 1;
Pierre Ossman689c4582011-05-26 15:39:41 +0000373
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000374 case FL_ENTER:
375 // Yes, we would like some pointer events please!
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000376#ifdef HAVE_FLTK_CURSOR
Pierre Ossman1f1f6fd2011-06-09 08:33:29 +0000377 if (cursor)
378 window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000379#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000380 return 1;
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000381
382 case FL_LEAVE:
383#ifdef HAVE_FLTK_CURSOR
384 window()->cursor(FL_CURSOR_DEFAULT);
385#endif
Pierre Ossman164865a2011-11-10 13:30:39 +0000386 // Fall through as we want a last move event to help trigger edge stuff
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000387 case FL_PUSH:
388 case FL_RELEASE:
389 case FL_DRAG:
390 case FL_MOVE:
391 case FL_MOUSEWHEEL:
392 buttonMask = 0;
393 if (Fl::event_button1())
394 buttonMask |= 1;
395 if (Fl::event_button2())
396 buttonMask |= 2;
397 if (Fl::event_button3())
398 buttonMask |= 4;
399
400 if (event == FL_MOUSEWHEEL) {
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000401 wheelMask = 0;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000402 if (Fl::event_dy() < 0)
Pierre Ossmandf0ed9f2011-05-24 11:33:43 +0000403 wheelMask |= 8;
404 if (Fl::event_dy() > 0)
405 wheelMask |= 16;
406 if (Fl::event_dx() < 0)
407 wheelMask |= 32;
408 if (Fl::event_dx() > 0)
409 wheelMask |= 64;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000410
411 // A quick press of the wheel "button", followed by a immediate
412 // release below
Pierre Ossman6a464be2011-04-15 12:57:31 +0000413 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()),
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000414 buttonMask | wheelMask);
415 }
416
Pierre Ossman6a464be2011-04-15 12:57:31 +0000417 handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000418 return 1;
419
420 case FL_FOCUS:
421 // Yes, we would like some focus please!
422 return 1;
423
424 case FL_UNFOCUS:
425 // Release all keys that were pressed as that generally makes most
426 // sense (e.g. Alt+Tab where we only see the Alt press)
Pierre Ossmanf8450ca2011-07-12 16:10:16 +0000427 while (!downKeySym.empty())
428 handleKeyEvent(downKeySym.begin()->first, downKeySym.begin()->first,
429 "", false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000430 return 1;
431
432 case FL_KEYDOWN:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000433 if (menuKeyCode && (Fl::event_key() == menuKeyCode)) {
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000434 popupContextMenu();
435 return 1;
436 }
437
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000438 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
439 Fl::event_text(), true);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000440 return 1;
441
442 case FL_KEYUP:
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000443 if (menuKeyCode && (Fl::event_key() == menuKeyCode))
444 return 1;
445
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000446 handleKeyEvent(Fl::event_key(), Fl::event_original_key(),
447 Fl::event_text(), false);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000448 return 1;
449 }
450
451 return Fl_Widget::handle(event);
452}
453
454
455void Viewport::handleUpdateTimeout(void *data)
456{
457 Viewport *self = (Viewport *)data;
458
459 assert(self);
460
461 self->updateWindow();
462}
463
464
Pierre Ossmanf3505452011-07-15 08:11:55 +0000465void Viewport::commitColourMap()
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000466{
Pierre Ossmanf3505452011-07-15 08:11:55 +0000467 if (pixelTrans == NULL)
468 return;
469 if (!colourMapChange)
470 return;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000471
Pierre Ossmanf3505452011-07-15 08:11:55 +0000472 colourMapChange = false;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000473
Pierre Ossmanf3505452011-07-15 08:11:55 +0000474 pixelTrans->setColourMapEntries(0, 0);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000475}
476
477
Pierre Ossman4a6be4a2011-05-19 14:49:18 +0000478void Viewport::handleClipboardChange(int source, void *data)
479{
480 Viewport *self = (Viewport *)data;
481
482 assert(self);
483
484 if (!sendPrimary && (source == 0))
485 return;
486
487 Fl::paste(*self, source);
488}
489
490
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000491void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask)
492{
493 if (!viewOnly) {
494 if (pointerEventInterval == 0 || buttonMask != lastButtonMask) {
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000495 try {
496 cc->writer()->pointerEvent(pos, buttonMask);
497 } catch (rdr::Exception& e) {
498 vlog.error(e.str());
499 exit_vncviewer(e.str());
500 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000501 } else {
502 if (!Fl::has_timeout(handlePointerTimeout, this))
503 Fl::add_timeout((double)pointerEventInterval/1000.0,
504 handlePointerTimeout, this);
505 }
506 lastPointerPos = pos;
507 lastButtonMask = buttonMask;
508 }
509}
510
511
512void Viewport::handlePointerTimeout(void *data)
513{
514 Viewport *self = (Viewport *)data;
515
516 assert(self);
517
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000518 try {
519 self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask);
520 } catch (rdr::Exception& e) {
521 vlog.error(e.str());
522 exit_vncviewer(e.str());
523 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000524}
525
526
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000527rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *keyText)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000528{
529 unsigned ucs;
530
531 // First check for function keys
532 if ((keyCode > FL_F) && (keyCode <= FL_F_Last))
533 return XK_F1 + (keyCode - FL_F - 1);
534
535 // Numpad numbers
536 if ((keyCode >= (FL_KP + '0')) && (keyCode <= (FL_KP + '9')))
537 return XK_KP_0 + (keyCode - (FL_KP + '0'));
538
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000539 // FLTK does some special remapping of numpad keys when numlock is off
540 if ((origKeyCode >= FL_KP) && (origKeyCode <= FL_KP_Last)) {
541 switch (keyCode) {
542 case FL_F+1:
543 return XK_KP_F1;
544 case FL_F+2:
545 return XK_KP_F2;
546 case FL_F+3:
547 return XK_KP_F3;
548 case FL_F+4:
549 return XK_KP_F4;
550 case FL_Home:
551 return XK_KP_Home;
552 case FL_Left:
553 return XK_KP_Left;
554 case FL_Up:
555 return XK_KP_Up;
556 case FL_Right:
557 return XK_KP_Right;
558 case FL_Down:
559 return XK_KP_Down;
560 case FL_Page_Up:
561 return XK_KP_Page_Up;
562 case FL_Page_Down:
563 return XK_KP_Page_Down;
564 case FL_End:
565 return XK_KP_End;
566 case FL_Insert:
567 return XK_KP_Insert;
568 case FL_Delete:
569 return XK_KP_Delete;
570 }
571 }
572
Pierre Ossmanaa336be2011-07-14 13:35:48 +0000573#ifdef __APPLE__
574 // Alt on OS X behaves more like AltGr on other systems, and to get
575 // sane behaviour we should translate things in that manner for the
576 // remote VNC server. However that means we lose the ability to use
577 // Alt as a shortcut modifier. Do what RealVNC does and hijack the
578 // left command key as an Alt replacement.
579 switch (keyCode) {
580 case FL_Meta_L:
581 return XK_Alt_L;
582 case FL_Meta_R:
583 return XK_Super_L;
584 case FL_Alt_L:
585 case FL_Alt_R:
586 return XK_ISO_Level3_Shift;
587 }
588#endif
589
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000590 // Then other special keys
591 switch (keyCode) {
592 case FL_BackSpace:
593 return XK_BackSpace;
594 case FL_Tab:
595 return XK_Tab;
596 case FL_Enter:
597 return XK_Return;
598 case FL_Pause:
599 return XK_Pause;
600 case FL_Scroll_Lock:
601 return XK_Scroll_Lock;
602 case FL_Escape:
603 return XK_Escape;
604 case FL_Home:
605 return XK_Home;
606 case FL_Left:
607 return XK_Left;
608 case FL_Up:
609 return XK_Up;
610 case FL_Right:
611 return XK_Right;
612 case FL_Down:
613 return XK_Down;
614 case FL_Page_Up:
615 return XK_Page_Up;
616 case FL_Page_Down:
617 return XK_Page_Down;
618 case FL_End:
619 return XK_End;
620 case FL_Print:
621 return XK_Print;
622 case FL_Insert:
623 return XK_Insert;
624 case FL_Menu:
625 return XK_Menu;
626 case FL_Help:
627 return XK_Help;
628 case FL_Num_Lock:
629 return XK_Num_Lock;
630 case FL_Shift_L:
631 return XK_Shift_L;
632 case FL_Shift_R:
633 return XK_Shift_R;
634 case FL_Control_L:
635 return XK_Control_L;
636 case FL_Control_R:
637 return XK_Control_R;
638 case FL_Caps_Lock:
639 return XK_Caps_Lock;
640 case FL_Meta_L:
641 return XK_Super_L;
642 case FL_Meta_R:
643 return XK_Super_R;
644 case FL_Alt_L:
645 return XK_Alt_L;
646 case FL_Alt_R:
647 return XK_Alt_R;
648 case FL_Delete:
649 return XK_Delete;
650 case FL_KP_Enter:
651 return XK_KP_Enter;
652 case FL_KP + '=':
653 return XK_KP_Equal;
654 case FL_KP + '*':
655 return XK_KP_Multiply;
656 case FL_KP + '+':
657 return XK_KP_Add;
658 case FL_KP + ',':
659 return XK_KP_Separator;
660 case FL_KP + '-':
661 return XK_KP_Subtract;
662 case FL_KP + '.':
663 return XK_KP_Decimal;
664 case FL_KP + '/':
665 return XK_KP_Divide;
Pierre Ossmancb0cffe2011-05-20 14:55:10 +0000666#ifdef HAVE_FLTK_MEDIAKEYS
667 case FL_Volume_Down:
668 return XF86XK_AudioLowerVolume;
669 case FL_Volume_Mute:
670 return XF86XK_AudioMute;
671 case FL_Volume_Up:
672 return XF86XK_AudioRaiseVolume;
673 case FL_Media_Play:
674 return XF86XK_AudioPlay;
675 case FL_Media_Stop:
676 return XF86XK_AudioStop;
677 case FL_Media_Prev:
678 return XF86XK_AudioPrev;
679 case FL_Media_Next:
680 return XF86XK_AudioNext;
681 case FL_Home_Page:
682 return XF86XK_HomePage;
683 case FL_Mail:
684 return XF86XK_Mail;
685 case FL_Search:
686 return XF86XK_Search;
687 case FL_Back:
688 return XF86XK_Back;
689 case FL_Forward:
690 return XF86XK_Forward;
691 case FL_Stop:
692 return XF86XK_Stop;
693 case FL_Refresh:
694 return XF86XK_Refresh;
695 case FL_Sleep:
696 return XF86XK_Sleep;
697 case FL_Favorites:
698 return XF86XK_Favorites;
699#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000700 case XK_ISO_Level3_Shift:
701 // FLTK tends to let this one leak through on X11...
702 return XK_ISO_Level3_Shift;
Pierre Ossmana75f8f82011-04-29 11:12:02 +0000703 case XK_Multi_key:
704 // Same for this...
705 return XK_Multi_key;
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000706 }
707
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000708 // Unknown special key?
709 if (keyText[0] == '\0') {
710 vlog.error(_("Unknown FLTK key code %d (0x%04x)"), keyCode, keyCode);
711 return XK_VoidSymbol;
712 }
713
714 // Look up the symbol the key produces and translate that from Unicode
715 // to a X11 keysym.
716 if (fl_utf_nb_char((const unsigned char*)keyText, strlen(keyText)) != 1) {
717 vlog.error(_("Multiple characters given for key code %d (0x%04x): '%s'"),
718 keyCode, keyCode, keyText);
719 return XK_VoidSymbol;
720 }
721
722 ucs = fl_utf8decode(keyText, NULL, NULL);
723 return ucs2keysym(ucs);
724}
725
726
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000727void Viewport::handleKeyEvent(int keyCode, int origKeyCode, const char *keyText, bool down)
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000728{
729 rdr::U32 keySym;
730
731 if (viewOnly)
732 return;
733
734 // Because of the way keyboards work, we cannot expect to have the same
735 // symbol on release as when pressed. This breaks the VNC protocol however,
736 // so we need to keep track of what keysym a key _code_ generated on press
737 // and send the same on release.
738 if (!down) {
739 DownMap::iterator iter;
740
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000741 iter = downKeySym.find(origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000742 if (iter == downKeySym.end()) {
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000743 vlog.error(_("Unexpected release of FLTK key code %d (0x%04x)"),
744 origKeyCode, origKeyCode);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000745 return;
746 }
747
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000748 vlog.debug("Key released: 0x%04x => 0x%04x", origKeyCode, iter->second);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000749
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000750 try {
751 cc->writer()->keyEvent(iter->second, false);
752 } catch (rdr::Exception& e) {
753 vlog.error(e.str());
754 exit_vncviewer(e.str());
755 }
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000756
757 downKeySym.erase(iter);
758
759 return;
760 }
761
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000762 keySym = translateKeyEvent(keyCode, origKeyCode, keyText);
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000763 if (keySym == XK_VoidSymbol)
764 return;
765
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000766#ifdef WIN32
767 // Ugly hack alert!
768 //
769 // Windows doesn't have a proper AltGr, but handles it using fake
770 // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
771 // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
772 // get everything in the correct state. Cheat and temporarily release
773 // Ctrl and Alt whenever we get a key with a symbol.
774 bool need_cheat = true;
775
776 if (keyText[0] == '\0')
777 need_cheat = false;
778 else if ((downKeySym.find(FL_Control_L) == downKeySym.end()) &&
779 (downKeySym.find(FL_Control_R) == downKeySym.end()))
780 need_cheat = false;
781 else if ((downKeySym.find(FL_Alt_L) == downKeySym.end()) &&
782 (downKeySym.find(FL_Alt_R) == downKeySym.end()))
783 need_cheat = false;
784
785 if (need_cheat) {
786 vlog.debug("Faking release of AltGr (Ctrl+Alt)");
787 try {
788 if (downKeySym.find(FL_Control_L) != downKeySym.end())
789 cc->writer()->keyEvent(XK_Control_L, false);
790 if (downKeySym.find(FL_Control_R) != downKeySym.end())
791 cc->writer()->keyEvent(XK_Control_R, false);
792 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
793 cc->writer()->keyEvent(XK_Alt_L, false);
794 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
795 cc->writer()->keyEvent(XK_Alt_R, false);
796 } catch (rdr::Exception& e) {
797 vlog.error(e.str());
798 exit_vncviewer(e.str());
799 }
800 }
801#endif
802
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000803 vlog.debug("Key pressed: 0x%04x (0x%04x) '%s' => 0x%04x",
804 origKeyCode, keyCode, keyText, keySym);
Pierre Ossman71f295a2011-05-19 14:55:12 +0000805
Pierre Ossmancd6ddef2011-05-20 12:05:20 +0000806 downKeySym[origKeyCode] = keySym;
Pierre Ossman829cdeb2011-07-12 16:58:12 +0000807
808 try {
809 cc->writer()->keyEvent(keySym, down);
810 } catch (rdr::Exception& e) {
811 vlog.error(e.str());
812 exit_vncviewer(e.str());
813 }
Pierre Ossmanf0d92832011-07-13 17:56:26 +0000814
815#ifdef WIN32
816 // Ugly hack continued...
817 if (need_cheat) {
818 vlog.debug("Restoring AltGr state");
819 try {
820 if (downKeySym.find(FL_Control_L) != downKeySym.end())
821 cc->writer()->keyEvent(XK_Control_L, true);
822 if (downKeySym.find(FL_Control_R) != downKeySym.end())
823 cc->writer()->keyEvent(XK_Control_R, true);
824 if (downKeySym.find(FL_Alt_L) != downKeySym.end())
825 cc->writer()->keyEvent(XK_Alt_L, true);
826 if (downKeySym.find(FL_Alt_R) != downKeySym.end())
827 cc->writer()->keyEvent(XK_Alt_R, true);
828 } catch (rdr::Exception& e) {
829 vlog.error(e.str());
830 exit_vncviewer(e.str());
831 }
832 }
833#endif
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000834}
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000835
836
837void Viewport::initContextMenu()
838{
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000839 contextMenu->clear();
840
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000841 contextMenu->add(_("Exit viewer"), 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER);
842
Pierre Ossman4c613d32011-05-26 14:14:06 +0000843#ifdef HAVE_FLTK_FULLSCREEN
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000844 contextMenu->add(_("Full screen"), 0, NULL, (void*)ID_FULLSCREEN,
845 FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
Pierre Ossman4c613d32011-05-26 14:14:06 +0000846#endif
847
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000848 contextMenu->add(_("Ctrl"), 0, NULL, (void*)ID_CTRL,
849 FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
850 contextMenu->add(_("Alt"), 0, NULL, (void*)ID_ALT,
851 FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000852
853 if (menuKeyCode) {
854 char sendMenuKey[64];
855 snprintf(sendMenuKey, 64, _("Send %s"), (const char *)menuKey);
856 contextMenu->add(sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
857 contextMenu->add("Secret shortcut menu key", menuKeyCode, NULL, (void*)ID_MENUKEY, FL_MENU_INVISIBLE);
858 }
859
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000860 contextMenu->add(_("Send Ctrl-Alt-Del"), 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
861
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000862 contextMenu->add(_("Refresh screen"), 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
863
Pierre Ossmand463b572011-05-16 12:04:43 +0000864 contextMenu->add(_("Options..."), 0, NULL, (void*)ID_OPTIONS, 0);
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000865 contextMenu->add(_("Connection info..."), 0, NULL, (void*)ID_INFO, 0);
Pierre Ossmanb8858222011-04-29 11:51:38 +0000866 contextMenu->add(_("About TigerVNC viewer..."), 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER);
867
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000868 contextMenu->add(_("Dismiss menu"), 0, NULL, (void*)ID_DISMISS, 0);
869}
870
871
872void Viewport::popupContextMenu()
873{
874 const Fl_Menu_Item *m;
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000875 char buffer[1024];
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000876
Pierre Ossmanb3ff4372011-06-03 11:45:15 +0000877 // Make sure the menu is reset to its initial state between goes or
878 // it will start up highlighting the previously selected entry.
879 contextMenu->value(-1);
880
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000881 // initialize context menu before display
882 initContextMenu();
883
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000884 m = contextMenu->popup();
885 if (m == NULL)
886 return;
887
888 switch (m->argument()) {
889 case ID_EXIT:
890 exit_vncviewer();
891 break;
Pierre Ossman4c613d32011-05-26 14:14:06 +0000892#ifdef HAVE_FLTK_FULLSCREEN
893 case ID_FULLSCREEN:
894 if (window()->fullscreen_active())
895 window()->fullscreen_off();
Peter Åstrand17067b12011-07-18 07:45:14 +0000896 else {
897 // See comment in DesktopWindow::handleOptions
898 window()->size_range(100, 100, 0, 0);
Pierre Ossman4c613d32011-05-26 14:14:06 +0000899 window()->fullscreen();
Peter Åstrand17067b12011-07-18 07:45:14 +0000900 }
Pierre Ossman4c613d32011-05-26 14:14:06 +0000901 break;
902#endif
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000903 case ID_CTRL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000904 handleKeyEvent(FL_Control_L, FL_Control_L, "", m->value());
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000905 menuCtrlKey = !menuCtrlKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000906 break;
907 case ID_ALT:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000908 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", m->value());
Henrik Anderssonabd70ce2011-09-14 06:31:06 +0000909 menuAltKey = !menuAltKey;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000910 break;
911 case ID_MENUKEY:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000912 handleKeyEvent(menuKeyCode, menuKeyCode, "", true);
913 handleKeyEvent(menuKeyCode, menuKeyCode, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000914 break;
915 case ID_CTRLALTDEL:
Pierre Ossman991b4fe2011-07-12 16:02:30 +0000916 handleKeyEvent(FL_Control_L, FL_Control_L, "", true);
917 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", true);
918 handleKeyEvent(FL_Delete, FL_Delete, "", true);
919
920 handleKeyEvent(FL_Delete, FL_Delete, "", false);
921 handleKeyEvent(FL_Alt_L, FL_Alt_L, "", false);
922 handleKeyEvent(FL_Control_L, FL_Control_L, "", false);
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000923 break;
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000924 case ID_REFRESH:
925 cc->refreshFramebuffer();
926 break;
Pierre Ossmand463b572011-05-16 12:04:43 +0000927 case ID_OPTIONS:
928 OptionsDialog::showDialog();
929 break;
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000930 case ID_INFO:
Pierre Ossmanc628ba42011-05-23 12:21:21 +0000931 if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) {
932 fl_message_title(_("VNC connection info"));
933 fl_message(buffer);
934 }
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000935 break;
Pierre Ossmanb8858222011-04-29 11:51:38 +0000936 case ID_ABOUT:
937 about_vncviewer();
938 break;
Pierre Ossmanc7bfaac2011-04-29 11:08:11 +0000939 case ID_DISMISS:
940 // Don't need to do anything
941 break;
942 }
943}
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000944
945
946void Viewport::setMenuKey()
947{
Martin Koegler498ef462011-09-04 07:04:43 +0000948 menuKeyCode = getMenuKeyCode();
Pierre Ossman4e7271e2011-05-24 12:47:12 +0000949}
950
951
952void Viewport::handleOptions(void *data)
953{
954 Viewport *self = (Viewport*)data;
955
956 self->setMenuKey();
957}