Second Life viewer sources 1.19.0.0

1 files changed, 378 insertions, 50 deletions

diff --git a/linden/indra/llwindow/llwindowmacosx.cpp b/linden/indra/llwindow/llwindowmacosx.cpp
index 93ef46b..f522abb 100644
--- a/linden/indra/llwindow/llwindowmacosx.cpp
+++ b/linden/indra/llwindow/llwindowmacosx.cpp
@@ -12,12 +12,12 @@
  * ("GPL"), unless you have obtained a separate licensing agreement
  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlife.com/developers/opensource/gplv2
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
  * There are special exceptions to the terms and conditions of the GPL as
  * it is applied to this Source Code. View the full text of the exception
  * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlife.com/developers/opensource/flossexception
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -48,6 +48,7 @@
 #include "indra_constants.h"
 
 #include "llwindowmacosx-objc.h"
+#include "llpreeditor.h"
 
 extern BOOL gDebugWindowProc;
 
@@ -69,7 +70,6 @@ const S32	MAX_NUM_RESOLUTIONS = 32;
 void show_window_creation_error(const char* title)
 {
         llwarns << title << llendl;
-        shell_open( "help/window_creation_error.html");
         /*
         OSMessageBox(
         "Second Life is unable to run because it can't set up your display.\n"
@@ -172,8 +172,22 @@ static EventTypeSpec WindowHandlerEventList[] =
         { kEventClassKeyboard, kEventRawKeyModifiersChanged },
 
         // Text input events
-        { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }
-
+        { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
+        { kEventClassTextInput, kEventTextInputUpdateActiveInputArea },
+        { kEventClassTextInput, kEventTextInputOffsetToPos },
+        { kEventClassTextInput, kEventTextInputPosToOffset },
+        { kEventClassTextInput, kEventTextInputShowHideBottomWindow },
+        { kEventClassTextInput, kEventTextInputGetSelectedText },
+        { kEventClassTextInput, kEventTextInputFilterText },
+
+        // TSM Document Access events (advanced input method support)
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetLength },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetSelectedRange },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetCharacters },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetFont },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetGlyphInfo },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessLockDocument },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessUnlockDocument }
 };
 
 static EventTypeSpec GlobalHandlerEventList[] =
@@ -195,7 +209,22 @@ static EventTypeSpec GlobalHandlerEventList[] =
         { kEventClassKeyboard, kEventRawKeyModifiersChanged },
 
         // Text input events
-        { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }
+        { kEventClassTextInput, kEventTextInputUpdateActiveInputArea },
+        { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
+        { kEventClassTextInput, kEventTextInputOffsetToPos },
+        { kEventClassTextInput, kEventTextInputPosToOffset },
+        { kEventClassTextInput, kEventTextInputShowHideBottomWindow },
+        { kEventClassTextInput, kEventTextInputGetSelectedText },
+        { kEventClassTextInput, kEventTextInputFilterText },
+
+        // TSM Document Access events (advanced input method support)
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetLength },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetSelectedRange },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetCharacters },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetFont },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessGetGlyphInfo },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessLockDocument },
+        { kEventClassTSMDocumentAccess, kEventTSMDocumentAccessUnlockDocument }
 };
 
 static EventTypeSpec CommandHandlerEventList[] =
@@ -246,6 +275,7 @@ LLWindowMacOSX::LLWindowMacOSX(char *title, char *name, S32 x, S32 y, S32 width,
         mLanguageTextInputAllowed = FALSE;
         mTSMScriptCode = 0;
         mTSMLangCode = 0;
+        mPreeditor = NULL;
         
         // 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.
@@ -497,15 +527,16 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                         mTSMDocument = NULL;
                 }
                 static InterfaceTypeList types = { kUnicodeDocument };
-                OSErr err = NewTSMDocument(1, types, &mTSMDocument, 0);
+                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);
+                        UseInputWindow(mTSMDocument, FALSE);
+                        allowLanguageTextInput(NULL, FALSE);
                 }
         }
 
@@ -703,7 +734,6 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                         if (check_for_card(RENDERER, CARD_LIST[i]))
                         {
                                 close();
-                                shell_open( "help/unsupported_card.html" );
                                 return FALSE;
                         }
                 }
@@ -1949,6 +1979,141 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                 {
                         switch (evtKind)
                         {
+                        case kEventTextInputUpdateActiveInputArea:
+                                {
+                                        EventParamType param_type;
+
+                                        long fix_len;
+                                        UInt32 text_len;
+                                        if (mPreeditor
+                                                && (result = GetEventParameter(event, kEventParamTextInputSendFixLen,
+                                                                                typeLongInteger, &param_type, sizeof(fix_len), NULL, &fix_len)) == noErr
+                                                && typeLongInteger == param_type 
+                                                && (result = GetEventParameter(event, kEventParamTextInputSendText,
+                                                                                typeUnicodeText, &param_type, 0, &text_len, NULL)) == noErr
+                                                && typeUnicodeText == param_type)
+                                        {
+                                                // Handle an optional (but essential to facilitate TSMDA) ReplaceRange param.
+                                                CFRange range;
+                                                if (GetEventParameter(event, kEventParamTextInputSendReplaceRange,
+                                                                typeCFRange, &param_type, sizeof(range), NULL, &range) == noErr
+                                                        && typeCFRange == param_type)
+                                                {
+                                                        // Although the spec. is unclear, replace range should
+                                                        // not present when there is an active preedit.  We just
+                                                        // ignore the case.  markAsPreedit will detect the case and warn it.
+                                                        const LLWString & text = mPreeditor->getWText();
+                                                        const S32 location = wstring_wstring_length_from_utf16_length(text, 0, range.location);
+                                                        const S32 length = wstring_wstring_length_from_utf16_length(text, location, range.length);
+                                                        mPreeditor->markAsPreedit(location, length);
+                                                }
+                                                mPreeditor->resetPreedit();
+                                                
+                                                // Receive the text from input method.
+                                                U16 *const text = new U16[text_len / sizeof(U16)];
+                                                GetEventParameter(event, kEventParamTextInputSendText, typeUnicodeText, NULL, text_len, NULL, text);
+                                                if (fix_len < 0)
+                                                {
+                                                        // Do we still need this?  Seems obsolete...
+                                                        fix_len = text_len;
+                                                }
+                                                const LLWString fix_string
+                                                                = utf16str_to_wstring(llutf16string(text, fix_len / sizeof(U16)));
+                                                const LLWString preedit_string
+                                                                = utf16str_to_wstring(llutf16string(text + fix_len / sizeof(U16), (text_len - fix_len) / sizeof(U16)));
+                                                delete[] text;
+
+                                                // Handle fixed (comitted) string.
+                                                if (fix_string.length() > 0)
+                                                {
+                                                        for (LLWString::const_iterator i = fix_string.begin(); i != fix_string.end(); i++)
+                                                        {
+                                                                mPreeditor->handleUnicodeCharHere(*i, FALSE);
+                                                        }
+                                                }
+
+                                                // Receive the segment info and caret position.
+                                                LLPreeditor::segment_lengths_t preedit_segment_lengths;
+                                                LLPreeditor::standouts_t preedit_standouts;
+                                                S32 caret_position = preedit_string.length();
+                                                UInt32 text_range_array_size;
+                                                if (GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray,
+                                                                &param_type, 0, &text_range_array_size, NULL) == noErr
+                                                        && typeTextRangeArray == param_type
+                                                        && text_range_array_size > sizeof(TextRangeArray))
+                                                {
+                                                        // TextRangeArray is a variable-length struct.
+                                                        TextRangeArray * const text_range_array = (TextRangeArray *) new char[text_range_array_size];
+                                                        GetEventParameter(event, kEventParamTextInputSendHiliteRng, typeTextRangeArray,
+                                                                        NULL, text_range_array_size, NULL, text_range_array);
+
+                                                        // WARNING: We assume ranges are in ascending order, 
+                                                        // although the condition is undocumented.  It seems
+                                                        // OK to assume this.  I also assumed
+                                                        // the ranges are contiguous in previous versions, but I
+                                                        // have heard a rumore that older versions os ATOK may 
+                                                        // return ranges with some _gap_.  I don't know whether
+                                                        // it is true, but I'm preparing my code for the case.
+
+                                                        const S32 ranges = text_range_array->fNumOfRanges;
+                                                        preedit_segment_lengths.reserve(ranges);
+                                                        preedit_standouts.reserve(ranges);
+
+                                                        S32 last_bytes = 0;
+                                                        S32 last_utf32 = 0;
+                                                        for (S32 i = 0; i < ranges; i++)
+                                                        {
+                                                                const TextRange &range = text_range_array->fRange[i];
+                                                                if (range.fStart > last_bytes)
+                                                                {
+                                                                        const S32 length_utf16 = (range.fStart - last_bytes) / sizeof(U16);
+                                                                        const S32 length_utf32 = wstring_wstring_length_from_utf16_length(preedit_string, last_utf32, length_utf16);
+                                                                        preedit_segment_lengths.push_back(length_utf32);
+                                                                        preedit_standouts.push_back(FALSE);
+                                                                        last_utf32 += length_utf32;
+                                                                }
+                                                                if (range.fEnd > range.fStart)
+                                                                {
+                                                                        const S32 length_utf16 = (range.fEnd - range.fStart) / sizeof(U16);
+                                                                        const S32 length_utf32 = wstring_wstring_length_from_utf16_length(preedit_string, last_utf32, length_utf16);
+                                                                        preedit_segment_lengths.push_back(length_utf32);
+                                                                        preedit_standouts.push_back(
+                                                                                kTSMHiliteSelectedRawText == range.fHiliteStyle
+                                                                                || kTSMHiliteSelectedConvertedText ==  range.fHiliteStyle
+                                                                                || kTSMHiliteSelectedText == range.fHiliteStyle);
+                                                                        last_utf32 += length_utf32;
+                                                                }
+                                                                if (kTSMHiliteCaretPosition == range.fHiliteStyle)
+                                                                {
+                                                                        caret_position = last_utf32;
+                                                                }
+                                                                last_bytes = range.fEnd;
+                                                        }
+                                                        if (preedit_string.length() > last_utf32)
+                                                        {
+                                                                preedit_segment_lengths.push_back(preedit_string.length() - last_utf32);
+                                                                preedit_standouts.push_back(FALSE);
+                                                        }
+
+                                                        delete[] (char *) text_range_array;
+                                                }
+
+                                                // Handle preedit string.
+                                                if (preedit_string.length() > 0)
+                                                {
+                                                        if (preedit_segment_lengths.size() == 0)
+                                                        {
+                                                                preedit_segment_lengths.push_back(preedit_string.length());
+                                                                preedit_standouts.push_back(FALSE);
+                                                        }
+                                                        mPreeditor->updatePreedit(preedit_string, preedit_segment_lengths, preedit_standouts, caret_position);
+                                                }
+
+                                                result = noErr;
+                                        }
+                                }
+                                break;
+                                
                         case kEventTextInputUnicodeForKeyEvent:
                                 {
                                         UInt32 modifiers = 0;
@@ -2021,6 +2186,63 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                                         result = err;
                                 }
                                 break;
+                                
+                        case kEventTextInputOffsetToPos:
+                                {
+                                        EventParamType param_type;
+                                        long offset;
+                                        if (mPreeditor
+                                                && GetEventParameter(event, kEventParamTextInputSendTextOffset, typeLongInteger,
+                                                                &param_type, sizeof(offset), NULL, &offset) == noErr
+                                                && typeLongInteger == param_type)
+                                        {
+                                                S32 preedit, preedit_length;
+                                                mPreeditor->getPreeditRange(&preedit, &preedit_length);
+                                                const LLWString & text = mPreeditor->getWText();
+                                                 
+                                                LLCoordGL caret_coord;
+                                                LLRect preedit_bounds;
+                                                if (0 <= offset
+                                                        && mPreeditor->getPreeditLocation(wstring_wstring_length_from_utf16_length(text, preedit, offset / sizeof(U16)),
+                                                                                                                          &caret_coord, &preedit_bounds, NULL))
+                                                {
+                                                        LLCoordGL caret_base_coord(caret_coord.mX, preedit_bounds.mBottom);
+                                                        LLCoordScreen caret_base_coord_screen;
+                                                        convertCoords(caret_base_coord, &caret_base_coord_screen);
+                                                        Point qd_point;
+                                                        qd_point.h = caret_base_coord_screen.mX;
+                                                        qd_point.v = caret_base_coord_screen.mY;
+                                                        SetEventParameter(event, kEventParamTextInputReplyPoint, typeQDPoint, sizeof(qd_point), &qd_point);
+                                                        
+                                                        short line_height = (short) preedit_bounds.getHeight();
+                                                        SetEventParameter(event, kEventParamTextInputReplyLineHeight, typeShortInteger, sizeof(line_height), &line_height);
+                                                        
+                                                        result = noErr;
+                                                }
+                                                else
+                                                {
+                                                        result = errOffsetInvalid;
+                                                }
+                                        }
+                                }
+                                break;
+
+                        case kEventTextInputGetSelectedText:
+                                {
+                                        if (mPreeditor)
+                                        {
+                                                S32 selection, selection_length;
+                                                mPreeditor->getSelectionRange(&selection, &selection_length);
+                                                if (selection_length)
+                                                {
+                                                        const LLWString text = mPreeditor->getWText().substr(selection, selection_length);
+                                                        const llutf16string text_utf16 = wstring_to_utf16str(text);
+                                                        result = SetEventParameter(event, kEventParamTextInputReplyText, typeUnicodeText,
+                                                                                text_utf16.length() * sizeof(U16), text_utf16.c_str());
+                                                }
+                                        }
+                                }
+                                break;
                         }
                 }
                 break;
@@ -2194,6 +2416,13 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                                 switch (evtKind)
                                 {
                                 case kEventMouseDown:
+                                        if (mLanguageTextInputAllowed)
+                                        {
+                                                // We need to interrupt before handling mouse events,
+                                                // so that the fixed string from IM are delivered to
+                                                // the currently focused UI component.
+                                                interruptLanguageTextInput();
+                                        }
                                         switch(button)
                                         {
                                         case kEventMouseButtonPrimary:
@@ -2287,6 +2516,10 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                         mCallbacks->handleFocus(this);
                         break;
                 case kEventWindowDeactivated:
+                        if (mTSMDocument)
+                        {
+                                DeactivateTSMDocument(mTSMDocument);
+                        }
                         mCallbacks->handleFocusLost(this);
                         break;
                 case kEventWindowBoundsChanging:
@@ -2359,6 +2592,109 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
                         //                                      BringToFront(mWindow);
                         //                                      result = noErr;
                         break;
+                
+                }
+                break;
+
+        case kEventClassTSMDocumentAccess:
+                if (mPreeditor)
+                {
+                        switch(evtKind)
+                        {               
+
+                        case kEventTSMDocumentAccessGetLength:
+                                {
+                                        // Return the number of UTF-16 units in the text, excluding those for preedit.
+
+                                        S32 preedit, preedit_length;
+                                        mPreeditor->getPreeditRange(&preedit, &preedit_length);
+                                        const LLWString & text = mPreeditor->getWText();
+                                        const CFIndex length = wstring_utf16_length(text, 0, preedit)
+                                                + wstring_utf16_length(text, preedit + preedit_length, text.length());
+                                        result = SetEventParameter(event, kEventParamTSMDocAccessCharacterCount, typeCFIndex, sizeof(length), &length);
+                                }
+                                break;
+
+                        case kEventTSMDocumentAccessGetSelectedRange:
+                                {
+                                        // Return the selected range, excluding preedit.
+                                        // In our preeditor, preedit and selection are exclusive, so,
+                                        // when it has a preedit, there is no selection and the 
+                                        // insertion point is on the preedit that corrupses into the
+                                        // beginning of the preedit when the preedit was removed.
+
+                                        S32 preedit, preedit_length;
+                                        mPreeditor->getPreeditRange(&preedit, &preedit_length);
+                                        const LLWString & text = mPreeditor->getWText();
+                                        
+                                        CFRange range;
+                                        if (preedit_length)
+                                        {
+                                                range.location = wstring_utf16_length(text, 0, preedit);
+                                                range.length = 0;
+                                        }
+                                        else
+                                        {
+                                                S32 selection, selection_length;
+                                                mPreeditor->getSelectionRange(&selection, &selection_length);
+                                                range.location = wstring_utf16_length(text, 0, selection);
+                                                range.length = wstring_utf16_length(text, selection, selection_length);
+                                        }
+
+                                        result = SetEventParameter(event, kEventParamTSMDocAccessReplyCharacterRange, typeCFRange, sizeof(range), &range);
+                                }
+                                break;
+
+                        case kEventTSMDocumentAccessGetCharacters:
+                                {
+                                        UniChar *target_pointer;
+                                        CFRange range;
+                                        EventParamType param_type;
+                                        if ((result = GetEventParameter(event, kEventParamTSMDocAccessSendCharacterRange,
+                                                                                typeCFRange, &param_type, sizeof(range), NULL, &range)) == noErr
+                                                && typeCFRange == param_type
+                                                && (result = GetEventParameter(event, kEventParamTSMDocAccessSendCharactersPtr,
+                                                                                typePtr, &param_type, sizeof(target_pointer), NULL, &target_pointer)) == noErr
+                                                && typePtr == param_type)
+                                        {
+                                                S32 preedit, preedit_length;
+                                                mPreeditor->getPreeditRange(&preedit, &preedit_length);
+                                                const LLWString & text = mPreeditor->getWText();
+
+                                                // The GetCharacters event of TSMDA has a fundamental flaw;
+                                                // An input method need to decide the starting offset and length
+                                                // *before* it actually see the contents, so it is impossible
+                                                // to guarantee the character-aligned access.  The event reply
+                                                // has no way to indicate a condition something like "Request
+                                                // was not fulfilled due to unaligned access.  Please retry."
+                                                // Any error sent back to the input method stops use of TSMDA
+                                                // entirely during the session...
+                                                // We need to simulate very strictly the behaviour as if the
+                                                // underlying *text engine* holds the contents in UTF-16.
+                                                // I guess this is the reason why Apple repeats saying "all
+                                                // text handling application should use UTF-16."  They are
+                                                // trying to _fix_ the flaw by changing the appliations...
+                                                // ... or, domination of UTF-16 in the industry may be a part
+                                                // of the company vision, and Apple is trying to force third
+                                                // party developers to obey their vision.  Remember that use
+                                                // of 16 bits per _a_character_ was one of the very fundamental
+                                                // Unicode design policy on its early days (during late 80s)
+                                                // and the original Unicode design was by two Apple employees...
+
+                                                const llutf16string text_utf16
+                                                        = wstring_to_utf16str(text, preedit)
+                                                        + wstring_to_utf16str(text.substr(preedit + preedit_length));
+
+                                                llassert_always(sizeof(U16) == sizeof(UniChar));
+                                                llassert(0 <= range.location && 0 <= range.length && range.location + range.length <= text_utf16.length());
+                                                memcpy(target_pointer, text_utf16.c_str() + range.location, range.length * sizeof(UniChar));
+
+                                                // Note that result has already been set above.
+                                        }                                       
+                                }
+                                break;
+
+                        }
                 }
                 break;
         }
@@ -2862,46 +3198,6 @@ void spawn_web_browser(const char* escaped_url)
         }
 }
 
-void shell_open( const char* file_path )
-{
-        OSStatus                        result = noErr;
-
-        llinfos << "Opening " << file_path << llendl;
-        CFURLRef        urlRef = NULL;
-
-        CFStringRef     stringRef = CFStringCreateWithCString(NULL, file_path, kCFStringEncodingUTF8);
-        if (stringRef)
-        {
-                // This will succeed if the string is a full URL, including the http://
-                // Note that URLs specified this way need to be properly percent-escaped.
-                urlRef = CFURLCreateWithString(NULL, stringRef, NULL);
-
-                if(urlRef == NULL)
-                {
-                        // This will succeed if the string is a full or partial posix path.
-                        // This will work even if the path contains characters that would need to be percent-escaped
-                        // in the URL (such as spaces).
-                        urlRef = CFURLCreateWithFileSystemPath(NULL, stringRef, kCFURLPOSIXPathStyle, false);
-                }
-
-                CFRelease(stringRef);
-        }
-
-        if (urlRef)
-        {
-                result = LSOpenCFURLRef(urlRef, NULL);
-
-                if (result != noErr)
-                {
-                        llinfos << "Error " << result << " on open." << llendl;
-                }
-                CFRelease(urlRef);
-        }
-        else
-        {
-                llinfos << "Error: couldn't create URL." << llendl;
-        }
-}
 
 BOOL LLWindowMacOSX::dialog_color_picker ( F32 *r, F32 *g, F32 *b)
 {
@@ -2995,10 +3291,34 @@ static long getDictLong (CFDictionaryRef refDict, CFStringRef key)
         return int_value; // otherwise return the long value
 }
 
-void LLWindowMacOSX::allowLanguageTextInput(BOOL b)
+void LLWindowMacOSX::allowLanguageTextInput(LLPreeditor *preeditor, BOOL b)
 {
         ScriptLanguageRecord script_language;
 
+        if (preeditor != mPreeditor && !b)
+        {
+                // This condition may occur by a call to
+                // setEnabled(BOOL) against LLTextEditor or LLLineEditor
+                // when the control is not focused.
+                // We need to silently ignore the case so that
+                // the language input status of the focused control
+                // is not disturbed.
+                return;
+        }
+
+        // Take care of old and new preeditors.
+        if (preeditor != mPreeditor || !b)
+        {
+                // We need to interrupt before updating mPreeditor,
+                // so that the fix string from input method goes to
+                // the old preeditor.
+                if (mLanguageTextInputAllowed)
+                {
+                        interruptLanguageTextInput();
+                }
+                mPreeditor = (b ? preeditor : NULL);
+        }
+
         if (b == mLanguageTextInputAllowed)
         {
                 return;
@@ -3028,4 +3348,12 @@ void LLWindowMacOSX::allowLanguageTextInput(BOOL b)
         }
 }
 
+void LLWindowMacOSX::interruptLanguageTextInput()
+{
+        if (mTSMDocument)
+        {
+                FixTSMDocument(mTSMDocument);
+        }
+}
+
 #endif // LL_DARWIN