1 files changed, 221 insertions, 115 deletions

diff --git a/indra/llwindow/llwindowsdl.h b/indra/llwindow/llwindowsdl.h
index 196ad2986d..10769bb3ba 100644
--- a/indra/llwindow/llwindowsdl.h
+++ b/indra/llwindow/llwindowsdl.h
@@ -24,20 +24,20 @@
  * $/LicenseInfo$
  */
 
-#ifndef LL_LLWINDOWSDL_H
-#define LL_LLWINDOWSDL_H
+#ifndef LL_LLWINDOWSDL2_H
+#define LL_LLWINDOWSDL2_H
 
 // Simple Directmedia Layer (http://libsdl.org/) implementation of LLWindow class
 
 #include "llwindow.h"
 #include "lltimer.h"
 
-#include "SDL/SDL.h"
-#include "SDL/SDL_endian.h"
+#include "SDL2/SDL.h"
+#include "SDL2/SDL_endian.h"
 
 #if LL_X11
 // get X11-specific headers for use in low-level stuff like copy-and-paste support
-#include "SDL/SDL_syswm.h"
+#include "SDL2/SDL_syswm.h"
 #endif
 
 // AssertMacros.h does bad things.
@@ -46,83 +46,139 @@
 #undef require
 
 
-class LLWindowSDL : public LLWindow
-{
+class LLWindowSDL : 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 disable_vsync, const LLCoordScreen * const posp = NULL);
-    /*virtual*/ bool setCursorPosition(LLCoordWindow position);
-    /*virtual*/ bool getCursorPosition(LLCoordWindow *position);
-    /*virtual*/ void showCursor();
-    /*virtual*/ void hideCursor();
-    /*virtual*/ void showCursorFromMouseMove();
-    /*virtual*/ void hideCursorUntilMouseMove();
-    /*virtual*/ bool isCursorHidden();
-    /*virtual*/ void updateCursor();
-    /*virtual*/ void captureMouse();
-    /*virtual*/ void releaseMouse();
-    /*virtual*/ void setMouseClipping( bool b );
-    /*virtual*/ void setMinSize(U32 min_width, U32 min_height, bool enforce_immediately = true);
-
-    /*virtual*/ bool isClipboardTextAvailable();
-    /*virtual*/ bool pasteTextFromClipboard(LLWString &dst);
-    /*virtual*/ bool copyTextToClipboard(const LLWString & src);
-
-    /*virtual*/ bool isPrimaryTextAvailable();
-    /*virtual*/ bool pasteTextFromPrimary(LLWString &dst);
-    /*virtual*/ bool copyTextToPrimary(const LLWString & src);
-
-    /*virtual*/ void flashIcon(F32 seconds);
-    /*virtual*/ F32 getGamma();
-    /*virtual*/ bool setGamma(const F32 gamma); // Set the gamma
-    /*virtual*/ U32 getFSAASamples();
-    /*virtual*/ void setFSAASamples(const U32 samples);
-    /*virtual*/ bool restoreGamma();            // Restore original gamma table (before updating gamma)
-    /*virtual*/ ESwapMethod getSwapMethod() { return mSwapMethod; }
-    /*virtual*/ void processMiscNativeEvents();
-    /*virtual*/ void gatherInput();
-    /*virtual*/ void swapBuffers();
-    /*virtual*/ void restoreGLContext() {};
-
-    /*virtual*/ void delayInputProcessing() { };
+    void show() override;
+
+    void hide() override;
+
+    void close() override;
+
+    bool getVisible() override;
+
+    bool getMinimized() override;
+
+    bool getMaximized() 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 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;
+
+    bool setCursorPosition(LLCoordWindow position) override;
+
+    bool getCursorPosition(LLCoordWindow *position) override;
+
+    void showCursor() override;
+
+    void hideCursor() override;
+
+    void showCursorFromMouseMove() override;
+
+    void hideCursorUntilMouseMove() override;
+
+    bool isCursorHidden() override;
+
+    void updateCursor() override;
+
+    void captureMouse() override;
+
+    void releaseMouse() override;
+
+    void setMouseClipping(bool b) override;
+
+       void setMinSize(U32 min_width, U32 min_height, bool enforce_immediately = true) override;
+
+    bool isClipboardTextAvailable() override;
+
+    bool pasteTextFromClipboard(LLWString &dst) override;
+
+    bool copyTextToClipboard(const LLWString &src) override;
+
+    bool isPrimaryTextAvailable() override;
+
+    bool pasteTextFromPrimary(LLWString &dst) override;
+
+    bool copyTextToPrimary(const LLWString &src) override;
+
+    void flashIcon(F32 seconds) override;
+
+    F32 getGamma() override;
+
+    bool setGamma(const F32 gamma) override; // Set the gamma
+    U32 getFSAASamples() 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 swapBuffers() override;
+
+    void restoreGLContext() {};
+
+    void delayInputProcessing()  override {};
 
     // 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);
