The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set ts=2 sw=2 et tw=80: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "mozilla/ArrayUtils.h"

 #include "TextInputHandler.h"

 #ifdef MOZ_LOGGING

 #define FORCE_PR_LOG /* Allow logging in the release build */

 #endif // MOZ_LOGGING

 #include "prlog.h"

 #include "mozilla/MiscEvents.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/TextEvents.h"

 #include "nsChildView.h"

 #include "nsObjCExceptions.h"

 #include "nsBidiUtils.h"

 #include "nsToolkit.h"

 #include "nsCocoaUtils.h"

 #include "WidgetUtils.h"

 #include "nsPrintfCString.h"

 #ifdef __LP64__

 #include "ComplexTextInputPanel.h"

 #include <objc/runtime.h>

 #endif // __LP64__

 #ifdef MOZ_LOGGING

 #define FORCE_PR_LOG

 #endif

 #include "prlog.h"

 #ifndef __LP64__

 enum {

   // Currently focused ChildView (while this TSM document is active).

   // Transient (only set while TSMProcessRawKeyEvent() is processing a key

   // event), and the ChildView will be retained and released around the call

   // to TSMProcessRawKeyEvent() -- so it can be weak.

   kFocusedChildViewTSMDocPropertyTag  = 'GKFV', // type ChildView* [WEAK]

 };

 // Undocumented HIToolbox function used by WebKit to allow Carbon-based IME

 // to work in a Cocoa-based browser (like Safari or Cocoa-widgets Firefox).

 // (Recent WebKit versions actually use a thin wrapper around this function

 // called WKSendKeyEventToTSM().)

 //

 // Calling TSMProcessRawKeyEvent() from ChildView's keyDown: and keyUp:

 // methods (when the ChildView is a plugin view) bypasses Cocoa's IME

 // infrastructure and (instead) causes Carbon TSM events to be sent on each

 // NSKeyDown event.  We install a Carbon event handler

 // (PluginKeyEventsHandler()) to catch these events and pass them to Gecko

 // (which in turn passes them to the plugin).

 extern "C" long TSMProcessRawKeyEvent(EventRef carbonEvent);

 #endif // __LP64__

 using namespace mozilla;

 using namespace mozilla::widget;

 #ifdef PR_LOGGING

 PRLogModuleInfo* gLog = nullptr;

 static const char*

 OnOrOff(bool aBool)

 {

   return aBool ? "ON" : "off";

 }

 static const char*

 TrueOrFalse(bool aBool)

 {

   return aBool ? "TRUE" : "FALSE";

 }

 static const char*

 GetKeyNameForNativeKeyCode(unsigned short aNativeKeyCode)

 {

   switch (aNativeKeyCode) {

     case kVK_Escape:              return "Escape";

     case kVK_RightCommand:        return "Right-Command";

     case kVK_Command:             return "Command";

     case kVK_Shift:               return "Shift";

     case kVK_CapsLock:            return "CapsLock";

     case kVK_Option:              return "Option";

     case kVK_Control:             return "Control";

     case kVK_RightShift:          return "Right-Shift";

     case kVK_RightOption:         return "Right-Option";

     case kVK_RightControl:        return "Right-Control";

     case kVK_ANSI_KeypadClear:    return "Clear";

     case kVK_F1:                  return "F1";

     case kVK_F2:                  return "F2";

     case kVK_F3:                  return "F3";

     case kVK_F4:                  return "F4";

     case kVK_F5:                  return "F5";

     case kVK_F6:                  return "F6";

     case kVK_F7:                  return "F7";

     case kVK_F8:                  return "F8";

     case kVK_F9:                  return "F9";

     case kVK_F10:                 return "F10";

     case kVK_F11:                 return "F11";

     case kVK_F12:                 return "F12";

     case kVK_F13:                 return "F13/PrintScreen";

     case kVK_F14:                 return "F14/ScrollLock";

     case kVK_F15:                 return "F15/Pause";

     case kVK_ANSI_Keypad0:        return "NumPad-0";

     case kVK_ANSI_Keypad1:        return "NumPad-1";

     case kVK_ANSI_Keypad2:        return "NumPad-2";

     case kVK_ANSI_Keypad3:        return "NumPad-3";

     case kVK_ANSI_Keypad4:        return "NumPad-4";

     case kVK_ANSI_Keypad5:        return "NumPad-5";

     case kVK_ANSI_Keypad6:        return "NumPad-6";

     case kVK_ANSI_Keypad7:        return "NumPad-7";

     case kVK_ANSI_Keypad8:        return "NumPad-8";

     case kVK_ANSI_Keypad9:        return "NumPad-9";

     case kVK_ANSI_KeypadMultiply: return "NumPad-*";

     case kVK_ANSI_KeypadPlus:     return "NumPad-+";

     case kVK_ANSI_KeypadMinus:    return "NumPad--";

     case kVK_ANSI_KeypadDecimal:  return "NumPad-.";

     case kVK_ANSI_KeypadDivide:   return "NumPad-/";

     case kVK_ANSI_KeypadEquals:   return "NumPad-=";

     case kVK_ANSI_KeypadEnter:    return "NumPad-Enter";

     case kVK_Return:              return "Return";

     case kVK_Powerbook_KeypadEnter: return "NumPad-EnterOnPowerBook";

     case kVK_PC_Insert:           return "Insert/Help";

     case kVK_PC_Delete:           return "Delete";

     case kVK_Tab:                 return "Tab";

     case kVK_PC_Backspace:        return "Backspace";

     case kVK_Home:                return "Home";

     case kVK_End:                 return "End";

     case kVK_PageUp:              return "PageUp";

     case kVK_PageDown:            return "PageDown";

     case kVK_LeftArrow:           return "LeftArrow";

     case kVK_RightArrow:          return "RightArrow";

     case kVK_UpArrow:             return "UpArrow";

     case kVK_DownArrow:           return "DownArrow";

     case kVK_PC_ContextMenu:      return "ContextMenu";

     case kVK_Function:            return "Function";

     case kVK_VolumeUp:            return "VolumeUp";

     case kVK_VolumeDown:          return "VolumeDown";

     case kVK_Mute:                return "Mute";

     case kVK_ISO_Section:         return "ISO_Section";

     case kVK_JIS_Yen:             return "JIS_Yen";

     case kVK_JIS_Underscore:      return "JIS_Underscore";

     case kVK_JIS_KeypadComma:     return "JIS_KeypadComma";

     case kVK_JIS_Eisu:            return "JIS_Eisu";

     case kVK_JIS_Kana:            return "JIS_Kana";

     case kVK_ANSI_A:              return "A";

     case kVK_ANSI_B:              return "B";

     case kVK_ANSI_C:              return "C";

     case kVK_ANSI_D:              return "D";

     case kVK_ANSI_E:              return "E";

     case kVK_ANSI_F:              return "F";

     case kVK_ANSI_G:              return "G";

     case kVK_ANSI_H:              return "H";

     case kVK_ANSI_I:              return "I";

     case kVK_ANSI_J:              return "J";

     case kVK_ANSI_K:              return "K";

     case kVK_ANSI_L:              return "L";

     case kVK_ANSI_M:              return "M";

     case kVK_ANSI_N:              return "N";

     case kVK_ANSI_O:              return "O";

     case kVK_ANSI_P:              return "P";

     case kVK_ANSI_Q:              return "Q";

     case kVK_ANSI_R:              return "R";

     case kVK_ANSI_S:              return "S";

     case kVK_ANSI_T:              return "T";

     case kVK_ANSI_U:              return "U";

     case kVK_ANSI_V:              return "V";

     case kVK_ANSI_W:              return "W";

     case kVK_ANSI_X:              return "X";

     case kVK_ANSI_Y:              return "Y";

     case kVK_ANSI_Z:              return "Z";

     case kVK_ANSI_1:              return "1";

     case kVK_ANSI_2:              return "2";

     case kVK_ANSI_3:              return "3";

     case kVK_ANSI_4:              return "4";

     case kVK_ANSI_5:              return "5";

     case kVK_ANSI_6:              return "6";

     case kVK_ANSI_7:              return "7";

     case kVK_ANSI_8:              return "8";

     case kVK_ANSI_9:              return "9";

     case kVK_ANSI_0:              return "0";

     case kVK_ANSI_Equal:          return "Equal";

     case kVK_ANSI_Minus:          return "Minus";

     case kVK_ANSI_RightBracket:   return "RightBracket";

     case kVK_ANSI_LeftBracket:    return "LeftBracket";

     case kVK_ANSI_Quote:          return "Quote";

     case kVK_ANSI_Semicolon:      return "Semicolon";

     case kVK_ANSI_Backslash:      return "Backslash";

     case kVK_ANSI_Comma:          return "Comma";

     case kVK_ANSI_Slash:          return "Slash";

     case kVK_ANSI_Period:         return "Period";

     case kVK_ANSI_Grave:          return "Grave";

     default:                      return "undefined";

   }

 }

 static const char*

 GetCharacters(const NSString* aString)

 {

   nsAutoString str;

   nsCocoaUtils::GetStringForNSString(aString, str);

   if (str.IsEmpty()) {

     return "";

   }

   nsAutoString escapedStr;

   for (uint32_t i = 0; i < str.Length(); i++) {

     char16_t ch = str[i];

     if (ch < 0x20) {

       nsPrintfCString utf8str("(U+%04X)", ch);

       escapedStr += NS_ConvertUTF8toUTF16(utf8str);

     } else if (ch <= 0x7E) {

       escapedStr += ch;

     } else {

       nsPrintfCString utf8str("(U+%04X)", ch);

       escapedStr += ch;

       escapedStr += NS_ConvertUTF8toUTF16(utf8str);

     }

   }

   // the result will be freed automatically by cocoa.

   NSString* result = nsCocoaUtils::ToNSString(escapedStr);

   return [result UTF8String];

 }

 static const char*

 GetCharacters(const CFStringRef aString)

 {

   const NSString* str = reinterpret_cast<const NSString*>(aString);

   return GetCharacters(str);

 }

 static const char*

 GetNativeKeyEventType(NSEvent* aNativeEvent)

 {

   switch ([aNativeEvent type]) {

     case NSKeyDown:      return "NSKeyDown";

     case NSKeyUp:        return "NSKeyUp";

     case NSFlagsChanged: return "NSFlagsChanged";

     default:             return "not key event";

   }

 }

 static const char*

 GetGeckoKeyEventType(const WidgetEvent& aEvent)

 {

   switch (aEvent.message) {

     case NS_KEY_DOWN:    return "NS_KEY_DOWN";

     case NS_KEY_UP:      return "NS_KEY_UP";

     case NS_KEY_PRESS:   return "NS_KEY_PRESS";

     default:             return "not key event";

   }

 }

 static const char*

 GetRangeTypeName(uint32_t aRangeType)

 {

   switch (aRangeType) {

     case NS_TEXTRANGE_RAWINPUT:

       return "NS_TEXTRANGE_RAWINPUT";

     case NS_TEXTRANGE_CONVERTEDTEXT:

       return "NS_TEXTRANGE_CONVERTEDTEXT";

     case NS_TEXTRANGE_SELECTEDRAWTEXT:

       return "NS_TEXTRANGE_SELECTEDRAWTEXT";

     case NS_TEXTRANGE_SELECTEDCONVERTEDTEXT:

       return "NS_TEXTRANGE_SELECTEDCONVERTEDTEXT";

     case NS_TEXTRANGE_CARETPOSITION:

       return "NS_TEXTRANGE_CARETPOSITION";

     default:

       return "invalid range type";

   }

 }

 static const char*

 GetWindowLevelName(NSInteger aWindowLevel)

 {

   switch (aWindowLevel) {

     case kCGBaseWindowLevelKey:

       return "kCGBaseWindowLevelKey (NSNormalWindowLevel)";

     case kCGMinimumWindowLevelKey:

       return "kCGMinimumWindowLevelKey";

     case kCGDesktopWindowLevelKey:

       return "kCGDesktopWindowLevelKey";

     case kCGBackstopMenuLevelKey:

       return "kCGBackstopMenuLevelKey";

     case kCGNormalWindowLevelKey:

       return "kCGNormalWindowLevelKey";

     case kCGFloatingWindowLevelKey:

       return "kCGFloatingWindowLevelKey (NSFloatingWindowLevel)";

     case kCGTornOffMenuWindowLevelKey:

       return "kCGTornOffMenuWindowLevelKey (NSSubmenuWindowLevel, NSTornOffMenuWindowLevel)";

     case kCGDockWindowLevelKey:

       return "kCGDockWindowLevelKey (NSDockWindowLevel)";

     case kCGMainMenuWindowLevelKey:

       return "kCGMainMenuWindowLevelKey (NSMainMenuWindowLevel)";

     case kCGStatusWindowLevelKey:

       return "kCGStatusWindowLevelKey (NSStatusWindowLevel)";

     case kCGModalPanelWindowLevelKey:

       return "kCGModalPanelWindowLevelKey (NSModalPanelWindowLevel)";

     case kCGPopUpMenuWindowLevelKey:

       return "kCGPopUpMenuWindowLevelKey (NSPopUpMenuWindowLevel)";

     case kCGDraggingWindowLevelKey:

       return "kCGDraggingWindowLevelKey";

     case kCGScreenSaverWindowLevelKey:

       return "kCGScreenSaverWindowLevelKey (NSScreenSaverWindowLevel)";

     case kCGMaximumWindowLevelKey:

       return "kCGMaximumWindowLevelKey";

     case kCGOverlayWindowLevelKey:

       return "kCGOverlayWindowLevelKey";

     case kCGHelpWindowLevelKey:

       return "kCGHelpWindowLevelKey";

     case kCGUtilityWindowLevelKey:

       return "kCGUtilityWindowLevelKey";

     case kCGDesktopIconWindowLevelKey:

       return "kCGDesktopIconWindowLevelKey";

     case kCGCursorWindowLevelKey:

       return "kCGCursorWindowLevelKey";

     case kCGNumberOfWindowLevelKeys:

       return "kCGNumberOfWindowLevelKeys";

     default:

       return "unknown window level";

   }

 }

 #endif // #ifdef PR_LOGGING

 static bool

 IsControlChar(uint32_t aCharCode)

 {

   return aCharCode < ' ' || aCharCode == 0x7F;

 }

 static uint32_t gHandlerInstanceCount = 0;

 static TISInputSourceWrapper gCurrentInputSource;

 static void

 InitLogModule()

 {

 #ifdef PR_LOGGING

   // Clear() is always called when TISInputSourceWrappper is created.

   if (!gLog) {

     gLog = PR_NewLogModule("TextInputHandlerWidgets");

     TextInputHandler::DebugPrintAllKeyboardLayouts();

     IMEInputHandler::DebugPrintAllIMEModes();

   }

 #endif

 }

 static void

 InitCurrentInputSource()

 {

   if (gHandlerInstanceCount > 0 &&

       !gCurrentInputSource.IsInitializedByCurrentInputSource()) {

     gCurrentInputSource.InitByCurrentInputSource();

   }

 }

 static void

 FinalizeCurrentInputSource()

 {

   gCurrentInputSource.Clear();

 }

 #pragma mark -

 /******************************************************************************

  *

  *  TISInputSourceWrapper implementation

  *

  ******************************************************************************/

 // static

 TISInputSourceWrapper&

 TISInputSourceWrapper::CurrentInputSource()

 {

   InitCurrentInputSource();

   return gCurrentInputSource;

 }

 bool

 TISInputSourceWrapper::TranslateToString(UInt32 aKeyCode, UInt32 aModifiers,

                                          UInt32 aKbType, nsAString &aStr)

 {

   aStr.Truncate();

   const UCKeyboardLayout* UCKey = GetUCKeyboardLayout();

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::TranslateToString, aKeyCode=0x%X, "

      "aModifiers=0x%X, aKbType=0x%X UCKey=%p\n    "

      "Shift: %s, Ctrl: %s, Opt: %s, Cmd: %s, CapsLock: %s, NumLock: %s",

      this, aKeyCode, aModifiers, aKbType, UCKey,

      OnOrOff(aModifiers & shiftKey), OnOrOff(aModifiers & controlKey),

      OnOrOff(aModifiers & optionKey), OnOrOff(aModifiers & cmdKey),

      OnOrOff(aModifiers & alphaLock),

      OnOrOff(aModifiers & kEventKeyModifierNumLockMask)));

   NS_ENSURE_TRUE(UCKey, false);

   UInt32 deadKeyState = 0;

   UniCharCount len;

   UniChar chars[5];

   OSStatus err = ::UCKeyTranslate(UCKey, aKeyCode,

                                   kUCKeyActionDown, aModifiers >> 8,

                                   aKbType, kUCKeyTranslateNoDeadKeysMask,

                                   &deadKeyState, 5, &len, chars);

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::TranslateToString, err=0x%X, len=%llu",

      this, err, len));

   NS_ENSURE_TRUE(err == noErr, false);

   if (len == 0) {

     return true;

   }

   NS_ENSURE_TRUE(EnsureStringLength(aStr, len), false);

   NS_ASSERTION(sizeof(char16_t) == sizeof(UniChar),

                "size of char16_t and size of UniChar are different");

   memcpy(aStr.BeginWriting(), chars, len * sizeof(char16_t));

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::TranslateToString, aStr=\"%s\"",

      this, NS_ConvertUTF16toUTF8(aStr).get()));

   return true;

 }

 uint32_t

 TISInputSourceWrapper::TranslateToChar(UInt32 aKeyCode, UInt32 aModifiers,

                                        UInt32 aKbType)

 {

   nsAutoString str;

   if (!TranslateToString(aKeyCode, aModifiers, aKbType, str) ||

       str.Length() != 1) {

     return 0;

   }

   return static_cast<uint32_t>(str.CharAt(0));

 }

 void

 TISInputSourceWrapper::InitByInputSourceID(const char* aID)

 {

   Clear();

   if (!aID)

     return;

   CFStringRef idstr = ::CFStringCreateWithCString(kCFAllocatorDefault, aID,

                                                   kCFStringEncodingASCII);

   InitByInputSourceID(idstr);

   ::CFRelease(idstr);

 }

 void

 TISInputSourceWrapper::InitByInputSourceID(const nsAFlatString &aID)

 {

   Clear();

   if (aID.IsEmpty())

     return;

   CFStringRef idstr = ::CFStringCreateWithCharacters(kCFAllocatorDefault,

                                                      reinterpret_cast<const UniChar*>(aID.get()),

                                                      aID.Length());

   InitByInputSourceID(idstr);

   ::CFRelease(idstr);

 }

 void

 TISInputSourceWrapper::InitByInputSourceID(const CFStringRef aID)

 {

   Clear();

   if (!aID)

     return;

   const void* keys[] = { kTISPropertyInputSourceID };

   const void* values[] = { aID };

   CFDictionaryRef filter =

   ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);

   NS_ASSERTION(filter, "failed to create the filter");

   mInputSourceList = ::TISCreateInputSourceList(filter, true);

   ::CFRelease(filter);

   if (::CFArrayGetCount(mInputSourceList) > 0) {

     mInputSource = static_cast<TISInputSourceRef>(

       const_cast<void *>(::CFArrayGetValueAtIndex(mInputSourceList, 0)));

     if (IsKeyboardLayout()) {

       mKeyboardLayout = mInputSource;

     }

   }

 }

 void

 TISInputSourceWrapper::InitByLayoutID(SInt32 aLayoutID,

                                       bool aOverrideKeyboard)

 {

   // NOTE: Doument new layout IDs in TextInputHandler.h when you add ones.

   switch (aLayoutID) {

     case 0:

       InitByInputSourceID("com.apple.keylayout.US");

       break;

     case 1:

       InitByInputSourceID("com.apple.keylayout.Greek");

       break;

     case 2:

       InitByInputSourceID("com.apple.keylayout.German");

       break;

     case 3:

       InitByInputSourceID("com.apple.keylayout.Swedish-Pro");

       break;

     case 4:

       InitByInputSourceID("com.apple.keylayout.DVORAK-QWERTYCMD");

       break;

     case 5:

       InitByInputSourceID("com.apple.keylayout.Thai");

       break;

     case 6:

       InitByInputSourceID("com.apple.keylayout.Arabic");

       break;

     case 7:

       InitByInputSourceID("com.apple.keylayout.French");

       break;

     case 8:

       InitByInputSourceID("com.apple.keylayout.Hebrew");

       break;

     case 9:

       InitByInputSourceID("com.apple.keylayout.Lithuanian");

       break;

     case 10:

       InitByInputSourceID("com.apple.keylayout.Norwegian");

       break;

     case 11:

       InitByInputSourceID("com.apple.keylayout.Spanish");

       break;

     default:

       Clear();

       break;

   }

   mOverrideKeyboard = aOverrideKeyboard;

 }

 void

 TISInputSourceWrapper::InitByCurrentInputSource()

 {

   Clear();

   mInputSource = ::TISCopyCurrentKeyboardInputSource();

   mKeyboardLayout = ::TISCopyInputMethodKeyboardLayoutOverride();

   if (!mKeyboardLayout) {

     mKeyboardLayout = ::TISCopyCurrentKeyboardLayoutInputSource();

   }

   // If this causes composition, the current keyboard layout may input non-ASCII

   // characters such as Japanese Kana characters or Hangul characters.

   // However, we need to set ASCII characters to DOM key events for consistency

   // with other platforms.

   if (IsOpenedIMEMode()) {

     TISInputSourceWrapper tis(mKeyboardLayout);

     if (!tis.IsASCIICapable()) {

       mKeyboardLayout =

         ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();

     }

   }

 }

 void

 TISInputSourceWrapper::InitByCurrentKeyboardLayout()

 {

   Clear();

   mInputSource = ::TISCopyCurrentKeyboardLayoutInputSource();

   mKeyboardLayout = mInputSource;

 }

 void

 TISInputSourceWrapper::InitByCurrentASCIICapableInputSource()

 {

   Clear();

   mInputSource = ::TISCopyCurrentASCIICapableKeyboardInputSource();

   mKeyboardLayout = ::TISCopyInputMethodKeyboardLayoutOverride();

   if (mKeyboardLayout) {

     TISInputSourceWrapper tis(mKeyboardLayout);

     if (!tis.IsASCIICapable()) {

       mKeyboardLayout = nullptr;

     }

   }

   if (!mKeyboardLayout) {

     mKeyboardLayout =

       ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();

   }

 }

 void

 TISInputSourceWrapper::InitByCurrentASCIICapableKeyboardLayout()

 {

   Clear();

   mInputSource = ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();

   mKeyboardLayout = mInputSource;

 }

 void

 TISInputSourceWrapper::InitByCurrentInputMethodKeyboardLayoutOverride()

 {

   Clear();

   mInputSource = ::TISCopyInputMethodKeyboardLayoutOverride();

   mKeyboardLayout = mInputSource;

 }

 void

 TISInputSourceWrapper::InitByTISInputSourceRef(TISInputSourceRef aInputSource)

 {

   Clear();

   mInputSource = aInputSource;

   if (IsKeyboardLayout()) {

     mKeyboardLayout = mInputSource;

   }

 }

 void

 TISInputSourceWrapper::InitByLanguage(CFStringRef aLanguage)

 {

   Clear();

   mInputSource = ::TISCopyInputSourceForLanguage(aLanguage);

   if (IsKeyboardLayout()) {

     mKeyboardLayout = mInputSource;

   }

 }

 const UCKeyboardLayout*

 TISInputSourceWrapper::GetUCKeyboardLayout()

 {

   NS_ENSURE_TRUE(mKeyboardLayout, nullptr);

   if (mUCKeyboardLayout) {

     return mUCKeyboardLayout;

   }

   CFDataRef uchr = static_cast<CFDataRef>(

     ::TISGetInputSourceProperty(mKeyboardLayout,

                                 kTISPropertyUnicodeKeyLayoutData));

   // We should be always able to get the layout here.

   NS_ENSURE_TRUE(uchr, nullptr);

   mUCKeyboardLayout =

     reinterpret_cast<const UCKeyboardLayout*>(CFDataGetBytePtr(uchr));

   return mUCKeyboardLayout;

 }

 bool

 TISInputSourceWrapper::GetBoolProperty(const CFStringRef aKey)

 {

   CFBooleanRef ret = static_cast<CFBooleanRef>(

     ::TISGetInputSourceProperty(mInputSource, aKey));

   return ::CFBooleanGetValue(ret);

 }

 bool

 TISInputSourceWrapper::GetStringProperty(const CFStringRef aKey,

                                          CFStringRef &aStr)

 {

   aStr = static_cast<CFStringRef>(

     ::TISGetInputSourceProperty(mInputSource, aKey));

   return aStr != nullptr;

 }

 bool

 TISInputSourceWrapper::GetStringProperty(const CFStringRef aKey,

                                          nsAString &aStr)

 {

   CFStringRef str;

   GetStringProperty(aKey, str);

   nsCocoaUtils::GetStringForNSString((const NSString*)str, aStr);

   return !aStr.IsEmpty();

 }

 bool

 TISInputSourceWrapper::IsOpenedIMEMode()

 {

   NS_ENSURE_TRUE(mInputSource, false);

   if (!IsIMEMode())

     return false;

   return !IsASCIICapable();

 }

 bool

 TISInputSourceWrapper::IsIMEMode()

 {

   NS_ENSURE_TRUE(mInputSource, false);

   CFStringRef str;

   GetInputSourceType(str);

   NS_ENSURE_TRUE(str, false);

   return ::CFStringCompare(kTISTypeKeyboardInputMode,

                            str, 0) == kCFCompareEqualTo;

 }

 bool

 TISInputSourceWrapper::IsKeyboardLayout()

 {

   NS_ENSURE_TRUE(mInputSource, false);

   CFStringRef str;

   GetInputSourceType(str);

   NS_ENSURE_TRUE(str, false);

   return ::CFStringCompare(kTISTypeKeyboardLayout,

                            str, 0) == kCFCompareEqualTo;

 }

 bool

 TISInputSourceWrapper::GetLanguageList(CFArrayRef &aLanguageList)

 {

   NS_ENSURE_TRUE(mInputSource, false);

   aLanguageList = static_cast<CFArrayRef>(

     ::TISGetInputSourceProperty(mInputSource,

                                 kTISPropertyInputSourceLanguages));

   return aLanguageList != nullptr;

 }

 bool

 TISInputSourceWrapper::GetPrimaryLanguage(CFStringRef &aPrimaryLanguage)

 {

   NS_ENSURE_TRUE(mInputSource, false);

   CFArrayRef langList;

   NS_ENSURE_TRUE(GetLanguageList(langList), false);

   if (::CFArrayGetCount(langList) == 0)

     return false;

   aPrimaryLanguage =

     static_cast<CFStringRef>(::CFArrayGetValueAtIndex(langList, 0));

   return aPrimaryLanguage != nullptr;

 }

 bool

 TISInputSourceWrapper::GetPrimaryLanguage(nsAString &aPrimaryLanguage)

 {

   NS_ENSURE_TRUE(mInputSource, false);

   CFStringRef primaryLanguage;

   NS_ENSURE_TRUE(GetPrimaryLanguage(primaryLanguage), false);

   nsCocoaUtils::GetStringForNSString((const NSString*)primaryLanguage,

                                      aPrimaryLanguage);

   return !aPrimaryLanguage.IsEmpty();

 }

 bool

 TISInputSourceWrapper::IsForRTLLanguage()

 {

   if (mIsRTL < 0) {

     // Get the input character of the 'A' key of ANSI keyboard layout.

     nsAutoString str;

     bool ret = TranslateToString(kVK_ANSI_A, 0, eKbdType_ANSI, str);

     NS_ENSURE_TRUE(ret, ret);

     char16_t ch = str.IsEmpty() ? char16_t(0) : str.CharAt(0);

     mIsRTL = UCS2_CHAR_IS_BIDI(ch) || ch == 0xD802 || ch == 0xD803;

   }

   return mIsRTL != 0;

 }

 bool

 TISInputSourceWrapper::IsInitializedByCurrentInputSource()

 {

   return mInputSource == ::TISCopyCurrentKeyboardInputSource();

 }

 void

 TISInputSourceWrapper::Select()

 {

   if (!mInputSource)

     return;

   ::TISSelectInputSource(mInputSource);

 }

 void

 TISInputSourceWrapper::Clear()

 {

   // Clear() is always called when TISInputSourceWrappper is created.

   InitLogModule();

   if (mInputSourceList) {

     ::CFRelease(mInputSourceList);

   }

   mInputSourceList = nullptr;

   mInputSource = nullptr;

   mKeyboardLayout = nullptr;

   mIsRTL = -1;

   mUCKeyboardLayout = nullptr;

   mOverrideKeyboard = false;

 }

 void

 TISInputSourceWrapper::InitKeyEvent(NSEvent *aNativeKeyEvent,

                                     WidgetKeyboardEvent& aKeyEvent,

                                     const nsAString *aInsertString)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyEvent, aNativeKeyEvent=%p, "

      "aKeyEvent.message=%s, aInsertString=%p, IsOpenedIMEMode()=%s",

      this, aNativeKeyEvent, GetGeckoKeyEventType(aKeyEvent), aInsertString,

      TrueOrFalse(IsOpenedIMEMode())));

   NS_ENSURE_TRUE(aNativeKeyEvent, );

   nsCocoaUtils::InitInputEvent(aKeyEvent, aNativeKeyEvent);

   // This is used only while dispatching the event (which is a synchronous

   // call), so there is no need to retain and release this data.

   aKeyEvent.mNativeKeyEvent = aNativeKeyEvent;

   aKeyEvent.refPoint = LayoutDeviceIntPoint(0, 0);

   // If a keyboard layout override is set, we also need to force the keyboard

   // type to something ANSI to avoid test failures on machines with JIS

   // keyboards (since the pair of keyboard layout and physical keyboard type

   // form the actual key layout).  This assumes that the test setting the

   // override was written assuming an ANSI keyboard.

   UInt32 kbType = mOverrideKeyboard ? eKbdType_ANSI : ::LMGetKbdType();

   UInt32 nativeKeyCode = [aNativeKeyEvent keyCode];

   bool isPrintableKey = !TextInputHandler::IsSpecialGeckoKey(nativeKeyCode);

   if (isPrintableKey &&

       [aNativeKeyEvent type] != NSKeyDown &&

       [aNativeKeyEvent type] != NSKeyUp) {

     NS_WARNING("Why the printable key doesn't cause NSKeyDown or NSKeyUp?");

     isPrintableKey = false;

   }

   // Decide what string will be input.

   nsAutoString insertString;

   if (aInsertString) {

     // If the caller expects that the aInsertString will be input, we shouldn't

     // change it.

     insertString = *aInsertString;

   } else if (isPrintableKey) {

     // If IME is open, [aNativeKeyEvent characters] may be a character

     // which will be appended to the composition string.  However, especially,

     // while IME is disabled, most users and developers expect the key event

     // works as IME closed.  So, we should compute the insertString with

     // the ASCII capable keyboard layout.

     // NOTE: Such keyboard layouts typically change the layout to its ASCII

     //       capable layout when Command key is pressed.  And we don't worry

     //       when Control key is pressed too because it causes inputting

     //       control characters.

     if (!aKeyEvent.IsMeta() && !aKeyEvent.IsControl() && IsOpenedIMEMode()) {

       UInt32 state =

         nsCocoaUtils::ConvertToCarbonModifier([aNativeKeyEvent modifierFlags]);

       uint32_t ch = TranslateToChar(nativeKeyCode, state, kbType);

       if (ch) {

         insertString = ch;

       }

     } else {

       // If the caller isn't sure what string will be input, let's use

       // characters of NSEvent.

       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],

                                          insertString);

     }

     // If control key is pressed and the eventChars is a non-printable control

     // character, we should convert it to ASCII alphabet.

     if (aKeyEvent.IsControl() &&

         !insertString.IsEmpty() && insertString[0] <= char16_t(26)) {

       insertString = (aKeyEvent.IsShift() ^ aKeyEvent.IsCapsLocked()) ?

         static_cast<char16_t>(insertString[0] + ('A' - 1)) :

         static_cast<char16_t>(insertString[0] + ('a' - 1));

     }

     // If Meta key is pressed, it may cause to switch the keyboard layout like

     // Arabic, Russian, Hebrew, Greek and Dvorak-QWERTY.

     else if (aKeyEvent.IsMeta() &&

              !(aKeyEvent.IsControl() || aKeyEvent.IsAlt())) {

       UInt32 numLockState =

         aKeyEvent.IsNumLocked() ? kEventKeyModifierNumLockMask : 0;

       UInt32 capsLockState = aKeyEvent.IsCapsLocked() ? alphaLock : 0;

       UInt32 shiftState = aKeyEvent.IsShift() ? shiftKey : 0;

       uint32_t uncmdedChar =

         TranslateToChar(nativeKeyCode, numLockState, kbType);

       uint32_t cmdedChar =

         TranslateToChar(nativeKeyCode, cmdKey | numLockState, kbType);

       // If we can make a good guess at the characters that the user would

       // expect this key combination to produce (with and without Shift) then

       // use those characters.  This also corrects for CapsLock.

       uint32_t ch = 0;

       if (uncmdedChar == cmdedChar) {

         // The characters produced with Command seem similar to those without

         // Command.

         ch = TranslateToChar(nativeKeyCode,

                              shiftState | capsLockState | numLockState, kbType);

       } else {

         TISInputSourceWrapper USLayout("com.apple.keylayout.US");

         uint32_t uncmdedUSChar =

           USLayout.TranslateToChar(nativeKeyCode, numLockState, kbType);

         // If it looks like characters from US keyboard layout when Command key

         // is pressed, we should compute a character in the layout.

         if (uncmdedUSChar == cmdedChar) {

           ch = USLayout.TranslateToChar(nativeKeyCode,

                           shiftState | capsLockState | numLockState, kbType);

         }

       }

       // If there is a more preferred character for the commanded key event,

       // we should use it.

       if (ch) {

         insertString = ch;

       }

     }

   }

   // Remove control characters which shouldn't be inputted on editor.

   // XXX Currently, we don't find any cases inserting control characters with

   //     printable character.  So, just checking first character is enough.

   if (!insertString.IsEmpty() && IsControlChar(insertString[0])) {

     insertString.Truncate();

   }

   aKeyEvent.keyCode =

     ComputeGeckoKeyCode(nativeKeyCode, kbType, aKeyEvent.IsMeta());

   switch (nativeKeyCode) {

     case kVK_Command:

     case kVK_Shift:

     case kVK_Option:

     case kVK_Control:

       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;

       break;

     case kVK_RightCommand:

     case kVK_RightShift:

     case kVK_RightOption:

     case kVK_RightControl:

       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_RIGHT;

       break;

     case kVK_ANSI_Keypad0:

     case kVK_ANSI_Keypad1:

     case kVK_ANSI_Keypad2:

     case kVK_ANSI_Keypad3:

     case kVK_ANSI_Keypad4:

     case kVK_ANSI_Keypad5:

     case kVK_ANSI_Keypad6:

     case kVK_ANSI_Keypad7:

     case kVK_ANSI_Keypad8:

     case kVK_ANSI_Keypad9:

     case kVK_ANSI_KeypadMultiply:

     case kVK_ANSI_KeypadPlus:

     case kVK_ANSI_KeypadMinus:

     case kVK_ANSI_KeypadDecimal:

     case kVK_ANSI_KeypadDivide:

     case kVK_ANSI_KeypadEquals:

     case kVK_ANSI_KeypadEnter:

     case kVK_JIS_KeypadComma:

     case kVK_Powerbook_KeypadEnter:

       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;

       break;

     default:

       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;

       break;

   }

   aKeyEvent.mIsRepeat =

     ([aNativeKeyEvent type] == NSKeyDown) ? [aNativeKeyEvent isARepeat] : false;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyEvent, "

      "shift=%s, ctrl=%s, alt=%s, meta=%s",

      this, OnOrOff(aKeyEvent.IsShift()), OnOrOff(aKeyEvent.IsControl()),

      OnOrOff(aKeyEvent.IsAlt()), OnOrOff(aKeyEvent.IsMeta())));

   if (aKeyEvent.message == NS_KEY_PRESS &&

       (isPrintableKey || !insertString.IsEmpty())) {

     InitKeyPressEvent(aNativeKeyEvent,

                       insertString.IsEmpty() ? 0 : insertString[0],

                       aKeyEvent, kbType);

     MOZ_ASSERT(!aKeyEvent.charCode || !IsControlChar(aKeyEvent.charCode),

                "charCode must not be a control character");

   } else {

     aKeyEvent.charCode = 0;

     aKeyEvent.isChar = false; // XXX not used in XP level

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TISInputSourceWrapper::InitKeyEvent, keyCode=0x%X charCode=0x0",

        this, aKeyEvent.keyCode));

   }

   if (isPrintableKey) {

     aKeyEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;

     // If insertText calls this method, let's use the string.

     if (aInsertString && !aInsertString->IsEmpty() &&

         !IsControlChar((*aInsertString)[0])) {

       aKeyEvent.mKeyValue = *aInsertString;

     }

     // If meta key is pressed, the printable key layout may be switched from

     // non-ASCII capable layout to ASCII capable, or from Dvorak to QWERTY.

     // KeyboardEvent.key value should be the switched layout's character.

     else if (aKeyEvent.IsMeta()) {

       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],

                                          aKeyEvent.mKeyValue);

     }

     // If control key is pressed, some keys may produce printable character via

     // [aNativeKeyEvent characters].  Otherwise, translate input character of

     // the key without control key.

     else if (aKeyEvent.IsControl()) {

       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],

                                          aKeyEvent.mKeyValue);

       if (aKeyEvent.mKeyValue.IsEmpty() ||

           IsControlChar(aKeyEvent.mKeyValue[0])) {

         NSUInteger cocoaState =

           [aNativeKeyEvent modifierFlags] & ~NSControlKeyMask;

         UInt32 carbonState = nsCocoaUtils::ConvertToCarbonModifier(cocoaState);

         aKeyEvent.mKeyValue =

           TranslateToChar(nativeKeyCode, carbonState, kbType);

       }

     }

     // Otherwise, KeyboardEvent.key expose

     // [aNativeKeyEvent characters] value.  However, if IME is open and the

     // keyboard layout isn't ASCII capable, exposing the non-ASCII character

     // doesn't match with other platform's behavior.  For the compatibility

     // with other platform's Gecko, we need to set a translated character.

     else if (IsOpenedIMEMode()) {

       UInt32 state =

         nsCocoaUtils::ConvertToCarbonModifier([aNativeKeyEvent modifierFlags]);

       aKeyEvent.mKeyValue = TranslateToChar(nativeKeyCode, state, kbType);

     } else {

       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],

                                          aKeyEvent.mKeyValue);

     }

     // Last resort.  If .key value becomes empty string, we should use

     // charactersIgnoringModifiers, if it's available.

     if (aKeyEvent.mKeyValue.IsEmpty() ||

         IsControlChar(aKeyEvent.mKeyValue[0])) {

       nsCocoaUtils::GetStringForNSString(

         [aNativeKeyEvent charactersIgnoringModifiers], aKeyEvent.mKeyValue);

       // But don't expose it if it's a control character.

       if (!aKeyEvent.mKeyValue.IsEmpty() &&

           IsControlChar(aKeyEvent.mKeyValue[0])) {

         aKeyEvent.mKeyValue.Truncate();

       }

     }

   } else {

     // Compute the key for non-printable keys and some special printable keys.

     aKeyEvent.mKeyNameIndex = ComputeGeckoKeyNameIndex(nativeKeyCode);

   }

   NS_OBJC_END_TRY_ABORT_BLOCK

 }

 void

 TISInputSourceWrapper::InitKeyPressEvent(NSEvent *aNativeKeyEvent,

                                          char16_t aInsertChar,

                                          WidgetKeyboardEvent& aKeyEvent,

                                          UInt32 aKbType)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   NS_ASSERTION(aKeyEvent.message == NS_KEY_PRESS,

                "aKeyEvent must be NS_KEY_PRESS event");

 #ifdef PR_LOGGING

   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {

     nsAutoString chars;

     nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters], chars);

     NS_ConvertUTF16toUTF8 utf8Chars(chars);

     char16_t expectedChar = static_cast<char16_t>(aInsertChar);

     NS_ConvertUTF16toUTF8 utf8ExpectedChar(&expectedChar, 1);

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TISInputSourceWrapper::InitKeyPressEvent, aNativeKeyEvent=%p, "

        "[aNativeKeyEvent characters]=\"%s\", aInsertChar=0x%X(%s), "

        "aKeyEvent.message=%s, aKbType=0x%X, IsOpenedIMEMode()=%s",

        this, aNativeKeyEvent, utf8Chars.get(), aInsertChar,

        utf8ExpectedChar.get(), GetGeckoKeyEventType(aKeyEvent), aKbType,

        TrueOrFalse(IsOpenedIMEMode())));

   }

 #endif // #ifdef PR_LOGGING

   aKeyEvent.isChar = true; // this is not a special key  XXX not used in XP

   aKeyEvent.charCode = aInsertChar;

   if (aKeyEvent.charCode != 0) {

     aKeyEvent.keyCode = 0;

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyPressEvent, "

      "aKeyEvent.keyCode=0x%X, aKeyEvent.charCode=0x%X",

      this, aKeyEvent.keyCode, aKeyEvent.charCode));

   if (!aKeyEvent.IsControl() && !aKeyEvent.IsMeta() && !aKeyEvent.IsAlt()) {

     return;

   }

   TISInputSourceWrapper USLayout("com.apple.keylayout.US");

   bool isRomanKeyboardLayout = IsASCIICapable();

   UInt32 key = [aNativeKeyEvent keyCode];

   // Caps lock and num lock modifier state:

   UInt32 lockState = 0;

   if ([aNativeKeyEvent modifierFlags] & NSAlphaShiftKeyMask) {

     lockState |= alphaLock;

   }

   if ([aNativeKeyEvent modifierFlags] & NSNumericPadKeyMask) {

     lockState |= kEventKeyModifierNumLockMask;

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyPressEvent, "

      "isRomanKeyboardLayout=%s, key=0x%X",

      this, TrueOrFalse(isRomanKeyboardLayout), aKbType, key));

   nsString str;

   // normal chars

   uint32_t unshiftedChar = TranslateToChar(key, lockState, aKbType);

   UInt32 shiftLockMod = shiftKey | lockState;

   uint32_t shiftedChar = TranslateToChar(key, shiftLockMod, aKbType);

   // characters generated with Cmd key

   // XXX we should remove CapsLock state, which changes characters from

   //     Latin to Cyrillic with Russian layout on 10.4 only when Cmd key

   //     is pressed.

   UInt32 numState = (lockState & ~alphaLock); // only num lock state

   uint32_t uncmdedChar = TranslateToChar(key, numState, aKbType);

   UInt32 shiftNumMod = numState | shiftKey;

   uint32_t uncmdedShiftChar = TranslateToChar(key, shiftNumMod, aKbType);

   uint32_t uncmdedUSChar = USLayout.TranslateToChar(key, numState, aKbType);

   UInt32 cmdNumMod = cmdKey | numState;

   uint32_t cmdedChar = TranslateToChar(key, cmdNumMod, aKbType);

   UInt32 cmdShiftNumMod = shiftKey | cmdNumMod;

   uint32_t cmdedShiftChar = TranslateToChar(key, cmdShiftNumMod, aKbType);

   // Is the keyboard layout changed by Cmd key?

   // E.g., Arabic, Russian, Hebrew, Greek and Dvorak-QWERTY.

   bool isCmdSwitchLayout = uncmdedChar != cmdedChar;

   // Is the keyboard layout for Latin, but Cmd key switches the layout?

   // I.e., Dvorak-QWERTY

   bool isDvorakQWERTY = isCmdSwitchLayout && isRomanKeyboardLayout;

   // If the current keyboard is not Dvorak-QWERTY or Cmd is not pressed,

   // we should append unshiftedChar and shiftedChar for handling the

   // normal characters.  These are the characters that the user is most

   // likely to associate with this key.

   if ((unshiftedChar || shiftedChar) &&

       (!aKeyEvent.IsMeta() || !isDvorakQWERTY)) {

     AlternativeCharCode altCharCodes(unshiftedChar, shiftedChar);

     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyPressEvent, "

      "aKeyEvent.isMeta=%s, isDvorakQWERTY=%s, "

      "unshiftedChar=U+%X, shiftedChar=U+%X",

      this, OnOrOff(aKeyEvent.IsMeta()), TrueOrFalse(isDvorakQWERTY),

      unshiftedChar, shiftedChar));

   // Most keyboard layouts provide the same characters in the NSEvents

   // with Command+Shift as with Command.  However, with Command+Shift we

   // want the character on the second level.  e.g. With a US QWERTY

   // layout, we want "?" when the "/","?" key is pressed with

   // Command+Shift.

   // On a German layout, the OS gives us '/' with Cmd+Shift+SS(eszett)

   // even though Cmd+SS is 'SS' and Shift+'SS' is '?'.  This '/' seems

   // like a hack to make the Cmd+"?" event look the same as the Cmd+"?"

   // event on a US keyboard.  The user thinks they are typing Cmd+"?", so

   // we'll prefer the "?" character, replacing charCode with shiftedChar

   // when Shift is pressed.  However, in case there is a layout where the

   // character unique to Cmd+Shift is the character that the user expects,

   // we'll send it as an alternative char.

   bool hasCmdShiftOnlyChar =

     cmdedChar != cmdedShiftChar && uncmdedShiftChar != cmdedShiftChar;

   uint32_t originalCmdedShiftChar = cmdedShiftChar;

   // If we can make a good guess at the characters that the user would

   // expect this key combination to produce (with and without Shift) then

   // use those characters.  This also corrects for CapsLock, which was

   // ignored above.

   if (!isCmdSwitchLayout) {

     // The characters produced with Command seem similar to those without

     // Command.

     if (unshiftedChar) {

       cmdedChar = unshiftedChar;

     }

     if (shiftedChar) {

       cmdedShiftChar = shiftedChar;

     }

   } else if (uncmdedUSChar == cmdedChar) {

     // It looks like characters from a US layout are provided when Command

     // is down.

     uint32_t ch = USLayout.TranslateToChar(key, lockState, aKbType);

     if (ch) {

       cmdedChar = ch;

     }

     ch = USLayout.TranslateToChar(key, shiftLockMod, aKbType);

     if (ch) {

       cmdedShiftChar = ch;

     }

   }

   // If the current keyboard layout is switched by the Cmd key,

   // we should append cmdedChar and shiftedCmdChar that are

   // Latin char for the key.

   // If the keyboard layout is Dvorak-QWERTY, we should append them only when

   // command key is pressed because when command key isn't pressed, uncmded

   // chars have been appended already.

   if ((cmdedChar || cmdedShiftChar) && isCmdSwitchLayout &&

       (aKeyEvent.IsMeta() || !isDvorakQWERTY)) {

     AlternativeCharCode altCharCodes(cmdedChar, cmdedShiftChar);

     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyPressEvent, "

      "hasCmdShiftOnlyChar=%s, isCmdSwitchLayout=%s, isDvorakQWERTY=%s, "

      "cmdedChar=U+%X, cmdedShiftChar=U+%X",

      this, TrueOrFalse(hasCmdShiftOnlyChar), TrueOrFalse(isDvorakQWERTY),

      TrueOrFalse(isDvorakQWERTY), cmdedChar, cmdedShiftChar));

   // Special case for 'SS' key of German layout. See the comment of

   // hasCmdShiftOnlyChar definition for the detail.

   if (hasCmdShiftOnlyChar && originalCmdedShiftChar) {

     AlternativeCharCode altCharCodes(0, originalCmdedShiftChar);

     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::InitKeyPressEvent, "

      "hasCmdShiftOnlyChar=%s, originalCmdedShiftChar=U+%X",

      this, TrueOrFalse(hasCmdShiftOnlyChar), originalCmdedShiftChar));

   NS_OBJC_END_TRY_ABORT_BLOCK

 }

 uint32_t

 TISInputSourceWrapper::ComputeGeckoKeyCode(UInt32 aNativeKeyCode,

                                            UInt32 aKbType,

                                            bool aCmdIsPressed)

 {

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TISInputSourceWrapper::ComputeGeckoKeyCode, aNativeKeyCode=0x%X, "

      "aKbType=0x%X, aCmdIsPressed=%s, IsOpenedIMEMode()=%s, "

      "IsASCIICapable()=%s",

      this, aNativeKeyCode, aKbType, TrueOrFalse(aCmdIsPressed),

      TrueOrFalse(IsOpenedIMEMode()), TrueOrFalse(IsASCIICapable())));

   switch (aNativeKeyCode) {

     case kVK_Space:             return NS_VK_SPACE;

     case kVK_Escape:            return NS_VK_ESCAPE;

     // modifiers

     case kVK_RightCommand:

     case kVK_Command:           return NS_VK_META;

     case kVK_RightShift:

     case kVK_Shift:             return NS_VK_SHIFT;

     case kVK_CapsLock:          return NS_VK_CAPS_LOCK;

     case kVK_RightControl:

     case kVK_Control:           return NS_VK_CONTROL;

     case kVK_RightOption:

     case kVK_Option:            return NS_VK_ALT;

     case kVK_ANSI_KeypadClear:  return NS_VK_CLEAR;

     // function keys

     case kVK_F1:                return NS_VK_F1;

     case kVK_F2:                return NS_VK_F2;

     case kVK_F3:                return NS_VK_F3;

     case kVK_F4:                return NS_VK_F4;

     case kVK_F5:                return NS_VK_F5;

     case kVK_F6:                return NS_VK_F6;

     case kVK_F7:                return NS_VK_F7;

     case kVK_F8:                return NS_VK_F8;

     case kVK_F9:                return NS_VK_F9;

     case kVK_F10:               return NS_VK_F10;

     case kVK_F11:               return NS_VK_F11;

     case kVK_F12:               return NS_VK_F12;

     // case kVK_F13:               return NS_VK_F13;  // clash with the 3 below

     // case kVK_F14:               return NS_VK_F14;

     // case kVK_F15:               return NS_VK_F15;

     case kVK_F16:               return NS_VK_F16;

     case kVK_F17:               return NS_VK_F17;

     case kVK_F18:               return NS_VK_F18;

     case kVK_F19:               return NS_VK_F19;

     case kVK_PC_Pause:          return NS_VK_PAUSE;

     case kVK_PC_ScrollLock:     return NS_VK_SCROLL_LOCK;

     case kVK_PC_PrintScreen:    return NS_VK_PRINTSCREEN;

     // keypad

     case kVK_ANSI_Keypad0:      return NS_VK_NUMPAD0;

     case kVK_ANSI_Keypad1:      return NS_VK_NUMPAD1;

     case kVK_ANSI_Keypad2:      return NS_VK_NUMPAD2;

     case kVK_ANSI_Keypad3:      return NS_VK_NUMPAD3;

     case kVK_ANSI_Keypad4:      return NS_VK_NUMPAD4;

     case kVK_ANSI_Keypad5:      return NS_VK_NUMPAD5;

     case kVK_ANSI_Keypad6:      return NS_VK_NUMPAD6;

     case kVK_ANSI_Keypad7:      return NS_VK_NUMPAD7;

     case kVK_ANSI_Keypad8:      return NS_VK_NUMPAD8;

     case kVK_ANSI_Keypad9:      return NS_VK_NUMPAD9;

     case kVK_ANSI_KeypadMultiply: return NS_VK_MULTIPLY;

     case kVK_ANSI_KeypadPlus:     return NS_VK_ADD;

     case kVK_ANSI_KeypadMinus:    return NS_VK_SUBTRACT;

     case kVK_ANSI_KeypadDecimal:  return NS_VK_DECIMAL;

     case kVK_ANSI_KeypadDivide:   return NS_VK_DIVIDE;

     case kVK_JIS_KeypadComma:   return NS_VK_SEPARATOR;

     // IME keys

     case kVK_JIS_Eisu:          return NS_VK_EISU;

     case kVK_JIS_Kana:          return NS_VK_KANA;

     // these may clash with forward delete and help

     case kVK_PC_Insert:         return NS_VK_INSERT;

     case kVK_PC_Delete:         return NS_VK_DELETE;

     case kVK_PC_Backspace:      return NS_VK_BACK;

     case kVK_Tab:               return NS_VK_TAB;

     case kVK_Home:              return NS_VK_HOME;

     case kVK_End:               return NS_VK_END;

     case kVK_PageUp:            return NS_VK_PAGE_UP;

     case kVK_PageDown:          return NS_VK_PAGE_DOWN;

     case kVK_LeftArrow:         return NS_VK_LEFT;

     case kVK_RightArrow:        return NS_VK_RIGHT;

     case kVK_UpArrow:           return NS_VK_UP;

     case kVK_DownArrow:         return NS_VK_DOWN;

     case kVK_PC_ContextMenu:    return NS_VK_CONTEXT_MENU;

     case kVK_ANSI_1:            return NS_VK_1;

     case kVK_ANSI_2:            return NS_VK_2;

     case kVK_ANSI_3:            return NS_VK_3;

     case kVK_ANSI_4:            return NS_VK_4;

     case kVK_ANSI_5:            return NS_VK_5;

     case kVK_ANSI_6:            return NS_VK_6;

     case kVK_ANSI_7:            return NS_VK_7;

     case kVK_ANSI_8:            return NS_VK_8;

     case kVK_ANSI_9:            return NS_VK_9;

     case kVK_ANSI_0:            return NS_VK_0;

     case kVK_ANSI_KeypadEnter:

     case kVK_Return:

     case kVK_Powerbook_KeypadEnter: return NS_VK_RETURN;

   }

   // If Cmd key is pressed, that causes switching keyboard layout temporarily.

   // E.g., Dvorak-QWERTY.  Therefore, if Cmd key is pressed, we should honor it.

   UInt32 modifiers = aCmdIsPressed ? cmdKey : 0;

   uint32_t charCode = TranslateToChar(aNativeKeyCode, modifiers, aKbType);

   // Special case for Mac.  Mac inputs Yen sign (U+00A5) directly instead of

   // Back slash (U+005C).  We should return NS_VK_BACK_SLASH for compatibility

   // with other platforms.

   // XXX How about Won sign (U+20A9) which has same problem as Yen sign?

   if (charCode == 0x00A5) {

     return NS_VK_BACK_SLASH;

   }

   uint32_t keyCode = WidgetUtils::ComputeKeyCodeFromChar(charCode);

   if (keyCode) {

     return keyCode;

   }

   // If the unshifed char isn't an ASCII character, use shifted char.

   charCode = TranslateToChar(aNativeKeyCode, modifiers | shiftKey, aKbType);

   keyCode = WidgetUtils::ComputeKeyCodeFromChar(charCode);

   if (keyCode) {

     return keyCode;

   }

   // If this is ASCII capable, give up to compute it.

   if (IsASCIICapable()) {

     return 0;

   }

   // Retry with ASCII capable keyboard layout.

   TISInputSourceWrapper currentKeyboardLayout;

   currentKeyboardLayout.InitByCurrentASCIICapableKeyboardLayout();

   NS_ENSURE_TRUE(mInputSource != currentKeyboardLayout.mInputSource, 0);

   keyCode = currentKeyboardLayout.ComputeGeckoKeyCode(aNativeKeyCode, aKbType,

                                                       aCmdIsPressed);

   // However, if keyCode isn't for an alphabet keys or a numeric key, we should

   // ignore it.  For example, comma key of Thai layout is same as close-square-

   // bracket key of US layout and an unicode character key of Thai layout is

   // same as comma key of US layout.  If we return NS_VK_COMMA for latter key,

   // web application developers cannot distinguish with the former key.

   return ((keyCode >= NS_VK_A && keyCode <= NS_VK_Z) ||

           (keyCode >= NS_VK_0 && keyCode <= NS_VK_9)) ? keyCode : 0;

 }

 // static

 KeyNameIndex

 TISInputSourceWrapper::ComputeGeckoKeyNameIndex(UInt32 aNativeKeyCode)

 {

   switch (aNativeKeyCode) {

 #define NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX(aNativeKey, aKeyNameIndex) \

     case aNativeKey: return aKeyNameIndex;

 #include "NativeKeyToDOMKeyName.h"

 #undef NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX

     default:

       return KEY_NAME_INDEX_Unidentified;

   }

 }

 #pragma mark -

 /******************************************************************************

  *

  *  TextInputHandler implementation (static methods)

  *

  ******************************************************************************/

 NSUInteger TextInputHandler::sLastModifierState = 0;

 // static

 CFArrayRef

 TextInputHandler::CreateAllKeyboardLayoutList()

 {

   const void* keys[] = { kTISPropertyInputSourceType };

   const void* values[] = { kTISTypeKeyboardLayout };

   CFDictionaryRef filter =

     ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);

   NS_ASSERTION(filter, "failed to create the filter");

   CFArrayRef list = ::TISCreateInputSourceList(filter, true);

   ::CFRelease(filter);

   return list;

 }

 // static

 void

 TextInputHandler::DebugPrintAllKeyboardLayouts()

 {

 #ifdef PR_LOGGING

   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {

     CFArrayRef list = CreateAllKeyboardLayoutList();

     PR_LOG(gLog, PR_LOG_ALWAYS, ("Keyboard layout configuration:"));

     CFIndex idx = ::CFArrayGetCount(list);

     TISInputSourceWrapper tis;

     for (CFIndex i = 0; i < idx; ++i) {

       TISInputSourceRef inputSource = static_cast<TISInputSourceRef>(

         const_cast<void *>(::CFArrayGetValueAtIndex(list, i)));

       tis.InitByTISInputSourceRef(inputSource);

       nsAutoString name, isid;

       tis.GetLocalizedName(name);

       tis.GetInputSourceID(isid);

       PR_LOG(gLog, PR_LOG_ALWAYS,

              ("  %s\t<%s>%s%s\n",

               NS_ConvertUTF16toUTF8(name).get(),

               NS_ConvertUTF16toUTF8(isid).get(),

               tis.IsASCIICapable() ? "" : "\t(Isn't ASCII capable)",

               tis.IsKeyboardLayout() && tis.GetUCKeyboardLayout() ?

                 "" : "\t(uchr is NOT AVAILABLE)"));

     }

     ::CFRelease(list);

   }

 #endif // #ifdef PR_LOGGING

 }

 #pragma mark -

 /******************************************************************************

  *

  *  TextInputHandler implementation

  *

  ******************************************************************************/

 TextInputHandler::TextInputHandler(nsChildView* aWidget,

                                    NSView<mozView> *aNativeView) :

   IMEInputHandler(aWidget, aNativeView)

 {

   InitLogModule();

   [mView installTextInputHandler:this];

 }

 TextInputHandler::~TextInputHandler()

 {

   [mView uninstallTextInputHandler];

 }

 bool

 TextInputHandler::HandleKeyDownEvent(NSEvent* aNativeEvent)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   if (Destroyed()) {

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleKeyDownEvent, "

        "widget has been already destroyed", this));

     return false;

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::HandleKeyDownEvent, aNativeEvent=%p, "

      "type=%s, keyCode=%lld (0x%X), modifierFlags=0x%X, characters=\"%s\", "

      "charactersIgnoringModifiers=\"%s\"",

      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),

      [aNativeEvent keyCode], [aNativeEvent keyCode],

      [aNativeEvent modifierFlags], GetCharacters([aNativeEvent characters]),

      GetCharacters([aNativeEvent charactersIgnoringModifiers])));

   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);

   KeyEventState* currentKeyEvent = PushKeyEvent(aNativeEvent);

   AutoKeyEventStateCleaner remover(this);

   if (!IsIMEComposing()) {

     NSResponder* firstResponder = [[mView window] firstResponder];

     WidgetKeyboardEvent keydownEvent(true, NS_KEY_DOWN, mWidget);

     InitKeyEvent(aNativeEvent, keydownEvent);

     currentKeyEvent->mKeyDownHandled = DispatchEvent(keydownEvent);

     if (Destroyed()) {

       PR_LOG(gLog, PR_LOG_ALWAYS,

         ("%p TextInputHandler::HandleKeyDownEvent, "

          "widget was destroyed by keydown event", this));

       return currentKeyEvent->IsDefaultPrevented();

     }

     // The key down event may have shifted the focus, in which

     // case we should not fire the key press.

     // XXX This is a special code only on Cocoa widget, why is this needed?

     if (firstResponder != [[mView window] firstResponder]) {

       PR_LOG(gLog, PR_LOG_ALWAYS,

         ("%p TextInputHandler::HandleKeyDownEvent, "

          "view lost focus by keydown event", this));

       return currentKeyEvent->IsDefaultPrevented();

     }

     if (currentKeyEvent->IsDefaultPrevented()) {

       PR_LOG(gLog, PR_LOG_ALWAYS,

         ("%p TextInputHandler::HandleKeyDownEvent, "

          "keydown event's default is prevented", this));

       return true;

     }

   }

   // Let Cocoa interpret the key events, caching IsIMEComposing first.

   bool wasComposing = IsIMEComposing();

   bool interpretKeyEventsCalled = false;

   if (IsIMEEnabled() || IsASCIICapableOnly()) {

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleKeyDownEvent, calling interpretKeyEvents",

        this));

     [mView interpretKeyEvents:[NSArray arrayWithObject:aNativeEvent]];

     interpretKeyEventsCalled = true;

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleKeyDownEvent, called interpretKeyEvents",

        this));

   }

   if (Destroyed()) {

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleKeyDownEvent, widget was destroyed",

        this));

     return currentKeyEvent->IsDefaultPrevented();

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::HandleKeyDownEvent, wasComposing=%s, "

      "IsIMEComposing()=%s",

      this, TrueOrFalse(wasComposing), TrueOrFalse(IsIMEComposing())));

   if (currentKeyEvent->CanDispatchKeyPressEvent() &&

       !wasComposing && !IsIMEComposing()) {

     WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);

     InitKeyEvent(aNativeEvent, keypressEvent);

     // If we called interpretKeyEvents and this isn't normal character input

     // then IME probably ate the event for some reason. We do not want to

     // send a key press event in that case.

     // TODO:

     // There are some other cases which IME eats the current event.

     // 1. If key events were nested during calling interpretKeyEvents, it means

     //    that IME did something.  Then, we should do nothing.

     // 2. If one or more commands are called like "deleteBackward", we should

     //    dispatch keypress event at that time.  Note that the command may have

     //    been a converted or generated action by IME.  Then, we shouldn't do

     //    our default action for this key.

     if (!(interpretKeyEventsCalled &&

           IsNormalCharInputtingEvent(keypressEvent))) {

       currentKeyEvent->mKeyPressHandled = DispatchEvent(keypressEvent);

       currentKeyEvent->mKeyPressDispatched = true;

       PR_LOG(gLog, PR_LOG_ALWAYS,

         ("%p TextInputHandler::HandleKeyDownEvent, keypress event dispatched",

          this));

     }

   }

   // Note: mWidget might have become null here. Don't count on it from here on.

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::HandleKeyDownEvent, "

      "keydown handled=%s, keypress handled=%s, causedOtherKeyEvents=%s",

      this, TrueOrFalse(currentKeyEvent->mKeyDownHandled),

      TrueOrFalse(currentKeyEvent->mKeyPressHandled),

      TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents)));

   return currentKeyEvent->IsDefaultPrevented();

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);

 }

 void

 TextInputHandler::HandleKeyUpEvent(NSEvent* aNativeEvent)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::HandleKeyUpEvent, aNativeEvent=%p, "

      "type=%s, keyCode=%lld (0x%X), modifierFlags=0x%X, characters=\"%s\", "

      "charactersIgnoringModifiers=\"%s\", "

      "mIgnoreNextKeyUpEvent=%s, IsIMEComposing()=%s",

      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),

      [aNativeEvent keyCode], [aNativeEvent keyCode],

      [aNativeEvent modifierFlags], GetCharacters([aNativeEvent characters]),

      GetCharacters([aNativeEvent charactersIgnoringModifiers]),

      TrueOrFalse(mIgnoreNextKeyUpEvent), TrueOrFalse(IsIMEComposing())));

   if (mIgnoreNextKeyUpEvent) {

     mIgnoreNextKeyUpEvent = false;

     return;

   }

   if (Destroyed()) {

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleKeyUpEvent, "

        "widget has been already destroyed", this));

     return;

   }

   // if we don't have any characters we can't generate a keyUp event

   if (IsIMEComposing()) {

     return;

   }

   WidgetKeyboardEvent keyupEvent(true, NS_KEY_UP, mWidget);

   InitKeyEvent(aNativeEvent, keyupEvent);

   DispatchEvent(keyupEvent);

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void

 TextInputHandler::HandleFlagsChanged(NSEvent* aNativeEvent)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (Destroyed()) {

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::HandleFlagsChanged, "

        "widget has been already destroyed", this));

     return;

   }

   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::HandleFlagsChanged, aNativeEvent=%p, "

      "type=%s, keyCode=%s (0x%X), modifierFlags=0x%08X, "

      "sLastModifierState=0x%08X, IsIMEComposing()=%s",

      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),

      GetKeyNameForNativeKeyCode([aNativeEvent keyCode]), [aNativeEvent keyCode],

      [aNativeEvent modifierFlags], sLastModifierState,

      TrueOrFalse(IsIMEComposing())));

   MOZ_ASSERT([aNativeEvent type] == NSFlagsChanged);

   NSUInteger diff = [aNativeEvent modifierFlags] ^ sLastModifierState;

   // Device dependent flags for left-control key, both shift keys, both command

   // keys and both option keys have been defined in Next's SDK.  But we

   // shouldn't use it directly as far as possible since Cocoa SDK doesn't

   // define them.  Fortunately, we need them only when we dispatch keyup

   // events.  So, we can usually know the actual relation between keyCode and

   // device dependent flags.  However, we need to remove following flags first

   // since the differences don't indicate modifier key state.

   // NX_STYLUSPROXIMITYMASK: Probably used for pen like device.

   // kCGEventFlagMaskNonCoalesced (= NX_NONCOALSESCEDMASK): See the document for

   // Quartz Event Services.

   diff &= ~(NX_STYLUSPROXIMITYMASK | kCGEventFlagMaskNonCoalesced);

   switch ([aNativeEvent keyCode]) {

     // CapsLock state and other modifier states are different:

     // CapsLock state does not revert when the CapsLock key goes up, as the

     // modifier state does for other modifier keys on key up.

     case kVK_CapsLock: {

       // Fire key down event for caps lock.

       DispatchKeyEventForFlagsChanged(aNativeEvent, true);

       // XXX should we fire keyup event too? The keyup event for CapsLock key

       // is never dispatched on Gecko.

       // XXX WebKit dispatches keydown event when CapsLock is locked, otherwise,

       // keyup event.  If we do so, we cannot keep the consistency with other

       // platform's behavior...

       break;

     }

     // If the event is caused by pressing or releasing a modifier key, just

     // dispatch the key's event.

     case kVK_Shift:

     case kVK_RightShift:

     case kVK_Command:

     case kVK_RightCommand:

     case kVK_Control:

     case kVK_RightControl:

     case kVK_Option:

     case kVK_RightOption:

     case kVK_Help: {

       // We assume that at most one modifier is changed per event if the event

       // is caused by pressing or releasing a modifier key.

       bool isKeyDown = ([aNativeEvent modifierFlags] & diff) != 0;

       DispatchKeyEventForFlagsChanged(aNativeEvent, isKeyDown);

       // XXX Some applications might send the event with incorrect device-

       //     dependent flags.

       if (isKeyDown && ((diff & ~NSDeviceIndependentModifierFlagsMask) != 0)) {

         unsigned short keyCode = [aNativeEvent keyCode];

         const ModifierKey* modifierKey =

           GetModifierKeyForDeviceDependentFlags(diff);

         if (modifierKey && modifierKey->keyCode != keyCode) {

           // Although, we're not sure the actual cause of this case, the stored

           // modifier information and the latest key event information may be

           // mismatched. Then, let's reset the stored information.

           // NOTE: If this happens, it may fail to handle NSFlagsChanged event

           // in the default case (below). However, it's the rare case handler

           // and this case occurs rarely. So, we can ignore the edge case bug.

           NS_WARNING("Resetting stored modifier key information");

           mModifierKeys.Clear();

           modifierKey = nullptr;

         }

         if (!modifierKey) {

           mModifierKeys.AppendElement(ModifierKey(diff, keyCode));

         }

       }

       break;

     }

     // Currently we don't support Fn key since other browsers don't dispatch

     // events for it and we don't have keyCode for this key.

     // It should be supported when we implement .key and .char.

     case kVK_Function:

       break;

     // If the event is caused by something else than pressing or releasing a

     // single modifier key (for example by the app having been deactivated

     // using command-tab), use the modifiers themselves to determine which

     // key's event to dispatch, and whether it's a keyup or keydown event.

     // In all cases we assume one or more modifiers are being deactivated

     // (never activated) -- otherwise we'd have received one or more events

     // corresponding to a single modifier key being pressed.

     default: {

       NSUInteger modifiers = sLastModifierState;

       for (int32_t bit = 0; bit < 32; ++bit) {

         NSUInteger flag = 1 << bit;

         if (!(diff & flag)) {

           continue;

         }

         // Given correct information from the application, a flag change here

         // will normally be a deactivation (except for some lockable modifiers

         // such as CapsLock).  But some applications (like VNC) can send an

         // activating event with a zero keyCode.  So we need to check for that

         // here.

         bool dispatchKeyDown = ((flag & [aNativeEvent modifierFlags]) != 0);

         unsigned short keyCode = 0;

         if (flag & NSDeviceIndependentModifierFlagsMask) {

           switch (flag) {

             case NSAlphaShiftKeyMask:

               keyCode = kVK_CapsLock;

               dispatchKeyDown = true;

               break;

             case NSNumericPadKeyMask:

               // NSNumericPadKeyMask is fired by VNC a lot. But not all of

               // these events can really be Clear key events, so we just ignore

               // them.

               continue;

             case NSHelpKeyMask:

               keyCode = kVK_Help;

               break;

             case NSFunctionKeyMask:

               // An NSFunctionKeyMask change here will normally be a

               // deactivation.  But sometimes it will be an activation send (by

               // VNC for example) with a zero keyCode.

               continue;

             // These cases (NSShiftKeyMask, NSControlKeyMask, NSAlternateKeyMask

             // and NSCommandKeyMask) should be handled by the other branch of

             // the if statement, below (which handles device dependent flags).

             // However, some applications (like VNC) can send key events without

             // any device dependent flags, so we handle them here instead.

             case NSShiftKeyMask:

               keyCode = (modifiers & 0x0004) ? kVK_RightShift : kVK_Shift;

               break;

             case NSControlKeyMask:

               keyCode = (modifiers & 0x2000) ? kVK_RightControl : kVK_Control;

               break;

             case NSAlternateKeyMask:

               keyCode = (modifiers & 0x0040) ? kVK_RightOption : kVK_Option;

               break;

             case NSCommandKeyMask:

               keyCode = (modifiers & 0x0010) ? kVK_RightCommand : kVK_Command;

               break;

             default:

               continue;

           }

         } else {

           const ModifierKey* modifierKey =

             GetModifierKeyForDeviceDependentFlags(flag);

           if (!modifierKey) {

             // See the note above (in the other branch of the if statement)

             // about the NSShiftKeyMask, NSControlKeyMask, NSAlternateKeyMask

             // and NSCommandKeyMask cases.

             continue;

           }

           keyCode = modifierKey->keyCode;

         }

         // Remove flags

         modifiers &= ~flag;

         switch (keyCode) {

           case kVK_Shift: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_RightShift);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSShiftKeyMask;

             }

             break;

           }

           case kVK_RightShift: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_Shift);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSShiftKeyMask;

             }

             break;

           }

           case kVK_Command: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_RightCommand);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSCommandKeyMask;

             }

             break;

           }

           case kVK_RightCommand: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_Command);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSCommandKeyMask;

             }

             break;

           }

           case kVK_Control: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_RightControl);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSControlKeyMask;

             }

             break;

           }

           case kVK_RightControl: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_Control);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSControlKeyMask;

             }

             break;

           }

           case kVK_Option: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_RightOption);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSAlternateKeyMask;

             }

             break;

           }

           case kVK_RightOption: {

             const ModifierKey* modifierKey =

               GetModifierKeyForNativeKeyCode(kVK_Option);

             if (!modifierKey ||

                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {

               modifiers &= ~NSAlternateKeyMask;

             }

             break;

           }

           case kVK_Help:

             modifiers &= ~NSHelpKeyMask;

             break;

           default:

             break;

         }

         NSEvent* event =

           [NSEvent keyEventWithType:NSFlagsChanged

                            location:[aNativeEvent locationInWindow]

                       modifierFlags:modifiers

                           timestamp:[aNativeEvent timestamp]

                        windowNumber:[aNativeEvent windowNumber]

                             context:[aNativeEvent context]

                          characters:nil

         charactersIgnoringModifiers:nil

                           isARepeat:NO

                             keyCode:keyCode];

         DispatchKeyEventForFlagsChanged(event, dispatchKeyDown);

         if (Destroyed()) {

           break;

         }

         // Stop if focus has changed.

         // Check to see if mView is still the first responder.

         if (![mView isFirstResponder]) {

           break;

         }

       }

       break;

     }

   }

   // Be aware, the widget may have been destroyed.

   sLastModifierState = [aNativeEvent modifierFlags];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 const TextInputHandler::ModifierKey*

 TextInputHandler::GetModifierKeyForNativeKeyCode(unsigned short aKeyCode) const

 {

   for (ModifierKeyArray::index_type i = 0; i < mModifierKeys.Length(); ++i) {

     if (mModifierKeys[i].keyCode == aKeyCode) {

       return &((ModifierKey&)mModifierKeys[i]);

     }

   }

   return nullptr;

 }

 const TextInputHandler::ModifierKey*

 TextInputHandler::GetModifierKeyForDeviceDependentFlags(NSUInteger aFlags) const

 {

   for (ModifierKeyArray::index_type i = 0; i < mModifierKeys.Length(); ++i) {

     if (mModifierKeys[i].GetDeviceDependentFlags() ==

           (aFlags & ~NSDeviceIndependentModifierFlagsMask)) {

       return &((ModifierKey&)mModifierKeys[i]);

     }

   }

   return nullptr;

 }

 void

 TextInputHandler::DispatchKeyEventForFlagsChanged(NSEvent* aNativeEvent,

                                                   bool aDispatchKeyDown)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (Destroyed()) {

     return;

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::DispatchKeyEventForFlagsChanged, aNativeEvent=%p, "

      "type=%s, keyCode=%s (0x%X), aDispatchKeyDown=%s, IsIMEComposing()=%s",

      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),

      GetKeyNameForNativeKeyCode([aNativeEvent keyCode]), [aNativeEvent keyCode],

      TrueOrFalse(aDispatchKeyDown), TrueOrFalse(IsIMEComposing())));

   if ([aNativeEvent type] != NSFlagsChanged || IsIMEComposing()) {

     return;

   }

   uint32_t message = aDispatchKeyDown ? NS_KEY_DOWN : NS_KEY_UP;

   NPCocoaEvent cocoaEvent;

   // Fire a key event.

   WidgetKeyboardEvent keyEvent(true, message, mWidget);

   InitKeyEvent(aNativeEvent, keyEvent);

   // create event for use by plugins

   if ([mView isPluginView]) {

     if ([mView pluginEventModel] == NPEventModelCocoa) {

       ConvertCocoaKeyEventToNPCocoaEvent(aNativeEvent, cocoaEvent);

       keyEvent.pluginEvent = &cocoaEvent;

     }

   }

   DispatchEvent(keyEvent);

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void

 TextInputHandler::InsertText(NSAttributedString* aAttrString,

                              NSRange* aReplacementRange)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (Destroyed()) {

     return;

   }

   KeyEventState* currentKeyEvent = GetCurrentKeyEvent();

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::InsertText, aAttrString=\"%s\", "

      "aReplacementRange=%p { location=%llu, length=%llu }, "

      "IsIMEComposing()=%s, IgnoreIMEComposition()=%s, "

      "keyevent=%p, keydownHandled=%s, keypressDispatched=%s, "

      "causedOtherKeyEvents=%s",

      this, GetCharacters([aAttrString string]), aReplacementRange,

      aReplacementRange ? aReplacementRange->location : 0,

      aReplacementRange ? aReplacementRange->length : 0,

      TrueOrFalse(IsIMEComposing()), TrueOrFalse(IgnoreIMEComposition()),

      currentKeyEvent ? currentKeyEvent->mKeyEvent : nullptr,

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mKeyDownHandled) : "N/A",

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mKeyPressDispatched) : "N/A",

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents) : "N/A"));

   if (IgnoreIMEComposition()) {

     return;

   }

   InputContext context = mWidget->GetInputContext();

   bool isEditable = (context.mIMEState.mEnabled == IMEState::ENABLED ||

                      context.mIMEState.mEnabled == IMEState::PASSWORD);

   NSRange selectedRange = SelectedRange();

   nsAutoString str;

   nsCocoaUtils::GetStringForNSString([aAttrString string], str);

   if (!IsIMEComposing() && str.IsEmpty()) {

     // nothing to do if there is no content which can be removed.

     if (!isEditable) {

       return;

     }

     // If replacement range is specified, we need to remove the range.

     // Otherwise, we need to remove the selected range if it's not collapsed.

     if (aReplacementRange && aReplacementRange->location != NSNotFound) {

       // nothing to do since the range is collapsed.

       if (aReplacementRange->length == 0) {

         return;

       }

       // If the replacement range is different from current selected range,

       // select the range.

       if (!NSEqualRanges(selectedRange, *aReplacementRange)) {

         NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));

       }

       selectedRange = SelectedRange();

     }

     NS_ENSURE_TRUE_VOID(selectedRange.location != NSNotFound);

     if (selectedRange.length == 0) {

       return; // nothing to do

     }

     // If this is caused by a key input, the keypress event which will be

     // dispatched later should cause the delete.  Therefore, nothing to do here.

     // Although, we're not sure if such case is actually possible.

     if (!currentKeyEvent) {

       return;

     }

     // Delete the selected range.

     nsRefPtr<TextInputHandler> kungFuDeathGrip(this);

     WidgetContentCommandEvent deleteCommandEvent(true,

                                                  NS_CONTENT_COMMAND_DELETE,

                                                  mWidget);

     DispatchEvent(deleteCommandEvent);

     NS_ENSURE_TRUE_VOID(deleteCommandEvent.mSucceeded);

     // Be aware! The widget might be destroyed here.

     return;

   }

   if (str.Length() != 1 || IsIMEComposing()) {

     InsertTextAsCommittingComposition(aAttrString, aReplacementRange);

     return;

   }

   // Don't let the same event be fired twice when hitting

   // enter/return! (Bug 420502)

   if (currentKeyEvent && !currentKeyEvent->CanDispatchKeyPressEvent()) {

     return;

   }

   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);

   // If the replacement range is specified, select the range.  Then, the

   // selection will be replaced by the later keypress event.

   if (isEditable &&

       aReplacementRange && aReplacementRange->location != NSNotFound &&

       !NSEqualRanges(selectedRange, *aReplacementRange)) {

     NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));

   }

   // Dispatch keypress event with char instead of textEvent

   WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);

   keypressEvent.isChar = IsPrintableChar(str.CharAt(0));

   // Don't set other modifiers from the current event, because here in

   // -insertText: they've already been taken into account in creating

   // the input string.

   if (currentKeyEvent) {

     NSEvent* keyEvent = currentKeyEvent->mKeyEvent;

     InitKeyEvent(keyEvent, keypressEvent, &str);

   } else {

     nsCocoaUtils::InitInputEvent(keypressEvent, static_cast<NSEvent*>(nullptr));

     if (keypressEvent.isChar) {

       keypressEvent.charCode = str.CharAt(0);

     }

     // Note that insertText is not called only at key pressing.

     if (!keypressEvent.charCode) {

       keypressEvent.keyCode =

         WidgetUtils::ComputeKeyCodeFromChar(keypressEvent.charCode);

     }

   }

   // Remove basic modifiers from keypress event because if they are included,

   // nsPlaintextEditor ignores the event.

   keypressEvent.modifiers &= ~(MODIFIER_CONTROL |

                                MODIFIER_ALT |

                                MODIFIER_META);

   // TODO:

   // If mCurrentKeyEvent.mKeyEvent is null and when we implement textInput

   // event of DOM3 Events, we should dispatch it instead of keypress event.

   bool keyPressHandled = DispatchEvent(keypressEvent);

   // Note: mWidget might have become null here. Don't count on it from here on.

   if (currentKeyEvent) {

     currentKeyEvent->mKeyPressHandled = keyPressHandled;

     currentKeyEvent->mKeyPressDispatched = true;

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 bool

 TextInputHandler::DoCommandBySelector(const char* aSelector)

 {

   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);

   KeyEventState* currentKeyEvent = GetCurrentKeyEvent();

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p TextInputHandler::DoCommandBySelector, aSelector=\"%s\", "

      "Destroyed()=%s, keydownHandled=%s, keypressHandled=%s, "

      "causedOtherKeyEvents=%s",

      this, aSelector ? aSelector : "", TrueOrFalse(Destroyed()),

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mKeyDownHandled) : "N/A",

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mKeyPressHandled) : "N/A",

      currentKeyEvent ?

        TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents) : "N/A"));

   if (currentKeyEvent && currentKeyEvent->CanDispatchKeyPressEvent()) {

     WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);

     InitKeyEvent(currentKeyEvent->mKeyEvent, keypressEvent);

     currentKeyEvent->mKeyPressHandled = DispatchEvent(keypressEvent);

     currentKeyEvent->mKeyPressDispatched = true;

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p TextInputHandler::DoCommandBySelector, keypress event "

        "dispatched, Destroyed()=%s, keypressHandled=%s",

        this, TrueOrFalse(Destroyed()),

        TrueOrFalse(currentKeyEvent->mKeyPressHandled)));

   }

   return (!Destroyed() && currentKeyEvent &&

           currentKeyEvent->IsDefaultPrevented());

 }

 #pragma mark -

 /******************************************************************************

  *

  *  IMEInputHandler implementation (static methods)

  *

  ******************************************************************************/

 bool IMEInputHandler::sStaticMembersInitialized = false;

 CFStringRef IMEInputHandler::sLatestIMEOpenedModeInputSourceID = nullptr;

 IMEInputHandler* IMEInputHandler::sFocusedIMEHandler = nullptr;

 // static

 void

 IMEInputHandler::InitStaticMembers()

 {

   if (sStaticMembersInitialized)

     return;

   sStaticMembersInitialized = true;

   // We need to check the keyboard layout changes on all applications.

   CFNotificationCenterRef center = ::CFNotificationCenterGetDistributedCenter();

   // XXX Don't we need to remove the observer at shut down?

   // Mac Dev Center's document doesn't say how to remove the observer if

   // the second parameter is NULL.

   ::CFNotificationCenterAddObserver(center, NULL,

       OnCurrentTextInputSourceChange,

       kTISNotifySelectedKeyboardInputSourceChanged, NULL,

       CFNotificationSuspensionBehaviorDeliverImmediately);

   // Initiailize with the current keyboard layout

   OnCurrentTextInputSourceChange(NULL, NULL,

                                  kTISNotifySelectedKeyboardInputSourceChanged,

                                  NULL, NULL);

 }

 // static

 void

 IMEInputHandler::OnCurrentTextInputSourceChange(CFNotificationCenterRef aCenter,

                                                 void* aObserver,

                                                 CFStringRef aName,

                                                 const void* aObject,

                                                 CFDictionaryRef aUserInfo)

 {

   // Cache the latest IME opened mode to sLatestIMEOpenedModeInputSourceID.

   TISInputSourceWrapper tis;

   tis.InitByCurrentInputSource();

   if (tis.IsOpenedIMEMode()) {

     tis.GetInputSourceID(sLatestIMEOpenedModeInputSourceID);

   }

 #ifdef PR_LOGGING

   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {

     static CFStringRef sLastTIS = nullptr;

     CFStringRef newTIS;

     tis.GetInputSourceID(newTIS);

     if (!sLastTIS ||

         ::CFStringCompare(sLastTIS, newTIS, 0) != kCFCompareEqualTo) {

       TISInputSourceWrapper tis1, tis2, tis3, tis4, tis5;

       tis1.InitByCurrentKeyboardLayout();

       tis2.InitByCurrentASCIICapableInputSource();

       tis3.InitByCurrentASCIICapableKeyboardLayout();

       tis4.InitByCurrentInputMethodKeyboardLayoutOverride();

       tis5.InitByTISInputSourceRef(tis.GetKeyboardLayoutInputSource());

       CFStringRef is0 = nullptr, is1 = nullptr, is2 = nullptr, is3 = nullptr,

                   is4 = nullptr, is5 = nullptr, type0 = nullptr,

                   lang0 = nullptr, bundleID0 = nullptr;

       tis.GetInputSourceID(is0);

       tis1.GetInputSourceID(is1);

       tis2.GetInputSourceID(is2);

       tis3.GetInputSourceID(is3);

       tis4.GetInputSourceID(is4);

       tis5.GetInputSourceID(is5);

       tis.GetInputSourceType(type0);

       tis.GetPrimaryLanguage(lang0);

       tis.GetBundleID(bundleID0);

       PR_LOG(gLog, PR_LOG_ALWAYS,

         ("IMEInputHandler::OnCurrentTextInputSourceChange,\n"

          "  Current Input Source is changed to:\n"

          "    currentInputContext=%p\n"

          "    %s\n"

          "      type=%s %s\n"

          "      overridden keyboard layout=%s\n"

          "      used keyboard layout for translation=%s\n"

          "    primary language=%s\n"

          "    bundle ID=%s\n"

          "    current ASCII capable Input Source=%s\n"

          "    current Keyboard Layout=%s\n"

          "    current ASCII capable Keyboard Layout=%s",

          [NSTextInputContext currentInputContext], GetCharacters(is0),

          GetCharacters(type0), tis.IsASCIICapable() ? "- ASCII capable " : "",

          GetCharacters(is4), GetCharacters(is5),

          GetCharacters(lang0), GetCharacters(bundleID0),

          GetCharacters(is2), GetCharacters(is1), GetCharacters(is3)));

     }

     sLastTIS = newTIS;

   }

 #endif // #ifdef PR_LOGGING

 }

 // static

 void

 IMEInputHandler::FlushPendingMethods(nsITimer* aTimer, void* aClosure)

 {

   NS_ASSERTION(aClosure, "aClosure is null");

   static_cast<IMEInputHandler*>(aClosure)->ExecutePendingMethods();

 }

 // static

 CFArrayRef

 IMEInputHandler::CreateAllIMEModeList()

 {

   const void* keys[] = { kTISPropertyInputSourceType };

   const void* values[] = { kTISTypeKeyboardInputMode };

   CFDictionaryRef filter =

     ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);

   NS_ASSERTION(filter, "failed to create the filter");

   CFArrayRef list = ::TISCreateInputSourceList(filter, true);

   ::CFRelease(filter);

   return list;

 }

 // static

 void

 IMEInputHandler::DebugPrintAllIMEModes()

 {

 #ifdef PR_LOGGING

   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {

     CFArrayRef list = CreateAllIMEModeList();

     PR_LOG(gLog, PR_LOG_ALWAYS, ("IME mode configuration:"));

     CFIndex idx = ::CFArrayGetCount(list);

     TISInputSourceWrapper tis;

     for (CFIndex i = 0; i < idx; ++i) {

       TISInputSourceRef inputSource = static_cast<TISInputSourceRef>(

         const_cast<void *>(::CFArrayGetValueAtIndex(list, i)));

       tis.InitByTISInputSourceRef(inputSource);

       nsAutoString name, isid;

       tis.GetLocalizedName(name);

       tis.GetInputSourceID(isid);

       PR_LOG(gLog, PR_LOG_ALWAYS,

              ("  %s\t<%s>%s%s\n",

               NS_ConvertUTF16toUTF8(name).get(),

               NS_ConvertUTF16toUTF8(isid).get(),

               tis.IsASCIICapable() ? "" : "\t(Isn't ASCII capable)",

               tis.IsEnabled() ? "" : "\t(Isn't Enabled)"));

     }

     ::CFRelease(list);

   }

 #endif // #ifdef PR_LOGGING

 }

 //static

 TSMDocumentID

 IMEInputHandler::GetCurrentTSMDocumentID()

 {

   // At least on Mac OS X 10.6.x and 10.7.x, ::TSMGetActiveDocument() has a bug.

   // The result of ::TSMGetActiveDocument() isn't modified for new active text

   // input context until [NSTextInputContext currentInputContext] is called.

   // Therefore, we need to call it here.

   [NSTextInputContext currentInputContext];

   return ::TSMGetActiveDocument();

 }

 #pragma mark -

 /******************************************************************************

  *

  *  IMEInputHandler implementation #1

  *    The methods are releated to the pending methods.  Some jobs should be

  *    run after the stack is finished, e.g, some methods cannot run the jobs

  *    during processing the focus event.  And also some other jobs should be

  *    run at the next focus event is processed.

  *    The pending methods are recorded in mPendingMethods.  They are executed

  *    by ExecutePendingMethods via FlushPendingMethods.

  *

  ******************************************************************************/

 void

 IMEInputHandler::NotifyIMEOfFocusChangeInGecko()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p IMEInputHandler::NotifyIMEOfFocusChangeInGecko, "

      "Destroyed()=%s, IsFocused()=%s, inputContext=%p",

      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),

      mView ? [mView inputContext] : nullptr));

   if (Destroyed()) {

     return;

   }

   if (!IsFocused()) {

     // retry at next focus event

     mPendingMethods |= kNotifyIMEOfFocusChangeInGecko;

     return;

   }

   MOZ_ASSERT(mView);

   NSTextInputContext* inputContext = [mView inputContext];

   NS_ENSURE_TRUE_VOID(inputContext);

   // When an <input> element on a XUL <panel> element gets focus from an <input>

   // element on the opener window of the <panel> element, the owner window

   // still has native focus.  Therefore, IMEs may store the opener window's

   // level at this time because they don't know the actual focus is moved to

   // different window.  If IMEs try to get the newest window level after the

   // focus change, we return the window level of the XUL <panel>'s widget.

   // Therefore, let's emulate the native focus change.  Then, IMEs can refresh

   // the stored window level.

   [inputContext deactivate];

   [inputContext activate];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void

 IMEInputHandler::DiscardIMEComposition()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p IMEInputHandler::DiscardIMEComposition, "

      "Destroyed()=%s, IsFocused()=%s, mView=%p, inputContext=%p",

      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),

      mView, mView ? [mView inputContext] : nullptr));

   if (Destroyed()) {

     return;

   }

   if (!IsFocused()) {

     // retry at next focus event

     mPendingMethods |= kDiscardIMEComposition;

     return;

   }

   NS_ENSURE_TRUE_VOID(mView);

   NSTextInputContext* inputContext = [mView inputContext];

   NS_ENSURE_TRUE_VOID(inputContext);

   mIgnoreIMECommit = true;

   [inputContext discardMarkedText];

   mIgnoreIMECommit = false;

   NS_OBJC_END_TRY_ABORT_BLOCK

 }

 void

 IMEInputHandler::SyncASCIICapableOnly()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p IMEInputHandler::SyncASCIICapableOnly, "

      "Destroyed()=%s, IsFocused()=%s, mIsASCIICapableOnly=%s, "

      "GetCurrentTSMDocumentID()=%p",

      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),

      TrueOrFalse(mIsASCIICapableOnly), GetCurrentTSMDocumentID()));

   if (Destroyed()) {

     return;

   }

   if (!IsFocused()) {

     // retry at next focus event

     mPendingMethods |= kSyncASCIICapableOnly;

     return;

   }

   TSMDocumentID doc = GetCurrentTSMDocumentID();

   if (!doc) {

     // retry

     mPendingMethods |= kSyncASCIICapableOnly;

     NS_WARNING("Application is active but there is no active document");

     ResetTimer();

     return;

   }

   if (mIsASCIICapableOnly) {

     CFArrayRef ASCIICapableTISList = ::TISCreateASCIICapableInputSourceList();

     ::TSMSetDocumentProperty(doc,

                              kTSMDocumentEnabledInputSourcesPropertyTag,

                              sizeof(CFArrayRef),

                              &ASCIICapableTISList);

     ::CFRelease(ASCIICapableTISList);

   } else {

     ::TSMRemoveDocumentProperty(doc,

                                 kTSMDocumentEnabledInputSourcesPropertyTag);

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void

 IMEInputHandler::ResetTimer()

 {

   NS_ASSERTION(mPendingMethods != 0,

                "There are not pending methods, why this is called?");

   if (mTimer) {

     mTimer->Cancel();

   } else {

     mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);

     NS_ENSURE_TRUE(mTimer, );

   }

   mTimer->InitWithFuncCallback(FlushPendingMethods, this, 0,

                                nsITimer::TYPE_ONE_SHOT);

 }

 void

 IMEInputHandler::ExecutePendingMethods()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (mTimer) {

     mTimer->Cancel();

     mTimer = nullptr;

   }

   if (![[NSApplication sharedApplication] isActive]) {

     mIsInFocusProcessing = false;

     // If we're not active, we should retry at focus event

     return;

   }

   uint32_t pendingMethods = mPendingMethods;

   // First, reset the pending method flags because if each methods cannot

   // run now, they can reentry to the pending flags by theirselves.

   mPendingMethods = 0;

   if (pendingMethods & kDiscardIMEComposition)

     DiscardIMEComposition();

   if (pendingMethods & kSyncASCIICapableOnly)

     SyncASCIICapableOnly();

   if (pendingMethods & kNotifyIMEOfFocusChangeInGecko) {

     NotifyIMEOfFocusChangeInGecko();

   }

   mIsInFocusProcessing = false;

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 #pragma mark -

 /******************************************************************************

  *

  * IMEInputHandler implementation (native event handlers)

  *

  ******************************************************************************/

 uint32_t

 IMEInputHandler::ConvertToTextRangeType(uint32_t aUnderlineStyle,

                                         NSRange& aSelectedRange)

 {

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p IMEInputHandler::ConvertToTextRangeType, "

      "aUnderlineStyle=%llu, aSelectedRange.length=%llu,",

      this, aUnderlineStyle, aSelectedRange.length));

   // We assume that aUnderlineStyle is NSUnderlineStyleSingle or

   // NSUnderlineStyleThick.  NSUnderlineStyleThick should indicate a selected

   // clause.  Otherwise, should indicate non-selected clause.

   if (aSelectedRange.length == 0) {

     switch (aUnderlineStyle) {

       case NSUnderlineStyleSingle:

         return NS_TEXTRANGE_RAWINPUT;

       case NSUnderlineStyleThick:

         return NS_TEXTRANGE_SELECTEDRAWTEXT;

       default:

         NS_WARNING("Unexpected line style");

         return NS_TEXTRANGE_SELECTEDRAWTEXT;

     }

   }

   switch (aUnderlineStyle) {

     case NSUnderlineStyleSingle:

       return NS_TEXTRANGE_CONVERTEDTEXT;

     case NSUnderlineStyleThick:

       return NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;

     default:

       NS_WARNING("Unexpected line style");

       return NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;

   }

 }

 uint32_t

 IMEInputHandler::GetRangeCount(NSAttributedString *aAttrString)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   // Iterate through aAttrString for the NSUnderlineStyleAttributeName and

   // count the different segments adjusting limitRange as we go.

   uint32_t count = 0;

   NSRange effectiveRange;

   NSRange limitRange = NSMakeRange(0, [aAttrString length]);

   while (limitRange.length > 0) {

     [aAttrString  attribute:NSUnderlineStyleAttributeName 

                     atIndex:limitRange.location 

       longestEffectiveRange:&effectiveRange

                     inRange:limitRange];

     limitRange =

       NSMakeRange(NSMaxRange(effectiveRange), 

                   NSMaxRange(limitRange) - NSMaxRange(effectiveRange));

     count++;

   }

   PR_LOG(gLog, PR_LOG_ALWAYS,

     ("%p IMEInputHandler::GetRangeCount, aAttrString=\"%s\", count=%llu",

      this, GetCharacters([aAttrString string]), count));

   return count;

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0);

 }

 already_AddRefed<mozilla::TextRangeArray>

 IMEInputHandler::CreateTextRangeArray(NSAttributedString *aAttrString,

                                       NSRange& aSelectedRange)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;

   // Convert the Cocoa range into the TextRange Array used in Gecko.

   // Iterate through the attributed string and map the underline attribute to

   // Gecko IME textrange attributes.  We may need to change the code here if

   // we change the implementation of validAttributesForMarkedText.

   NSRange limitRange = NSMakeRange(0, [aAttrString length]);

   uint32_t rangeCount = GetRangeCount(aAttrString);

   nsRefPtr<mozilla::TextRangeArray> textRangeArray =

                                       new mozilla::TextRangeArray();

   for (uint32_t i = 0; i < rangeCount && limitRange.length > 0; i++) {

     NSRange effectiveRange;

     id attributeValue = [aAttrString attribute:NSUnderlineStyleAttributeName

                                        atIndex:limitRange.location

                          longestEffectiveRange:&effectiveRange

                                        inRange:limitRange];

     TextRange range;

     range.mStartOffset = effectiveRange.location;

     range.mEndOffset = NSMaxRange(effectiveRange);

     range.mRangeType =

       ConvertToTextRangeType([attributeValue intValue], aSelectedRange);

     textRangeArray->AppendElement(range);

     PR_LOG(gLog, PR_LOG_ALWAYS,

       ("%p IMEInputHandler::CreateTextRangeArray, "

        "range={ mStartOffset=%llu, mEndOffset=%llu, mRangeType=%s }",

        this, range.mStartOffset, range.mEndOffset,

        GetRangeTypeName(range.mRangeType)));