remove crashy LLSD ctor used by GameControl

author: leviathan <leviathan@lindenlab.com> 2024-09-03 15:38:35 -0700
committer: Andrew Meadows <andrew.l.meadows@gmail.com> 2024-10-03 09:16:46 -0700
commit: 0617923ae7f450ece7288f8a73446c45a8ed32db (patch)
tree: 1914627e41be3619eb335aa28e6acdfb98925ea0 /indra
parent: 8213a0fb6b3149042d6833c8f0c4a3c1bfdc8bc9 (diff)
34 files changed, 585 insertions, 480 deletions
diff --git a/indra/cmake/00-COMPILE-LINK-RUN.txt b/indra/cmake/00-COMPILE-LINK-RUN.txt
index 1933072a6d..6cff0c0f28 100644
--- a/indra/cmake/00-COMPILE-LINK-RUN.txt
+++ b/indra/cmake/00-COMPILE-LINK-RUN.txt
@@ -162,7 +162,7 @@ Linking
 
     *  Update the autobuild.xml of ALL consumers of the library.  In
     the case of zlib, that meant updating freetype, libpng, openssl,
-    libxml2, fontconfig, curl, Boost, SDL, llqtwebkit, google-mock and
+    libxml2, fontconfig, curl, Boost, SDL2, llqtwebkit, google-mock and
     colladadom.
 
     *  Confirm by test and observation that the consumers actually use
diff --git a/indra/cmake/UI.cmake b/indra/cmake/UI.cmake
index 0df62808e7..ae039b4a47 100644
--- a/indra/cmake/UI.cmake
+++ b/indra/cmake/UI.cmake
@@ -21,9 +21,10 @@ if (LINUX)
           Xext
           Xft
           Xinerama
+          X11
           ll::fontconfig
           ll::freetype
-          ll::SDL
+          ll::SDL2
           ll::glib
           ll::gio
   )
diff --git a/indra/llappearance/CMakeLists.txt b/indra/llappearance/CMakeLists.txt
index c3be8bc78e..c510d01e3a 100644
--- a/indra/llappearance/CMakeLists.txt
+++ b/indra/llappearance/CMakeLists.txt
@@ -27,7 +27,7 @@ set(llappearance_SOURCE_FILES
     llviewervisualparam.cpp
     llavatarappearancedefines.cpp
     )
