From 940cb4fcd54d317a69b556e73effbf29ded83bac Mon Sep 17 00:00:00 2001 From: Nicky Date: Tue, 19 Mar 2019 05:23:33 +0100 Subject: [PATCH] - Correct MD5 for libndofdev. - New dullahan with updated SDL2 keyboard - Improve keyboard handling for SDL2 and make sure: - accelerators work again. - enter is properly forwarded as an input event. - mousewheel messages get handled. --- autobuild.xml | 10 +- indra/llwindow/llkeyboardsdl.cpp | 398 ++++++++++++------- indra/llwindow/llkeyboardsdl.h | 2 +- indra/llwindow/llwindowsdl.cpp | 47 ++- indra/llwindow/llwindowsdl.h | 2 - indra/media_plugins/cef/media_plugin_cef.cpp | 33 +- 6 files changed, 312 insertions(+), 180 deletions(-) diff --git a/autobuild.xml b/autobuild.xml index 3a83fa0dc3..35390e03af 100644 --- a/autobuild.xml +++ b/autobuild.xml @@ -80,9 +80,9 @@ archive hash - 3156400f22047d6e194884970842f571 + b2d2a51bca4e3c3acc98eaab881a652e url - http://downloads.phoenixviewer.com/dullahan_gcc5-1.1.1313_3.3626.1895.g7001d56-linux64-190760044.tar.bz2 + http://downloads.phoenixviewer.com/dullahan_gcc5-1.1.1313_3.3626.1895.g7001d56-linux64-190772217.tar.bz2 name linux64 @@ -866,9 +866,9 @@ archive hash - ccee21f79ca1628c38c55295cd2544e6 + 0f83072d15c7265b21d33b677a511efc url - http://downloads.phoenixviewer.com/dullahan-1.1.1313_3.3626.1895.g7001d56-linux64-190760005.tar.bz2 + http://downloads.phoenixviewer.com/dullahan-1.1.1313_3.3626.1895.g7001d56-linux64-190772141.tar.bz2 name linux64 @@ -2922,7 +2922,7 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors archive hash - 63d804306cf94a338a8690050928cefb + a32657211755c612faa3b7c5fb061465 url http://downloads.phoenixviewer.com/open_libndofdev-0.3.190761441-linux64-190761441.tar.bz2 diff --git a/indra/llwindow/llkeyboardsdl.cpp b/indra/llwindow/llkeyboardsdl.cpp index 1874d4f323..af303ada7f 100644 --- a/indra/llwindow/llkeyboardsdl.cpp +++ b/indra/llwindow/llkeyboardsdl.cpp @@ -42,24 +42,23 @@ LLKeyboardSDL::LLKeyboardSDL() // SDL maps the letter keys to the ASCII you'd expect, but it's lowercase... - // Those are handled by SDL2 via text input, do not map them - - // U16 cur_char; - // for (cur_char = 'A'; cur_char <= 'Z'; cur_char++) - // { - // mTranslateKeyMap[cur_char] = cur_char; - // } - // for (cur_char = 'a'; cur_char <= 'z'; cur_char++) - // { - // mTranslateKeyMap[cur_char] = (cur_char - 'a') + 'A'; - // } - // - // for (cur_char = '0'; cur_char <= '9'; cur_char++) - // { - // mTranslateKeyMap[cur_char] = cur_char; - // } + // Looks like we need to map those despite of SDL_TEXTINPUT handling most of this, but without + // the translation lower->upper here accelerators will not work. - // Compatibility shim for SDL2 > SDL1. -// The dullahan plugin still expects SDL1 codes. Temporarily map those SDL keyes till the plugin is updated -enum class SDL1Keys: U32 { - SDLK_UNKNOWN = 0, - SDLK_BACKSPACE = 8, - SDLK_TAB = 9, - SDLK_CLEAR = 12, - SDLK_RETURN = 13, - SDLK_PAUSE = 19, - SDLK_ESCAPE = 27, - SDLK_DELETE = 127, - SDLK_KP_PERIOD = 266, - SDLK_KP_DIVIDE = 267, - SDLK_KP_MULTIPLY= 268, - SDLK_KP_MINUS = 269, - SDLK_KP_PLUS = 270, - SDLK_KP_ENTER = 271, - SDLK_KP_EQUALS = 272, - SDLK_UP = 273, - SDLK_DOWN = 274, - SDLK_RIGHT = 275, - SDLK_LEFT = 276, - SDLK_INSERT = 277, - SDLK_HOME = 278, - SDLK_END = 279, - SDLK_PAGEUP = 280, - SDLK_PAGEDOWN = 281, - SDLK_F1 = 282, - SDLK_F2 = 283, - SDLK_F3 = 284, - SDLK_F4 = 285, - SDLK_F5 = 286, - SDLK_F6 = 287, - SDLK_F7 = 288, - SDLK_F8 = 289, - SDLK_F9 = 290, - SDLK_F10 = 291, - SDLK_F11 = 292, - SDLK_F12 = 293, - SDLK_F13 = 294, - SDLK_F14 = 295, - SDLK_F15 = 296, - SDLK_CAPSLOCK = 301, - SDLK_RSHIFT = 303, - SDLK_LSHIFT = 304, - SDLK_RCTRL = 305, - SDLK_LCTRL = 306, - SDLK_RALT = 307, - SDLK_LALT = 308, - SDLK_MODE = 313, /**< "Alt Gr" key */ - SDLK_HELP = 315, - SDLK_SYSREQ = 317, - SDLK_MENU = 319, - SDLK_POWER = 320, /**< Power Macintosh power key */ - SDLK_UNDO = 322, /**< Atari keyboard has Undo */ -}; - -std::map< U32, U32 > mSDL2_to_SDL1; - -U32 LLKeyboardSDL::mapSDL2toSDL1( U32 aSymbol ) +enum class WindowsVK : U32 { - if( mSDL2_to_SDL1.empty() ) - { - mSDL2_to_SDL1[ SDLK_UNKNOWN ] = (U32)SDL1Keys::SDLK_UNKNOWN; - mSDL2_to_SDL1[ SDLK_BACKSPACE ] = (U32)SDL1Keys::SDLK_BACKSPACE; - mSDL2_to_SDL1[ SDLK_TAB ] = (U32)SDL1Keys::SDLK_TAB; - mSDL2_to_SDL1[ SDLK_CLEAR ] = (U32)SDL1Keys::SDLK_CLEAR; - mSDL2_to_SDL1[ SDLK_RETURN ] = (U32)SDL1Keys::SDLK_RETURN; - mSDL2_to_SDL1[ SDLK_PAUSE ] = (U32)SDL1Keys::SDLK_PAUSE; - mSDL2_to_SDL1[ SDLK_ESCAPE ] = (U32)SDL1Keys::SDLK_ESCAPE; - mSDL2_to_SDL1[ SDLK_DELETE ] = (U32)SDL1Keys::SDLK_DELETE; - mSDL2_to_SDL1[ SDLK_KP_PERIOD ] = (U32)SDL1Keys::SDLK_KP_PERIOD; - mSDL2_to_SDL1[ SDLK_KP_DIVIDE ] = (U32)SDL1Keys::SDLK_KP_DIVIDE; - mSDL2_to_SDL1[ SDLK_KP_MULTIPLY] = (U32)SDL1Keys::SDLK_KP_MULTIPLY; - mSDL2_to_SDL1[ SDLK_KP_MINUS ] = (U32)SDL1Keys::SDLK_KP_MINUS; - mSDL2_to_SDL1[ SDLK_KP_PLUS ] = (U32)SDL1Keys::SDLK_KP_PLUS; - mSDL2_to_SDL1[ SDLK_KP_ENTER ] = (U32)SDL1Keys::SDLK_KP_ENTER; - mSDL2_to_SDL1[ SDLK_KP_EQUALS ] = (U32)SDL1Keys::SDLK_KP_EQUALS; - mSDL2_to_SDL1[ SDLK_UP ] = (U32)SDL1Keys::SDLK_UP; - mSDL2_to_SDL1[ SDLK_DOWN ] = (U32)SDL1Keys::SDLK_DOWN; - mSDL2_to_SDL1[ SDLK_RIGHT ] = (U32)SDL1Keys::SDLK_RIGHT; - mSDL2_to_SDL1[ SDLK_LEFT ] = (U32)SDL1Keys::SDLK_LEFT; - mSDL2_to_SDL1[ SDLK_INSERT ] = (U32)SDL1Keys::SDLK_INSERT; - mSDL2_to_SDL1[ SDLK_HOME ] = (U32)SDL1Keys::SDLK_HOME; - mSDL2_to_SDL1[ SDLK_END ] = (U32)SDL1Keys::SDLK_END; - mSDL2_to_SDL1[ SDLK_PAGEUP ] = (U32)SDL1Keys::SDLK_PAGEUP; - mSDL2_to_SDL1[ SDLK_PAGEDOWN ] = (U32)SDL1Keys::SDLK_PAGEDOWN; - mSDL2_to_SDL1[ SDLK_F1 ] = (U32)SDL1Keys::SDLK_F1; - mSDL2_to_SDL1[ SDLK_F2 ] = (U32)SDL1Keys::SDLK_F2; - mSDL2_to_SDL1[ SDLK_F3 ] = (U32)SDL1Keys::SDLK_F3; - mSDL2_to_SDL1[ SDLK_F4 ] = (U32)SDL1Keys::SDLK_F4; - mSDL2_to_SDL1[ SDLK_F5 ] = (U32)SDL1Keys::SDLK_F5; - mSDL2_to_SDL1[ SDLK_F6 ] = (U32)SDL1Keys::SDLK_F6; - mSDL2_to_SDL1[ SDLK_F7 ] = (U32)SDL1Keys::SDLK_F7; - mSDL2_to_SDL1[ SDLK_F8 ] = (U32)SDL1Keys::SDLK_F8; - mSDL2_to_SDL1[ SDLK_F9 ] = (U32)SDL1Keys::SDLK_F9; - mSDL2_to_SDL1[ SDLK_F10 ] = (U32)SDL1Keys::SDLK_F10; - mSDL2_to_SDL1[ SDLK_F11 ] = (U32)SDL1Keys::SDLK_F11; - mSDL2_to_SDL1[ SDLK_F12 ] = (U32)SDL1Keys::SDLK_F12; - mSDL2_to_SDL1[ SDLK_F13 ] = (U32)SDL1Keys::SDLK_F13; - mSDL2_to_SDL1[ SDLK_F14 ] = (U32)SDL1Keys::SDLK_F14; - mSDL2_to_SDL1[ SDLK_F15 ] = (U32)SDL1Keys::SDLK_F15; - mSDL2_to_SDL1[ SDLK_CAPSLOCK ] = (U32)SDL1Keys::SDLK_CAPSLOCK; - mSDL2_to_SDL1[ SDLK_RSHIFT ] = (U32)SDL1Keys::SDLK_RSHIFT; - mSDL2_to_SDL1[ SDLK_LSHIFT ] = (U32)SDL1Keys::SDLK_LSHIFT; - mSDL2_to_SDL1[ SDLK_RCTRL ] = (U32)SDL1Keys::SDLK_RCTRL; - mSDL2_to_SDL1[ SDLK_LCTRL ] = (U32)SDL1Keys::SDLK_LCTRL; - mSDL2_to_SDL1[ SDLK_RALT ] = (U32)SDL1Keys::SDLK_RALT; - mSDL2_to_SDL1[ SDLK_LALT ] = (U32)SDL1Keys::SDLK_LALT; - mSDL2_to_SDL1[ SDLK_MODE ] = (U32)SDL1Keys::SDLK_MODE; - mSDL2_to_SDL1[ SDLK_HELP ] = (U32)SDL1Keys::SDLK_HELP; - mSDL2_to_SDL1[ SDLK_SYSREQ ] = (U32)SDL1Keys::SDLK_SYSREQ; - mSDL2_to_SDL1[ SDLK_MENU ] = (U32)SDL1Keys::SDLK_MENU; - mSDL2_to_SDL1[ SDLK_POWER ] = (U32)SDL1Keys::SDLK_POWER; - mSDL2_to_SDL1[ SDLK_UNDO ] = (U32)SDL1Keys::SDLK_UNDO; - } + VK_UNKNOWN = 0, + VK_BACK = 0x08, + VK_TAB = 0x09, + VK_CLEAR = 0x0C, + VK_RETURN = 0x0D, + VK_SHIFT = 0x10, + VK_CONTROL = 0x11, + VK_MENU = 0x12, + VK_PAUSE = 0x13, + VK_CAPITAL = 0x14, + VK_KANA = 0x15, + VK_HANGUL = 0x15, + VK_JUNJA = 0x17, + VK_FINAL = 0x18, + VK_HANJA = 0x19, + VK_KANJI = 0x19, + VK_ESCAPE = 0x1B, + VK_CONVERT = 0x1C, + VK_NONCONVERT = 0x1D, + VK_ACCEPT = 0x1E, + VK_MODECHANGE = 0x1F, + VK_SPACE = 0x20, + VK_PRIOR = 0x21, + VK_NEXT = 0x22, + VK_END = 0x23, + VK_HOME = 0x24, + VK_LEFT = 0x25, + VK_UP = 0x26, + VK_RIGHT = 0x27, + VK_DOWN = 0x28, + VK_SELECT = 0x29, + VK_PRINT = 0x2A, + VK_EXECUTE = 0x2B, + VK_SNAPSHOT = 0x2C, + VK_INSERT = 0x2D, + VK_DELETE = 0x2E, + VK_HELP = 0x2F, + VK_0 = 0x30, + VK_1 = 0x31, + VK_2 = 0x32, + VK_3 = 0x33, + VK_4 = 0x34, + VK_5 = 0x35, + VK_6 = 0x36, + VK_7 = 0x37, + VK_8 = 0x38, + VK_9 = 0x39, + VK_A = 0x41, + VK_B = 0x42, + VK_C = 0x43, + VK_D = 0x44, + VK_E = 0x45, + VK_F = 0x46, + VK_G = 0x47, + VK_H = 0x48, + VK_I = 0x49, + VK_J = 0x4A, + VK_K = 0x4B, + VK_L = 0x4C, + VK_M = 0x4D, + VK_N = 0x4E, + VK_O = 0x4F, + VK_P = 0x50, + VK_Q = 0x51, + VK_R = 0x52, + VK_S = 0x53, + VK_T = 0x54, + VK_U = 0x55, + VK_V = 0x56, + VK_W = 0x57, + VK_X = 0x58, + VK_Y = 0x59, + VK_Z = 0x5A, + VK_LWIN = 0x5B, + VK_RWIN = 0x5C, + VK_APPS = 0x5D, + VK_SLEEP = 0x5F, + VK_NUMPAD0 = 0x60, + VK_NUMPAD1 = 0x61, + VK_NUMPAD2 = 0x62, + VK_NUMPAD3 = 0x63, + VK_NUMPAD4 = 0x64, + VK_NUMPAD5 = 0x65, + VK_NUMPAD6 = 0x66, + VK_NUMPAD7 = 0x67, + VK_NUMPAD8 = 0x68, + VK_NUMPAD9 = 0x69, + VK_MULTIPLY = 0x6A, + VK_ADD = 0x6B, + VK_SEPARATOR = 0x6C, + VK_SUBTRACT = 0x6D, + VK_DECIMAL = 0x6E, + VK_DIVIDE = 0x6F, + VK_F1 = 0x70, + VK_F2 = 0x71, + VK_F3 = 0x72, + VK_F4 = 0x73, + VK_F5 = 0x74, + VK_F6 = 0x75, + VK_F7 = 0x76, + VK_F8 = 0x77, + VK_F9 = 0x78, + VK_F10 = 0x79, + VK_F11 = 0x7A, + VK_F12 = 0x7B, + VK_F13 = 0x7C, + VK_F14 = 0x7D, + VK_F15 = 0x7E, + VK_F16 = 0x7F, + VK_F17 = 0x80, + VK_F18 = 0x81, + VK_F19 = 0x82, + VK_F20 = 0x83, + VK_F21 = 0x84, + VK_F22 = 0x85, + VK_F23 = 0x86, + VK_F24 = 0x87, + VK_NUMLOCK = 0x90, + VK_SCROLL = 0x91, + VK_LSHIFT = 0xA0, + VK_RSHIFT = 0xA1, + VK_LCONTROL = 0xA2, + VK_RCONTROL = 0xA3, + VK_LMENU = 0xA4, + VK_RMENU = 0xA5, + VK_BROWSER_BACK = 0xA6, + VK_BROWSER_FORWARD = 0xA7, + VK_BROWSER_REFRESH = 0xA8, + VK_BROWSER_STOP = 0xA9, + VK_BROWSER_SEARCH = 0xAA, + VK_BROWSER_FAVORITES = 0xAB, + VK_BROWSER_HOME = 0xAC, + VK_VOLUME_MUTE = 0xAD, + VK_VOLUME_DOWN = 0xAE, + VK_VOLUME_UP = 0xAF, + VK_MEDIA_NEXT_TRACK = 0xB0, + VK_MEDIA_PREV_TRACK = 0xB1, + VK_MEDIA_STOP = 0xB2, + VK_MEDIA_PLAY_PAUSE = 0xB3, + VK_MEDIA_LAUNCH_MAIL = 0xB4, + VK_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5, + VK_MEDIA_LAUNCH_APP1 = 0xB6, + VK_MEDIA_LAUNCH_APP2 = 0xB7, + VK_OEM_1 = 0xBA, + VK_OEM_PLUS = 0xBB, + VK_OEM_COMMA = 0xBC, + VK_OEM_MINUS = 0xBD, + VK_OEM_PERIOD = 0xBE, + VK_OEM_2 = 0xBF, + VK_OEM_3 = 0xC0, + VK_OEM_4 = 0xDB, + VK_OEM_5 = 0xDC, + VK_OEM_6 = 0xDD, + VK_OEM_7 = 0xDE, + VK_OEM_8 = 0xDF, + VK_OEM_102 = 0xE2, + VK_PROCESSKEY = 0xE5, + VK_PACKET = 0xE7, + VK_ATTN = 0xF6, + VK_CRSEL = 0xF7, + VK_EXSEL = 0xF8, + VK_EREOF = 0xF9, + VK_PLAY = 0xFA, + VK_ZOOM = 0xFB, + VK_NONAME = 0xFC, + VK_PA1 = 0xFD, + VK_OEM_CLEAR = 0xFE, +}; - auto itr = mSDL2_to_SDL1.find( aSymbol ); - if( itr != mSDL2_to_SDL1.end() ) +std::map< U32, U32 > mSDL2_to_Win; +std::set< U32 > mIgnoreSDL2Keys; + +U32 LLKeyboardSDL::mapSDL2toWin( U32 aSymbol ) +{ + // Map SDLK_ virtual keys to Windows VK_ virtual keys. + // Text is handled via unicode input (SDL_TEXTINPUT event) and does not need to be translated into VK_ values as those match already. + if( mSDL2_to_Win.empty() ) + { + mSDL2_to_Win[ SDLK_UNKNOWN ] = (U32)WindowsVK::VK_UNKNOWN; + mSDL2_to_Win[ SDLK_BACKSPACE ] = (U32)WindowsVK::VK_BACK; + mSDL2_to_Win[ SDLK_TAB ] = (U32)WindowsVK::VK_TAB; + mSDL2_to_Win[ SDLK_CLEAR ] = (U32)WindowsVK::VK_CLEAR; + mSDL2_to_Win[ SDLK_RETURN ] = (U32)WindowsVK::VK_RETURN; + mSDL2_to_Win[ SDLK_PAUSE ] = (U32)WindowsVK::VK_PAUSE; + mSDL2_to_Win[ SDLK_ESCAPE ] = (U32)WindowsVK::VK_ESCAPE; + mSDL2_to_Win[ SDLK_DELETE ] = (U32)WindowsVK::VK_DELETE; + mSDL2_to_Win[ SDLK_KP_PERIOD ] = (U32)WindowsVK::VK_OEM_PERIOD; + mSDL2_to_Win[ SDLK_KP_DIVIDE ] = (U32)WindowsVK::VK_DIVIDE; + mSDL2_to_Win[ SDLK_KP_MULTIPLY] = (U32)WindowsVK::VK_MULTIPLY; + mSDL2_to_Win[ SDLK_KP_MINUS ] = (U32)WindowsVK::VK_OEM_MINUS; + mSDL2_to_Win[ SDLK_KP_PLUS ] = (U32)WindowsVK::VK_OEM_PLUS; + mSDL2_to_Win[ SDLK_KP_ENTER ] = (U32)WindowsVK::VK_RETURN; + + // ? + //mSDL2_to_Win[ SDLK_KP_EQUALS ] = (U32)WindowsVK::VK_EQUALS; + + mSDL2_to_Win[ SDLK_UP ] = (U32)WindowsVK::VK_UP; + mSDL2_to_Win[ SDLK_DOWN ] = (U32)WindowsVK::VK_DOWN; + mSDL2_to_Win[ SDLK_RIGHT ] = (U32)WindowsVK::VK_RIGHT; + mSDL2_to_Win[ SDLK_LEFT ] = (U32)WindowsVK::VK_LEFT; + mSDL2_to_Win[ SDLK_INSERT ] = (U32)WindowsVK::VK_INSERT; + mSDL2_to_Win[ SDLK_HOME ] = (U32)WindowsVK::VK_HOME; + mSDL2_to_Win[ SDLK_END ] = (U32)WindowsVK::VK_END; + mSDL2_to_Win[ SDLK_PAGEUP ] = (U32)WindowsVK::VK_PRIOR; + mSDL2_to_Win[ SDLK_PAGEDOWN ] = (U32)WindowsVK::VK_NEXT; + mSDL2_to_Win[ SDLK_F1 ] = (U32)WindowsVK::VK_F1; + mSDL2_to_Win[ SDLK_F2 ] = (U32)WindowsVK::VK_F2; + mSDL2_to_Win[ SDLK_F3 ] = (U32)WindowsVK::VK_F3; + mSDL2_to_Win[ SDLK_F4 ] = (U32)WindowsVK::VK_F4; + mSDL2_to_Win[ SDLK_F5 ] = (U32)WindowsVK::VK_F5; + mSDL2_to_Win[ SDLK_F6 ] = (U32)WindowsVK::VK_F6; + mSDL2_to_Win[ SDLK_F7 ] = (U32)WindowsVK::VK_F7; + mSDL2_to_Win[ SDLK_F8 ] = (U32)WindowsVK::VK_F8; + mSDL2_to_Win[ SDLK_F9 ] = (U32)WindowsVK::VK_F9; + mSDL2_to_Win[ SDLK_F10 ] = (U32)WindowsVK::VK_F10; + mSDL2_to_Win[ SDLK_F11 ] = (U32)WindowsVK::VK_F11; + mSDL2_to_Win[ SDLK_F12 ] = (U32)WindowsVK::VK_F12; + mSDL2_to_Win[ SDLK_F13 ] = (U32)WindowsVK::VK_F13; + mSDL2_to_Win[ SDLK_F14 ] = (U32)WindowsVK::VK_F14; + mSDL2_to_Win[ SDLK_F15 ] = (U32)WindowsVK::VK_F15; + mSDL2_to_Win[ SDLK_CAPSLOCK ] = (U32)WindowsVK::VK_CAPITAL; + mSDL2_to_Win[ SDLK_RSHIFT ] = (U32)WindowsVK::VK_SHIFT; + mSDL2_to_Win[ SDLK_LSHIFT ] = (U32)WindowsVK::VK_SHIFT; + mSDL2_to_Win[ SDLK_RCTRL ] = (U32)WindowsVK::VK_CONTROL; + mSDL2_to_Win[ SDLK_LCTRL ] = (U32)WindowsVK::VK_CONTROL; + mSDL2_to_Win[ SDLK_RALT ] = (U32)WindowsVK::VK_MENU; + mSDL2_to_Win[ SDLK_LALT ] = (U32)WindowsVK::VK_MENU; + + // VK_MODECHANGE ? + // mSDL2_to_Win[ SDLK_MODE ] = (U32)WindowsVK::VK_MODE; + + mSDL2_to_Win[ SDLK_HELP ] = (U32)WindowsVK::VK_HELP; + + // ? + // mSDL2_to_Win[ SDLK_SYSREQ ] = (U32)WindowsVK::VK_SYSREQ; + mSDL2_to_Win[ SDLK_MENU ] = (U32)WindowsVK::VK_MENU; + + // ? + // mSDL2_to_Win[ SDLK_POWER ] = (U32)WindowsVK::VK_POWER; + + // ? + //mSDL2_to_Win[ SDLK_UNDO ] = (U32)WindowsVK::VK_UNDO; + } + + auto itr = mSDL2_to_Win.find( aSymbol ); + if( itr != mSDL2_to_Win.end() ) return itr->second; return aSymbol; } -// Compatibility shim for SDL2 > SDL1. - #endif diff --git a/indra/llwindow/llkeyboardsdl.h b/indra/llwindow/llkeyboardsdl.h index cefde07148..e31229eb6e 100644 --- a/indra/llwindow/llkeyboardsdl.h +++ b/indra/llwindow/llkeyboardsdl.h @@ -52,7 +52,7 @@ private: std::map mInvTranslateNumpadMap; // inverse of the above public: - static U32 mapSDL2toSDL1( U32 ); + static U32 mapSDL2toWin( U32 ); }; #endif diff --git a/indra/llwindow/llwindowsdl.cpp b/indra/llwindow/llwindowsdl.cpp index 5fe817923a..20873bb151 100644 --- a/indra/llwindow/llwindowsdl.cpp +++ b/indra/llwindow/llwindowsdl.cpp @@ -250,7 +250,6 @@ LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks, mFlashing = FALSE; #endif // LL_X11 - mKeyScanCode = 0; mKeyVirtualKey = 0; mKeyModifiers = KMOD_NONE; } @@ -1738,6 +1737,11 @@ void LLWindowSDL::gatherInput() { switch (event.type) { + case SDL_MOUSEWHEEL: + if( event.wheel.y != 0 ) + mCallbacks->handleScrollWheel(this, event.wheel.y); + break; + case SDL_MOUSEMOTION: { LLCoordWindow winCoord(event.button.x, event.button.y); @@ -1753,44 +1757,39 @@ void LLWindowSDL::gatherInput() auto string = utf8str_to_utf16str( event.text.text ); for( auto key: string ) { - mKeyScanCode = string[0]; mKeyVirtualKey = string[0]; mKeyModifiers = SDL_GetModState(); - mSDLSym = string[0]; - handleUnicodeUTF16( key, gKeyboard->currentMask(FALSE)); + handleUnicodeUTF16( key, mKeyModifiers ); } break; } case SDL_KEYDOWN: - mKeyScanCode = event.key.keysym.scancode; - mKeyVirtualKey = LLKeyboardSDL::mapSDL2toSDL1( event.key.keysym.sym ); + mKeyVirtualKey = event.key.keysym.sym; mKeyModifiers = event.key.keysym.mod; - mSDLSym = LLKeyboardSDL::mapSDL2toSDL1( event.key.keysym.sym ); - gKeyboard->handleKeyDown(event.key.keysym.sym, event.key.keysym.mod); + gKeyboard->handleKeyDown(mKeyVirtualKey, mKeyModifiers ); + + // Slightly hacky :| To make the viewer honor enter (eg to accept form input) we've to not only send handleKeyDown but also send a + // invoke handleUnicodeUTF16 in case the user hits return. + // Note that we cannot blindly use handleUnicodeUTF16 for each SDL_KEYDOWN. Doing so will create bogus keyboard input (like % for cursor left). + if( mKeyVirtualKey == SDLK_RETURN ) + handleUnicodeUTF16( mKeyVirtualKey, mKeyModifiers ); + // part of the fix for SL-13243 if (SDLCheckGrabbyKeys(event.key.keysym.sym, TRUE) != 0) SDLReallyCaptureInput(TRUE); - { - KEY dummyKey{}; - - if( gKeyboard->translateKey( mSDLSym, &dummyKey ) ) - handleUnicodeUTF16( mSDLSym, gKeyboard->currentMask(FALSE)); - } break; case SDL_KEYUP: - mKeyScanCode = event.key.keysym.scancode; - mKeyVirtualKey = LLKeyboardSDL::mapSDL2toSDL1( event.key.keysym.sym ); + mKeyVirtualKey = event.key.keysym.sym; mKeyModifiers = event.key.keysym.mod; - mSDLSym = LLKeyboardSDL::mapSDL2toSDL1( event.key.keysym.sym ); - if (SDLCheckGrabbyKeys(event.key.keysym.sym, FALSE) == 0) + if (SDLCheckGrabbyKeys(mKeyVirtualKey, FALSE) == 0) SDLReallyCaptureInput(FALSE); // part of the fix for SL-13243 - gKeyboard->handleKeyUp(event.key.keysym.sym, event.key.keysym.mod); + gKeyboard->handleKeyUp(mKeyVirtualKey,mKeyModifiers); break; case SDL_MOUSEBUTTONDOWN: @@ -2365,7 +2364,7 @@ static void color_changed_callback(GtkWidget *widget, */ LLSD LLWindowSDL::getNativeKeyData() { - LLSD result = LLSD::emptyMap(); + LLSD result = LLSD::emptyMap(); U32 modifiers = 0; // pretend-native modifiers... oh what a tangled web we weave! @@ -2383,11 +2382,11 @@ LLSD LLWindowSDL::getNativeKeyData() // *todo: test ALTs - I don't have a case for testing these. Do you? // *todo: NUM? - I don't care enough right now (and it's not a GDK modifier). - result["scan_code"] = (S32)mKeyScanCode; - result["virtual_key"] = (S32)mKeyVirtualKey; + result["virtual_key"] = (S32)mKeyVirtualKey; + result["virtual_key_win"] = (S32)LLKeyboardSDL::mapSDL2toWin( mKeyVirtualKey ); result["modifiers"] = (S32)modifiers; - result[ "sdl_sym" ] = (S32)mSDLSym; // Store the SDL Keysym too. - return result; + + return result; } diff --git a/indra/llwindow/llwindowsdl.h b/indra/llwindow/llwindowsdl.h index c2b366a690..027bd0ab6b 100644 --- a/indra/llwindow/llwindowsdl.h +++ b/indra/llwindow/llwindowsdl.h @@ -215,10 +215,8 @@ private: LLTimer mFlashTimer; #endif //LL_X11 - U32 mKeyScanCode; U32 mKeyVirtualKey; U32 mKeyModifiers; - U32 mSDLSym; // Store the SDL Keysym too. BOOL mUseLegacyCursors; // Legacy cursor setting from main program private: diff --git a/indra/media_plugins/cef/media_plugin_cef.cpp b/indra/media_plugins/cef/media_plugin_cef.cpp index 607a4b4ec0..cd653df257 100644 --- a/indra/media_plugins/cef/media_plugin_cef.cpp +++ b/indra/media_plugins/cef/media_plugin_cef.cpp @@ -832,12 +832,20 @@ void MediaPluginCEF::keyEvent(dullahan::EKeyEvent key_event, LLSD native_key_dat // Keyboard handling for Linux. #if LL_LINUX - uint32_t native_scan_code = (uint32_t)(native_key_data["sdl_sym"].asInteger()); - uint32_t native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger()); - uint32_t native_modifiers = (uint32_t)(native_key_data["cef_modifiers"].asInteger()); - if( native_scan_code == '\n' ) - native_scan_code = '\r'; - mCEFLib->nativeKeyboardEvent(key_event, native_scan_code, native_virtual_key, native_modifiers); + uint32_t native_virtual_key = (uint32_t)(native_key_data["virtual_key_win"].asInteger()); + uint32_t native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger()); + + if( native_virtual_key == '\n' ) + native_virtual_key = '\r'; + + mCEFLib->nativeKeyboardEventSDL2(key_event, native_virtual_key, native_modifiers, false); + + // Slightly hacky :| To make CEF honor enter (eg to accept form input) we've to not only send KE_KEY_UP/KE_KEY_DOWN + // but also a KE_KEY_CHAR event. + // Note that we cannot blindly send a KE_CHAR for each KE_KEY_UP. Doing so will create bogus keyboard input (like % for cursor left). + // Adding this just in llwindowsdl does not seem to fire an appropriate unicodeInput event down below, thus repeat this check here again :( + if( dullahan::KE_KEY_UP == key_event && native_virtual_key == '\r' ) + mCEFLib->nativeKeyboardEventSDL2(dullahan::KE_KEY_CHAR, native_virtual_key, native_modifiers, false); #endif // }; @@ -872,12 +880,13 @@ void MediaPluginCEF::unicodeInput(std::string event, LLSD native_key_data = LLSD #endif // Keyboard handling for Linux. #if LL_LINUX - uint32_t native_scan_code = (uint32_t)(native_key_data["sdl_sym"].asInteger()); - uint32_t native_virtual_key = (uint32_t)(native_key_data["virtual_key"].asInteger()); - uint32_t native_modifiers = (uint32_t)(native_key_data["cef_modifiers"].asInteger()); - if( native_scan_code == '\n' ) - native_scan_code = '\r'; - mCEFLib->nativeKeyboardEvent(dullahan::KE_KEY_DOWN, native_scan_code, native_virtual_key, native_modifiers); + uint32_t native_virtual_key = (uint32_t)(native_key_data["virtual_key_win"].asInteger()); + uint32_t native_modifiers = (uint32_t)(native_key_data["modifiers"].asInteger()); + + if( native_virtual_key == '\n' ) + native_virtual_key = '\r'; + + mCEFLib->nativeKeyboardEventSDL2(dullahan::KE_KEY_CHAR, native_virtual_key, native_modifiers, false); #endif // };