Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 1 | /* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. |
Pierre Ossman | ff9eb5a | 2014-01-30 17:47:31 +0100 | [diff] [blame] | 2 | * Copyright 2011-2014 Pierre Ossman for Cendio AB |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 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 Åstrand | c359f36 | 2011-08-23 12:04:46 +0000 | [diff] [blame] | 20 | #ifdef HAVE_CONFIG_H |
| 21 | #include <config.h> |
| 22 | #endif |
| 23 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 24 | #include <assert.h> |
| 25 | #include <stdio.h> |
| 26 | #include <string.h> |
| 27 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 28 | #include <rfb/CMsgWriter.h> |
| 29 | #include <rfb/LogWriter.h> |
Pierre Ossman | d1a853b | 2014-10-10 13:37:35 +0200 | [diff] [blame] | 30 | #include <rfb/Exception.h> |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 31 | #include <rfb/ledStates.h> |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 32 | |
| 33 | // FLTK can pull in the X11 headers on some systems |
| 34 | #ifndef XK_VoidSymbol |
Pierre Ossman | 13a809a | 2014-08-22 15:09:54 +0200 | [diff] [blame] | 35 | #define XK_LATIN1 |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 36 | #define XK_MISCELLANY |
| 37 | #define XK_XKB_KEYS |
| 38 | #include <rfb/keysymdef.h> |
| 39 | #endif |
| 40 | |
Pierre Ossman | cb0cffe | 2011-05-20 14:55:10 +0000 | [diff] [blame] | 41 | #ifndef XF86XK_ModeLock |
| 42 | #include <rfb/XF86keysym.h> |
| 43 | #endif |
| 44 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 45 | #if ! (defined(WIN32) || defined(__APPLE__)) |
| 46 | #include <X11/XKBlib.h> |
| 47 | #endif |
| 48 | |
Pierre Ossman | 7b8bff6 | 2014-07-21 16:17:23 +0200 | [diff] [blame] | 49 | #ifndef NoSymbol |
| 50 | #define NoSymbol 0 |
| 51 | #endif |
| 52 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 53 | // Missing in at least some versions of MinGW |
| 54 | #ifndef MAPVK_VK_TO_VSC |
| 55 | #define MAPVK_VK_TO_VSC 0 |
| 56 | #endif |
| 57 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 58 | #include "Viewport.h" |
| 59 | #include "CConn.h" |
Pierre Ossman | d463b57 | 2011-05-16 12:04:43 +0000 | [diff] [blame] | 60 | #include "OptionsDialog.h" |
Pierre Ossman | 947b48d | 2014-01-27 16:52:35 +0100 | [diff] [blame] | 61 | #include "DesktopWindow.h" |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 62 | #include "i18n.h" |
Pierre Ossman | c628ba4 | 2011-05-23 12:21:21 +0000 | [diff] [blame] | 63 | #include "fltk_layout.h" |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 64 | #include "parameters.h" |
| 65 | #include "keysym2ucs.h" |
Martin Koegler | 498ef46 | 2011-09-04 07:04:43 +0000 | [diff] [blame] | 66 | #include "menukey.h" |
Pierre Ossman | 39ceb50 | 2011-07-12 15:54:25 +0000 | [diff] [blame] | 67 | #include "vncviewer.h" |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 68 | |
Pierre Ossman | ac13abe | 2014-02-07 14:46:26 +0100 | [diff] [blame] | 69 | #include "PlatformPixelBuffer.h" |
Pierre Ossman | 947b48d | 2014-01-27 16:52:35 +0100 | [diff] [blame] | 70 | |
DRC | b65bb93 | 2011-06-24 03:17:00 +0000 | [diff] [blame] | 71 | #include <FL/fl_draw.H> |
| 72 | #include <FL/fl_ask.H> |
| 73 | |
Pierre Ossman | 769963f | 2014-01-20 14:43:52 +0100 | [diff] [blame] | 74 | #include <FL/Fl_Menu.H> |
| 75 | #include <FL/Fl_Menu_Button.H> |
| 76 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 77 | #if !defined(WIN32) && !defined(__APPLE__) |
| 78 | #include <X11/XKBlib.h> |
| 79 | extern const struct _code_map_xkb_to_qnum { |
| 80 | const char * from; |
| 81 | const unsigned short to; |
| 82 | } code_map_xkb_to_qnum[]; |
| 83 | extern const unsigned int code_map_xkb_to_qnum_len; |
| 84 | |
| 85 | static int code_map_keycode_to_qnum[256]; |
| 86 | #endif |
| 87 | |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 88 | #ifdef __APPLE__ |
| 89 | #include "cocoa.h" |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 90 | extern const unsigned short code_map_osx_to_qnum[]; |
| 91 | extern const unsigned int code_map_osx_to_qnum_len; |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 92 | #endif |
| 93 | |
DRC | b65bb93 | 2011-06-24 03:17:00 +0000 | [diff] [blame] | 94 | #ifdef WIN32 |
| 95 | #include "win32.h" |
| 96 | #endif |
| 97 | |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 98 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 99 | using namespace rfb; |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 100 | using namespace rdr; |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 101 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 102 | static rfb::LogWriter vlog("Viewport"); |
| 103 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 104 | // Menu constants |
| 105 | |
Joel Teichroeb | a7494ac | 2015-07-13 14:46:22 -0700 | [diff] [blame] | 106 | enum { ID_EXIT, ID_FULLSCREEN, ID_MINIMIZE, ID_RESIZE, |
Pierre Ossman | 8dc8bca | 2012-07-04 11:37:10 +0000 | [diff] [blame] | 107 | ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL, |
Pierre Ossman | 2eb1d11 | 2011-05-16 12:18:08 +0000 | [diff] [blame] | 108 | ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS }; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 109 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 110 | // Used to detect fake input (0xaa is not a real key) |
| 111 | #ifdef WIN32 |
| 112 | static const WORD SCAN_FAKE = 0xaa; |
| 113 | #endif |
| 114 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 115 | Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_) |
Pierre Ossman | 0c9bd4b | 2014-07-09 16:44:11 +0200 | [diff] [blame] | 116 | : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL), |
Pierre Ossman | b6b4dc6 | 2014-01-20 15:05:21 +0100 | [diff] [blame] | 117 | lastPointerPos(0, 0), lastButtonMask(0), |
Pierre Ossman | b1cd6ca | 2015-03-03 16:37:43 +0100 | [diff] [blame] | 118 | menuCtrlKey(false), menuAltKey(false), cursor(NULL) |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 119 | { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 120 | #if !defined(WIN32) && !defined(__APPLE__) |
| 121 | XkbDescPtr xkb; |
| 122 | Status status; |
| 123 | |
| 124 | xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd); |
| 125 | if (!xkb) |
Pierre Ossman | 87b9d5f | 2017-09-18 16:07:12 +0200 | [diff] [blame] | 126 | throw rfb::Exception("XkbGetMap"); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 127 | |
| 128 | status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb); |
| 129 | if (status != Success) |
Pierre Ossman | 87b9d5f | 2017-09-18 16:07:12 +0200 | [diff] [blame] | 130 | throw rfb::Exception("XkbGetNames"); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 131 | |
| 132 | memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum)); |
| 133 | for (KeyCode keycode = xkb->min_key_code; |
| 134 | keycode < xkb->max_key_code; |
| 135 | keycode++) { |
| 136 | const char *keyname = xkb->names->keys[keycode].name; |
| 137 | unsigned short rfbcode; |
| 138 | |
| 139 | if (keyname[0] == '\0') |
| 140 | continue; |
| 141 | |
| 142 | rfbcode = 0; |
| 143 | for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) { |
| 144 | if (strncmp(code_map_xkb_to_qnum[i].from, |
| 145 | keyname, XkbKeyNameLength) == 0) { |
| 146 | rfbcode = code_map_xkb_to_qnum[i].to; |
| 147 | break; |
| 148 | } |
| 149 | } |
| 150 | if (rfbcode != 0) |
| 151 | code_map_keycode_to_qnum[keycode] = rfbcode; |
| 152 | else |
| 153 | vlog.debug("No key mapping for key %.4s", keyname); |
| 154 | } |
| 155 | |
| 156 | XkbFreeKeyboard(xkb, 0, True); |
| 157 | #endif |
| 158 | |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 159 | Fl::add_clipboard_notify(handleClipboardChange, this); |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 160 | |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 161 | // We need to intercept keyboard events early |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 162 | Fl::add_system_handler(handleSystemEvent, this); |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 163 | |
Pierre Ossman | 403ac27 | 2017-01-02 17:00:41 +0100 | [diff] [blame] | 164 | frameBuffer = new PlatformPixelBuffer(w, h); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 165 | assert(frameBuffer); |
Pierre Ossman | 9f273e9 | 2015-11-09 16:34:54 +0100 | [diff] [blame] | 166 | cc->setFramebuffer(frameBuffer); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 167 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 168 | contextMenu = new Fl_Menu_Button(0, 0, 0, 0); |
Pierre Ossman | ad9d1ae | 2011-05-26 14:16:02 +0000 | [diff] [blame] | 169 | // Setting box type to FL_NO_BOX prevents it from trying to draw the |
| 170 | // button component (which we don't want) |
| 171 | contextMenu->box(FL_NO_BOX); |
| 172 | |
Pierre Ossman | b043ad1 | 2011-06-01 09:26:57 +0000 | [diff] [blame] | 173 | // The (invisible) button associated with this widget can mess with |
| 174 | // things like Fl_Scroll so we need to get rid of any parents. |
| 175 | // Unfortunately that's not possible because of STR #2654, but |
| 176 | // reparenting to the current window works for most cases. |
| 177 | window()->add(contextMenu); |
| 178 | |
Pierre Ossman | 4e7271e | 2011-05-24 12:47:12 +0000 | [diff] [blame] | 179 | setMenuKey(); |
| 180 | |
| 181 | OptionsDialog::addCallback(handleOptions, this); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | |
| 185 | Viewport::~Viewport() |
| 186 | { |
| 187 | // Unregister all timeouts in case they get a change tro trigger |
| 188 | // again later when this object is already gone. |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 189 | Fl::remove_timeout(handlePointerTimeout, this); |
| 190 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 191 | Fl::remove_system_handler(handleSystemEvent); |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 192 | |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 193 | Fl::remove_clipboard_notify(handleClipboardChange); |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 194 | |
Pierre Ossman | 4e7271e | 2011-05-24 12:47:12 +0000 | [diff] [blame] | 195 | OptionsDialog::removeCallback(handleOptions); |
| 196 | |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 197 | if (cursor) { |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 198 | if (!cursor->alloc_array) |
| 199 | delete [] cursor->array; |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 200 | delete cursor; |
| 201 | } |
| 202 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 203 | // FLTK automatically deletes all child widgets, so we shouldn't touch |
| 204 | // them ourselves here |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 208 | const rfb::PixelFormat &Viewport::getPreferredPF() |
| 209 | { |
Pierre Ossman | 132b3d0 | 2011-06-13 11:19:32 +0000 | [diff] [blame] | 210 | return frameBuffer->getPF(); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 214 | // Copy the areas of the framebuffer that have been changed (damaged) |
| 215 | // to the displayed window. |
| 216 | |
| 217 | void Viewport::updateWindow() |
| 218 | { |
| 219 | Rect r; |
| 220 | |
Pierre Ossman | 0c9bd4b | 2014-07-09 16:44:11 +0200 | [diff] [blame] | 221 | r = frameBuffer->getDamage(); |
| 222 | damage(FL_DAMAGE_USER1, r.tl.x + x(), r.tl.y + y(), r.width(), r.height()); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 223 | } |
| 224 | |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 225 | static const char * dotcursor_xpm[] = { |
| 226 | "5 5 2 1", |
| 227 | ". c #000000", |
| 228 | " c #FFFFFF", |
| 229 | " ", |
| 230 | " ... ", |
| 231 | " ... ", |
| 232 | " ... ", |
| 233 | " "}; |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 234 | |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 235 | void Viewport::setCursor(int width, int height, const Point& hotspot, |
Pierre Ossman | 6a1a0d0 | 2017-02-19 15:48:17 +0100 | [diff] [blame] | 236 | const rdr::U8* data) |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 237 | { |
Pierre Ossman | 6a1a0d0 | 2017-02-19 15:48:17 +0100 | [diff] [blame] | 238 | int i; |
| 239 | |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 240 | if (cursor) { |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 241 | if (!cursor->alloc_array) |
| 242 | delete [] cursor->array; |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 243 | delete cursor; |
| 244 | } |
| 245 | |
Pierre Ossman | 6a1a0d0 | 2017-02-19 15:48:17 +0100 | [diff] [blame] | 246 | for (i = 0; i < width*height; i++) |
| 247 | if (data[i*4 + 3] != 0) break; |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 248 | |
Pierre Ossman | 6a1a0d0 | 2017-02-19 15:48:17 +0100 | [diff] [blame] | 249 | if ((i == width*height) && dotWhenNoCursor) { |
Pierre Ossman | a51574a | 2011-06-09 08:39:35 +0000 | [diff] [blame] | 250 | vlog.debug("cursor is empty - using dot"); |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 251 | |
| 252 | Fl_Pixmap pxm(dotcursor_xpm); |
| 253 | cursor = new Fl_RGB_Image(&pxm); |
| 254 | cursorHotspot.x = cursorHotspot.y = 2; |
| 255 | } else { |
Pierre Ossman | 17a48f0 | 2011-06-09 08:42:04 +0000 | [diff] [blame] | 256 | if ((width == 0) || (height == 0)) { |
| 257 | U8 *buffer = new U8[4]; |
| 258 | memset(buffer, 0, 4); |
| 259 | cursor = new Fl_RGB_Image(buffer, 1, 1, 4); |
| 260 | cursorHotspot.x = cursorHotspot.y = 0; |
| 261 | } else { |
Pierre Ossman | 6a1a0d0 | 2017-02-19 15:48:17 +0100 | [diff] [blame] | 262 | U8 *buffer = new U8[width * height * 4]; |
| 263 | memcpy(buffer, data, width * height * 4); |
Pierre Ossman | 17a48f0 | 2011-06-09 08:42:04 +0000 | [diff] [blame] | 264 | cursor = new Fl_RGB_Image(buffer, width, height, 4); |
Pierre Ossman | 17a48f0 | 2011-06-09 08:42:04 +0000 | [diff] [blame] | 265 | cursorHotspot = hotspot; |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 266 | } |
Pierre Ossman | f741d34 | 2011-06-09 08:32:49 +0000 | [diff] [blame] | 267 | } |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 268 | |
| 269 | if (Fl::belowmouse() == this) |
| 270 | window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y); |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 271 | } |
| 272 | |
| 273 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 274 | void Viewport::setLEDState(unsigned int state) |
| 275 | { |
| 276 | Fl_Widget *focus; |
| 277 | |
| 278 | vlog.debug("Got server LED state: 0x%08x", state); |
| 279 | |
| 280 | focus = Fl::grab(); |
| 281 | if (!focus) |
| 282 | focus = Fl::focus(); |
| 283 | if (!focus) |
| 284 | return; |
| 285 | |
| 286 | if (focus != this) |
| 287 | return; |
| 288 | |
| 289 | #if defined(WIN32) |
| 290 | INPUT input[6]; |
| 291 | UINT count; |
| 292 | UINT ret; |
| 293 | |
| 294 | memset(input, 0, sizeof(input)); |
| 295 | count = 0; |
| 296 | |
| 297 | if (!!(state & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) { |
| 298 | input[count].type = input[count+1].type = INPUT_KEYBOARD; |
| 299 | input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL; |
| 300 | input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE; |
| 301 | input[count].ki.dwFlags = 0; |
| 302 | input[count+1].ki.dwFlags = KEYEVENTF_KEYUP; |
| 303 | count += 2; |
| 304 | } |
| 305 | |
| 306 | if (!!(state & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) { |
| 307 | input[count].type = input[count+1].type = INPUT_KEYBOARD; |
| 308 | input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK; |
| 309 | input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE; |
| 310 | input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY; |
| 311 | input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY; |
| 312 | count += 2; |
| 313 | } |
| 314 | |
| 315 | if (!!(state & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) { |
| 316 | input[count].type = input[count+1].type = INPUT_KEYBOARD; |
| 317 | input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL; |
| 318 | input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE; |
| 319 | input[count].ki.dwFlags = 0; |
| 320 | input[count+1].ki.dwFlags = KEYEVENTF_KEYUP; |
| 321 | count += 2; |
| 322 | } |
| 323 | |
| 324 | if (count == 0) |
| 325 | return; |
| 326 | |
| 327 | ret = SendInput(count, input, sizeof(*input)); |
| 328 | if (ret < count) |
| 329 | vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError()); |
| 330 | #elif defined(__APPLE__) |
| 331 | int ret; |
| 332 | |
| 333 | ret = cocoa_set_caps_lock_state(state & ledCapsLock); |
| 334 | if (ret != 0) { |
| 335 | vlog.error(_("Failed to update keyboard LED state: %d"), ret); |
| 336 | return; |
| 337 | } |
| 338 | |
| 339 | ret = cocoa_set_num_lock_state(state & ledNumLock); |
| 340 | if (ret != 0) { |
| 341 | vlog.error(_("Failed to update keyboard LED state: %d"), ret); |
| 342 | return; |
| 343 | } |
| 344 | |
| 345 | // No support for Scroll Lock // |
| 346 | |
| 347 | #else |
| 348 | unsigned int affect, values; |
| 349 | unsigned int mask; |
| 350 | |
| 351 | Bool ret; |
| 352 | |
| 353 | affect = values = 0; |
| 354 | |
| 355 | affect |= LockMask; |
| 356 | if (state & ledCapsLock) |
| 357 | values |= LockMask; |
| 358 | |
| 359 | mask = getModifierMask(XK_Num_Lock); |
| 360 | affect |= mask; |
| 361 | if (state & ledNumLock) |
| 362 | values |= mask; |
| 363 | |
| 364 | mask = getModifierMask(XK_Scroll_Lock); |
| 365 | affect |= mask; |
| 366 | if (state & ledScrollLock) |
| 367 | values |= mask; |
| 368 | |
| 369 | ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values); |
| 370 | if (!ret) |
| 371 | vlog.error(_("Failed to update keyboard LED state")); |
| 372 | #endif |
| 373 | } |
| 374 | |
Pierre Ossman | 1668cfa | 2016-12-10 17:13:40 +0100 | [diff] [blame] | 375 | void Viewport::pushLEDState() |
| 376 | { |
| 377 | unsigned int state; |
| 378 | |
| 379 | // Server support? |
| 380 | if (cc->cp.ledState() == ledUnknown) |
| 381 | return; |
| 382 | |
| 383 | state = 0; |
| 384 | |
| 385 | #if defined(WIN32) |
| 386 | if (GetKeyState(VK_CAPITAL) & 0x1) |
| 387 | state |= ledCapsLock; |
| 388 | if (GetKeyState(VK_NUMLOCK) & 0x1) |
| 389 | state |= ledNumLock; |
| 390 | if (GetKeyState(VK_SCROLL) & 0x1) |
| 391 | state |= ledScrollLock; |
| 392 | #elif defined(__APPLE__) |
| 393 | int ret; |
| 394 | bool on; |
| 395 | |
| 396 | ret = cocoa_get_caps_lock_state(&on); |
| 397 | if (ret != 0) { |
| 398 | vlog.error(_("Failed to get keyboard LED state: %d"), ret); |
| 399 | return; |
| 400 | } |
| 401 | if (on) |
| 402 | state |= ledCapsLock; |
| 403 | |
| 404 | ret = cocoa_get_num_lock_state(&on); |
| 405 | if (ret != 0) { |
| 406 | vlog.error(_("Failed to get keyboard LED state: %d"), ret); |
| 407 | return; |
| 408 | } |
| 409 | if (on) |
| 410 | state |= ledNumLock; |
| 411 | |
| 412 | // No support for Scroll Lock // |
| 413 | state |= (cc->cp.ledState() & ledScrollLock); |
| 414 | |
| 415 | #else |
| 416 | unsigned int mask; |
| 417 | |
| 418 | Status status; |
| 419 | XkbStateRec xkbState; |
| 420 | |
| 421 | status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState); |
| 422 | if (status != Success) { |
| 423 | vlog.error(_("Failed to get keyboard LED state: %d"), status); |
| 424 | return; |
| 425 | } |
| 426 | |
| 427 | if (xkbState.locked_mods & LockMask) |
| 428 | state |= ledCapsLock; |
| 429 | |
| 430 | mask = getModifierMask(XK_Num_Lock); |
| 431 | if (xkbState.locked_mods & mask) |
| 432 | state |= ledNumLock; |
| 433 | |
| 434 | mask = getModifierMask(XK_Scroll_Lock); |
| 435 | if (xkbState.locked_mods & mask) |
| 436 | state |= ledScrollLock; |
| 437 | #endif |
| 438 | |
| 439 | if ((state & ledCapsLock) != (cc->cp.ledState() & ledCapsLock)) { |
| 440 | vlog.debug("Inserting fake CapsLock to get in sync with server"); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 441 | handleKeyPress(0x3a, XK_Caps_Lock); |
| 442 | handleKeyRelease(0x3a); |
Pierre Ossman | 1668cfa | 2016-12-10 17:13:40 +0100 | [diff] [blame] | 443 | } |
| 444 | if ((state & ledNumLock) != (cc->cp.ledState() & ledNumLock)) { |
| 445 | vlog.debug("Inserting fake NumLock to get in sync with server"); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 446 | handleKeyPress(0x45, XK_Num_Lock); |
| 447 | handleKeyRelease(0x45); |
Pierre Ossman | 1668cfa | 2016-12-10 17:13:40 +0100 | [diff] [blame] | 448 | } |
| 449 | if ((state & ledScrollLock) != (cc->cp.ledState() & ledScrollLock)) { |
| 450 | vlog.debug("Inserting fake ScrollLock to get in sync with server"); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 451 | handleKeyPress(0x46, XK_Scroll_Lock); |
| 452 | handleKeyRelease(0x46); |
Pierre Ossman | 1668cfa | 2016-12-10 17:13:40 +0100 | [diff] [blame] | 453 | } |
| 454 | } |
| 455 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 456 | |
Pierre Ossman | 3d74d88 | 2017-01-02 19:49:52 +0100 | [diff] [blame] | 457 | void Viewport::draw(Surface* dst) |
| 458 | { |
| 459 | int X, Y, W, H; |
| 460 | |
| 461 | // Check what actually needs updating |
| 462 | fl_clip_box(x(), y(), w(), h(), X, Y, W, H); |
| 463 | if ((W == 0) || (H == 0)) |
| 464 | return; |
| 465 | |
| 466 | frameBuffer->draw(dst, X - x(), Y - y(), X, Y, W, H); |
| 467 | } |
| 468 | |
| 469 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 470 | void Viewport::draw() |
| 471 | { |
| 472 | int X, Y, W, H; |
| 473 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 474 | // Check what actually needs updating |
Pierre Ossman | a6e2077 | 2011-04-15 11:10:52 +0000 | [diff] [blame] | 475 | fl_clip_box(x(), y(), w(), h(), X, Y, W, H); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 476 | if ((W == 0) || (H == 0)) |
| 477 | return; |
| 478 | |
Pierre Ossman | 132b3d0 | 2011-06-13 11:19:32 +0000 | [diff] [blame] | 479 | frameBuffer->draw(X - x(), Y - y(), X, Y, W, H); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 480 | } |
| 481 | |
| 482 | |
Pierre Ossman | e00f0aa | 2011-06-01 09:31:53 +0000 | [diff] [blame] | 483 | void Viewport::resize(int x, int y, int w, int h) |
| 484 | { |
Pierre Ossman | 9f273e9 | 2015-11-09 16:34:54 +0100 | [diff] [blame] | 485 | if ((w != frameBuffer->width()) || (h != frameBuffer->height())) { |
| 486 | vlog.debug("Resizing framebuffer from %dx%d to %dx%d", |
| 487 | frameBuffer->width(), frameBuffer->height(), w, h); |
Pierre Ossman | e00f0aa | 2011-06-01 09:31:53 +0000 | [diff] [blame] | 488 | |
Pierre Ossman | 403ac27 | 2017-01-02 17:00:41 +0100 | [diff] [blame] | 489 | frameBuffer = new PlatformPixelBuffer(w, h); |
Pierre Ossman | 9f273e9 | 2015-11-09 16:34:54 +0100 | [diff] [blame] | 490 | assert(frameBuffer); |
| 491 | cc->setFramebuffer(frameBuffer); |
Pierre Ossman | e00f0aa | 2011-06-01 09:31:53 +0000 | [diff] [blame] | 492 | } |
| 493 | |
Pierre Ossman | e00f0aa | 2011-06-01 09:31:53 +0000 | [diff] [blame] | 494 | Fl_Widget::resize(x, y, w, h); |
| 495 | } |
| 496 | |
| 497 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 498 | int Viewport::handle(int event) |
| 499 | { |
Pierre Ossman | 689c458 | 2011-05-26 15:39:41 +0000 | [diff] [blame] | 500 | char *buffer; |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 501 | int ret; |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 502 | int buttonMask, wheelMask; |
| 503 | DownMap::const_iterator iter; |
| 504 | |
| 505 | switch (event) { |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 506 | case FL_PASTE: |
Pierre Ossman | 689c458 | 2011-05-26 15:39:41 +0000 | [diff] [blame] | 507 | buffer = new char[Fl::event_length() + 1]; |
| 508 | |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 509 | // This is documented as to ASCII, but actually does to 8859-1 |
Pierre Ossman | 689c458 | 2011-05-26 15:39:41 +0000 | [diff] [blame] | 510 | ret = fl_utf8toa(Fl::event_text(), Fl::event_length(), buffer, |
| 511 | Fl::event_length() + 1); |
| 512 | assert(ret < (Fl::event_length() + 1)); |
| 513 | |
Pierre Ossman | fb450fb | 2015-03-03 16:34:56 +0100 | [diff] [blame] | 514 | vlog.debug("Sending clipboard data (%d bytes)", (int)strlen(buffer)); |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 515 | |
| 516 | try { |
| 517 | cc->writer()->clientCutText(buffer, ret); |
| 518 | } catch (rdr::Exception& e) { |
Pierre Ossman | ad8609a | 2012-04-26 09:04:14 +0000 | [diff] [blame] | 519 | vlog.error("%s", e.str()); |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 520 | exit_vncviewer(e.str()); |
| 521 | } |
Pierre Ossman | 689c458 | 2011-05-26 15:39:41 +0000 | [diff] [blame] | 522 | |
| 523 | delete [] buffer; |
| 524 | |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 525 | return 1; |
Pierre Ossman | 689c458 | 2011-05-26 15:39:41 +0000 | [diff] [blame] | 526 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 527 | case FL_ENTER: |
Pierre Ossman | 1f1f6fd | 2011-06-09 08:33:29 +0000 | [diff] [blame] | 528 | if (cursor) |
| 529 | window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y); |
Pierre Ossman | 56610fb | 2015-01-27 16:28:15 +0100 | [diff] [blame] | 530 | // Yes, we would like some pointer events please! |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 531 | return 1; |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 532 | |
| 533 | case FL_LEAVE: |
Pierre Ossman | 835b4ef | 2011-06-08 17:02:36 +0000 | [diff] [blame] | 534 | window()->cursor(FL_CURSOR_DEFAULT); |
Pierre Ossman | 164865a | 2011-11-10 13:30:39 +0000 | [diff] [blame] | 535 | // Fall through as we want a last move event to help trigger edge stuff |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 536 | case FL_PUSH: |
| 537 | case FL_RELEASE: |
| 538 | case FL_DRAG: |
| 539 | case FL_MOVE: |
| 540 | case FL_MOUSEWHEEL: |
| 541 | buttonMask = 0; |
| 542 | if (Fl::event_button1()) |
| 543 | buttonMask |= 1; |
| 544 | if (Fl::event_button2()) |
| 545 | buttonMask |= 2; |
| 546 | if (Fl::event_button3()) |
| 547 | buttonMask |= 4; |
| 548 | |
| 549 | if (event == FL_MOUSEWHEEL) { |
Pierre Ossman | df0ed9f | 2011-05-24 11:33:43 +0000 | [diff] [blame] | 550 | wheelMask = 0; |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 551 | if (Fl::event_dy() < 0) |
Pierre Ossman | df0ed9f | 2011-05-24 11:33:43 +0000 | [diff] [blame] | 552 | wheelMask |= 8; |
| 553 | if (Fl::event_dy() > 0) |
| 554 | wheelMask |= 16; |
| 555 | if (Fl::event_dx() < 0) |
| 556 | wheelMask |= 32; |
| 557 | if (Fl::event_dx() > 0) |
| 558 | wheelMask |= 64; |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 559 | |
| 560 | // A quick press of the wheel "button", followed by a immediate |
| 561 | // release below |
Pierre Ossman | 6a464be | 2011-04-15 12:57:31 +0000 | [diff] [blame] | 562 | handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 563 | buttonMask | wheelMask); |
| 564 | } |
| 565 | |
Pierre Ossman | 6a464be | 2011-04-15 12:57:31 +0000 | [diff] [blame] | 566 | handlePointerEvent(Point(Fl::event_x() - x(), Fl::event_y() - y()), buttonMask); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 567 | return 1; |
| 568 | |
| 569 | case FL_FOCUS: |
Pierre Ossman | 48ef54d | 2014-08-19 14:08:04 +0200 | [diff] [blame] | 570 | Fl::disable_im(); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 571 | // Yes, we would like some focus please! |
| 572 | return 1; |
| 573 | |
| 574 | case FL_UNFOCUS: |
| 575 | // Release all keys that were pressed as that generally makes most |
| 576 | // sense (e.g. Alt+Tab where we only see the Alt press) |
Pierre Ossman | f8450ca | 2011-07-12 16:10:16 +0000 | [diff] [blame] | 577 | while (!downKeySym.empty()) |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 578 | handleKeyRelease(downKeySym.begin()->first); |
Pierre Ossman | 48ef54d | 2014-08-19 14:08:04 +0200 | [diff] [blame] | 579 | Fl::enable_im(); |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 580 | return 1; |
| 581 | |
| 582 | case FL_KEYDOWN: |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 583 | case FL_KEYUP: |
Pierre Ossman | 56610fb | 2015-01-27 16:28:15 +0100 | [diff] [blame] | 584 | // Just ignore these as keys were handled in the event handler |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 585 | return 1; |
| 586 | } |
| 587 | |
| 588 | return Fl_Widget::handle(event); |
| 589 | } |
| 590 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 591 | |
| 592 | #if ! (defined(WIN32) || defined(__APPLE__)) |
| 593 | unsigned int Viewport::getModifierMask(unsigned int keysym) |
| 594 | { |
| 595 | XkbDescPtr xkb; |
| 596 | unsigned int mask, keycode; |
| 597 | XkbAction *act; |
| 598 | |
| 599 | mask = 0; |
| 600 | |
| 601 | xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd); |
| 602 | if (xkb == NULL) |
| 603 | return 0; |
| 604 | |
| 605 | for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) { |
| 606 | unsigned int state_out; |
| 607 | KeySym ks; |
| 608 | |
| 609 | XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks); |
| 610 | if (ks == NoSymbol) |
| 611 | continue; |
| 612 | |
| 613 | if (ks == keysym) |
| 614 | break; |
| 615 | } |
| 616 | |
| 617 | // KeySym not mapped? |
| 618 | if (keycode > xkb->max_key_code) |
| 619 | goto out; |
| 620 | |
| 621 | act = XkbKeyAction(xkb, keycode, 0); |
| 622 | if (act == NULL) |
| 623 | goto out; |
| 624 | if (act->type != XkbSA_LockMods) |
| 625 | goto out; |
| 626 | |
| 627 | if (act->mods.flags & XkbSA_UseModMapMods) |
| 628 | mask = xkb->map->modmap[keycode]; |
| 629 | else |
| 630 | mask = act->mods.mask; |
| 631 | |
| 632 | out: |
| 633 | XkbFreeKeyboard(xkb, XkbAllComponentsMask, True); |
| 634 | |
| 635 | return mask; |
| 636 | } |
| 637 | #endif |
| 638 | |
| 639 | |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 640 | void Viewport::handleClipboardChange(int source, void *data) |
| 641 | { |
| 642 | Viewport *self = (Viewport *)data; |
| 643 | |
| 644 | assert(self); |
| 645 | |
Pierre Ossman | a432b58 | 2017-01-02 15:16:58 +0100 | [diff] [blame] | 646 | if (!sendClipboard) |
| 647 | return; |
| 648 | |
Pierre Ossman | f7fef92 | 2015-12-10 21:24:08 +0100 | [diff] [blame] | 649 | #if !defined(WIN32) && !defined(__APPLE__) |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 650 | if (!sendPrimary && (source == 0)) |
| 651 | return; |
Pierre Ossman | f7fef92 | 2015-12-10 21:24:08 +0100 | [diff] [blame] | 652 | #endif |
Pierre Ossman | 4a6be4a | 2011-05-19 14:49:18 +0000 | [diff] [blame] | 653 | |
| 654 | Fl::paste(*self, source); |
| 655 | } |
| 656 | |
| 657 | |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 658 | void Viewport::handlePointerEvent(const rfb::Point& pos, int buttonMask) |
| 659 | { |
| 660 | if (!viewOnly) { |
| 661 | if (pointerEventInterval == 0 || buttonMask != lastButtonMask) { |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 662 | try { |
| 663 | cc->writer()->pointerEvent(pos, buttonMask); |
| 664 | } catch (rdr::Exception& e) { |
Pierre Ossman | ad8609a | 2012-04-26 09:04:14 +0000 | [diff] [blame] | 665 | vlog.error("%s", e.str()); |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 666 | exit_vncviewer(e.str()); |
| 667 | } |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 668 | } else { |
| 669 | if (!Fl::has_timeout(handlePointerTimeout, this)) |
| 670 | Fl::add_timeout((double)pointerEventInterval/1000.0, |
| 671 | handlePointerTimeout, this); |
| 672 | } |
| 673 | lastPointerPos = pos; |
| 674 | lastButtonMask = buttonMask; |
| 675 | } |
| 676 | } |
| 677 | |
| 678 | |
| 679 | void Viewport::handlePointerTimeout(void *data) |
| 680 | { |
| 681 | Viewport *self = (Viewport *)data; |
| 682 | |
| 683 | assert(self); |
| 684 | |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 685 | try { |
| 686 | self->cc->writer()->pointerEvent(self->lastPointerPos, self->lastButtonMask); |
| 687 | } catch (rdr::Exception& e) { |
Pierre Ossman | ad8609a | 2012-04-26 09:04:14 +0000 | [diff] [blame] | 688 | vlog.error("%s", e.str()); |
Pierre Ossman | 829cdeb | 2011-07-12 16:58:12 +0000 | [diff] [blame] | 689 | exit_vncviewer(e.str()); |
| 690 | } |
Pierre Ossman | d50b3d1 | 2011-04-15 07:46:56 +0000 | [diff] [blame] | 691 | } |
| 692 | |
| 693 | |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 694 | void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym) |
| 695 | { |
| 696 | static bool menuRecursion = false; |
| 697 | |
| 698 | // Prevent recursion if the menu wants to send its own |
| 699 | // activation key. |
| 700 | if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) { |
| 701 | menuRecursion = true; |
| 702 | popupContextMenu(); |
| 703 | menuRecursion = false; |
| 704 | return; |
| 705 | } |
| 706 | |
| 707 | if (viewOnly) |
| 708 | return; |
| 709 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 710 | if (keyCode == 0) { |
| 711 | vlog.error(_("No key code specified on key press")); |
| 712 | return; |
| 713 | } |
| 714 | |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 715 | #ifdef __APPLE__ |
| 716 | // Alt on OS X behaves more like AltGr on other systems, and to get |
| 717 | // sane behaviour we should translate things in that manner for the |
| 718 | // remote VNC server. However that means we lose the ability to use |
| 719 | // Alt as a shortcut modifier. Do what RealVNC does and hijack the |
| 720 | // left command key as an Alt replacement. |
| 721 | switch (keySym) { |
| 722 | case XK_Super_L: |
| 723 | keySym = XK_Alt_L; |
| 724 | break; |
| 725 | case XK_Super_R: |
| 726 | keySym = XK_Super_L; |
| 727 | break; |
| 728 | case XK_Alt_L: |
Pierre Ossman | 38fcebb | 2014-08-21 13:44:28 +0200 | [diff] [blame] | 729 | keySym = XK_Mode_switch; |
| 730 | break; |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 731 | case XK_Alt_R: |
| 732 | keySym = XK_ISO_Level3_Shift; |
| 733 | break; |
| 734 | } |
| 735 | #endif |
| 736 | |
| 737 | #ifdef WIN32 |
| 738 | // Ugly hack alert! |
| 739 | // |
| 740 | // Windows doesn't have a proper AltGr, but handles it using fake |
| 741 | // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination |
| 742 | // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to |
| 743 | // get everything in the correct state. Cheat and temporarily release |
| 744 | // Ctrl and Alt when we send some other symbol. |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 745 | if (downKeySym.count(0x1d) && downKeySym.count(0xb8)) { |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 746 | vlog.debug("Faking release of AltGr (Ctrl_L+Alt_R)"); |
| 747 | try { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 748 | cc->writer()->keyEvent(downKeySym[0x1d], 0x1d, false); |
| 749 | cc->writer()->keyEvent(downKeySym[0xb8], 0xb8, false); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 750 | } catch (rdr::Exception& e) { |
| 751 | vlog.error("%s", e.str()); |
| 752 | exit_vncviewer(e.str()); |
| 753 | } |
| 754 | } |
| 755 | #endif |
| 756 | |
| 757 | // Because of the way keyboards work, we cannot expect to have the same |
| 758 | // symbol on release as when pressed. This breaks the VNC protocol however, |
| 759 | // so we need to keep track of what keysym a key _code_ generated on press |
| 760 | // and send the same on release. |
| 761 | downKeySym[keyCode] = keySym; |
| 762 | |
| 763 | #if defined(WIN32) || defined(__APPLE__) |
| 764 | vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym); |
| 765 | #else |
| 766 | vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)", |
| 767 | keyCode, XKeysymToString(keySym), keySym); |
| 768 | #endif |
| 769 | |
| 770 | try { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 771 | // Fake keycode? |
| 772 | if (keyCode > 0xff) |
| 773 | cc->writer()->keyEvent(keySym, 0, true); |
| 774 | else |
| 775 | cc->writer()->keyEvent(keySym, keyCode, true); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 776 | } catch (rdr::Exception& e) { |
| 777 | vlog.error("%s", e.str()); |
| 778 | exit_vncviewer(e.str()); |
| 779 | } |
| 780 | |
| 781 | #ifdef WIN32 |
| 782 | // Ugly hack continued... |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 783 | if (downKeySym.count(0x1d) && downKeySym.count(0xb8)) { |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 784 | vlog.debug("Restoring AltGr state"); |
| 785 | try { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 786 | cc->writer()->keyEvent(downKeySym[0x1d], 0x1d, true); |
| 787 | cc->writer()->keyEvent(downKeySym[0xb8], 0xb8, true); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 788 | } catch (rdr::Exception& e) { |
| 789 | vlog.error("%s", e.str()); |
| 790 | exit_vncviewer(e.str()); |
| 791 | } |
| 792 | } |
| 793 | #endif |
| 794 | } |
| 795 | |
| 796 | |
| 797 | void Viewport::handleKeyRelease(int keyCode) |
| 798 | { |
| 799 | DownMap::iterator iter; |
| 800 | |
| 801 | if (viewOnly) |
| 802 | return; |
| 803 | |
| 804 | iter = downKeySym.find(keyCode); |
| 805 | if (iter == downKeySym.end()) { |
| 806 | // These occur somewhat frequently so let's not spam them unless |
| 807 | // logging is turned up. |
| 808 | vlog.debug("Unexpected release of key code %d", keyCode); |
| 809 | return; |
| 810 | } |
| 811 | |
| 812 | #if defined(WIN32) || defined(__APPLE__) |
| 813 | vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second); |
| 814 | #else |
| 815 | vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)", |
| 816 | keyCode, XKeysymToString(iter->second), iter->second); |
| 817 | #endif |
| 818 | |
| 819 | try { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 820 | if (keyCode > 0xff) |
| 821 | cc->writer()->keyEvent(iter->second, 0, false); |
| 822 | else |
| 823 | cc->writer()->keyEvent(iter->second, keyCode, false); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 824 | } catch (rdr::Exception& e) { |
| 825 | vlog.error("%s", e.str()); |
| 826 | exit_vncviewer(e.str()); |
| 827 | } |
| 828 | |
| 829 | downKeySym.erase(iter); |
| 830 | } |
| 831 | |
| 832 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 833 | int Viewport::handleSystemEvent(void *event, void *data) |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 834 | { |
| 835 | Viewport *self = (Viewport *)data; |
| 836 | Fl_Widget *focus; |
| 837 | |
| 838 | assert(self); |
| 839 | |
| 840 | focus = Fl::grab(); |
| 841 | if (!focus) |
| 842 | focus = Fl::focus(); |
| 843 | if (!focus) |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 844 | return 0; |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 845 | |
| 846 | if (focus != self) |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 847 | return 0; |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 848 | |
| 849 | assert(event); |
| 850 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 851 | #if defined(WIN32) |
| 852 | MSG *msg = (MSG*)event; |
| 853 | |
| 854 | if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) { |
| 855 | UINT vKey; |
| 856 | bool isExtended; |
| 857 | int keyCode; |
| 858 | rdr::U32 keySym; |
| 859 | |
| 860 | vKey = msg->wParam; |
| 861 | isExtended = (msg->lParam & (1 << 24)) != 0; |
| 862 | |
| 863 | keyCode = ((msg->lParam >> 16) & 0xff); |
| 864 | |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 865 | if (keyCode == SCAN_FAKE) { |
| 866 | vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey); |
| 867 | return 1; |
| 868 | } |
| 869 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 870 | // Windows sets the scan code to 0x00 for multimedia keys, so we |
| 871 | // have to do a reverse lookup based on the vKey. |
| 872 | if (keyCode == 0x00) { |
| 873 | keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC); |
| 874 | if (keyCode == 0x00) { |
Pierre Ossman | f05f355 | 2014-09-22 12:19:52 +0200 | [diff] [blame] | 875 | if (isExtended) |
| 876 | vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey); |
| 877 | else |
| 878 | vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey); |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 879 | return 1; |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 880 | } |
| 881 | } |
| 882 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 883 | if (keyCode & ~0x7f) { |
| 884 | vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode); |
| 885 | return 1; |
| 886 | } |
| 887 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 888 | if (isExtended) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 889 | keyCode |= 0x80; |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 890 | |
Pierre Ossman | f73214c | 2017-11-13 09:06:03 +0100 | [diff] [blame] | 891 | |
| 892 | // Fortunately RFB and Windows use the same scan code set (mostly), |
| 893 | // so there is no conversion needed |
| 894 | // (as long as we encode the extended keys with the high bit) |
| 895 | |
| 896 | // However Pause sends a code that conflicts with NumLock, so use |
| 897 | // the code most RFB implementations use (part of the sequence for |
| 898 | // Ctrl+Pause, i.e. Break) |
| 899 | if (keyCode == 0x45) |
| 900 | keyCode = 0xc6; |
| 901 | |
| 902 | // And NumLock incorrectly has the extended bit set |
| 903 | if (keyCode == 0xc5) |
| 904 | keyCode = 0x45; |
| 905 | |
| 906 | // And Alt+PrintScreen (i.e. SysRq) sends a different code than |
| 907 | // PrintScreen |
| 908 | if (keyCode == 0xb7) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 909 | keyCode = 0x54; |
Pierre Ossman | a7d3dc7 | 2014-09-30 17:03:28 +0200 | [diff] [blame] | 910 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 911 | keySym = win32_vkey_to_keysym(vKey, isExtended); |
| 912 | if (keySym == NoSymbol) { |
Pierre Ossman | f05f355 | 2014-09-22 12:19:52 +0200 | [diff] [blame] | 913 | if (isExtended) |
| 914 | vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey); |
| 915 | else |
| 916 | vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey); |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 917 | } |
| 918 | |
Pierre Ossman | 30b3f92 | 2017-11-13 09:07:59 +0100 | [diff] [blame] | 919 | // Windows sends the same vKey for both shifts, so we need to look |
| 920 | // at the scan code to tell them apart |
| 921 | if ((keySym == XK_Shift_L) && (keyCode == 0x36)) |
| 922 | keySym = XK_Shift_R; |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 923 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 924 | self->handleKeyPress(keyCode, keySym); |
| 925 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 926 | return 1; |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 927 | } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) { |
| 928 | UINT vKey; |
| 929 | bool isExtended; |
| 930 | int keyCode; |
| 931 | |
| 932 | vKey = msg->wParam; |
| 933 | isExtended = (msg->lParam & (1 << 24)) != 0; |
| 934 | |
| 935 | keyCode = ((msg->lParam >> 16) & 0xff); |
Pierre Ossman | 2fa63f8 | 2016-12-05 15:26:21 +0100 | [diff] [blame] | 936 | |
| 937 | if (keyCode == SCAN_FAKE) { |
| 938 | vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey); |
| 939 | return 1; |
| 940 | } |
| 941 | |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 942 | if (keyCode == 0x00) |
| 943 | keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC); |
| 944 | if (isExtended) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 945 | keyCode |= 0x80; |
Pierre Ossman | f73214c | 2017-11-13 09:06:03 +0100 | [diff] [blame] | 946 | if (keyCode == 0x45) |
| 947 | keyCode = 0xc6; |
| 948 | if (keyCode == 0xc5) |
| 949 | keyCode = 0x45; |
| 950 | if (keyCode == 0xb7) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 951 | keyCode = 0x54; |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 952 | |
| 953 | self->handleKeyRelease(keyCode); |
| 954 | |
Pierre Ossman | 30b3f92 | 2017-11-13 09:07:59 +0100 | [diff] [blame] | 955 | // Windows has a rather nasty bug where it won't send key release |
| 956 | // events for a Shift button if the other Shift is still pressed |
| 957 | if ((keyCode == 0x2a) || (keyCode == 0x36)) { |
| 958 | if (self->downKeySym.count(0x2a)) |
| 959 | self->handleKeyRelease(0x2a); |
| 960 | if (self->downKeySym.count(0x36)) |
| 961 | self->handleKeyRelease(0x36); |
| 962 | } |
| 963 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 964 | return 1; |
Pierre Ossman | 2e9684f | 2014-07-21 16:46:22 +0200 | [diff] [blame] | 965 | } |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 966 | #elif defined(__APPLE__) |
| 967 | if (cocoa_is_keyboard_event(event)) { |
| 968 | int keyCode; |
| 969 | |
| 970 | keyCode = cocoa_event_keycode(event); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 971 | if ((unsigned)keyCode >= code_map_osx_to_qnum_len) |
| 972 | keyCode = 0; |
| 973 | else |
| 974 | keyCode = code_map_osx_to_qnum[keyCode]; |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 975 | |
| 976 | if (cocoa_is_key_press(event)) { |
| 977 | rdr::U32 keySym; |
| 978 | |
| 979 | keySym = cocoa_event_keysym(event); |
| 980 | if (keySym == NoSymbol) { |
| 981 | vlog.error(_("No symbol for key code 0x%02x (in the current state)"), |
| 982 | (int)keyCode); |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 983 | } |
| 984 | |
| 985 | self->handleKeyPress(keyCode, keySym); |
| 986 | |
| 987 | // We don't get any release events for CapsLock, so we have to |
| 988 | // send the release right away. |
| 989 | if (keySym == XK_Caps_Lock) |
| 990 | self->handleKeyRelease(keyCode); |
| 991 | } else { |
| 992 | self->handleKeyRelease(keyCode); |
| 993 | } |
| 994 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 995 | return 1; |
Pierre Ossman | 6b743d0 | 2014-07-21 16:48:43 +0200 | [diff] [blame] | 996 | } |
| 997 | #else |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 998 | XEvent *xevent = (XEvent*)event; |
| 999 | |
| 1000 | if (xevent->type == KeyPress) { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1001 | int keycode; |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1002 | char str; |
| 1003 | KeySym keysym; |
| 1004 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1005 | keycode = code_map_keycode_to_qnum[xevent->xkey.keycode]; |
| 1006 | |
| 1007 | // Generate a fake keycode just for tracking if we can't figure |
| 1008 | // out the proper one |
| 1009 | if (keycode == 0) |
| 1010 | keycode = 0x100 | xevent->xkey.keycode; |
| 1011 | |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1012 | XLookupString(&xevent->xkey, &str, 1, &keysym, NULL); |
| 1013 | if (keysym == NoSymbol) { |
| 1014 | vlog.error(_("No symbol for key code %d (in the current state)"), |
| 1015 | (int)xevent->xkey.keycode); |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1016 | } |
| 1017 | |
| 1018 | switch (keysym) { |
| 1019 | // For the first few years, there wasn't a good consensus on what the |
| 1020 | // Windows keys should be mapped to for X11. So we need to help out a |
| 1021 | // bit and map all variants to the same key... |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1022 | case XK_Hyper_L: |
| 1023 | keysym = XK_Super_L; |
| 1024 | break; |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1025 | case XK_Hyper_R: |
| 1026 | keysym = XK_Super_R; |
| 1027 | break; |
| 1028 | // There has been several variants for Shift-Tab over the years. |
| 1029 | // RFB states that we should always send a normal tab. |
| 1030 | case XK_ISO_Left_Tab: |
| 1031 | keysym = XK_Tab; |
| 1032 | break; |
| 1033 | } |
| 1034 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1035 | self->handleKeyPress(keycode, keysym); |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 1036 | return 1; |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1037 | } else if (xevent->type == KeyRelease) { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1038 | int keycode = code_map_keycode_to_qnum[xevent->xkey.keycode]; |
| 1039 | if (keycode == 0) |
| 1040 | keycode = 0x100 | xevent->xkey.keycode; |
| 1041 | self->handleKeyRelease(keycode); |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 1042 | return 1; |
Pierre Ossman | 6b9622d | 2014-07-21 16:42:12 +0200 | [diff] [blame] | 1043 | } |
| 1044 | #endif |
| 1045 | |
Pierre Ossman | 64ff1ca | 2014-09-11 10:48:29 +0200 | [diff] [blame] | 1046 | return 0; |
Pierre Ossman | 4f3ac69 | 2014-08-22 15:10:22 +0200 | [diff] [blame] | 1047 | } |
| 1048 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1049 | void Viewport::initContextMenu() |
| 1050 | { |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1051 | contextMenu->clear(); |
| 1052 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1053 | fltk_menu_add(contextMenu, p_("ContextMenu|", "E&xit viewer"), |
| 1054 | 0, NULL, (void*)ID_EXIT, FL_MENU_DIVIDER); |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1055 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1056 | fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"), |
| 1057 | 0, NULL, (void*)ID_FULLSCREEN, |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1058 | FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0)); |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1059 | fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"), |
| 1060 | 0, NULL, (void*)ID_MINIMIZE, 0); |
| 1061 | fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"), |
| 1062 | 0, NULL, (void*)ID_RESIZE, |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1063 | (window()->fullscreen_active()?FL_MENU_INACTIVE:0) | |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1064 | FL_MENU_DIVIDER); |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1065 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1066 | fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"), |
| 1067 | 0, NULL, (void*)ID_CTRL, |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1068 | FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0)); |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1069 | fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"), |
| 1070 | 0, NULL, (void*)ID_ALT, |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1071 | FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0)); |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1072 | |
| 1073 | if (menuKeySym) { |
| 1074 | char sendMenuKey[64]; |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1075 | snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey); |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1076 | fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0); |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1077 | fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL, |
Pierre Ossman | 245c802 | 2015-02-25 11:27:49 +0100 | [diff] [blame] | 1078 | (void*)ID_MENUKEY, FL_MENU_INVISIBLE); |
Pierre Ossman | 4e7271e | 2011-05-24 12:47:12 +0000 | [diff] [blame] | 1079 | } |
| 1080 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1081 | fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"), |
| 1082 | 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER); |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1083 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1084 | fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"), |
| 1085 | 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER); |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1086 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1087 | fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."), |
| 1088 | 0, NULL, (void*)ID_OPTIONS, 0); |
| 1089 | fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."), |
| 1090 | 0, NULL, (void*)ID_INFO, 0); |
| 1091 | fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."), |
| 1092 | 0, NULL, (void*)ID_ABOUT, FL_MENU_DIVIDER); |
Pierre Ossman | b5b0ea5 | 2015-02-25 10:35:03 +0100 | [diff] [blame] | 1093 | |
Pierre Ossman | ff626f8 | 2015-09-23 16:39:54 +0200 | [diff] [blame] | 1094 | fltk_menu_add(contextMenu, p_("ContextMenu|", "Dismiss &menu"), |
| 1095 | 0, NULL, (void*)ID_DISMISS, 0); |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1096 | } |
| 1097 | |
| 1098 | |
| 1099 | void Viewport::popupContextMenu() |
| 1100 | { |
| 1101 | const Fl_Menu_Item *m; |
Pierre Ossman | c628ba4 | 2011-05-23 12:21:21 +0000 | [diff] [blame] | 1102 | char buffer[1024]; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1103 | |
Pierre Ossman | b3ff437 | 2011-06-03 11:45:15 +0000 | [diff] [blame] | 1104 | // Make sure the menu is reset to its initial state between goes or |
| 1105 | // it will start up highlighting the previously selected entry. |
| 1106 | contextMenu->value(-1); |
| 1107 | |
Henrik Andersson | abd70ce | 2011-09-14 06:31:06 +0000 | [diff] [blame] | 1108 | // initialize context menu before display |
| 1109 | initContextMenu(); |
| 1110 | |
Pierre Ossman | fd177f3 | 2012-01-05 12:37:04 +0000 | [diff] [blame] | 1111 | // Unfortunately FLTK doesn't reliably restore the mouse pointer for |
| 1112 | // menus, so we have to help it out. |
Pierre Ossman | bfbdb10 | 2012-01-05 12:32:03 +0000 | [diff] [blame] | 1113 | if (Fl::belowmouse() == this) |
| 1114 | window()->cursor(FL_CURSOR_DEFAULT); |
Pierre Ossman | bfbdb10 | 2012-01-05 12:32:03 +0000 | [diff] [blame] | 1115 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1116 | m = contextMenu->popup(); |
Pierre Ossman | bfbdb10 | 2012-01-05 12:32:03 +0000 | [diff] [blame] | 1117 | |
Pierre Ossman | fd177f3 | 2012-01-05 12:37:04 +0000 | [diff] [blame] | 1118 | // Back to our proper mouse pointer. |
Pierre Ossman | de1a3b9 | 2014-03-17 14:29:49 +0100 | [diff] [blame] | 1119 | if ((Fl::belowmouse() == this) && cursor) |
Pierre Ossman | bfbdb10 | 2012-01-05 12:32:03 +0000 | [diff] [blame] | 1120 | window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y); |
Pierre Ossman | bfbdb10 | 2012-01-05 12:32:03 +0000 | [diff] [blame] | 1121 | |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1122 | if (m == NULL) |
| 1123 | return; |
| 1124 | |
| 1125 | switch (m->argument()) { |
| 1126 | case ID_EXIT: |
| 1127 | exit_vncviewer(); |
| 1128 | break; |
Pierre Ossman | 4c613d3 | 2011-05-26 14:14:06 +0000 | [diff] [blame] | 1129 | case ID_FULLSCREEN: |
| 1130 | if (window()->fullscreen_active()) |
| 1131 | window()->fullscreen_off(); |
Pierre Ossman | 275284f | 2012-07-04 11:37:48 +0000 | [diff] [blame] | 1132 | else |
Pierre Ossman | aae3891 | 2012-07-13 11:22:55 +0000 | [diff] [blame] | 1133 | ((DesktopWindow*)window())->fullscreen_on(); |
Pierre Ossman | 4c613d3 | 2011-05-26 14:14:06 +0000 | [diff] [blame] | 1134 | break; |
Joel Teichroeb | a7494ac | 2015-07-13 14:46:22 -0700 | [diff] [blame] | 1135 | case ID_MINIMIZE: |
| 1136 | window()->iconize(); |
Joel Teichroeb | 1f9e45a | 2015-07-18 07:09:24 -0700 | [diff] [blame] | 1137 | break; |
Pierre Ossman | 8dc8bca | 2012-07-04 11:37:10 +0000 | [diff] [blame] | 1138 | case ID_RESIZE: |
Pierre Ossman | 8dc8bca | 2012-07-04 11:37:10 +0000 | [diff] [blame] | 1139 | if (window()->fullscreen_active()) |
| 1140 | break; |
Pierre Ossman | 8dc8bca | 2012-07-04 11:37:10 +0000 | [diff] [blame] | 1141 | window()->size(w(), h()); |
| 1142 | break; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1143 | case ID_CTRL: |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 1144 | if (m->value()) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1145 | handleKeyPress(0x1d, XK_Control_L); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 1146 | else |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1147 | handleKeyRelease(0x1d); |
Henrik Andersson | abd70ce | 2011-09-14 06:31:06 +0000 | [diff] [blame] | 1148 | menuCtrlKey = !menuCtrlKey; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1149 | break; |
| 1150 | case ID_ALT: |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 1151 | if (m->value()) |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1152 | handleKeyPress(0x38, XK_Alt_L); |
Pierre Ossman | 25188c4 | 2014-07-21 16:30:08 +0200 | [diff] [blame] | 1153 | else |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1154 | handleKeyRelease(0x38); |
Henrik Andersson | abd70ce | 2011-09-14 06:31:06 +0000 | [diff] [blame] | 1155 | menuAltKey = !menuAltKey; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1156 | break; |
| 1157 | case ID_MENUKEY: |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1158 | handleKeyPress(menuKeyCode, menuKeySym); |
| 1159 | handleKeyRelease(menuKeyCode); |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1160 | break; |
| 1161 | case ID_CTRLALTDEL: |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1162 | handleKeyPress(0x1d, XK_Control_L); |
| 1163 | handleKeyPress(0x38, XK_Alt_L); |
| 1164 | handleKeyPress(0xd3, XK_Delete); |
Pierre Ossman | 991b4fe | 2011-07-12 16:02:30 +0000 | [diff] [blame] | 1165 | |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1166 | handleKeyRelease(0xd3); |
| 1167 | handleKeyRelease(0x38); |
| 1168 | handleKeyRelease(0x1d); |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1169 | break; |
Pierre Ossman | d4c61ce | 2011-04-29 11:18:12 +0000 | [diff] [blame] | 1170 | case ID_REFRESH: |
| 1171 | cc->refreshFramebuffer(); |
| 1172 | break; |
Pierre Ossman | d463b57 | 2011-05-16 12:04:43 +0000 | [diff] [blame] | 1173 | case ID_OPTIONS: |
| 1174 | OptionsDialog::showDialog(); |
| 1175 | break; |
Pierre Ossman | 2eb1d11 | 2011-05-16 12:18:08 +0000 | [diff] [blame] | 1176 | case ID_INFO: |
Pierre Ossman | c628ba4 | 2011-05-23 12:21:21 +0000 | [diff] [blame] | 1177 | if (fltk_escape(cc->connectionInfo(), buffer, sizeof(buffer)) < sizeof(buffer)) { |
| 1178 | fl_message_title(_("VNC connection info")); |
Pierre Ossman | f52740e | 2012-04-25 15:43:56 +0000 | [diff] [blame] | 1179 | fl_message("%s", buffer); |
Pierre Ossman | c628ba4 | 2011-05-23 12:21:21 +0000 | [diff] [blame] | 1180 | } |
Pierre Ossman | 2eb1d11 | 2011-05-16 12:18:08 +0000 | [diff] [blame] | 1181 | break; |
Pierre Ossman | b885822 | 2011-04-29 11:51:38 +0000 | [diff] [blame] | 1182 | case ID_ABOUT: |
| 1183 | about_vncviewer(); |
| 1184 | break; |
Pierre Ossman | c7bfaac | 2011-04-29 11:08:11 +0000 | [diff] [blame] | 1185 | case ID_DISMISS: |
| 1186 | // Don't need to do anything |
| 1187 | break; |
| 1188 | } |
| 1189 | } |
Pierre Ossman | 4e7271e | 2011-05-24 12:47:12 +0000 | [diff] [blame] | 1190 | |
| 1191 | |
| 1192 | void Viewport::setMenuKey() |
| 1193 | { |
Pierre Ossman | 0c15866 | 2017-07-13 15:54:11 +0200 | [diff] [blame] | 1194 | getMenuKey(&menuKeyFLTK, &menuKeyCode, &menuKeySym); |
Pierre Ossman | 4e7271e | 2011-05-24 12:47:12 +0000 | [diff] [blame] | 1195 | } |
| 1196 | |
| 1197 | |
| 1198 | void Viewport::handleOptions(void *data) |
| 1199 | { |
| 1200 | Viewport *self = (Viewport*)data; |
| 1201 | |
| 1202 | self->setMenuKey(); |
| 1203 | } |