-    
+
 set(llappearance_HEADER_FILES
     CMakeLists.txt
 
diff --git a/indra/llcommon/llsd.h b/indra/llcommon/llsd.h
index 7fa193e035..e018b400cb 100644
--- a/indra/llcommon/llsd.h
+++ b/indra/llcommon/llsd.h
@@ -335,20 +335,6 @@ public:
         {
             return c ? (*this)[std::string_view(c)] : *this;
         }
-
-        template<typename T>
-        LLSD(const std::map<String, T>& map, bool exclude_empty = false)
-        {
-            assign(emptyMap());
-            for (const std::pair<String, T>& pair : map)
-            {
-                LLSD value(pair.second);
-                if (!exclude_empty || !value.isEmpty())
-                {
-                    insert(pair.first, value);
-                }
-            }
-        }
     //@}
 
     /** @name Array Values */
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 7d0806b22e..b15a85cb2a 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -36,6 +36,7 @@
 //#include <locale>
 #include <iomanip>
 #include <algorithm>
+#include <functional>
 #include <vector>
 #include <map>
 #include <type_traits>
diff --git a/indra/llmath/llsimdmath.h b/indra/llmath/llsimdmath.h
index 40953dc2e8..592bb124c2 100644
--- a/indra/llmath/llsimdmath.h
+++ b/indra/llmath/llsimdmath.h
@@ -31,8 +31,15 @@
 #error "Please include llmath.h before this file."
 #endif
 
-#if ( ( LL_DARWIN || LL_LINUX ) && !(__SSE2__) ) || ( LL_WINDOWS && ( _M_IX86_FP < 2 && ADDRESS_SIZE == 32 ) )
-#error SSE2 not enabled. LLVector4a and related class will not compile.
+// the check for this error case must be split into multiple parts
+// because some versions of VS complain about '__SSE2__'
+//#if ( ( LL_DARWIN || LL_LINUX ) && !(__SSE2__) ) || ( LL_WINDOWS && ( _M_IX86_FP < 2 && ADDRESS_SIZE == 32 ) )
+#if ( ( LL_DARWIN || LL_LINUX ) )
+    #if !(__SSE2__)
+        #error SSE2 not enabled. LLVector4a and related class will not compile.
+    #endif
+#elif ( LL_WINDOWS && ( _M_IX86_FP < 2 && ADDRESS_SIZE == 32 ) )
+    #error SSE2 not enabled. LLVector4a and related class will not compile.
 #endif
 
 #if !LL_WINDOWS
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 6d45a72deb..cedb79bf62 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -314,6 +314,7 @@ public:
     void            pasteTextWithLinebreaksImpl(const LLWString& clean_string);
 
 private:
+    void            pasteTextWithLinebreaksInternal(const LLWString & clean_string);
     void            onKeyStroke();
 
     // Concrete TextCmd sub-classes used by the LLTextEditor base class
diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index ebac55cb9c..e86ef2d578 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -26,6 +26,7 @@ set(llwindow_SOURCE_FILES
     llgamecontroltranslator.cpp
     llkeyboard.cpp
     llkeyboardheadless.cpp
+    llsdl.cpp
     llwindowheadless.cpp
     llwindowcallbacks.cpp
     llwindow.cpp
@@ -39,6 +40,7 @@ set(llwindow_HEADER_FILES
     llgamecontroltranslator.h
     llkeyboard.h
     llkeyboardheadless.h
+    llsdl.h
     llwindowheadless.h
     llwindowcallbacks.h
     )
@@ -63,7 +65,7 @@ set(llwindow_LINK_LIBRARIES
         ll::glm
         ll::glext
         ll::uilibraries
-        ll::SDL
+        ll::SDL2
         ll::zlib-ng
         )
 
@@ -178,11 +180,11 @@ endif (llwindow_HEADER_FILES)
     ${viewer_SOURCE_FILES}
     )
 
-if (SDL_FOUND)
+if (SDL2_FOUND)
   set_property(TARGET llwindow
     PROPERTY COMPILE_DEFINITIONS LL_SDL=1
     )
-endif (SDL_FOUND)
+endif (SDL2_FOUND)
 
   target_link_libraries (llwindow ${llwindow_LINK_LIBRARIES})
   target_include_directories(llwindow INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/indra/llwindow/llgamecontrol.cpp b/indra/llwindow/llgamecontrol.cpp
index c7a27c5558..01c6f91d25 100644
--- a/indra/llwindow/llgamecontrol.cpp
+++ b/indra/llwindow/llgamecontrol.cpp
@@ -156,10 +156,6 @@ namespace std
         {
             ss << ",version:" << version;
         }
-        if (U16 firmware = SDL_JoystickGetFirmwareVersion(joystick))
-        {
-            ss << ",firmware:" << firmware;
-        }
         if (const char* serial = SDL_JoystickGetSerial(joystick))
         {
             ss << ",serial:'" << serial << "'";
@@ -190,10 +186,6 @@ namespace std
         {
             ss << ",version:" << version;
         }
-        if (U16 firmware = SDL_GameControllerGetFirmwareVersion(controller))
-        {
-            ss << ",firmware:" << firmware;
-        }
         if (const char* serial = SDL_GameControllerGetSerial(controller))
         {
             ss << ",serial:'" << serial << "'";
@@ -1420,13 +1412,11 @@ void onJoystickDeviceAdded(const SDL_Event& event)
     SDL_JoystickGUID guid(SDL_JoystickGetDeviceGUID(event.cdevice.which));
     SDL_JoystickType type(SDL_JoystickGetDeviceType(event.cdevice.which));
     std::string name(std::to_string(SDL_JoystickNameForIndex(event.cdevice.which)));
-    std::string path(std::to_string(SDL_JoystickPathForIndex(event.cdevice.which)));
 
     LL_INFOS("SDL2") << "joystick {id:" << event.cdevice.which
         << ",guid:'" << guid << "'"
         << ",type:'" << type << "'"
         << ",name:'" << name << "'"
-        << ",path:'" << path << "'"
         << "}" << LL_ENDL;
 
     if (SDL_Joystick* joystick = SDL_JoystickOpen(event.cdevice.which))
@@ -1449,13 +1439,11 @@ void onControllerDeviceAdded(const SDL_Event& event)
     std::string guid(std::to_string(SDL_JoystickGetDeviceGUID(event.cdevice.which)));
     SDL_GameControllerType type(SDL_GameControllerTypeForIndex(event.cdevice.which));
     std::string name(std::to_string(SDL_GameControllerNameForIndex(event.cdevice.which)));
-    std::string path(std::to_string(SDL_GameControllerPathForIndex(event.cdevice.which)));
 
     LL_INFOS("SDL2") << "controller {id:" << event.cdevice.which
         << ",guid:'" << guid << "'"
         << ",type:'" << type << "'"
         << ",name:'" << name << "'"
-        << ",path:'" << path << "'"
         << "}" << LL_ENDL;
 
     SDL_JoystickID id = SDL_JoystickGetDeviceInstanceID(event.cdevice.which);
@@ -1525,11 +1513,6 @@ bool LLGameControl::isInitialized()
     return g_gameControl != nullptr;
 }
 
-void sdl_logger(void *userdata, int category, SDL_LogPriority priority, const char *message)
-{
-    LL_DEBUGS("SDL2") << "log='" << message << "'" << LL_ENDL;
-}
-
 // static
 void LLGameControl::init(const std::string& gamecontrollerdb_path,
     std::function<bool(const std::string&)> loadBoolean,
@@ -1551,16 +1534,14 @@ void LLGameControl::init(const std::string& gamecontrollerdb_path,
     llassert(saveObject);
     llassert(updateUI);
 
-    int result = SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER);
+    int result = SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER | SDL_INIT_SENSOR);
     if (result < 0)
     {
         // This error is critical, we stop working with SDL and return
-        LL_WARNS("SDL2") << "Error initializing the subsystems : " << SDL_GetError() << LL_ENDL;
+        LL_WARNS("SDL2") << "Error initializing GameController subsystems : " << SDL_GetError() << LL_ENDL;
         return;
     }
 
-    SDL_LogSetOutputFunction(&sdl_logger, nullptr);
-
     // The inability to read this file is not critical, we can continue working
     if (!LLFile::isfile(gamecontrollerdb_path.c_str()))
     {
@@ -1596,7 +1577,6 @@ void LLGameControl::init(const std::string& gamecontrollerdb_path,
 void LLGameControl::terminate()
 {
     g_manager.clear();
-    SDL_Quit();
 }
 
 // static
@@ -1638,6 +1618,7 @@ void LLGameControl::clearAllStates()
 // static
 void LLGameControl::processEvents(bool app_has_focus)
 {
+    // This method used by non-linux platforms which only use SDL for GameController input
     SDL_Event event;
     if (!app_has_focus)
     {
@@ -1652,31 +1633,42 @@ void LLGameControl::processEvents(bool app_has_focus)
 
     while (g_gameControl && SDL_PollEvent(&event))
     {
-        switch (event.type)
-        {
-            case SDL_JOYDEVICEADDED:
-                onJoystickDeviceAdded(event);
-                break;
-            case SDL_JOYDEVICEREMOVED:
-                onJoystickDeviceRemoved(event);
-                break;
-            case SDL_CONTROLLERDEVICEADDED:
-                onControllerDeviceAdded(event);
-                break;
-            case SDL_CONTROLLERDEVICEREMOVED:
-                onControllerDeviceRemoved(event);
-                break;
-            case SDL_CONTROLLERBUTTONDOWN:
-                /* FALLTHROUGH */
-            case SDL_CONTROLLERBUTTONUP:
+        handleEvent(event, app_has_focus);
+    }
+}
+
+void LLGameControl::handleEvent(const SDL_Event& event, bool app_has_focus)
+{
+    switch (event.type)
+    {
+        case SDL_JOYDEVICEADDED:
+            onJoystickDeviceAdded(event);
+            break;
+        case SDL_JOYDEVICEREMOVED:
+            onJoystickDeviceRemoved(event);
+            break;
+        case SDL_CONTROLLERDEVICEADDED:
+            onControllerDeviceAdded(event);
+            break;
+        case SDL_CONTROLLERDEVICEREMOVED:
+            onControllerDeviceRemoved(event);
+            break;
+        case SDL_CONTROLLERBUTTONDOWN:
+            /* FALLTHROUGH */
+        case SDL_CONTROLLERBUTTONUP:
+            if (app_has_focus)
+            {
                 onControllerButton(event);
-                break;
-            case SDL_CONTROLLERAXISMOTION:
+            }
+            break;
+        case SDL_CONTROLLERAXISMOTION:
+            if (app_has_focus)
+            {
                 onControllerAxis(event);
-                break;
-            default:
-                break;
-        }
+            }
+            break;
+        default:
+            break;
     }
 }
 
@@ -2112,7 +2104,18 @@ void LLGameControl::saveToSettings()
     s_saveString(SETTING_FLYCAMMAPPINGS, g_manager.getFlycamMappings());
 
     g_manager.saveDeviceOptionsToSettings();
-    LLSD deviceOptions(g_deviceOptions, true);
+
+    // construct LLSD version of g_deviceOptions but only include non-empty values
+    LLSD deviceOptions = LLSD::emptyMap();
+    for (const auto& data_pair : g_deviceOptions)
+    {
+        if (!data_pair.second.empty())
+        {
+            LLSD value(data_pair.second);
+            deviceOptions.insert(data_pair.first, value);
+        }
+    }
+
     s_saveObject(SETTING_KNOWNCONTROLLERS, deviceOptions);
 }
 
diff --git a/indra/llwindow/llgamecontrol.h b/indra/llwindow/llgamecontrol.h
index 9dfce4c287..5472a8ce6d 100644
--- a/indra/llwindow/llgamecontrol.h
+++ b/indra/llwindow/llgamecontrol.h
@@ -32,6 +32,7 @@
 #include "llerror.h"
 #include "llsingleton.h"
 #include "stdtypes.h"
+#include "SDL2/SDL_events.h"
 
 // For reference, here are the RAW indices of the various input channels
 // of a standard XBox controller.  Button (N) is numbered in parentheses,
@@ -287,6 +288,7 @@ public:
     static void clearAllStates();
 
     static void processEvents(bool app_has_focus = true);
+    static void handleEvent(const SDL_Event& event, bool app_has_focus);
     static const State& getState();
     static InputChannel getActiveInputChannel();
     static void getFlycamInputs(std::vector<F32>& inputs_out);
diff --git a/indra/llwindow/llkeyboard.cpp b/indra/llwindow/llkeyboard.cpp
index 44679d3843..cb0c312a1d 100644
--- a/indra/llwindow/llkeyboard.cpp
+++ b/indra/llwindow/llkeyboard.cpp
@@ -227,7 +227,7 @@ LLKeyboard::NATIVE_KEY_TYPE LLKeyboard::inverseTranslateKey(const KEY translated
 }
 
 
-bool LLKeyboard::handleTranslatedKeyDown(KEY translated_key, U32 translated_mask)
+bool LLKeyboard::handleTranslatedKeyDown(KEY translated_key, MASK translated_mask)
 {
     bool handled = false;
     bool repeated = false;
@@ -255,7 +255,7 @@ bool LLKeyboard::handleTranslatedKeyDown(KEY translated_key, U32 translated_mask
 }
 
 
-bool LLKeyboard::handleTranslatedKeyUp(KEY translated_key, U32 translated_mask)
+bool LLKeyboard::handleTranslatedKeyUp(KEY translated_key, MASK translated_mask)
 {
     bool handled = false;
     if( mKeyLevel[translated_key] )
@@ -276,58 +276,29 @@ bool LLKeyboard::handleTranslatedKeyUp(KEY translated_key, U32 translated_mask)
     return handled;
 }
 
-<<<<<<< HEAD
-bool LLKeyboard::handleKeyDown(const U16 key, const U32 mask)
-{
-    U32 translated_mask = updateModifiers(mask);
 
-=======
-bool LLKeyboard::handleKeyDown(const U16 key, const MASK mask)
+bool LLKeyboard::handleKeyDown(const NATIVE_KEY_TYPE key, const MASK mask)
 {
-    U32 translated_mask = updateModifiers(mask);
->>>>>>> 7733b56eab (Add GameControl UI for per device settings)
+    MASK translated_mask = updateModifiers(mask);
     KEY     translated_key = 0;
     bool    handled = false;
     if(translateKey(key, &translated_key))
     {
         handled = handleTranslatedKeyDown(translated_key, translated_mask);
     }
-<<<<<<< HEAD
-    if (!handled)
-    {
-        LLGameControl::onKeyDown(translated_key, translated_mask);
-    }
-
-=======
->>>>>>> 7733b56eab (Add GameControl UI for per device settings)
     return handled;
 }
 
 
-<<<<<<< HEAD
-bool LLKeyboard::handleKeyUp(const U16 key, const U32 mask)
+bool LLKeyboard::handleKeyUp(const NATIVE_KEY_TYPE key, const MASK mask)
 {
-    U32 translated_mask = updateModifiers(mask);
-
-=======
-bool LLKeyboard::handleKeyUp(const U16 key, const MASK mask)
-{
-    U32 translated_mask = updateModifiers(mask);
->>>>>>> 7733b56eab (Add GameControl UI for per device settings)
+    MASK translated_mask = updateModifiers(mask);
     KEY     translated_key = 0;
     bool    handled = false;
     if(translateKey(key, &translated_key))
     {
         handled = handleTranslatedKeyUp(translated_key, translated_mask);
     }
-<<<<<<< HEAD
-    if (!handled)
-    {
-        LLGameControl::onKeyUp(translated_key, translated_mask);
-    }
-
-=======
->>>>>>> 7733b56eab (Add GameControl UI for per device settings)
     return handled;
 }
 
diff --git a/indra/llwindow/llkeyboard.h b/indra/llwindow/llkeyboard.h
index d91e023b85..da406b28e8 100644
--- a/indra/llwindow/llkeyboard.h
+++ b/indra/llwindow/llkeyboard.h
@@ -55,10 +55,12 @@ class LLWindowCallbacks;
 class LLKeyboard
 {
 public:
-#ifndef LL_SDL
-    typedef U16 NATIVE_KEY_TYPE;
-#else
+#ifdef LL_LINUX
+    // linux relies on SDL2 which uses U32 for its native key type
     typedef U32 NATIVE_KEY_TYPE;
+#else
+    // on non-linux platforms we can get by with a smaller native key type
+    typedef U16 NATIVE_KEY_TYPE;
 #endif
     LLKeyboard();
     virtual ~LLKeyboard();
@@ -73,9 +75,9 @@ public:
     bool            getKeyRepeated(const KEY key) { return mKeyRepeated[key]; }
 
     bool            translateKey(const NATIVE_KEY_TYPE os_key, KEY *translated_key);
-    NATIVE_KEY_TYPE     inverseTranslateKey(const KEY translated_key);
-    bool            handleTranslatedKeyUp(KEY translated_key, U32 translated_mask);     // Translated into "Linden" keycodes
-    bool            handleTranslatedKeyDown(KEY translated_key, U32 translated_mask);   // Translated into "Linden" keycodes
+    NATIVE_KEY_TYPE inverseTranslateKey(const KEY translated_key);
+    bool            handleTranslatedKeyUp(KEY translated_key, MASK translated_mask);     // Translated into "Linden" keycodes
+    bool            handleTranslatedKeyDown(KEY translated_key, MASK translated_mask);   // Translated into "Linden" keycodes
 
     virtual bool    handleKeyUp(const NATIVE_KEY_TYPE key, MASK mask) = 0;
     virtual bool    handleKeyDown(const NATIVE_KEY_TYPE key, MASK mask) = 0;
diff --git a/indra/llwindow/llkeyboardheadless.cpp b/indra/llwindow/llkeyboardheadless.cpp
index a827424141..0ca8c09f42 100644
--- a/indra/llwindow/llkeyboardheadless.cpp
+++ b/indra/llwindow/llkeyboardheadless.cpp
@@ -31,6 +31,16 @@
 LLKeyboardHeadless::LLKeyboardHeadless()
 { }
 
+bool LLKeyboardHeadless::handleKeyUp(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask)
+{
+    return false;
+}
+
+bool LLKeyboardHeadless::handleKeyDown(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask)
+{
+    return false;
+}
+
 void LLKeyboardHeadless::resetMaskKeys()
 { }
 
diff --git a/indra/llwindow/llkeyboardheadless.h b/indra/llwindow/llkeyboardheadless.h
index cc31b99d3f..60c4d61e1c 100644
--- a/indra/llwindow/llkeyboardheadless.h
+++ b/indra/llwindow/llkeyboardheadless.h
@@ -35,8 +35,8 @@ public:
     LLKeyboardHeadless();
     ~LLKeyboardHeadless() {};
 
-    bool    handleKeyUp(const U16 key, MASK mask) override;
-    bool    handleKeyDown(const U16 key, MASK mask) override;
+    bool    handleKeyUp(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask) override;
+    bool    handleKeyDown(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask) override;
     void    resetMaskKeys() override;
     MASK    currentMask(bool for_mouse_event) override;
     void    scanKeyboard() override;
diff --git a/indra/llwindow/llkeyboardsdl.cpp b/indra/llwindow/llkeyboardsdl.cpp
index b8b2b311f7..b6666195a6 100644
--- a/indra/llwindow/llkeyboardsdl.cpp
+++ b/indra/llwindow/llkeyboardsdl.cpp
@@ -26,7 +26,7 @@
 #include "linden_common.h"
 #include "llkeyboardsdl.h"
 #include "llwindowcallbacks.h"
-#include "SDL2/SDL.h"
+
 #include "SDL2/SDL_keycode.h"
 
 LLKeyboardSDL::LLKeyboardSDL()
@@ -42,7 +42,7 @@ LLKeyboardSDL::LLKeyboardSDL()
     // <FS:ND> 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.
 
-    U16 cur_char;
+    LLKeyboard::NATIVE_KEY_TYPE cur_char;
     for (cur_char = 'A'; cur_char <= 'Z'; cur_char++)
     {
         mTranslateKeyMap[cur_char] = cur_char;
@@ -201,7 +201,7 @@ MASK LLKeyboardSDL::updateModifiers(const MASK mask)
 }
 
 
-static U32 adjustNativekeyFromUnhandledMask(const U16 key, const MASK mask)
+U32 adjustNativekeyFromUnhandledMask(const LLKeyboard::NATIVE_KEY_TYPE key, const MASK mask)
 {
     // SDL doesn't automatically adjust the keysym according to
     // whether NUMLOCK is engaged, so we massage the keysym manually.
@@ -226,11 +226,11 @@ static U32 adjustNativekeyFromUnhandledMask(const U16 key, const MASK mask)
 }
 
 
-bool LLKeyboardSDL::handleKeyDown(const U32 key, const MASK mask)
+bool LLKeyboardSDL::handleKeyDown(const LLKeyboard::NATIVE_KEY_TYPE key, const MASK mask)
 {
     U32 adjusted_nativekey;
     KEY translated_key = 0;
-    U32 translated_mask = MASK_NONE;
+    MASK translated_mask = MASK_NONE;
     bool handled = false;
 
     adjusted_nativekey = adjustNativekeyFromUnhandledMask(key, mask);
@@ -246,7 +246,7 @@ bool LLKeyboardSDL::handleKeyDown(const U32 key, const MASK mask)
 }
 
 
-bool LLKeyboardSDL::handleKeyUp(const U32 key, const MASK mask)
+bool LLKeyboardSDL::handleKeyUp(const LLKeyboard::NATIVE_KEY_TYPE key, const MASK mask)
 {
     U32 adjusted_nativekey;
     KEY translated_key = 0;
@@ -315,12 +315,12 @@ void LLKeyboardSDL::scanKeyboard()
 }
 
 
-bool LLKeyboardSDL::translateNumpadKey( const U32 os_key, KEY *translated_key)
+bool LLKeyboardSDL::translateNumpadKey( const LLKeyboard::NATIVE_KEY_TYPE os_key, KEY *translated_key)
 {
     return translateKey(os_key, translated_key);
 }
 
-U16 LLKeyboardSDL::inverseTranslateNumpadKey(const KEY translated_key)
+LLKeyboard::NATIVE_KEY_TYPE LLKeyboardSDL::inverseTranslateNumpadKey(const KEY translated_key)
 {
     return inverseTranslateKey(translated_key);
 }
@@ -498,7 +498,6 @@ enum class WindowsVK : U32
 };
 
 std::map< U32, U32 > mSDL2_to_Win;
-std::set< U32 > mIgnoreSDL2Keys;
 
 U32 LLKeyboardSDL::mapSDL2toWin( U32 aSymbol )
 {
diff --git a/indra/llwindow/llkeyboardsdl.h b/indra/llwindow/llkeyboardsdl.h
index fb08fd218b..7671e4c859 100644
--- a/indra/llwindow/llkeyboardsdl.h
+++ b/indra/llwindow/llkeyboardsdl.h
@@ -33,22 +33,22 @@ class LLKeyboardSDL : public LLKeyboard
 {
 public:
     LLKeyboardSDL();
-    /*virtual*/ ~LLKeyboardSDL() {};
+    ~LLKeyboardSDL() {};
 
-    /*virtual*/ bool    handleKeyUp(const U32 key, MASK mask);
-    /*virtual*/ bool    handleKeyDown(const U32 key, MASK mask);
-    /*virtual*/ void    resetMaskKeys();
-    /*virtual*/ MASK    currentMask(bool for_mouse_event);
-    /*virtual*/ void    scanKeyboard();
+    bool    handleKeyUp(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask) override;
+    bool    handleKeyDown(const LLKeyboard::NATIVE_KEY_TYPE key, MASK mask) override;
+    void    resetMaskKeys() override;
+    MASK    currentMask(bool for_mouse_event) override;
+    void    scanKeyboard() override;
 
 protected:
     MASK    updateModifiers(const MASK mask) override;
     void    setModifierKeyLevel( KEY key, bool new_state );
-    bool    translateNumpadKey( const U32 os_key, KEY *translated_key );
-    U16 inverseTranslateNumpadKey(const KEY translated_key);
+    bool    translateNumpadKey( const LLKeyboard::NATIVE_KEY_TYPE os_key, KEY *translated_key );
+    LLKeyboard::NATIVE_KEY_TYPE inverseTranslateNumpadKey(const KEY translated_key);
 private:
-    std::map<U32, KEY> mTranslateNumpadMap;  // special map for translating OS keys to numpad keys
-    std::map<KEY, U32> mInvTranslateNumpadMap; // inverse of the above
+    std::map<LLKeyboard::NATIVE_KEY_TYPE, KEY> mTranslateNumpadMap;  // special map for translating OS keys to numpad keys
+    std::map<KEY, LLKeyboard::NATIVE_KEY_TYPE> mInvTranslateNumpadMap; // inverse of the above
 
 public:
     static U32 mapSDL2toWin( U32 );
diff --git a/indra/llwindow/llsdl.cpp b/indra/llwindow/llsdl.cpp
new file mode 100644
index 0000000000..6161bd2972
--- /dev/null
+++ b/indra/llwindow/llsdl.cpp
@@ -0,0 +1,102 @@
+/**
+ * @file llsdl.cpp
+ * @brief SDL2 initialization
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include <initializer_list>
+#include <list>
+
+#include "SDL2/SDL.h"
+
+#include "llerror.h"
+#include "llwindow.h"
+
+void sdl_logger(void *userdata, int category, SDL_LogPriority priority, const char *message)
+{
+    LL_DEBUGS("SDL2") << "log='" << message << "'" << LL_ENDL;
+}
+
+void init_sdl()
+{
+    SDL_version c_sdl_version;
+    SDL_VERSION(&c_sdl_version);
+    LL_INFOS() << "Compiled against SDL "
+               << int(c_sdl_version.major) << "."
+               << int(c_sdl_version.minor) << "."
+               << int(c_sdl_version.patch) << LL_ENDL;
+    SDL_version r_sdl_version;
+    SDL_GetVersion(&r_sdl_version);
+    LL_INFOS() << "Running with SDL "
+               << int(r_sdl_version.major) << "."
+               << int(r_sdl_version.minor) << "."
+               << int(r_sdl_version.patch) << LL_ENDL;
+#ifdef LL_LINUX
+    // For linux we SDL_INIT_VIDEO and _AUDIO
+    std::initializer_list<std::tuple< char const*, char const * > > hintList =
+            {
+                    {SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR,"0"},
+                    {SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH,"1"},
+                    {SDL_HINT_IME_INTERNAL_EDITING,"1"}
+            };
+
+    for (auto hint: hintList)
+    {
+        SDL_SetHint(std::get<0>(hint), std::get<1>(hint));
+    }
+
+    std::initializer_list<std::tuple<uint32_t, char const*, bool>> initList=
+            { {SDL_INIT_VIDEO,"SDL_INIT_VIDEO", true},
+              {SDL_INIT_AUDIO,"SDL_INIT_AUDIO", false},
+            };
+#else
+    // For non-linux platforms we still SDL_INIT_VIDEO because it is a pre-requisite
+    // for SDL_INIT_GAMECONTROLLER.
+    std::initializer_list<std::tuple<uint32_t, char const*, bool>> initList=
+            { {SDL_INIT_VIDEO,"SDL_INIT_VIDEO", false},
+            };
+#endif // LL_LINUX
+    // We SDL_INIT_GAMECONTROLLER later in the startup process to make it
+    // more likely we'll catch initial SDL_CONTROLLERDEVICEADDED events.
+
+    for (auto subSystem : initList)
+    {
+        if (SDL_InitSubSystem(std::get<0>(subSystem)) < 0)
+        {
+            LL_WARNS() << "SDL_InitSubSystem for " << std::get<1>(subSystem) << " failed " << SDL_GetError() << LL_ENDL;
+
+            if (std::get<2>(subSystem))
+            {
+                OSMessageBox("SDL_Init() failure", "error", OSMB_OK);
+                return;
+            }
+        }
+    }
+
+    SDL_LogSetOutputFunction(&sdl_logger, nullptr);
+}
+
+void quit_sdl()
+{
+    SDL_Quit();
+}
diff --git a/indra/llwindow/llsdl.h b/indra/llwindow/llsdl.h
new file mode 100644
index 0000000000..9fc8de129c
--- /dev/null
+++ b/indra/llwindow/llsdl.h
@@ -0,0 +1,30 @@
+/**
+ * @file llsdl.h
+ * @brief SDL2 initialization
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+void init_sdl();
+void quit_sdl();
diff --git a/indra/llwindow/llwindow.cpp b/indra/llwindow/llwindow.cpp
index 861fd10e30..93ac58ca6f 100644
--- a/indra/llwindow/llwindow.cpp
+++ b/indra/llwindow/llwindow.cpp
@@ -39,6 +39,7 @@
 
 #include "llerror.h"
 #include "llkeyboard.h"
+#include "llsdl.h"
 #include "llwindowcallbacks.h"
 
 
@@ -415,6 +416,7 @@ LLWindow* LLWindowManager::createWindow(
 
     if (use_gl)
     {
+        init_sdl();
 #if LL_WINDOWS
         new_window = new LLWindowWin32(callbacks,
             title, name, x, y, width, height, flags,
@@ -462,6 +464,7 @@ bool LLWindowManager::destroyWindow(LLWindow* window)
     window->close();
 
     sWindowList.erase(window);
+    quit_sdl();
 
     delete window;
 
diff --git a/indra/llwindow/llwindow.h b/indra/llwindow/llwindow.h
index fcc4fd863a..e74142c7df 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -24,8 +24,7 @@
  * $/LicenseInfo$
  */
 
-#ifndef LL_LLWINDOW_H
-#define LL_LLWINDOW_H
+#pragma once
 
 #include "llrect.h"
 #include "llcoord.h"
@@ -33,6 +32,7 @@
 #include "llcursortypes.h"
 #include "llinstancetracker.h"
 #include "llsd.h"
+#include "llsdl.h"
 
 class LLSplashScreen;
 class LLPreeditor;
@@ -63,16 +63,16 @@ public:
     virtual void show() = 0;
     virtual void hide() = 0;
     virtual void close() = 0;
-    virtual bool getVisible() = 0;
-    virtual bool getMinimized() = 0;
-    virtual bool getMaximized() = 0;
+    virtual bool getVisible() const = 0;
+    virtual bool getMinimized() const = 0;
+    virtual bool getMaximized() const = 0;
     virtual bool maximize() = 0;
     virtual void minimize() = 0;
     virtual void restore() = 0;
-    bool getFullscreen()    { return mFullscreen; };
-    virtual bool getPosition(LLCoordScreen *position) = 0;
-    virtual bool getSize(LLCoordScreen *size) = 0;
-    virtual bool getSize(LLCoordWindow *size) = 0;
+    virtual bool getFullscreen() const { return mFullscreen; };
+    virtual bool getPosition(LLCoordScreen *position) const = 0;
+    virtual bool getSize(LLCoordScreen *size) const = 0;
+    virtual bool getSize(LLCoordWindow *size) const = 0;
     virtual bool setPosition(LLCoordScreen position) = 0;
     bool setSize(LLCoordScreen size);
     bool setSize(LLCoordWindow size);
@@ -93,7 +93,7 @@ public:
     virtual bool setCursorPosition(LLCoordWindow position) = 0;
     virtual bool getCursorPosition(LLCoordWindow *position) = 0;
 #if LL_WINDOWS
-    virtual bool getCursorDelta(LLCoordCommon* delta) = 0;
+    virtual bool getCursorDelta(LLCoordCommon* delta) const = 0;
 #endif
     virtual void showCursor() = 0;
     virtual void hideCursor() = 0;
@@ -135,14 +135,14 @@ public:
     virtual bool copyTextToPrimary(const LLWString &src);
 
     virtual void flashIcon(F32 seconds) = 0;
-    virtual F32 getGamma() = 0;
+    virtual F32 getGamma() const = 0;
     virtual bool setGamma(const F32 gamma) = 0; // Set the gamma
     virtual void setFSAASamples(const U32 fsaa_samples) = 0; //set number of FSAA samples
-    virtual U32  getFSAASamples() = 0;
+    virtual U32  getFSAASamples() const = 0;
     virtual bool restoreGamma() = 0;            // Restore original gamma table (before updating gamma)
-    virtual ESwapMethod getSwapMethod() { return mSwapMethod; }
+    ESwapMethod getSwapMethod() { return mSwapMethod; }
     virtual void processMiscNativeEvents();
-    virtual void gatherInput() = 0;
+    virtual void gatherInput(bool app_has_focus) = 0;
     virtual void delayInputProcessing() = 0;
     virtual void swapBuffers() = 0;
     virtual void bringToFront() = 0;
@@ -151,12 +151,12 @@ public:
     // handy coordinate space conversion routines
     // NB: screen to window and vice verse won't work on width/height coordinate pairs,
     // as the conversion must take into account left AND right border widths, etc.
-    virtual bool convertCoords( LLCoordScreen from, LLCoordWindow *to) = 0;
-    virtual bool convertCoords( LLCoordWindow from, LLCoordScreen *to) = 0;
-    virtual bool convertCoords( LLCoordWindow from, LLCoordGL *to) = 0;
-    virtual bool convertCoords( LLCoordGL from, LLCoordWindow *to) = 0;
-    virtual bool convertCoords( LLCoordScreen from, LLCoordGL *to) = 0;
-    virtual bool convertCoords( LLCoordGL from, LLCoordScreen *to) = 0;
+    virtual bool convertCoords( LLCoordScreen from, LLCoordWindow *to) const = 0;
+    virtual bool convertCoords( LLCoordWindow from, LLCoordScreen *to) const = 0;
+    virtual bool convertCoords( LLCoordWindow from, LLCoordGL *to) const = 0;
+    virtual bool convertCoords( LLCoordGL from, LLCoordWindow *to) const = 0;
+    virtual bool convertCoords( LLCoordScreen from, LLCoordGL *to) const = 0;
+    virtual bool convertCoords( LLCoordGL from, LLCoordScreen *to) const = 0;
 
     // query supported resolutions
     virtual LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) = 0;
@@ -189,7 +189,7 @@ public:
     static std::vector<std::string> getDynamicFallbackFontList();
 
     // Provide native key event data
-    virtual LLSD getNativeKeyData() { return LLSD::emptyMap(); }
+    virtual LLSD getNativeKeyData() const { return LLSD::emptyMap(); }
 
     // Get system UI size based on DPI (for 96 DPI UI size should be 1.0)
     virtual F32 getSystemUISize() { return 1.0; }
@@ -206,7 +206,7 @@ public:
         return false;
     };
 
-    virtual S32 getRefreshRate() { return mRefreshRate; }
+    virtual S32 getRefreshRate() const { return mRefreshRate; }
 protected:
     LLWindow(LLWindowCallbacks* callbacks, bool fullscreen, U32 flags);
     virtual ~LLWindow();
@@ -328,4 +328,3 @@ extern const S32 gURLProtocolWhitelistCount;
 extern const std::string gURLProtocolWhitelist[];
 //extern const std::string gURLProtocolWhitelistHandler[];
 
-#endif // _LL_window_h_
diff --git a/indra/llwindow/llwindowheadless.h b/indra/llwindow/llwindowheadless.h
index 5696b69a59..96654b8838 100644
--- a/indra/llwindow/llwindowheadless.h
+++ b/indra/llwindow/llwindowheadless.h
@@ -32,77 +32,70 @@
 class LLWindowHeadless : public LLWindow
 {
 public:
-    /*virtual*/ void show() override {}
-    /*virtual*/ void hide() override {}
-    /*virtual*/ void close() override {}
-    /*virtual*/ bool getVisible() override {return false;}
-    /*virtual*/ bool getMinimized() override {return false;}
-    /*virtual*/ bool getMaximized() override {return false;}
-    /*virtual*/ bool maximize() override {return false;}
-    /*virtual*/ void minimize() override {}
-    /*virtual*/ void restore() override {}
-    // TODO: LLWindow::getFullscreen() is (intentionally?) NOT virtual.
-    // Apparently the coder of LLWindowHeadless didn't realize that. Is it a
-    // mistake to shadow the base-class method with an LLWindowHeadless
-    // override when called on the subclass, yet call the base-class method
-    // when indirecting through a polymorphic pointer or reference?
-    bool getFullscreen() {return false;}
-    /*virtual*/ bool getPosition(LLCoordScreen *position) override {return false;}
-    /*virtual*/ bool getSize(LLCoordScreen *size) override {return false;}
-    /*virtual*/ bool getSize(LLCoordWindow *size) override {return false;}
-    /*virtual*/ bool setPosition(LLCoordScreen position) override {return false;}
-    /*virtual*/ bool setSizeImpl(LLCoordScreen size) override {return false;}
-    /*virtual*/ bool setSizeImpl(LLCoordWindow size) override {return false;}
-    /*virtual*/ bool switchContext(bool fullscreen, const LLCoordScreen &size, bool enable_vsync, const LLCoordScreen * const posp = NULL) override {return false;}
+    void show() override {}
+    void hide() override {}
+    void close() override {}
+    bool getVisible() const override {return false;}
+    bool getMinimized() const override {return false;}
+    bool getMaximized() const override {return false;}
+    bool maximize() override {return false;}
+    void minimize() override {}
+    void restore() override {}
+    bool getFullscreen() const override {return false;};
+    bool getPosition(LLCoordScreen *position) const override {return false;}
+    bool getSize(LLCoordScreen *size) const override {return false;}
+    bool getSize(LLCoordWindow *size) const override {return false;}
+    bool setPosition(LLCoordScreen position) override {return false;}
+    bool setSizeImpl(LLCoordScreen size) override {return false;}
+    bool setSizeImpl(LLCoordWindow size) override {return false;}
+    bool switchContext(bool fullscreen, const LLCoordScreen &size, bool enable_vsync, const LLCoordScreen * const posp = NULL) override {return false;}
     void* createSharedContext() override  { return nullptr; }
     void makeContextCurrent(void*) override  {}
     void destroySharedContext(void*) override  {}
-    /*virtual*/ void toggleVSync(bool enable_vsync) override { }
-    /*virtual*/ bool setCursorPosition(LLCoordWindow position) override {return false;}
-    /*virtual*/ bool getCursorPosition(LLCoordWindow *position) override {return false;}
+    void toggleVSync(bool enable_vsync) override { }
+    bool setCursorPosition(LLCoordWindow position) override {return false;}
+    bool getCursorPosition(LLCoordWindow *position) override {return false;}
 #if LL_WINDOWS
-    /*virtual*/ bool getCursorDelta(LLCoordCommon* delta) override { return false; }
+    bool getCursorDelta(LLCoordCommon* delta) const override { return false; }
 #endif
-    /*virtual*/ void showCursor() override {}
-    /*virtual*/ void hideCursor() override {}
-    /*virtual*/ void showCursorFromMouseMove() override {}
-    /*virtual*/ void hideCursorUntilMouseMove() override {}
-    /*virtual*/ bool isCursorHidden() override {return false;}
-    /*virtual*/ void updateCursor() override {}
-    //virtual ECursorType getCursor() override { return mCurrentCursor; }
-    /*virtual*/ void captureMouse() override {}
-    /*virtual*/ void releaseMouse() override {}
-    /*virtual*/ void setMouseClipping( bool b ) override {}
-    /*virtual*/ bool isClipboardTextAvailable() override {return false; }
-    /*virtual*/ bool pasteTextFromClipboard(LLWString &dst) override {return false; }
-    /*virtual*/ bool copyTextToClipboard(const LLWString &src) override {return false; }
-    /*virtual*/ void flashIcon(F32 seconds) override {}
-    /*virtual*/ F32 getGamma() override {return 1.0f; }
-    /*virtual*/ bool setGamma(const F32 gamma) override {return false; } // Set the gamma
-    /*virtual*/ void setFSAASamples(const U32 fsaa_samples) override { }
-    /*virtual*/ U32 getFSAASamples() override { return 0; }
-    /*virtual*/ bool restoreGamma() override {return false; }   // Restore original gamma table (before updating gamma)
-    //virtual ESwapMethod getSwapMethod() override { return mSwapMethod; }
-    /*virtual*/ void gatherInput() override {}
-    /*virtual*/ void delayInputProcessing() override {}
-    /*virtual*/ void swapBuffers() override;
+    void showCursor() override {}
+    void hideCursor() override {}
+    void showCursorFromMouseMove() override {}
+    void hideCursorUntilMouseMove() override {}
+    bool isCursorHidden() override {return false;}
+    void updateCursor() override {}
+    void captureMouse() override {}
+    void releaseMouse() override {}
+    void setMouseClipping( bool b ) override {}
+    bool isClipboardTextAvailable() override {return false; }
+    bool pasteTextFromClipboard(LLWString &dst) override {return false; }
+    bool copyTextToClipboard(const LLWString &src) override {return false; }
+    void flashIcon(F32 seconds) override {}
+    F32 getGamma() const override {return 1.0f; }
+    bool setGamma(const F32 gamma) override {return false; } // Set the gamma
+    void setFSAASamples(const U32 fsaa_samples) override { }
+    U32 getFSAASamples() const override { return 0; }
+    bool restoreGamma() override {return false; }   // Restore original gamma table (before updating gamma)
+    void gatherInput(bool app_has_focus) override {}
+    void delayInputProcessing() override {}
+    void swapBuffers() override;
 
 
     // handy coordinate space conversion routines
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordWindow *to) override { return false; }
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordScreen *to) override { return false; }
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordGL *to) override { return false; }
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordWindow *to) override { return false; }
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordGL *to) override { return false; }
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordScreen *to) override { return false; }
+    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) const override { return false; }
+    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) const override { return false; }
+    bool convertCoords(LLCoordWindow from, LLCoordGL *to) const override { return false; }
+    bool convertCoords(LLCoordGL from, LLCoordWindow *to) const override { return false; }
+    bool convertCoords(LLCoordScreen from, LLCoordGL *to) const override { return false; }
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) const override { return false; }
 
