Second Life viewer sources 1.17.1.0

7 files changed, 325 insertions, 11 deletions

diff --git a/linden/indra/llwindow/llwindow.cpp b/linden/indra/llwindow/llwindow.cpp
index cad1dc4..faa5e61 100644
--- a/linden/indra/llwindow/llwindow.cpp
+++ b/linden/indra/llwindow/llwindow.cpp
@@ -241,7 +241,8 @@ LLWindow::LLWindow(BOOL fullscreen, U32 flags)
           mIsMouseClipping(FALSE),
           mSwapMethod(SWAP_METHOD_UNDEFINED),
           mHideCursorPermanent(FALSE),
-          mFlags(flags)
+          mFlags(flags),
+          mHighSurrogate(0)
 {
         for (U32 i = 0; i < 6; i++)
         {
@@ -296,6 +297,53 @@ void LLWindow::setCallbacks(LLWindowCallbacks *callbacks)
         }
 }
 
+#define UTF16_IS_HIGH_SURROGATE(U) ((U16)((U) - 0xD800) < 0x0400)
+#define UTF16_IS_LOW_SURROGATE(U)  ((U16)((U) - 0xDC00) < 0x0400)
+#define UTF16_SURROGATE_PAIR_TO_UTF32(H,L) (((H) << 10) + (L) - (0xD800 << 10) - 0xDC00 + 0x00010000)
+
+void LLWindow::handleUnicodeUTF16(U16 utf16, MASK mask)
+{
+        // Note that we could discard unpaired surrogates, but I'm
+        // following the Unicode Consortium's recommendation here;
+        // that is, to preserve those unpaired surrogates in UTF-32
+        // values.  _To_preserve_ means to pass to the callback in our
+        // context.
+
+        if (mHighSurrogate == 0)
+        {
+                if (UTF16_IS_HIGH_SURROGATE(utf16))
+                {
+                        mHighSurrogate = utf16;
+                }
+                else
+                {
+                        mCallbacks->handleUnicodeChar(utf16, mask);
+                }
+        }
+        else
+        {
+                if (UTF16_IS_LOW_SURROGATE(utf16))
+                {
+                        /* A legal surrogate pair.  */                  
+                        mCallbacks->handleUnicodeChar(UTF16_SURROGATE_PAIR_TO_UTF32(mHighSurrogate, utf16), mask);
+                        mHighSurrogate = 0;
+                }
+                else if (UTF16_IS_HIGH_SURROGATE(utf16))
+                {
+                        /* Two consecutive high surrogates.  */
+                        mCallbacks->handleUnicodeChar(mHighSurrogate, mask);
+                        mHighSurrogate = utf16;
+                }
+                else
+                {
+                        /* A non-low-surrogate preceeded by a high surrogate. */
+                        mCallbacks->handleUnicodeChar(mHighSurrogate, mask);
+                        mHighSurrogate = 0;
+                        mCallbacks->handleUnicodeChar(utf16, mask);
+                }
+        }
+}
+
 //
 // LLSplashScreen
 //
diff --git a/linden/indra/llwindow/llwindow.h b/linden/indra/llwindow/llwindow.h
index 2bb49e9..1016bce 100644
--- a/linden/indra/llwindow/llwindow.h
+++ b/linden/indra/llwindow/llwindow.h
@@ -218,6 +218,10 @@ public:
 // return a platform-specific window reference (HWND on Windows, WindowRef on the Mac)
         virtual void *getPlatformWindow() = 0;
         
+        // control platform's Language Text Input mechanisms.
+        virtual void allowLanguageTextInput( BOOL b ) {};
+        virtual void setLanguageTextInput( LLCoordWindow pos ) {};
+
 protected:
         LLWindow(BOOL fullscreen, U32 flags);
         virtual ~LLWindow() {}
@@ -246,6 +250,15 @@ protected:
         U32                     mFlags;
         F32                     mJoyAxis[6]; 
         U8                      mJoyButtonState[16];
