Handle XK_Zenkaku_Hankaku, Henkan, Muhenkan, Hangul etc. in Chrome

chrome/browser/chromeos/input_method/input_method_manager.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
@@ skipping 22 matching lines @@
 #if !defined(TOUCH_UI)
 #include "chrome/browser/chromeos/input_method/candidate_window.h"
 #endif
 
 #include <X11/X.h>  // ShiftMask, ControlMask, etc.
 #include <X11/Xutil.h>  // for XK_* macros.
 
 namespace {
 
 const char kIBusDaemonPath[] = "/usr/bin/ibus-daemon";
+const size_t kMaxInputMethodsPerHotkey = 2;
 
 // For hotkey handling.
-enum HotkeyEvents {
+enum HotkeyEvent {
+  // Global hotkeys.
   kPreviousInputMethod = 0,
   kNextInputMethod,
+  // Input method specific hotkeys.
+  kJapaneseInputMethod,
+  kJapaneseLayout,
+  kJapaneseInputMethodOrLayout,
+  kKoreanInputMethodOrLayout,
 };
 
+// Details of the input method specific hotkeys.
+const struct InputMethodSpecificHotkeySetting {
+  const char* input_method_ids[kMaxInputMethodsPerHotkey];
+  int event_id;
+  KeySym keysym;
+  uint32 modifiers;
+  bool trigger_on_press;  // if true. false means 'trigger on release'.
+} kInputMethodSpecificHotkeySettings[] = {
+  {
+    { "mozc-jp" },
+    kJapaneseInputMethod,
+    XK_Henkan,
+    0x0,
+    true,
+  },
+  {
+    { "xkb:jp::jpn" },
+    kJapaneseLayout,
+    XK_Muhenkan,
+    0x0,
+    true,
+  },
+  {
+    { "mozc-jp", "xkb:jp::jpn" },
+    kJapaneseInputMethodOrLayout,
+    XK_Zenkaku_Hankaku,
+    0x0,
+    true,
+  },
+  {
+    { "mozc-hangul", "xkb:kr:kr104:kor" },
+    kKoreanInputMethodOrLayout,
+    XK_Hangul,
+    0x0,
+    true,
+  },
+  {
+    { "mozc-hangul", "xkb:kr:kr104:kor" },
+    kKoreanInputMethodOrLayout,
+    XK_space,
+    ShiftMask,
+    true,
+  },
+};
+
+const size_t kInputMethodSpecificHotkeySettingsLen =
+    arraysize(kInputMethodSpecificHotkeySettings);
+
 // Finds a property which has |new_prop.key| from |prop_list|, and replaces the
 // property with |new_prop|. Returns true if such a property is found.
 bool FindAndUpdateProperty(
     const chromeos::input_method::ImeProperty& new_prop,
     chromeos::input_method::ImePropertyList* prop_list) {
   for (size_t i = 0; i < prop_list->size(); ++i) {
     chromeos::input_method::ImeProperty& prop = prop_list->at(i);
     if (prop.key == new_prop.key) {
       const int saved_id = prop.selection_item_id;
       // Update the list except the radio id. As written in
@@ skipping 37 matching lines @@
     // details.
     notification_registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                                 NotificationService::AllSources());
 
     ibus_controller_ = IBusController::Create();
     // The observer should be added before Connect() so we can capture the
     // initial connection change.
     ibus_controller_->AddObserver(this);
     ibus_controller_->Connect();
 
+    // Initialize extra_hotkeys_.
+    for (size_t i = 0; i < kInputMethodSpecificHotkeySettingsLen; ++i) {
+      const char* const* input_method_ids =
+          kInputMethodSpecificHotkeySettings[i].input_method_ids;
+      for (size_t j = 0;
+           j < kMaxInputMethodsPerHotkey && input_method_ids[j];
+           ++j) {
+        extra_hotkeys_.insert(std::make_pair(
+            input_method_ids[j], &kInputMethodSpecificHotkeySettings[i]));
+      }
+    }
+
+    // Register global input method hotkeys: Control+space and Shift+Alt.
     InitHotkeyManager();
   }
 
   virtual ~InputMethodManagerImpl() {
     hotkey_manager_.RemoveObserver(this);
     ibus_controller_->RemoveObserver(this);
   }
 
   virtual void AddObserver(InputMethodManager::Observer* observer) {
     if (!observers_.size()) {
@@ skipping 105 matching lines @@
     if (section == language_prefs::kGeneralSectionName &&
         config_name == language_prefs::kPreloadEnginesConfigName &&
         value.type == ImeConfigValue::kValueTypeStringList) {
       active_input_method_ids_ = value.string_list_value;
 
       std::map<std::string, InputMethodDescriptor>::const_iterator ix;
       for (ix = extra_input_method_ids_.begin();
            ix != extra_input_method_ids_.end(); ++ix) {
         active_input_method_ids_.push_back(ix->first);
       }
+
+      UpdateInputMethodSpecificHotkeys();
     }
 
     // Before calling FlushImeConfig(), start input method process if necessary.
     MaybeStartInputMethodDaemon(section, config_name, value);
 
     const ConfigKeyType key = std::make_pair(section, config_name);
     current_config_values_[key] = value;
     if (ime_connected_) {
       pending_config_requests_[key] = value;
       FlushImeConfig();
     }
 
     // Stop input method process if necessary.
     MaybeStopInputMethodDaemon(section, config_name, value);
     // Change the current keyboard layout if necessary.
     MaybeChangeCurrentKeyboardLayout(section, config_name, value);
     return pending_config_requests_.empty();
   }
 
+  // TODO(yusukes): Support input method specific hotkeys.
   virtual void AddActiveIme(const std::string& id,
                             const std::string& name,
                             const std::vector<std::string>& layouts,
                             const std::string& language) {
     std::string virtual_layouts = JoinString(layouts, ',');
 
     extra_input_method_ids_[id] =
         InputMethodDescriptor::CreateInputMethodDescriptor(
             id, virtual_layouts, language);
     active_input_method_ids_.push_back(id);
+    // TODO(yusukes): Call UpdateInputMethodSpecificHotkeys() here once IME
+    // extension supports hotkeys.
   }
 
   virtual void RemoveActiveIme(const std::string& id) {
     std::vector<std::string>::iterator ix =
         std::find(active_input_method_ids_.begin(),
                   active_input_method_ids_.end(),
                   id);
     if (ix != active_input_method_ids_.end()) {
       active_input_method_ids_.erase(ix);
     }
-
     extra_input_method_ids_.erase(id);
+    // TODO(yusukes): Call UpdateInputMethodSpecificHotkeys() here once IME
+    // extension supports hotkeys.
   }
 
   virtual bool GetExtraDescriptor(const std::string& id,
                                   InputMethodDescriptor* descriptor) {
     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
         extra_input_method_ids_.find(id);
     if (ix != extra_input_method_ids_.end()) {
       *descriptor = ix->second;
       return true;
     } else {
@@ skipping 59 matching lines @@
   virtual void ClearAllVirtualKeyboardPreferences() {
     virtual_keyboard_selector_.ClearAllUserPreferences();
     UpdateVirtualKeyboardUI();
   }
 
   virtual HotkeyManager* GetHotkeyManager() {
     return &hotkey_manager_;
   }
 
   virtual void HotkeyPressed(HotkeyManager* manager, int event_id) {
-    switch (HotkeyEvents(event_id)) {
+    const HotkeyEvent event = HotkeyEvent(event_id);
+    switch (event) {
       case kPreviousInputMethod:
         SwitchToPreviousInputMethod();
         break;
       case kNextInputMethod:
         SwitchToNextInputMethod();
         break;
+      case kJapaneseInputMethod:
+      case kJapaneseLayout:
+      case kJapaneseInputMethodOrLayout:
+      case kKoreanInputMethodOrLayout:
+        SwitchToInputMethod(event);
+        break;
     }
-    // TODO(yusukes): handle engine specific hotkeys like Henkan, Muhenkan, and
-    // Hangul.
   }
 
   static InputMethodManagerImpl* GetInstance() {
     return Singleton<InputMethodManagerImpl,
         DefaultSingletonTraits<InputMethodManagerImpl> >::get();
   }
 
  private:
   friend struct DefaultSingletonTraits<InputMethodManagerImpl>;
 
@@ skipping 582 matching lines @@
                               ShiftMask | Mod1Mask,
                               false);
     hotkey_manager_.AddHotkey(kNextInputMethod,
                               XK_Meta_L,
                               ShiftMask | Mod1Mask,
                               false);
     hotkey_manager_.AddHotkey(kNextInputMethod,
                               XK_Meta_R,
                               ShiftMask | Mod1Mask,
                               false);
+    // Input method specific hotkeys will be added in SetImeConfig().
 
-    // TODO(yusukes): Support engine specific hotkeys like XK_Henkan, Muhenkan,
-    // and Hangul.
     hotkey_manager_.AddObserver(this);
   }
 
+  void UpdateInputMethodSpecificHotkeys() {
+    // Remove all input method specific hotkeys first.
+    for (size_t i = 0; i < kInputMethodSpecificHotkeySettingsLen; ++i) {
+      hotkey_manager_.RemoveHotkey(
+          kInputMethodSpecificHotkeySettings[i].event_id);
+    }
+
+    for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
+      typedef std::map<std::string,
+          const InputMethodSpecificHotkeySetting*>::const_iterator Iter;
+      std::pair<Iter, Iter> result = extra_hotkeys_.equal_range(
+          active_input_method_ids_[i]);
+      for (Iter iter = result.first; iter != result.second; ++iter) {
+        hotkey_manager_.AddHotkey(iter->second->event_id,
+                                  iter->second->keysym,
+                                  iter->second->modifiers,
+                                  iter->second->trigger_on_press);
+      }
+    }
+    // TODO(yusukes): Check hotkeys for IME extensions.
+  }
+
   // Handles "Shift+Alt" hotkey.
   void SwitchToNextInputMethod() {
     // Sanity checks.
     if (active_input_method_ids_.empty()) {
       LOG(ERROR) << "active input method is empty";
       return;
     }
     if (current_input_method_.id().empty()) {
       LOG(ERROR) << "current_input_method_ is unknown";
       return;
@@ skipping 32 matching lines @@
                   active_input_method_ids_.end(),
                   previous_input_method_.id());
     if (iter == active_input_method_ids_.end()) {
       // previous_input_method_ is not supported.
       SwitchToNextInputMethod();
     } else {
       ChangeInputMethod(*iter);
     }
   }
 
+  // Handles input method specific hotkeys like XK_Henkan.
+  void SwitchToInputMethod(HotkeyEvent event) {
+    // Sanity check.
+    if (active_input_method_ids_.empty()) {
+      LOG(ERROR) << "active input method is empty";
+      return;
+    }
+
+    // Get the list of input method ids for |event_id|. For example, get
+    // { "mozc-hangul", "xkb:kr:kr104:kor" } for kKoreanInputMethodOrLayout.
+    const char* const* input_method_ids_to_switch = NULL;
+    switch (event) {
+      case kPreviousInputMethod:
+      case kNextInputMethod:
+        // These events should not be handled here.
+        break;
+      case kJapaneseInputMethod:
+      case kJapaneseLayout:
+      case kJapaneseInputMethodOrLayout:
+      case kKoreanInputMethodOrLayout:
+        for (size_t i = 0; i < kInputMethodSpecificHotkeySettingsLen; ++i) {
+          if (event == kInputMethodSpecificHotkeySettings[i].event_id) {
+            input_method_ids_to_switch =
+                kInputMethodSpecificHotkeySettings[i].input_method_ids;
+          }
+        }
+        break;
+    }
+    if (!input_method_ids_to_switch) {
+      LOG(ERROR) << "Unknown event: " << event;
+      return;
+    }
+
+    // Obtain the intersection of input_method_ids_to_switch and
+    // active_input_method_ids_. The order of IDs in active_input_method_ids_ is
+    // preserved.
+    std::vector<std::string> ids;
+    for (size_t i = 0; i < kMaxInputMethodsPerHotkey; ++i) {
+      const char* id = input_method_ids_to_switch[i];
+      if (id && std::find(active_input_method_ids_.begin(),
+                          active_input_method_ids_.end(),
+                          id) != active_input_method_ids_.end()) {
+        ids.push_back(id);
+      }
+    }
+    if (ids.empty()) {
+      LOG(ERROR) << "No input method for " << event << " is active";
+      return;
+    }
+
+    // If current_input_method_ is not in ids, switch to ids[0]. If
+    // current_input_method_ is ids[N], switch to ids[N+1].
+    std::vector<std::string>::const_iterator iter =
+        std::find(ids.begin(), ids.end(), current_input_method_.id());
+    if (iter != ids.end()) {
+      ++iter;
+    }
+    if (iter == ids.end()) {
+      iter = ids.begin();
+    }
+    ChangeInputMethod(*iter);
+  }
+
   // A reference to the language api, to allow callbacks when the input method
   // status changes.
   IBusController* ibus_controller_;
   ObserverList<InputMethodManager::Observer> observers_;
   ObserverList<VirtualKeyboardObserver> virtual_keyboard_observers_;
 
   // The input method which was/is selected.
   InputMethodDescriptor previous_input_method_;
   InputMethodDescriptor current_input_method_;
 
@@ skipping 49 matching lines @@
   // An object which keeps a list of available virtual keyboards.
   VirtualKeyboardSelector virtual_keyboard_selector_;
 
   // The active input method ids cache.
   std::vector<std::string> active_input_method_ids_;
 
   // Extra input methods that have been explicitly added to the menu, such as
   // those created by extension.
   std::map<std::string, InputMethodDescriptor> extra_input_method_ids_;
 
+  // A muitlmap from input method id to input method specific hotkey
+  // information. e.g. "mozc-jp" to XK_ZenkakuHankaku, "mozc-jp" to XK_Henkan.
+  std::multimap<std::string,
+                const InputMethodSpecificHotkeySetting*> extra_hotkeys_;
   // An object which detects Control+space and Shift+Alt key presses.
   HotkeyManager hotkey_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImpl);
 };
 
 // static
 InputMethodManager* InputMethodManager::GetInstance() {
   return InputMethodManagerImpl::GetInstance();
 }
 
 }  // namespace input_method
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     chromeos::input_method::InputMethodManagerImpl);