-    /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override { return NULL; }
-    /*virtual*/ F32 getNativeAspectRatio() override { return 1.0f; }
-    /*virtual*/ F32 getPixelAspectRatio() override { return 1.0f; }
-    /*virtual*/ void setNativeAspectRatio(F32 ratio) override {}
+    LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override { return NULL; }
+    F32 getNativeAspectRatio() override { return 1.0f; }
+    F32 getPixelAspectRatio() override { return 1.0f; }
+    void setNativeAspectRatio(F32 ratio) override {}
 
-    /*virtual*/ void *getPlatformWindow() override { return 0; }
-    /*virtual*/ void bringToFront() override {}
+    void *getPlatformWindow() override { return 0; }
+    void bringToFront() override {}
 
     LLWindowHeadless(LLWindowCallbacks* callbacks,
         const std::string& title, const std::string& name,
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index e95ad4d970..1883c6c9c1 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -28,6 +28,7 @@
 
 #include "llwindowmacosx.h"
 
+#include "llgamecontrol.h"
 #include "llkeyboardmacosx.h"
 #include "llwindowcallbacks.h"
 #include "llpreeditor.h"
@@ -625,7 +626,7 @@ void LLWindowMacOSX::updateMouseDeltas(float* deltas)
     }
 }
 
-void LLWindowMacOSX::getMouseDeltas(float* delta)
+void LLWindowMacOSX::getMouseDeltas(float* delta) const
 {
     delta[0] = mCursorLastEventDeltaX;
     delta[1] = mCursorLastEventDeltaY;
@@ -845,7 +846,7 @@ bool LLWindowMacOSX::isValid()
     return (mWindow != NULL);
 }
 