+        U16                     mHighSurrogate;
+
+        // Handle a UTF-16 encoding unit received from keyboard.
+        // Converting the series of UTF-16 encoding units to UTF-32 data,
+        // this method passes the resulting UTF-32 data to mCallback's
+        // handleUnicodeChar.  The mask should be that to be passed to the
+        // callback.  This method uses mHighSurrogate as a dedicated work
+        // variable.
+        void handleUnicodeUTF16(U16 utf16, MASK mask);
 
         friend class LLWindowManager;
 };
diff --git a/linden/indra/llwindow/llwindowmacosx.cpp b/linden/indra/llwindow/llwindowmacosx.cpp
index 0c5d6ed..021d7a4 100644
--- a/linden/indra/llwindow/llwindowmacosx.cpp
+++ b/linden/indra/llwindow/llwindowmacosx.cpp
@@ -239,6 +239,10 @@ LLWindowMacOSX::LLWindowMacOSX(char *title, char *name, S32 x, S32 y, S32 width,
         mNeedsResize = FALSE;
         mOverrideAspectRatio = 0.f;
         mMinimized = FALSE;
+        mTSMDocument = NULL; // Just in case.
+        mLanguageTextInputAllowed = FALSE;
+        mTSMScriptCode = 0;
+        mTSMLangCode = 0;
         
         // For reasons that aren't clear to me, LLTimers seem to be created in the "started" state.
         // Since the started state of this one is used to track whether the NMRec has been installed, it wants to start out in the "stopped" state.
@@ -479,6 +483,29 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
         }
 
+        {
+                // Create and initialize our TSM document for language text input.
+                // If an error occured, we can do nothing better than simply ignore it.
+                // mTSMDocument will be kept NULL in case.
+                if (mTSMDocument)
+                {
+                        DeactivateTSMDocument(mTSMDocument);
+                        DeleteTSMDocument(mTSMDocument);
+                        mTSMDocument = NULL;
+                }
+                static InterfaceTypeList types = { kUnicodeDocument };
+                OSErr err = NewTSMDocument(1, types, &mTSMDocument, 0);
+                if (err != noErr)
+                {
+                        llwarns << "createContext: couldn't create a TSMDocument (" << err << ")" << llendl;
+                }
+                if (mTSMDocument)
+                {
+                        UseInputWindow(mTSMDocument, TRUE);
+                        ActivateTSMDocument(mTSMDocument);
+                }
+        }
+
         if(mContext == NULL)
         {
                 AGLRendererInfo rendererInfo = NULL;
@@ -924,6 +951,15 @@ void LLWindowMacOSX::destroyContext()
                 mWindowHandlerRef = NULL;
         }
 