+    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;
 
-    /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions);
-    /*virtual*/ F32 getNativeAspectRatio();
-    /*virtual*/ F32 getPixelAspectRatio();
-    /*virtual*/ void setNativeAspectRatio(F32 ratio) { mOverrideAspectRatio = ratio; }
+    bool convertCoords(LLCoordGL from, LLCoordScreen *to) override;
 
-    /*virtual*/ void beforeDialog();
-    /*virtual*/ void afterDialog();
+    LLWindowResolution *getSupportedResolutions(S32 &num_resolutions) override;
 
-    /*virtual*/ bool dialogColorPicker(F32 *r, F32 *g, F32 *b);
+    F32 getNativeAspectRatio() override;
 
-    /*virtual*/ void *getPlatformWindow();
-    /*virtual*/ void bringToFront();
+    F32 getPixelAspectRatio() override;
 
-    /*virtual*/ void spawnWebBrowser(const std::string& escaped_url, bool async);
+    void setNativeAspectRatio(F32 ratio)  override { mOverrideAspectRatio = ratio; }
+
+    void beforeDialog() override;
+
+    void afterDialog() override;
+
+    bool dialogColorPicker(F32 *r, F32 *g, F32 *b) override;
+
+    void *getPlatformWindow() override;
+
+    void bringToFront() override;
+
+    void setLanguageTextInput(const LLCoordGL& pos) override;
+
+    void spawnWebBrowser(const std::string &escaped_url, bool async) override;
+
+    void openFile(const std::string &file_name);
+
+    void setTitle(const std::string title) override;
 
     static std::vector<std::string> getDynamicFallbackFontList();
 
@@ -132,40 +188,52 @@ public:
     Window mSDL_XWindowID;
     Display *mSDL_Display;
 #endif
+
     void (*Lock_Display)(void);
-    void (*Unlock_Display)(void);
 
-#if LL_GTK
-    // Lazily initialize and check the runtime GTK version for goodness.
-    static bool ll_try_gtk_init(void);
-#endif // LL_GTK
+    void (*Unlock_Display)(void);
 
 #if LL_X11
+
     static Window get_SDL_XWindowID(void);
-    static Display* get_SDL_Display(void);
+
+    static Display *get_SDL_Display(void);
+
 #endif // LL_X11
 
+    void *createSharedContext() override;
+
+    void makeContextCurrent(void *context) override;
+
+    void destroySharedContext(void *context) override;
+
+    void toggleVSync(bool enable_vsync) override;
+
 protected:
-    LLWindowSDL(LLWindowCallbacks* callbacks,
-        const std::string& title, int x, int y, int width, int height, U32 flags,
-        bool fullscreen, bool clearBg, bool disable_vsync, bool use_gl,
-        bool ignore_pixel_depth, U32 fsaa_samples);
+    LLWindowSDL(LLWindowCallbacks *callbacks,
+                const std::string &title, int x, int y, int width, int height, U32 flags,
+                bool fullscreen, bool clearBg, bool enable_vsync, bool use_gl,
+                bool ignore_pixel_depth, U32 fsaa_samples);
+
     ~LLWindowSDL();
 
-    /*virtual*/ bool    isValid();
-    /*virtual*/ LLSD    getNativeKeyData();
+    bool isValid() override;
+
+    LLSD getNativeKeyData() override;
+
+    void initCursors();
 
-    void    initCursors();
-    void    quitCursors();
-    void    moveWindow(const LLCoordScreen& position,const LLCoordScreen& size);
+    void quitCursors();
+
+    void moveWindow(const LLCoordScreen &position, const LLCoordScreen &size);
 
     // Changes display resolution. Returns true if successful
-    bool    setDisplayResolution(S32 width, S32 height, S32 bits, S32 refresh);
+    bool setDisplayResolution(S32 width, S32 height, S32 bits, S32 refresh);
 
     // Go back to last fullscreen display resolution.
-    bool    setFullscreenResolution();
+    bool setFullscreenResolution();
 