-bool LLWindowMacOSX::getVisible()
+bool LLWindowMacOSX::getVisible() const
 {
     bool result = false;
 
@@ -860,12 +861,12 @@ bool LLWindowMacOSX::getVisible()
     return(result);
 }
 
-bool LLWindowMacOSX::getMinimized()
+bool LLWindowMacOSX::getMinimized() const
 {
     return mMinimized;
 }
 
-bool LLWindowMacOSX::getMaximized()
+bool LLWindowMacOSX::getMaximized() const
 {
     return mMaximized;
 }
@@ -879,17 +880,13 @@ bool LLWindowMacOSX::maximize()
     return mMaximized;
 }
 
-bool LLWindowMacOSX::getFullscreen()
-{
-    return mFullscreen;
-}
-
-void LLWindowMacOSX::gatherInput()
+void LLWindowMacOSX::gatherInput(bool app_has_focus)
 {
     updateCursor();
+    LLGameControl::processEvents(app_has_focus);
 }
 
-bool LLWindowMacOSX::getPosition(LLCoordScreen *position)
+bool LLWindowMacOSX::getPosition(LLCoordScreen *position) const
 {
     S32 err = -1;
 
@@ -916,7 +913,7 @@ bool LLWindowMacOSX::getPosition(LLCoordScreen *position)
     return (err == noErr);
 }
 