+        // Cleanup any TSM document we created.
+        if(mTSMDocument != NULL)
+        {
+                llinfos << "destroyContext: deleting TSM document" << llendl;
+                DeactivateTSMDocument(mTSMDocument);
+                DeleteTSMDocument(mTSMDocument);
+                mTSMDocument = NULL;
+        }
+
         // Close the window
         if(mWindow != NULL)
         {
@@ -1529,7 +1565,7 @@ void LLWindowMacOSX::flashIcon(F32 seconds)
                 OSErr err;
 
                 mBounceTime = seconds;
-                memset(&mBounceRec, sizeof(mBounceRec), 0);
+                memset(&mBounceRec, 0, sizeof(mBounceRec));
                 mBounceRec.qType = nmType;
                 mBounceRec.nmMark = 1;
                 err = NMInstall(&mBounceRec);
@@ -2241,6 +2277,10 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                 switch(evtKind)
                 {               
                 case kEventWindowActivated:
+                        if (mTSMDocument)
+                        {
+                                ActivateTSMDocument(mTSMDocument);
+                        }
                         mCallbacks->handleFocus(this);
                         break;
                 case kEventWindowDeactivated:
@@ -2952,4 +2992,37 @@ static long getDictLong (CFDictionaryRef refDict, CFStringRef key)
         return int_value; // otherwise return the long value
 }
 
+void LLWindowMacOSX::allowLanguageTextInput(BOOL b)
+{
+        ScriptLanguageRecord script_language;
+
+        if (b == mLanguageTextInputAllowed)
+        {
+                return;
+        }
+        mLanguageTextInputAllowed = b;
+        
+        if (b)
+        {
+                if (mTSMScriptCode != smRoman)
+                {
+                        script_language.fScript = mTSMScriptCode;
+                        script_language.fLanguage = mTSMLangCode;
+                        SetTextServiceLanguage(&script_language);
+                }
+        }
+        else
+        {
+                GetTextServiceLanguage(&script_language);
+                mTSMScriptCode = script_language.fScript;
+                mTSMLangCode = script_language.fLanguage;
+                if (mTSMScriptCode != smRoman)
+                {
+                        script_language.fScript = smRoman;
+                        script_language.fLanguage = langEnglish;
+                        SetTextServiceLanguage(&script_language);
+                }
+        }
+}
+
 #endif // LL_DARWIN
diff --git a/linden/indra/llwindow/llwindowmacosx.h b/linden/indra/llwindow/llwindowmacosx.h
index 63d846e..01b9303 100644
--- a/linden/indra/llwindow/llwindowmacosx.h
+++ b/linden/indra/llwindow/llwindowmacosx.h
@@ -108,6 +108,8 @@ public:
         /*virtual*/ void *getPlatformWindow();
         /*virtual*/ void bringToFront() {};
         
+        /*virtual*/ void allowLanguageTextInput(BOOL b);
+        
 protected:
         LLWindowMacOSX(
                 char *title, char *name, int x, int y, int width, int height, U32 flags,
@@ -183,6 +185,12 @@ protected:
         NMRec           mBounceRec;
         LLTimer         mBounceTimer;
 
+        // Imput method management through Text Service Manager.
+        TSMDocumentID   mTSMDocument;
+        BOOL            mLanguageTextInputAllowed;
+        ScriptCode      mTSMScriptCode;
+        LangCode        mTSMLangCode;
+
         friend class LLWindowManager;
 };
 
diff --git a/linden/indra/llwindow/llwindowsdl.cpp b/linden/indra/llwindow/llwindowsdl.cpp
index a1cdeb3..94111e7 100644
--- a/linden/indra/llwindow/llwindowsdl.cpp
+++ b/linden/indra/llwindow/llwindowsdl.cpp
@@ -42,7 +42,9 @@
 #include "indra_constants.h"
 
 #if LL_GTK
+extern "C" {
 # include "gtk/gtk.h"
+}
 #endif // LL_GTK
 
 #if LL_LINUX
@@ -1984,7 +1986,10 @@ void LLWindowSDL::gatherInput()
                         SDLReallyCaptureInput(TRUE);
 
                 if (event.key.keysym.unicode)
-                        mCallbacks->handleUnicodeChar(event.key.keysym.unicode, gKeyboard->currentMask(FALSE));
+                                {
+                                        handleUnicodeUTF16(event.key.keysym.unicode,
+                                                                           gKeyboard->currentMask(FALSE));
+                                }
                 break;
 
             case SDL_KEYUP:
diff --git a/linden/indra/llwindow/llwindowwin32.cpp b/linden/indra/llwindow/llwindowwin32.cpp
index 2cd1353..0b3cdd4 100644
--- a/linden/indra/llwindow/llwindowwin32.cpp
+++ b/linden/indra/llwindow/llwindowwin32.cpp
@@ -37,6 +37,7 @@
 #include <mapi.h>
 #include <process.h>    // for _spawn
 #include <shellapi.h>
+#include <Imm.h>
 
 // Require DirectInput version 8
 #define DIRECTINPUT_VERSION 0x0800
@@ -84,6 +85,98 @@ void show_window_creation_error(const char* title)
 //static
 BOOL LLWindowWin32::sIsClassRegistered = FALSE;
 
+BOOL    LLWindowWin32::sLanguageTextInputAllowed = TRUE; /* XXX */
+BOOL    LLWindowWin32::sWinIMEOpened = FALSE;
+HKL             LLWindowWin32::sWinInputLocale;
+DWORD   LLWindowWin32::sWinIMEConversionMode;
+DWORD   LLWindowWin32::sWinIMESentenceMode;
+
+// The following class LLWinImm delegates Windows IMM APIs.
+// We need this because some language versions of Windows,
+// e.g., US version of Windows XP, doesn't install IMM32.DLL
+// as a default, and we can't link against imm32.lib statically.
+// I believe DLL loading of this type is best suited to do
+// in a static initialization of a class.  What I'm not sure is
+// whether it follows the Linden Conding Standard... 
+// See http://wiki.secondlife.com/wiki/Coding_standards#Static_Members
+
+class LLWinImm
+{
+public:
+        static bool             isAvailable() { return sTheInstance.mHImmDll != NULL; }
+
+public:
+        // Wrappers for IMM API.
+        static BOOL             isIME(HKL hkl)                                                                                                                  { return sTheInstance.mImmIsIME(hkl); }
+        static HIMC             getContext(HWND hwnd)                                                                                                   { return sTheInstance.mImmGetContext(hwnd); }
+        static BOOL             releaseContext(HWND hwnd, HIMC himc)                                                                    { return sTheInstance.mImmReleaseContext(hwnd, himc); }
+        static BOOL             getOpenStatus(HIMC himc)                                                                                                { return sTheInstance.mImmGetOpenStatus(himc); }
+        static BOOL             setOpenStatus(HIMC himc, BOOL status)                                                                   { return sTheInstance.mImmSetOpenStatus(himc, status); }
+        static BOOL             getConversionStatus(HIMC himc, LPDWORD conversion, LPDWORD sentence)    { return sTheInstance.mImmGetConversionStatus(himc, conversion, sentence); }
+        static BOOL             setConversionStatus(HIMC himc, DWORD conversion, DWORD sentence)                { return sTheInstance.mImmSetConversionStatus(himc, conversion, sentence); }
+
+private:
+        LLWinImm();
+        ~LLWinImm();
+
+private:
+        // Pointers to IMM API.
+        BOOL            (WINAPI *mImmIsIME)(HKL);
+        HIMC            (WINAPI *mImmGetContext)(HWND);
+        BOOL            (WINAPI *mImmReleaseContext)(HWND, HIMC);
+        BOOL            (WINAPI *mImmGetOpenStatus)(HIMC);
+        BOOL            (WINAPI *mImmSetOpenStatus)(HIMC, BOOL);
+        BOOL            (WINAPI *mImmGetConversionStatus)(HIMC, LPDWORD, LPDWORD);
+        BOOL            (WINAPI *mImmSetConversionStatus)(HIMC, DWORD, DWORD);
+
+private:
+        HMODULE         mHImmDll;
+        static LLWinImm sTheInstance;
+};
+
+LLWinImm LLWinImm::sTheInstance;
+
+LLWinImm::LLWinImm()
+{
+        mHImmDll = LoadLibraryA("Imm32");
+        if (mHImmDll != NULL)
+        {
+                mImmIsIME               = (BOOL (WINAPI *)(HKL))                    GetProcAddress(mHImmDll, "ImmIsIME");
+                mImmGetContext          = (HIMC (WINAPI *)(HWND))                   GetProcAddress(mHImmDll, "ImmGetContext");
+                mImmReleaseContext      = (BOOL (WINAPI *)(HWND, HIMC))             GetProcAddress(mHImmDll, "ImmReleaseContext");
+                mImmGetOpenStatus       = (BOOL (WINAPI *)(HIMC))                   GetProcAddress(mHImmDll, "ImmGetOpenStatus");
+                mImmSetOpenStatus       = (BOOL (WINAPI *)(HIMC, BOOL))             GetProcAddress(mHImmDll, "ImmSetOpenStatus");
+                mImmGetConversionStatus = (BOOL (WINAPI *)(HIMC, LPDWORD, LPDWORD)) GetProcAddress(mHImmDll, "ImmGetConversionStatus");
+                mImmSetConversionStatus = (BOOL (WINAPI *)(HIMC, DWORD, DWORD))     GetProcAddress(mHImmDll, "ImmSetConversionStatus");
+                if (mImmIsIME == NULL ||
+                        mImmGetContext == NULL ||
+                        mImmReleaseContext == NULL ||
+                        mImmGetOpenStatus == NULL ||
+                        mImmSetOpenStatus == NULL ||
+                        mImmGetConversionStatus == NULL ||
+                        mImmSetConversionStatus == NULL)
+                {
+                        // If any of the above API entires are not found, we can't use IMM API.  
+                        // So, turn off the IMM support.  We should log some warning message in 
+                        // the case, since it is very unusual; these APIs are available from 
+                        // the beginning, and all versions of IMM32.DLL should have them all.  
+                        // Unfortunately, this code may be executed before initialization of 
+                        // the logging channel (llwarns), and we can't do it here...  Yes, this 
+                        // is one of disadvantages to use static constraction to DLL loading. 
+                        FreeLibrary(mHImmDll);
+                        mHImmDll = NULL;
+                }
+        }
+}
+
+LLWinImm::~LLWinImm()
+{
+        if (mHImmDll != NULL)
+        {
+                FreeLibrary(mHImmDll);
+                mHImmDll = NULL;
+        }
+}
 
 
 LPDIRECTINPUT8       g_pDI              = NULL;         
@@ -111,6 +204,10 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
         // Initialize the keyboard
         gKeyboard = new LLKeyboardWin32();
 
+        // Initialize (boot strap) the Language text input management,
+        // based on the system's (user's) default settings.
+        allowLanguageTextInput(FALSE);
+
         GLuint                  pixel_format;
         WNDCLASS                wc;
         DWORD                   dw_ex_style;
@@ -347,7 +444,6 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
 
         if (!mWindowHandle)
         {
-                DestroyWindow(mWindowHandle);
                 OSMessageBox("Window creation error", "Error", OSMB_OK);
                 return;
         }
@@ -1926,6 +2022,15 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 case WM_CHAR:
                         // Should really use WM_UNICHAR eventually, but it requires a specific Windows version and I need
                         // to figure out how that works. - Doug
+                        //
+                        // ... Well, I don't think so.
+                        // How it works is explained in Win32 API document, but WM_UNICHAR didn't work
+                        // as specified at least on Windows XP SP1 Japanese version.  I have never used
+                        // it since then, and I'm not sure whether it has been fixed now, but I don't think
+                        // it is worth trying.  The good old WM_CHAR works just fine even for supplementary
+                        // characters.  We just need to take care of surrogate pairs sent as two WM_CHAR's
+                        // by ourselves.  It is not that tough.  -- Alissa Sabre @ SL
+                        //
                         // llinfos << "WM_CHAR: " << w_param << llendl;
                         if (gDebugWindowProc)
                         {
@@ -1933,11 +2038,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                                         << " key " << S32(w_param) 
                                         << llendl;
                         }
-                        if (window_imp->mCallbacks->handleUnicodeChar(w_param, gKeyboard->currentMask(FALSE)))
-                        {
-                                return 0;
-                        }
-                        break;
+                        // Even if LLWindowCallbacks::handleUnicodeChar(llwchar, BOOL) returned FALSE,
+                        // we *did* processed the event, so I believe we should not pass it to DefWindowProc...
+                        window_imp->handleUnicodeUTF16((U16)w_param, gKeyboard->currentMask(FALSE));
+                        return 0;
 
                 case WM_LBUTTONDOWN:
                         {
@@ -2971,7 +3075,7 @@ void spawn_web_browser(const char* escaped_url )
         char reg_path_str[256]; /* Flawfinder: ignore */
         snprintf(reg_path_str, sizeof(reg_path_str), "%s\\shell\\open\\command", gURLProtocolWhitelistHandler[i]);      /* Flawfinder: ignore */
         WCHAR reg_path_wstr[256];
-        mbstowcs(reg_path_wstr, reg_path_str, 1024);
+        mbstowcs(reg_path_wstr, reg_path_str, sizeof(reg_path_wstr)/sizeof(reg_path_wstr[0]));
 
         HKEY key;
         WCHAR browser_open_wstr[1024];
@@ -3102,6 +3206,58 @@ void LLWindowWin32::bringToFront()
 void LLWindowWin32::focusClient()
 {
         SetFocus ( mWindowHandle );
-};
+}
+
+void LLWindowWin32::allowLanguageTextInput(BOOL b)
+{
+        if (b == sLanguageTextInputAllowed || !LLWinImm::isAvailable())
+        {
+                /* Not actually allowing/disallowing.  Do nothing.  */
+                return;
+        }
+        sLanguageTextInputAllowed = b;
+
+        if (b)
+        {
+                /* Allowing: Restore the previous IME status, 
+                   so that the user has a feeling that the previous 
+                   text input continues naturally.  Be careful, however,
+                   the IME status is meaningful only during the user keeps 
+                   using same Input Locale (aka Keyboard Layout).  */
+                if (sWinIMEOpened && GetKeyboardLayout(0) == sWinInputLocale)
+                {
+                        HIMC himc = LLWinImm::getContext(mWindowHandle);
+                        LLWinImm::setOpenStatus(himc, TRUE);
+                        LLWinImm::setConversionStatus(himc, sWinIMEConversionMode, sWinIMESentenceMode);
+                        LLWinImm::releaseContext(mWindowHandle, himc);
+                }
+        }
+        else
+        {
+                /* Disallowing: Turn off the IME so that succeeding 
+                   key events bypass IME and come to us directly.
+                   However, do it after saving the current IME 
+                   status.  We need to restore the status when
+                   allowing language text input again.  */
+                sWinInputLocale = GetKeyboardLayout(0);
+                sWinIMEOpened = LLWinImm::isIME(sWinInputLocale);
+                if (sWinIMEOpened)
+                {
+                        HIMC himc = LLWinImm::getContext(mWindowHandle);
+                        sWinIMEOpened = LLWinImm::getOpenStatus(himc);
+                        if (sWinIMEOpened)
+                        {
+                                LLWinImm::getConversionStatus(himc, &sWinIMEConversionMode, &sWinIMESentenceMode);
+
+                                /* We need both ImmSetConversionStatus and ImmSetOpenStatus here
+                                   to surely disable IME's keyboard hooking, because Some IME reacts 
+                                   only on the former and some other on the latter...  */
+                                LLWinImm::setConversionStatus(himc, IME_CMODE_NOCONVERSION, sWinIMESentenceMode);
+                                LLWinImm::setOpenStatus(himc, FALSE);
+                        }
+                        LLWinImm::releaseContext(mWindowHandle, himc);
+                }
+        }
+}
 
 #endif // LL_WINDOWS
diff --git a/linden/indra/llwindow/llwindowwin32.h b/linden/indra/llwindow/llwindowwin32.h
index 691c648..0f0cf7c 100644
--- a/linden/indra/llwindow/llwindowwin32.h
+++ b/linden/indra/llwindow/llwindowwin32.h
@@ -106,6 +106,8 @@ public:
         /*virtual*/ void bringToFront();
         /*virtual*/ void focusClient();
 
+        /*virtual*/ void allowLanguageTextInput(BOOL b);
+
 protected:
         LLWindowWin32(
                 char *title, char *name, int x, int y, int width, int height, U32 flags, 
@@ -174,6 +176,15 @@ protected:
         BOOL            mMousePositionModified;
         BOOL            mInputProcessingPaused;
 
+        // The following five variables are for Language Text Input control.
+        // They are all static, since one context is shared by all LLWindowWin32
+        // instances.
+        static BOOL             sLanguageTextInputAllowed;
+        static BOOL             sWinIMEOpened;
+        static HKL              sWinInputLocale;
+        static DWORD    sWinIMEConversionMode;
+        static DWORD    sWinIMESentenceMode;
+
         friend class LLWindowManager;
 };