-    bool    shouldPostQuit() { return mPostQuit; }
+    bool shouldPostQuit() { return mPostQuit; }
 
 protected:
     //
@@ -173,47 +241,85 @@ protected:
     //
 
     // create or re-create the GL context/window.  Called from the constructor and switchContext().
-    bool createContext(int x, int y, int width, int height, int bits, bool fullscreen, bool disable_vsync);
+    bool createContext(int x, int y, int width, int height, int bits, bool fullscreen, bool enable_vsync);
+
     void destroyContext();
-    void setupFailure(const std::string& text, const std::string& caption, U32 type);
+
+    void setupFailure(const std::string &text, const std::string &caption, U32 type);
+
     void fixWindowSize(void);
-    U32 SDLCheckGrabbyKeys(SDLKey keysym, bool gain);
+
+    U32 SDLCheckGrabbyKeys(U32 keysym, bool gain);
+
     bool SDLReallyCaptureInput(bool capture);
 
     //
     // Platform specific variables
     //
-    U32             mGrabbyKeyFlags;
-    int         mReallyCapturedCount;
-    SDL_Surface *   mWindow;
+    U32 mGrabbyKeyFlags;
+    int mReallyCapturedCount;
+
+    SDL_Window *mWindow;
+    SDL_Surface *mSurface;
+    SDL_GLContext mContext;
+    SDL_Cursor *mSDLCursors[UI_CURSOR_COUNT];
+
     std::string mWindowTitle;
-    double      mOriginalAspectRatio;
-    bool        mNeedsResize;       // Constructor figured out the window is too big, it needs a resize.
-    LLCoordScreen   mNeedsResizeSize;
-    F32         mOverrideAspectRatio;
-    F32     mGamma;
-    U32     mFSAASamples;
+    double mOriginalAspectRatio;
+    bool mNeedsResize;        // Constructor figured out the window is too big, it needs a resize.
+    LLCoordScreen mNeedsResizeSize;
+    F32 mOverrideAspectRatio;
+    F32 mGamma;
+    U32 mFSAASamples;
 
-    int     mSDLFlags;
+    int mSDLFlags;
 
-    SDL_Cursor* mSDLCursors[UI_CURSOR_COUNT];
-    int             mHaveInputFocus; /* 0=no, 1=yes, else unknown */
-    int             mIsMinimized; /* 0=no, 1=yes, else unknown */
+    int mHaveInputFocus; /* 0=no, 1=yes, else unknown */
+    int mIsMinimized; /* 0=no, 1=yes, else unknown */
 
     friend class LLWindowManager;
 
 private:
 #if LL_X11
+
     void x11_set_urgent(bool urgent);
+
     bool mFlashing;
     LLTimer mFlashTimer;
 #endif //LL_X11
 
-    U32 mKeyScanCode;
-        U32 mKeyVirtualKey;
-    SDLMod mKeyModifiers;
-};
+    U32 mKeyVirtualKey;
+    U32 mKeyModifiers;
+    std::string mInputType;
+
+public:
+#if LL_X11
+
+    static Display *getSDLDisplay();
 
+    LLWString const &getPrimaryText() const { return mPrimaryClipboard; }
+
+    LLWString const &getSecondaryText() const { return mSecondaryClipboard; }
+
+    void clearPrimaryText() { mPrimaryClipboard.clear(); }
+
+    void clearSecondaryText() { mSecondaryClipboard.clear(); }
+
+private:
+    void tryFindFullscreenSize(int &aWidth, int &aHeight);
+
+    void initialiseX11Clipboard();
+
+    bool getSelectionText(Atom selection, LLWString &text);
+
+    bool getSelectionText(Atom selection, Atom type, LLWString &text);
+
+    bool setSelectionText(Atom selection, const LLWString &text);
+
+#endif
+    LLWString mPrimaryClipboard;
+    LLWString mSecondaryClipboard;
+};
 
 class LLSplashScreenSDL : public LLSplashScreen
 {
@@ -221,9 +327,9 @@ public:
     LLSplashScreenSDL();
     virtual ~LLSplashScreenSDL();
 
-    /*virtual*/ void showImpl();
-    /*virtual*/ void updateImpl(const std::string& mesg);
-    /*virtual*/ void hideImpl();
+    void showImpl();
+    void updateImpl(const std::string& mesg);
+    void hideImpl();
 };
 
 S32 OSMessageBoxSDL(const std::string& text, const std::string& caption, U32 type);