-bool LLWindowMacOSX::getSize(LLCoordScreen *size)
+bool LLWindowMacOSX::getSize(LLCoordScreen *size) const
 {
     S32 err = -1;
 
@@ -942,7 +939,7 @@ bool LLWindowMacOSX::getSize(LLCoordScreen *size)
     return (err == noErr);
 }
 
-bool LLWindowMacOSX::getSize(LLCoordWindow *size)
+bool LLWindowMacOSX::getSize(LLCoordWindow *size) const
 {
     S32 err = -1;
 
@@ -1016,7 +1013,7 @@ void LLWindowMacOSX::restoreGLContext()
     CGLSetCurrentContext(mContext);
 }
 
-F32 LLWindowMacOSX::getGamma()
+F32 LLWindowMacOSX::getGamma() const
 {
     F32 result = 2.2;   // Default to something sane
 
@@ -1050,7 +1047,7 @@ F32 LLWindowMacOSX::getGamma()
     return result;
 }
 
-U32 LLWindowMacOSX::getFSAASamples()
+U32 LLWindowMacOSX::getFSAASamples() const
 {
     return mFSAASamples;
 }
@@ -1376,21 +1373,21 @@ LLWindow::LLWindowResolution* LLWindowMacOSX::getSupportedResolutions(S32 &num_r
     return mSupportedResolutions;
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordWindow *to)
+bool LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordWindow *to) const
 {
     to->mX = from.mX;
     to->mY = from.mY;
     return true;
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordGL* to)
+bool LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordGL* to) const
 {
     to->mX = from.mX;
     to->mY = from.mY;
     return true;
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordWindow* to)
+bool LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordWindow* to) const
 {
     if(mWindow)
     {
@@ -1409,7 +1406,7 @@ bool LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordWindow* to)
     return false;
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordScreen *to)
+bool LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordScreen *to) const
 {
     if(mWindow)
     {
@@ -1428,14 +1425,14 @@ bool LLWindowMacOSX::convertCoords(LLCoordWindow from, LLCoordScreen *to)
     return false;
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordGL *to)
+bool LLWindowMacOSX::convertCoords(LLCoordScreen from, LLCoordGL *to) const
 {
     LLCoordWindow window_coord;
 
     return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
 }
 
-bool LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordScreen *to)
+bool LLWindowMacOSX::convertCoords(LLCoordGL from, LLCoordScreen *to) const
 {
     LLCoordWindow window_coord;
 
@@ -2321,7 +2318,7 @@ bool LLWindowMacOSX::getInputDevices(U32 device_type_filter,
     return return_value;
 }
 
-LLSD LLWindowMacOSX::getNativeKeyData()
+LLSD LLWindowMacOSX::getNativeKeyData() const
 {
     LLSD result = LLSD::emptyMap();
 
@@ -2505,6 +2502,7 @@ void LLWindowMacOSX::interruptLanguageTextInput()
     commitCurrentPreedit(mGLView);
 }
 
+// static
 std::vector<std::string> LLWindowMacOSX::getDisplaysResolutionList()
 {
     std::vector<std::string> resolution_list;
@@ -2534,7 +2532,7 @@ std::vector<std::string> LLWindowMacOSX::getDisplaysResolutionList()
     return resolution_list;
 }
 
-//static
+// static
 std::vector<std::string> LLWindowMacOSX::getDynamicFallbackFontList()
 {
     // Fonts previously in getFontListSans() have moved to fonts.xml.
diff --git a/indra/llwindow/llwindowmacosx.h b/indra/llwindow/llwindowmacosx.h
index 211ae872c6..14a56a038e 100644
--- a/indra/llwindow/llwindowmacosx.h
+++ b/indra/llwindow/llwindowmacosx.h
@@ -47,16 +47,15 @@ public:
     void show() override;
     void hide() override;
     void close() override;
-    bool getVisible() override;
-    bool getMinimized() override;
-    bool getMaximized() override;
+    bool getVisible() const override;
+    bool getMinimized() const override;
+    bool getMaximized() const override;
     bool maximize() override;
     void minimize() override;
     void restore() override;
-    bool getFullscreen();
-    bool getPosition(LLCoordScreen *position) override;
-    bool getSize(LLCoordScreen *size) override;
-    bool getSize(LLCoordWindow *size) override;
+    bool getPosition(LLCoordScreen *position) const override;
+    bool getSize(LLCoordScreen *size) const override;
+    bool getSize(LLCoordWindow *size) const override;
     bool setPosition(LLCoordScreen position) override;
     bool setSizeImpl(LLCoordScreen size) override;
     bool setSizeImpl(LLCoordWindow size) override;
@@ -77,23 +76,22 @@ public:
     bool pasteTextFromClipboard(LLWString &dst) override;
     bool copyTextToClipboard(const LLWString & src) override;
     void flashIcon(F32 seconds) override;
-    F32 getGamma() override;
+    F32 getGamma() const override;
     bool setGamma(const F32 gamma) override; // Set the gamma
-    U32 getFSAASamples() override;
+    U32 getFSAASamples() const override;
     void setFSAASamples(const U32 fsaa_samples) override;
     bool restoreGamma() override;           // Restore original gamma table (before updating gamma)
-    ESwapMethod getSwapMethod() override { return mSwapMethod; }
-    void gatherInput() override;
+    void gatherInput(bool app_has_focus) override;
     void delayInputProcessing() override {};
     void swapBuffers() override;
 
     // handy coordinate space conversion routines
-    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) override;
-    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) override;
-    bool convertCoords(LLCoordWindow from, LLCoordGL *to) override;
-    bool convertCoords(LLCoordGL from, LLCoordWindow *to) override;
-    bool convertCoords(LLCoordScreen from, LLCoordGL *to) override;
-    bool convertCoords(LLCoordGL from, LLCoordScreen *to) override;
+    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) const override;
+    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) const override;
+    bool convertCoords(LLCoordWindow from, LLCoordGL *to) const override;
+    bool convertCoords(LLCoordGL from, LLCoordWindow *to) const override;
+    bool convertCoords(LLCoordScreen from, LLCoordGL *to) const override;
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) const override;
 
     LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override;
     F32 getNativeAspectRatio() override;
@@ -125,14 +123,14 @@ public:
     static std::vector<std::string> getDynamicFallbackFontList();
 
     // Provide native key event data
-    LLSD getNativeKeyData() override;
+    LLSD getNativeKeyData() const override;
 
     void* getWindow() { return mWindow; }
     LLWindowCallbacks* getCallbacks() { return mCallbacks; }
     LLPreeditor* getPreeditor() { return mPreeditor; }
 
     void updateMouseDeltas(float* deltas);
-    void getMouseDeltas(float* delta);
+    void getMouseDeltas(float* delta) const;
 
     void handleDragNDrop(std::string url, LLWindowCallbacks::DragNDropAction action);
 
diff --git a/indra/llwindow/llwindowmesaheadless.h b/indra/llwindow/llwindowmesaheadless.h
index 0bf8c46a30..0a29ddfa5b 100644
--- a/indra/llwindow/llwindowmesaheadless.h
+++ b/indra/llwindow/llwindowmesaheadless.h
@@ -36,64 +36,64 @@
 class LLWindowMesaHeadless : public LLWindow
 {
 public:
-    /*virtual*/ void show() {};
-    /*virtual*/ void hide() {};
-    /*virtual*/ void close() {};
-    /*virtual*/ bool getVisible() {return false;};
-    /*virtual*/ bool getMinimized() {return false;};
-    /*virtual*/ bool getMaximized() {return false;};
-    /*virtual*/ bool maximize() {return false;};
-    /*virtual*/ void minimize() {};
-    /*virtual*/ void restore() {};
-    /*virtual*/ bool getFullscreen() {return false;};
-    /*virtual*/ bool getPosition(LLCoordScreen *position) {return false;};
-    /*virtual*/ bool getSize(LLCoordScreen *size) {return false;};
-    /*virtual*/ bool getSize(LLCoordWindow *size) {return false;};
-    /*virtual*/ bool setPosition(LLCoordScreen position) {return false;};
-    /*virtual*/ bool setSizeImpl(LLCoordScreen size) {return false;};
-    /*virtual*/ bool switchContext(bool fullscreen, const LLCoordScreen &size, bool disable_vsync, const LLCoordScreen * const posp = NULL) {return false;};
-    /*virtual*/ bool setCursorPosition(LLCoordWindow position) {return false;};
-    /*virtual*/ bool getCursorPosition(LLCoordWindow *position) {return false;};
-    /*virtual*/ void showCursor() {};
-    /*virtual*/ void hideCursor() {};
-    /*virtual*/ void showCursorFromMouseMove() {};
-    /*virtual*/ void hideCursorUntilMouseMove() {};
-    /*virtual*/ bool isCursorHidden() {return false;};
-    /*virtual*/ void updateCursor() {};
-    //virtual ECursorType getCursor() { return mCurrentCursor; };
-    /*virtual*/ void captureMouse() {};
-    /*virtual*/ void releaseMouse() {};
-    /*virtual*/ void setMouseClipping( bool b ) {};
-    /*virtual*/ bool isClipboardTextAvailable() {return false; };
-    /*virtual*/ bool pasteTextFromClipboard(LLWString &dst) {return false; };
-    /*virtual*/ bool copyTextToClipboard(const LLWString &src) {return false; };
-    /*virtual*/ void flashIcon(F32 seconds) {};
-    /*virtual*/ F32 getGamma() {return 1.0f; };
-    /*virtual*/ bool setGamma(const F32 gamma) {return false; }; // Set the gamma
-    /*virtual*/ bool restoreGamma() {return false; };   // Restore original gamma table (before updating gamma)
-    /*virtual*/ void setFSAASamples(const U32 fsaa_samples) { /* FSAA not supported yet on Mesa headless.*/ }
-    /*virtual*/ U32  getFSAASamples() { return 0; }
-    //virtual ESwapMethod getSwapMethod() { return mSwapMethod; }
-    /*virtual*/ void gatherInput() {};
-    /*virtual*/ void delayInputProcessing() {};
-    /*virtual*/ void swapBuffers();
-    /*virtual*/ void restoreGLContext() {};
+    void show() override {};
+    void hide() override {};
+    void close() override {};
+    bool getVisible() override {return false;};
+    bool getMinimized() override {return false;};
+    bool getMaximized() override {return false;};
+    bool maximize() override {return false;};
+    void minimize() override {};
+    void restore() override {};
+    bool getFullscreen() override {return false;};
+    bool getPosition(LLCoordScreen *position) override {return false;};
+    bool getSize(LLCoordScreen *size) override {return false;};
+    bool getSize(LLCoordWindow *size) override {return false;};
+    bool setPosition(LLCoordScreen position) override {return false;};
+    bool setSizeImpl(LLCoordScreen size) override {return false;};
+    bool switchContext(bool fullscreen, const LLCoordScreen &size, bool disable_vsync, const LLCoordScreen * const posp = NULL) override {return false;};
+    bool setCursorPosition(LLCoordWindow position) override {return false;};
+    bool getCursorPosition(LLCoordWindow *position) override {return false;};
+    void showCursor() override {};
+    void hideCursor() override {};
+    void showCursorFromMouseMove() override {};
+    void hideCursorUntilMouseMove() override {};
+    bool isCursorHidden() override {return false;};
+    void updateCursor() override {};
+    //ECursorType getCursor() override { return mCurrentCursor; };
+    void captureMouse() override {};
+    void releaseMouse() override {};
+    void setMouseClipping( bool b ) override {};
+    bool isClipboardTextAvailable() override {return false; };
+    bool pasteTextFromClipboard(LLWString &dst) override {return false; };
+    bool copyTextToClipboard(const LLWString &src) override {return false; };
+    void flashIcon(F32 seconds) override {};
+    F32 getGamma() override {return 1.0f; };
+    bool setGamma(const F32 gamma) override {return false; }; // Set the gamma
+    bool restoreGamma() override {return false; };   // Restore original gamma table (before updating gamma)
+    void setFSAASamples(const U32 fsaa_samples) override { /* FSAA not supported yet on Mesa headless.*/ }
+    U32  getFSAASamples() override { return 0; }
+    //ESwapMethod getSwapMethod() override { return mSwapMethod; }
+    void gatherInput(bool app_has_focus) override {};
+    void delayInputProcessing() override {};
+    void swapBuffers() override;
+    void restoreGLContext() override {};
 
     // handy coordinate space conversion routines
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordWindow *to) { return false; };
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordScreen *to) { return false; };
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordGL *to) { return false; };
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordWindow *to) { return false; };
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordGL *to) { return false; };
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordScreen *to) { return false; };
+    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) override { return false; };
+    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) override { return false; };
+    bool convertCoords(LLCoordWindow from, LLCoordGL *to) override { return false; };
+    bool convertCoords(LLCoordGL from, LLCoordWindow *to) override { return false; };
+    bool convertCoords(LLCoordScreen from, LLCoordGL *to) override { return false; };
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) override { return false; };
 
-    /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) { return NULL; };
-    /*virtual*/ F32 getNativeAspectRatio() { return 1.0f; };
-    /*virtual*/ F32 getPixelAspectRatio() { return 1.0f; };
-    /*virtual*/ void setNativeAspectRatio(F32 ratio) {}
+    LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override { return NULL; };
+    F32 getNativeAspectRatio() override { return 1.0f; };
+    F32 getPixelAspectRatio() override { return 1.0f; };
+    void setNativeAspectRatio(F32 ratio) override {}
 
-    /*virtual*/ void *getPlatformWindow() { return 0; };
-    /*virtual*/ void bringToFront() {};
+    void *getPlatformWindow() override { return 0; };
+    void bringToFront() override {};
 
     LLWindowMesaHeadless(LLWindowCallbacks* callbacks,
                          const std::string& title, const std::string& name, S32 x, S32 y, S32 width, S32 height,
@@ -112,9 +112,9 @@ public:
     LLSplashScreenMesaHeadless() {};
     virtual ~LLSplashScreenMesaHeadless() {};
 
-    /*virtual*/ void showImpl() {};
-    /*virtual*/ void updateImpl(const std::string& mesg) {};
-    /*virtual*/ void hideImpl() {};
+    void showImpl() override {};
+    void updateImpl(const std::string& mesg) override {};
+    void hideImpl() override {};
 
 };
 
diff --git a/indra/llwindow/llwindowsdl.cpp b/indra/llwindow/llwindowsdl.cpp
index ec0972eaae..770170179a 100644
--- a/indra/llwindow/llwindowsdl.cpp
+++ b/indra/llwindow/llwindowsdl.cpp
@@ -37,6 +37,7 @@
 #include "llstring.h"
 #include "lldir.h"
 #include "llfindlocale.h"
+#include "llgamecontrol.h"
 
 #ifdef LL_GLIB
 #include <glib.h>
@@ -246,8 +247,10 @@ void LLWindowSDL::tryFindFullscreenSize( int &width, int &height )
 
 bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, bool fullscreen, bool enable_vsync)
 {
-    //bool          glneedsinit = false;
-
+    if (width == 0)
+        width = 1024;
+    if (height == 0)
+        width = 768;
     LL_INFOS() << "createContext, fullscreen=" << fullscreen <<
                " size=" << width << "x" << height << LL_ENDL;
 
@@ -687,7 +690,7 @@ bool LLWindowSDL::isValid()
     return (mWindow != NULL);
 }
 
-bool LLWindowSDL::getVisible()
+bool LLWindowSDL::getVisible() const
 {
     bool result = false;
     if (mWindow)
@@ -701,7 +704,7 @@ bool LLWindowSDL::getVisible()
     return result;
 }
 
-bool LLWindowSDL::getMinimized()
+bool LLWindowSDL::getMinimized() const
 {
     bool result = false;
     if (mWindow)
@@ -715,7 +718,7 @@ bool LLWindowSDL::getMinimized()
     return result;
 }
 
-bool LLWindowSDL::getMaximized()
+bool LLWindowSDL::getMaximized() const
 {
     bool result = false;
     if (mWindow)
@@ -740,12 +743,7 @@ bool LLWindowSDL::maximize()
     return FALSE;
 }
 
-bool LLWindowSDL::getFullscreen()
-{
-    return mFullscreen;
-}
-
-bool LLWindowSDL::getPosition(LLCoordScreen *position)
+bool LLWindowSDL::getPosition(LLCoordScreen *position) const
 {
     if (mWindow)
     {
@@ -755,7 +753,7 @@ bool LLWindowSDL::getPosition(LLCoordScreen *position)
     return false;
 }
 
-bool LLWindowSDL::getSize(LLCoordScreen *size)
+bool LLWindowSDL::getSize(LLCoordScreen *size) const
 {
     if (mSurface)
     {
@@ -767,7 +765,7 @@ bool LLWindowSDL::getSize(LLCoordScreen *size)
     return (false);
 }
 
-bool LLWindowSDL::getSize(LLCoordWindow *size)
+bool LLWindowSDL::getSize(LLCoordWindow *size) const
 {
     if (mSurface)
     {
@@ -833,7 +831,7 @@ void LLWindowSDL::swapBuffers()
     LL_PROFILER_GPU_COLLECT;
 }
 
-U32 LLWindowSDL::getFSAASamples()
+U32 LLWindowSDL::getFSAASamples() const
 {
     return mFSAASamples;
 }
@@ -843,7 +841,7 @@ void LLWindowSDL::setFSAASamples(const U32 samples)
     mFSAASamples = samples;
 }
 
-F32 LLWindowSDL::getGamma()
+F32 LLWindowSDL::getGamma() const
 {
     return 1.f / mGamma;
 }
@@ -1142,7 +1140,7 @@ LLWindow::LLWindowResolution* LLWindowSDL::getSupportedResolutions(S32 &num_reso
     return mSupportedResolutions;
 }
 
-bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordWindow *to)
+bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordWindow *to) const
 {
     if (!to)
         return false;
@@ -1153,7 +1151,7 @@ bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordWindow *to)
     return true;
 }
 
-bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordGL* to)
+bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordGL* to) const
 {
     if (!to)
         return false;
@@ -1164,7 +1162,7 @@ bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordGL* to)
     return true;
 }
 
-bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordWindow* to)
+bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordWindow* to) const
 {
     if (!to)
         return false;
@@ -1175,7 +1173,7 @@ bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordWindow* to)
     return (true);
 }
 
-bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to)
+bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to) const
 {
     if (!to)
         return false;
@@ -1186,14 +1184,14 @@ bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to)
     return (true);
 }
 
-bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordGL *to)
+bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordGL *to) const
 {
     LLCoordWindow window_coord;
 
     return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
 }
 
-bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordScreen *to)
+bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordScreen *to) const
 {
     LLCoordWindow window_coord;
 
@@ -1415,7 +1413,7 @@ void LLWindowSDL::processMiscNativeEvents()
     }
 }
 
-void LLWindowSDL::gatherInput()
+void LLWindowSDL::gatherInput(bool app_has_focus)
 {
     SDL_Event event;
 
@@ -1618,7 +1616,7 @@ void LLWindowSDL::gatherInput()
                 }
                 break;
             default:
-                //LL_INFOS() << "Unhandled SDL event type " << event.type << LL_ENDL;
+                LLGameControl::handleEvent(event, app_has_focus);
                 break;
         }
     }
@@ -1942,7 +1940,7 @@ bool LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
         Make the raw keyboard data available - used to poke through to LLQtWebKit so
         that Qt/Webkit has access to the virtual keycodes etc. that it needs
 */
-LLSD LLWindowSDL::getNativeKeyData()
+LLSD LLWindowSDL::getNativeKeyData() const
 {
     LLSD result = LLSD::emptyMap();
 
diff --git a/indra/llwindow/llwindowsdl.h b/indra/llwindow/llwindowsdl.h
index 609d8a6f49..a85b7c11e7 100644
--- a/indra/llwindow/llwindowsdl.h
+++ b/indra/llwindow/llwindowsdl.h
@@ -55,11 +55,11 @@ public:
 
     void close() override;
 
-    bool getVisible() override;
+    bool getVisible() const override;
 
-    bool getMinimized() override;
+    bool getMinimized() const override;
 
-    bool getMaximized() override;
+    bool getMaximized() const override;
 
     bool maximize() override;
 
@@ -67,13 +67,11 @@ public:
 
     void restore() override;
 
-    bool getFullscreen();
+    bool getPosition(LLCoordScreen *position) const override;
 
-    bool getPosition(LLCoordScreen *position) override;
+    bool getSize(LLCoordScreen *size) const override;
 
-    bool getSize(LLCoordScreen *size) override;
-
-    bool getSize(LLCoordWindow *size) override;
+    bool getSize(LLCoordWindow *size) const override;
 
     bool setPosition(LLCoordScreen position) override;
 
@@ -122,19 +120,19 @@ public:
 
     void flashIcon(F32 seconds) override;
 
-    F32 getGamma() override;
+    F32 getGamma() const override;
 
     bool setGamma(const F32 gamma) override; // Set the gamma
-    U32 getFSAASamples() override;
+
+    U32 getFSAASamples() const override;
 
     void setFSAASamples(const U32 samples) override;
 
     bool restoreGamma() override;            // Restore original gamma table (before updating gamma)
-    ESwapMethod getSwapMethod()  override { return mSwapMethod; }
 
     void processMiscNativeEvents() override;
 
-    void gatherInput() override;
+    void gatherInput(bool app_has_focus) override;
 
     void swapBuffers() override;
 
@@ -143,17 +141,17 @@ public:
     void delayInputProcessing()  override {};
 
     // handy coordinate space conversion routines
-    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) override;
+    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) const override;
 
-    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) override;
+    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) const override;
 
-    bool convertCoords(LLCoordWindow from, LLCoordGL *to) override;
+    bool convertCoords(LLCoordWindow from, LLCoordGL *to) const override;
 
-    bool convertCoords(LLCoordGL from, LLCoordWindow *to) override;
+    bool convertCoords(LLCoordGL from, LLCoordWindow *to) const override;
 
-    bool convertCoords(LLCoordScreen from, LLCoordGL *to) override;
+    bool convertCoords(LLCoordScreen from, LLCoordGL *to) const override;
 
-    bool convertCoords(LLCoordGL from, LLCoordScreen *to) override;
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) const override;
 
     LLWindowResolution *getSupportedResolutions(S32 &num_resolutions) override;
 
@@ -218,7 +216,7 @@ protected:
 
     bool isValid() override;
 
-    LLSD getNativeKeyData() override;
+    LLSD getNativeKeyData() const override;
 
     void initCursors();
 
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index b19fa13b41..f8294f063f 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -31,6 +31,7 @@
 #include "llwindowwin32.h"
 
 // LLWindow library includes
+#include "llgamecontrol.h"
 #include "llkeyboardwin32.h"
 #include "lldragdropwin32.h"
 #include "llpreeditor.h"
@@ -982,17 +983,17 @@ bool LLWindowWin32::isValid()
     return (mWindowHandle != NULL);
 }
 
-bool LLWindowWin32::getVisible()
+bool LLWindowWin32::getVisible() const
 {
     return (mWindowHandle && IsWindowVisible(mWindowHandle));
 }
 
-bool LLWindowWin32::getMinimized()
+bool LLWindowWin32::getMinimized() const
 {
     return (mWindowHandle && IsIconic(mWindowHandle));
 }
 
-bool LLWindowWin32::getMaximized()
+bool LLWindowWin32::getMaximized() const
 {
     return (mWindowHandle && IsZoomed(mWindowHandle));
 }
@@ -1017,26 +1018,21 @@ bool LLWindowWin32::maximize()
     return true;
 }
 
-bool LLWindowWin32::getFullscreen()
-{
-    return mFullscreen;
-}
-
-bool LLWindowWin32::getPosition(LLCoordScreen *position)
+bool LLWindowWin32::getPosition(LLCoordScreen *position) const
 {
     position->mX = mRect.left;
     position->mY = mRect.top;
     return true;
 }
 
-bool LLWindowWin32::getSize(LLCoordScreen *size)
+bool LLWindowWin32::getSize(LLCoordScreen *size) const
 {
     size->mX = mRect.right - mRect.left;
     size->mY = mRect.bottom - mRect.top;
     return true;
 }
 
-bool LLWindowWin32::getSize(LLCoordWindow *size)
+bool LLWindowWin32::getSize(LLCoordWindow *size) const
 {
     size->mX = mClientRect.right - mClientRect.left;
     size->mY = mClientRect.bottom - mClientRect.top;
@@ -1974,7 +1970,7 @@ bool LLWindowWin32::getCursorPosition(LLCoordWindow *position)
     return true;
 }
 
-bool LLWindowWin32::getCursorDelta(LLCoordCommon* delta)
+bool LLWindowWin32::getCursorDelta(LLCoordCommon* delta) const
 {
     if (delta == nullptr)
     {
@@ -2162,7 +2158,7 @@ void LLWindowWin32::delayInputProcessing()
 }
 
 
-void LLWindowWin32::gatherInput()
+void LLWindowWin32::gatherInput(bool app_has_focus)
 {
     ASSERT_MAIN_THREAD();
     LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
@@ -2242,6 +2238,8 @@ void LLWindowWin32::gatherInput()
     mInputProcessingPaused = false;
 
     updateCursor();
+
+    LLGameControl::processEvents(app_has_focus);
 }
 
 static LLTrace::BlockTimerStatHandle FTM_KEYHANDLER("Handle Keyboard");
@@ -3112,7 +3110,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
     return ret;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordGL from, LLCoordWindow *to)
+bool LLWindowWin32::convertCoords(LLCoordGL from, LLCoordWindow *to) const
 {
     S32     client_height;
     RECT    client_rect;
@@ -3132,7 +3130,7 @@ bool LLWindowWin32::convertCoords(LLCoordGL from, LLCoordWindow *to)
     return true;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordGL* to)
+bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordGL* to) const
 {
     S32     client_height;
     RECT    client_rect;
@@ -3151,7 +3149,7 @@ bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordGL* to)
     return true;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordWindow* to)
+bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordWindow* to) const
 {
     POINT mouse_point;
 
@@ -3168,7 +3166,7 @@ bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordWindow* to)
     return result;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordScreen *to)
+bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordScreen *to) const
 {
     POINT mouse_point;
 
@@ -3185,7 +3183,7 @@ bool LLWindowWin32::convertCoords(LLCoordWindow from, LLCoordScreen *to)
     return result;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordGL *to)
+bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordGL *to) const
 {
     LLCoordWindow window_coord;
 
@@ -3199,7 +3197,7 @@ bool LLWindowWin32::convertCoords(LLCoordScreen from, LLCoordGL *to)
     return true;
 }
 
-bool LLWindowWin32::convertCoords(LLCoordGL from, LLCoordScreen *to)
+bool LLWindowWin32::convertCoords(LLCoordGL from, LLCoordScreen *to) const
 {
     LLCoordWindow window_coord;
 
@@ -3318,7 +3316,7 @@ void LLWindowWin32::setMouseClipping( bool b )
     }
 }
 
-bool LLWindowWin32::getClientRectInScreenSpace( RECT* rectp )
+bool LLWindowWin32::getClientRectInScreenSpace( RECT* rectp ) const
 {
     bool success = false;
 
@@ -3362,7 +3360,7 @@ void LLWindowWin32::flashIcon(F32 seconds)
         });
 }
 
-F32 LLWindowWin32::getGamma()
+F32 LLWindowWin32::getGamma() const
 {
     return mCurrentGamma;
 }
@@ -3424,7 +3422,7 @@ void LLWindowWin32::setFSAASamples(const U32 fsaa_samples)
     mFSAASamples = fsaa_samples;
 }
 
-U32 LLWindowWin32::getFSAASamples()
+U32 LLWindowWin32::getFSAASamples() const
 {
     return mFSAASamples;
 }
@@ -3787,7 +3785,7 @@ void LLWindowWin32::openFolder(const std::string &path)
     Make the raw keyboard data available - used to poke through to LLQtWebKit so
     that Qt/Webkit has access to the virtual keycodes etc. that it needs
 */
-LLSD LLWindowWin32::getNativeKeyData()
+LLSD LLWindowWin32::getNativeKeyData() const
 {
     LLSD result = LLSD::emptyMap();
 
diff --git a/indra/llwindow/llwindowwin32.h b/indra/llwindow/llwindowwin32.h
index e38cfe7ebc..f4964d064e 100644
--- a/indra/llwindow/llwindowwin32.h
+++ b/indra/llwindow/llwindowwin32.h
@@ -45,84 +45,82 @@ typedef void (*LLW32MsgCallback)(const MSG &msg);
 class LLWindowWin32 : public LLWindow
 {
 public:
-    /*virtual*/ void show();
-    /*virtual*/ void hide();
-    /*virtual*/ void close();
-    /*virtual*/ bool getVisible();
-    /*virtual*/ bool getMinimized();
-    /*virtual*/ bool getMaximized();
-    /*virtual*/ bool maximize();
-    /*virtual*/ void minimize();
-    /*virtual*/ void restore();
-    /*virtual*/ bool getFullscreen();
-    /*virtual*/ bool getPosition(LLCoordScreen *position);
-    /*virtual*/ bool getSize(LLCoordScreen *size);
-    /*virtual*/ bool getSize(LLCoordWindow *size);
-    /*virtual*/ bool setPosition(LLCoordScreen position);
-    /*virtual*/ bool setSizeImpl(LLCoordScreen size);
-    /*virtual*/ bool setSizeImpl(LLCoordWindow size);
-    /*virtual*/ bool switchContext(bool fullscreen, const LLCoordScreen &size, bool enable_vsync, const LLCoordScreen * const posp = NULL);
-    /*virtual*/ void setTitle(const std::string title);
+    void show() override;
+    void hide() override;
+    void close() override;
+    bool getVisible() const override;
+    bool getMinimized() const override;
+    bool getMaximized() const override;
+    bool maximize() override;
+    void minimize() override;
+    void restore() override;
+    bool getPosition(LLCoordScreen *position) const override;
+    bool getSize(LLCoordScreen *size) const override;
+    bool getSize(LLCoordWindow *size) const override;
+    bool setPosition(LLCoordScreen position) override;
+    bool setSizeImpl(LLCoordScreen size) override;
+    bool setSizeImpl(LLCoordWindow size) override;
+    bool switchContext(bool fullscreen, const LLCoordScreen &size, bool enable_vsync, const LLCoordScreen * const posp = NULL) override;
+    void setTitle(const std::string title) override;
     void* createSharedContext() override;
     void makeContextCurrent(void* context) override;
     void destroySharedContext(void* context) override;
-    /*virtual*/ void toggleVSync(bool enable_vsync);
-    /*virtual*/ bool setCursorPosition(LLCoordWindow position);
-    /*virtual*/ bool getCursorPosition(LLCoordWindow *position);
-    /*virtual*/ bool getCursorDelta(LLCoordCommon* delta);
-    /*virtual*/ void showCursor();
-    /*virtual*/ void hideCursor();
-    /*virtual*/ void showCursorFromMouseMove();
-    /*virtual*/ void hideCursorUntilMouseMove();
-    /*virtual*/ bool isCursorHidden();
-    /*virtual*/ void updateCursor();
-    /*virtual*/ ECursorType getCursor() const;
-    /*virtual*/ void captureMouse();
-    /*virtual*/ void releaseMouse();
-    /*virtual*/ void setMouseClipping( bool b );
-    /*virtual*/ bool isClipboardTextAvailable();
-    /*virtual*/ bool pasteTextFromClipboard(LLWString &dst);
-    /*virtual*/ bool copyTextToClipboard(const LLWString &src);
-    /*virtual*/ void flashIcon(F32 seconds);
-    /*virtual*/ F32 getGamma();
-    /*virtual*/ bool setGamma(const F32 gamma); // Set the gamma
-    /*virtual*/ void setFSAASamples(const U32 fsaa_samples);
-    /*virtual*/ U32 getFSAASamples();
-    /*virtual*/ bool restoreGamma();            // Restore original gamma table (before updating gamma)
-    /*virtual*/ ESwapMethod getSwapMethod() { return mSwapMethod; }
-    /*virtual*/ void gatherInput();
-    /*virtual*/ void delayInputProcessing();
-    /*virtual*/ void swapBuffers();
-    /*virtual*/ void restoreGLContext() {};
+    void toggleVSync(bool enable_vsync) override;
+    bool setCursorPosition(LLCoordWindow position) override;
+    bool getCursorPosition(LLCoordWindow *position) override;
+    bool getCursorDelta(LLCoordCommon* delta) const override;
+    void showCursor() override;
+    void hideCursor() override;
+    void showCursorFromMouseMove() override;
+    void hideCursorUntilMouseMove() override;
+    bool isCursorHidden() override;
+    void updateCursor() override;
+    ECursorType getCursor() const override;
+    void captureMouse() override;
+    void releaseMouse() override;
+    void setMouseClipping( bool b ) override;
+    bool isClipboardTextAvailable() override;
+    bool pasteTextFromClipboard(LLWString &dst) override;
+    bool copyTextToClipboard(const LLWString &src) override;
+    void flashIcon(F32 seconds) override;
+    F32 getGamma() const override;
+    bool setGamma(const F32 gamma) override; // Set the gamma
+    void setFSAASamples(const U32 fsaa_samples) override;
+    U32 getFSAASamples() const override;
+    bool restoreGamma() override;            // Restore original gamma table (before updating gamma)
+    void gatherInput(bool app_has_focus) override;
+    void delayInputProcessing() override;
+    void swapBuffers() override;
+    void restoreGLContext() {};
 
     // handy coordinate space conversion routines
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordWindow *to);
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordScreen *to);
-    /*virtual*/ bool convertCoords(LLCoordWindow from, LLCoordGL *to);
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordWindow *to);
-    /*virtual*/ bool convertCoords(LLCoordScreen from, LLCoordGL *to);
-    /*virtual*/ bool convertCoords(LLCoordGL from, LLCoordScreen *to);
-
-    /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions);
-    /*virtual*/ F32 getNativeAspectRatio();
-    /*virtual*/ F32 getPixelAspectRatio();
-    /*virtual*/ void setNativeAspectRatio(F32 ratio) { mOverrideAspectRatio = ratio; }
-
-    /*virtual*/ bool dialogColorPicker(F32 *r, F32 *g, F32 *b );
-
-    /*virtual*/ void *getPlatformWindow();
-    /*virtual*/ void bringToFront();
-    /*virtual*/ void focusClient();
-
-    /*virtual*/ void allowLanguageTextInput(LLPreeditor *preeditor, bool b);
-    /*virtual*/ void setLanguageTextInput( const LLCoordGL & pos );
-    /*virtual*/ void updateLanguageTextInputArea();
-    /*virtual*/ void interruptLanguageTextInput();
-    /*virtual*/ void spawnWebBrowser(const std::string& escaped_url, bool async);
+    bool convertCoords(LLCoordScreen from, LLCoordWindow *to) const override;
+    bool convertCoords(LLCoordWindow from, LLCoordScreen *to) const override;
+    bool convertCoords(LLCoordWindow from, LLCoordGL *to) const override;
+    bool convertCoords(LLCoordGL from, LLCoordWindow *to) const override;
+    bool convertCoords(LLCoordScreen from, LLCoordGL *to) const override;
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) const override;
+
+    LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override;
+    F32 getNativeAspectRatio() override;
+    F32 getPixelAspectRatio() override;
+    void setNativeAspectRatio(F32 ratio) override { mOverrideAspectRatio = ratio; }
+
+    bool dialogColorPicker(F32 *r, F32 *g, F32 *b ) override;
+
+    void *getPlatformWindow() override;
+    void bringToFront() override;
+    void focusClient() override;
+
+    void allowLanguageTextInput(LLPreeditor *preeditor, bool b) override;
+    void setLanguageTextInput( const LLCoordGL & pos ) override;
+    void updateLanguageTextInputArea() override;
+    void interruptLanguageTextInput() override;
+    void spawnWebBrowser(const std::string& escaped_url, bool async) override;
 
     void openFolder(const std::string &path) override;
 
-    /*virtual*/ F32 getSystemUISize();
+    F32 getSystemUISize() override;
 
     LLWindowCallbacks::DragNDropResult completeDragNDropRequest( const LLCoordGL gl_coord, const MASK mask, LLWindowCallbacks::DragNDropAction action, const std::string url );
 
@@ -130,13 +128,13 @@ public:
     static std::vector<std::string> getDynamicFallbackFontList();
     static void setDPIAwareness();
 
-    /*virtual*/ void* getDirectInput8();
-    /*virtual*/ bool getInputDevices(U32 device_type_filter,
+    void* getDirectInput8() override;
+    bool getInputDevices(U32 device_type_filter,
                                      std::function<bool(std::string&, LLSD&, void*)> osx_callback,
                                      void* win_callback,
-                                     void* userdata);
+                                     void* userdata) override;
 
-    U32 getRawWParam() { return mRawWParam; }
+    U32 getRawWParam() const { return mRawWParam; }
 
 protected:
     LLWindowWin32(LLWindowCallbacks* callbacks,
@@ -149,7 +147,7 @@ protected:
     HCURSOR loadColorCursor(LPCTSTR name);
     bool    isValid();
     void    moveWindow(const LLCoordScreen& position,const LLCoordScreen& size);
-    virtual LLSD    getNativeKeyData();
+    LLSD    getNativeKeyData() const override;
 
     // Changes display resolution. Returns true if successful
     bool    setDisplayResolution(S32 width, S32 height, S32 bits, S32 refresh);
@@ -175,7 +173,7 @@ protected:
     // Platform specific methods
     //
 
-    bool    getClientRectInScreenSpace(RECT* rectp);
+    bool    getClientRectInScreenSpace(RECT* rectp) const;
 
     static LRESULT CALLBACK mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_param, LPARAM l_param);
 
@@ -266,9 +264,9 @@ public:
     LLSplashScreenWin32();
     virtual ~LLSplashScreenWin32();
 
-    /*virtual*/ void showImpl();
-    /*virtual*/ void updateImpl(const std::string& mesg);
-    /*virtual*/ void hideImpl();
+    void showImpl() override;
+    void updateImpl(const std::string& mesg) override;
+    void hideImpl() override;
 
 #if LL_WINDOWS
     static LRESULT CALLBACK windowProc(HWND h_wnd, UINT u_msg,
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index a69a777e1e..448ee575f5 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -498,7 +498,7 @@ private:
     // mControlFlags is a bitmask of behavior instructions for compact
     // transmission to the server.  It does NOT represent "input", rather
     // the consequences of it, which will sometimes depend on "state".
-    U32             mControlFlags;                  // Replacement for the mFooKey's
+    U32             mControlFlags;
 
     //--------------------------------------------------------------------
     // GameControls
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 475610be36..75cd189980 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1531,7 +1531,7 @@ bool LLAppViewer::doFrame()
                     LL_WARNS() << " Someone took over my signal/exception handler (post messagehandling)!" << LL_ENDL;
                 }
 
-                gViewerWindow->getWindow()->gatherInput();
+                gViewerWindow->getWindow()->gatherInput(gFocusMgr.getAppHasFocus());
             }
 
             //memory leaking simulation
@@ -4811,11 +4811,6 @@ void LLAppViewer::idle()
             gAgent.autoPilot(&yaw);
         }
 
-        // Some GameControl logic needs to run even when the feature is not enabled
-        // Note: we process game_control before sending AgentUpdate
-        // because it may translate to control flags that control avatar motion.
-        LLGameControl::processEvents(gFocusMgr.getAppHasFocus());
-
         // get control flags from each side
         U32 control_flags = gAgent.getControlFlags();
         U32 game_control_action_flags = LLGameControl::computeInternalActionFlags();
@@ -4841,6 +4836,12 @@ void LLAppViewer::idle()
         }
 
         send_agent_update(false);
+
+        // After calling send_agent_update() in the mainloop we always clear
+        // the agent's ephemeral ControlFlags (whether an AgentUpdate was
+        // actually sent or not) because these will be recomputed based on
+        // real-time key/controller input and resubmitted next frame.
+        gAgent.resetControlFlags();
     }
 
     //////////////////////////////////////
diff --git a/indra/newview/llappviewerlinux.cpp b/indra/newview/llappviewerlinux.cpp
index 38f2f1ae7f..7ce74649e2 100644
--- a/indra/newview/llappviewerlinux.cpp
+++ b/indra/newview/llappviewerlinux.cpp
@@ -129,7 +129,7 @@ int main( int argc, char **argv )
         return -1;
     }
 
-        // Run the application main loop
+    // Run the application main loop
     while (! viewer_app_ptr->frame())
     {}
 
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 109db7e3d7..ec725a8ace 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -3506,8 +3506,21 @@ bool LLPanelPreferenceGameControl::postBuild()
     mCheckGameControlToAgent = getChild<LLCheckBoxCtrl>("game_control_to_agent");
     mCheckAgentToGameControl = getChild<LLCheckBoxCtrl>("agent_to_game_control");
 
-    mCheckGameControlToAgent->setCommitCallback([this](LLUICtrl*, const LLSD&) { updateActionTableState(); });
-    mCheckAgentToGameControl->setCommitCallback([this](LLUICtrl*, const LLSD&) { updateActionTableState(); });
+    mCheckGameControlToServer->setCommitCallback([this](LLUICtrl*, const LLSD&)
+        {
+            LLGameControl::setSendToServer(mCheckGameControlToServer->getValue());
+            updateActionTableState();
+        });
+    mCheckGameControlToAgent->setCommitCallback([this](LLUICtrl*, const LLSD&)
+        {
+            LLGameControl::setControlAgent(mCheckGameControlToAgent->getValue());
+            updateActionTableState();
+        });
+    mCheckAgentToGameControl->setCommitCallback([this](LLUICtrl*, const LLSD&)
+        {
+            LLGameControl::setTranslateAgentActions(mCheckAgentToGameControl->getValue());
+            updateActionTableState();
+        });
 
     getChild<LLTabContainer>("game_control_tabs")->setCommitCallback([this](LLUICtrl*, const LLSD&) { clearSelectionState(); });
     getChild<LLTabContainer>("device_settings_tabs")->setCommitCallback([this](LLUICtrl*, const LLSD&) { clearSelectionState(); });
diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h
index 57eaa193a3..33d1cb0c87 100644
--- a/indra/newview/llfloaterpreference.h
+++ b/indra/newview/llfloaterpreference.h
@@ -447,9 +447,9 @@ private:
     void resetButtonMappingsToDefaults();
 
     // Above the tab container
-    LLCheckBoxCtrl  *mCheckGameControlToServer; // send game_control data to server
-    LLCheckBoxCtrl  *mCheckGameControlToAgent; // use game_control data to move avatar
-    LLCheckBoxCtrl  *mCheckAgentToGameControl; // translate external avatar actions to game_control data
+    LLCheckBoxCtrl* mCheckGameControlToServer; // send game_control data to server
+    LLCheckBoxCtrl* mCheckGameControlToAgent;  // use game_control data to move avatar
+    LLCheckBoxCtrl* mCheckAgentToGameControl;  // translate external avatar actions to game_control data
 
     // 1st tab "Channel mappings"
     LLPanel* mTabChannelMappings;
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index 39b81f2395..efc90b8991 100755
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -1420,15 +1420,6 @@ class Linux_x86_64_Manifest(LinuxManifest):
 
             self.path_optional("libjemalloc*.so")
 
-            self.path("libdb*.so")
-            self.path("libuuid.so*")
-            self.path("libdirectfb-1.*.so.*")
-            self.path("libfusion-1.*.so.*")
-            self.path("libdirect-1.*.so.*")
-            self.path("libopenjp2.so*")
-            self.path("libdirectfb-1.4.so.5")
-            self.path("libfusion-1.4.so.5")
-            self.path("libdirect-1.4.so.5*")
             self.path("libalut.so*")
             self.path("libopenal.so*")
             self.path("libopenal.so", "libvivoxoal.so.1") # vivox's sdk expects this soname
author	leviathan <leviathan@lindenlab.com>	2024-09-03 15:38:35 -0700
committer	Andrew Meadows <andrew.l.meadows@gmail.com>	2024-10-03 09:16:46 -0700
commit	0617923ae7f450ece7288f8a73446c45a8ed32db (patch)
tree	1914627e41be3619eb335aa28e6acdfb98925ea0 /indra
parent	8213a0fb6b3149042d6833c8f0c4a3c1bfdc8bc9 (diff)