Supports unicode composition(Ctrl+Shift+U) with C-S pressed.

ui/base/ime/input_method_ibus.cc

 // Copyright (c) 2012 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 "ui/base/ime/input_method_ibus.h"
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #undef FocusIn
@@ skipping 35 matching lines @@
 // http://ibus.googlecode.com/svn/docs/ibus-1.4/ibus-ibustypes.html#IBusCapabilite
 const uint32 kIBusCapabilityPreeditText = 1U;
 const uint32 kIBusCapabilityFocus = 8U;
 const uint32 kIBusCapabilitySurroundingText = 32U;
 
 XKeyEvent* GetKeyEvent(XEvent* event) {
   DCHECK(event && (event->type == KeyPress || event->type == KeyRelease));
   return &event->xkey;
 }
 
-// Converts X (and ibus) flags to event flags.
-int EventFlagsFromXFlags(unsigned int flags) {
-  return (flags & LockMask ? ui::EF_CAPS_LOCK_DOWN : 0) |
-      (flags & ControlMask ? ui::EF_CONTROL_DOWN : 0) |
-      (flags & ShiftMask ? ui::EF_SHIFT_DOWN : 0) |
-      (flags & Mod1Mask ? ui::EF_ALT_DOWN : 0) |
-      (flags & Button1Mask ? ui::EF_LEFT_MOUSE_BUTTON : 0) |
-      (flags & Button2Mask ? ui::EF_MIDDLE_MOUSE_BUTTON : 0) |
-      (flags & Button3Mask ? ui::EF_RIGHT_MOUSE_BUTTON : 0);
+// Converts X (and ibus) state to event flags.
+int EventFlagsFromXState(unsigned int state) {
+  return (state & LockMask ? ui::EF_CAPS_LOCK_DOWN : 0) |
+      (state & ControlMask ? ui::EF_CONTROL_DOWN : 0) |
+      (state & ShiftMask ? ui::EF_SHIFT_DOWN : 0) |
+      (state & Mod1Mask ? ui::EF_ALT_DOWN : 0) |
+      (state & Button1Mask ? ui::EF_LEFT_MOUSE_BUTTON : 0) |
+      (state & Button2Mask ? ui::EF_MIDDLE_MOUSE_BUTTON : 0) |
+      (state & Button3Mask ? ui::EF_RIGHT_MOUSE_BUTTON : 0);
 }
 
-// Converts X flags to ibus key state flags.
-uint32 IBusStateFromXFlags(unsigned int flags) {
-  return (flags & (LockMask | ControlMask | ShiftMask | Mod1Mask |
+// Converts X state to ibus key and button state.
+uint32 IBusStateFromXState(unsigned int state) {
+  return (state & (LockMask | ControlMask | ShiftMask | Mod1Mask |
                    Button1Mask | Button2Mask | Button3Mask));
 }
 
 chromeos::IBusInputContextClient* GetInputContextClient() {
   return chromeos::DBusThreadManager::Get()->GetIBusInputContextClient();
 }
 
 // Converts gfx::Rect to ibus::Rect.
 chromeos::ibus::Rect GfxRectToIBusRect(const gfx::Rect& rect) {
   return chromeos::ibus::Rect(rect.x(), rect.y(), rect.width(), rect.height());
@@ skipping 53 matching lines @@
 
   // Create the input context if the connection is already established.
   if (IsConnected())
     CreateContext();
 
   InputMethodBase::Init(focused);
 }
 
 void InputMethodIBus::ProcessKeyEventDone(uint32 id,
                                           XEvent* event,
-                                          uint32 keyval,
+                                          uint32 ibus_keyval,
+                                          uint32 ibus_keycode,
+                                          uint32 ibus_state,
                                           bool is_handled) {
   DCHECK(event);
   std::set<uint32>::iterator it = pending_key_events_.find(id);
 
   if (it == pending_key_events_.end())
     return;  // Abandoned key event.
   if (event->type == KeyPress || event->type == KeyRelease)
-    ProcessKeyEventPostIME(event, keyval, is_handled);
+    ProcessKeyEventPostIME(event, ibus_keyval, ibus_keycode, ibus_state,
+                           is_handled);
 
   // Do not use |it| for erasing, ProcessKeyEventPostIME may change the
   // |pending_key_events_|.
   pending_key_events_.erase(id);
 }
 
 bool InputMethodIBus::DispatchKeyEvent(const base::NativeEvent& native_event) {
   DCHECK(native_event && (native_event->type == KeyPress ||
                           native_event->type == KeyRelease));
   DCHECK(system_toplevel_window_focused());
 
   uint32 ibus_keyval = 0;
   uint32 ibus_keycode = 0;
   uint32 ibus_state = 0;
   IBusKeyEventFromNativeKeyEvent(
-      native_event, &ibus_keyval, &ibus_keycode, &ibus_state);
+      native_event,
+      &ibus_keyval, &ibus_keycode, &ibus_state);
 
   // If |context_| is not usable, then we can only dispatch the key event as is.
   // We also dispatch the key event directly if the current text input type is
   // TEXT_INPUT_TYPE_PASSWORD, to bypass the input method.
   // Note: We need to send the key event to ibus even if the |context_| is not
   // enabled, so that ibus can have a chance to enable the |context_|.
   if (!context_focused_ ||
       GetTextInputType() == TEXT_INPUT_TYPE_PASSWORD ||
       !GetInputContextClient() ||
       GetInputContextClient()->IsXKBLayout()) {
     if (native_event->type == KeyPress)
-      ProcessUnfilteredKeyPressEvent(native_event, ibus_keyval);
+      ProcessUnfilteredKeyPressEvent(native_event,
+                                     ibus_keyval, ibus_keycode, ibus_state);
     else
       DispatchKeyEventPostIME(native_event);
     return true;
   }
 
   pending_key_events_.insert(current_keyevent_id_);
 
   // Since |native_event| might be treated as XEvent whose size is bigger than
   // XKeyEvent e.g. in CopyNativeEvent() in ui/base/events/event.cc, allocating
   // |event| as XKeyEvent and casting it to XEvent is unsafe. crbug.com/151884
   XEvent* event = new XEvent;
   *event = *native_event;
   const chromeos::IBusInputContextClient::ProcessKeyEventCallback callback =
       base::Bind(&InputMethodIBus::ProcessKeyEventDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  current_keyevent_id_,
                  base::Owned(event),  // Pass the ownership of |event|.
-                 ibus_keyval);
+                 ibus_keyval,
+                 ibus_keycode,
+                 ibus_state);
 
   GetInputContextClient()->ProcessKeyEvent(ibus_keyval,
                                            ibus_keycode,
                                            ibus_state,
                                            callback,
                                            base::Bind(callback, false));
   ++current_keyevent_id_;
 
   // We don't want to suppress the result generated by this key event, but it
   // may cause problem. See comment in ResetContext() method.
   suppress_next_result_ = false;
   return true;
 }
 
 bool InputMethodIBus::DispatchFabricatedKeyEvent(const ui::KeyEvent& event) {
   // TODO(bryeung): The fabricated events should also pass through IME.
   if (event.type() == ET_KEY_PRESSED) {
     ProcessUnfilteredFabricatedKeyPressEvent(
-        ET_KEY_PRESSED, event.key_code(), event.flags(), 0);
+        ET_KEY_PRESSED, event.key_code(), event.flags(), 0, 0);
   } else {
     DispatchFabricatedKeyEventPostIME(
         ET_KEY_RELEASED,
         event.key_code(),
         event.flags());
   }
   return true;
 }
 
 void InputMethodIBus::OnTextInputTypeChanged(const TextInputClient* client) {
@@ skipping 220 matching lines @@
     uint32 capability = kIBusCapabilityFocus | kIBusCapabilitySurroundingText;
     if (CanComposeInline())
       capability |= kIBusCapabilityPreeditText;
     GetInputContextClient()->SetCapabilities(capability);
   }
 }
 
 void InputMethodIBus::ProcessKeyEventPostIME(
     const base::NativeEvent& native_event,
     uint32 ibus_keyval,
+    uint32 ibus_keycode,
+    uint32 ibus_state,
     bool handled) {
   TextInputClient* client = GetTextInputClient();
 
   if (!client) {
     // As ibus works asynchronously, there is a chance that the focused client
     // loses focus before this method gets called.
     DispatchKeyEventPostIME(native_event);
     return;
   }
 
   if (native_event->type == KeyPress && handled)
     ProcessFilteredKeyPressEvent(native_event);
 
   // In case the focus was changed by the key event. The |context_| should have
   // been reset when the focused window changed.
   if (client != GetTextInputClient())
     return;
 
   if (HasInputMethodResult())
     ProcessInputMethodResult(native_event, handled);
 
   // In case the focus was changed when sending input method results to the
   // focused window.
   if (client != GetTextInputClient())
     return;
 
   if (native_event->type == KeyPress && !handled)
-    ProcessUnfilteredKeyPressEvent(native_event, ibus_keyval);
+    ProcessUnfilteredKeyPressEvent(native_event,
+                                   ibus_keyval, ibus_keycode, ibus_state);
   else if (native_event->type == KeyRelease)
     DispatchKeyEventPostIME(native_event);
 }
 
 void InputMethodIBus::IBusKeyEventFromNativeKeyEvent(
     const base::NativeEvent& native_event,
     uint32* ibus_keyval,
     uint32* ibus_keycode,
     uint32* ibus_state) {
   DCHECK(native_event);  // A fabricated event is not supported here.
   XKeyEvent* x_key = GetKeyEvent(native_event);
 
   // Yes, ibus uses X11 keysym. We cannot use XLookupKeysym(), which doesn't
   // translate Shift and CapsLock states.
   KeySym keysym = NoSymbol;
   ::XLookupString(x_key, NULL, 0, &keysym, NULL);
   *ibus_keyval = keysym;
   *ibus_keycode = x_key->keycode;
-  *ibus_state = IBusStateFromXFlags(x_key->state);
+  *ibus_state = IBusStateFromXState(x_key->state);
   if (native_event->type == KeyRelease)
     *ibus_state |= kIBusReleaseMask;
 }
 
 void InputMethodIBus::ProcessFilteredKeyPressEvent(
     const base::NativeEvent& native_event) {
   if (NeedInsertChar())
     DispatchKeyEventPostIME(native_event);
   else
     DispatchFabricatedKeyEventPostIME(
         ET_KEY_PRESSED,
         VKEY_PROCESSKEY,
-        EventFlagsFromXFlags(GetKeyEvent(native_event)->state));
+        EventFlagsFromXState(GetKeyEvent(native_event)->state));
 }
 
 void InputMethodIBus::ProcessUnfilteredKeyPressEvent(
     const base::NativeEvent& native_event,
-    uint32 ibus_keyval) {
+    uint32 ibus_keyval,
+    uint32 ibus_keycode,
+    uint32 ibus_state) {
   // For a fabricated event, ProcessUnfilteredFabricatedKeyPressEvent should be
   // called instead.
   DCHECK(native_event);
 
   TextInputClient* client = GetTextInputClient();
   DispatchKeyEventPostIME(native_event);
 
   // We shouldn't dispatch the character anymore if the key event dispatch
   // caused focus change. For example, in the following scenario,
   // 1. visit a web page which has a <textarea>.
   // 2. click Omnibox.
   // 3. enable Korean IME, press A, then press Tab to move the focus to the web
   //    page.
   // We should return here not to send the Tab key event to RWHV.
   if (client != GetTextInputClient())
     return;
 
-  const uint32 state =
-      EventFlagsFromXFlags(GetKeyEvent(native_event)->state);
+  const uint32 event_flags = EventFlagsFromXState(ibus_state);
 
   // Process compose and dead keys
-  if (ProcessUnfilteredKeyPressEventWithCharacterComposer(ibus_keyval, state))
+  if (ProcessUnfilteredKeyPressEventWithCharacterComposer(
+          ibus_keyval, ibus_keycode, event_flags))
     return;
 
   // If a key event was not filtered by |context_| and |character_composer_|,
   // then it means the key event didn't generate any result text. So we need
   // to send corresponding character to the focused text input client.
   client = GetTextInputClient();
 
   uint16 ch = 0;
-  if (!(state & ui::EF_CONTROL_DOWN))
+  if (!(event_flags & ui::EF_CONTROL_DOWN))
     ch = ui::GetCharacterFromXEvent(native_event);
   if (!ch) {
     ch = ui::GetCharacterFromKeyCode(
-        ui::KeyboardCodeFromNative(native_event), state);
+        ui::KeyboardCodeFromNative(native_event), event_flags);
   }
 
   if (client && ch)
-    client->InsertChar(ch, state);
+    client->InsertChar(ch, event_flags);
 }
 
 void InputMethodIBus::ProcessUnfilteredFabricatedKeyPressEvent(
     EventType type,
     KeyboardCode key_code,
-    int flags,
-    uint32 ibus_keyval) {
+    int event_flags,
+    uint32 ibus_keyval,
+    uint32 ibus_keycode) {
   TextInputClient* client = GetTextInputClient();
-  DispatchFabricatedKeyEventPostIME(type, key_code, flags);
+  DispatchFabricatedKeyEventPostIME(type, key_code, event_flags);
 
   if (client != GetTextInputClient())
     return;
 
-  if (ProcessUnfilteredKeyPressEventWithCharacterComposer(ibus_keyval, flags))
+  if (ProcessUnfilteredKeyPressEventWithCharacterComposer(
+          ibus_keyval, ibus_keycode, event_flags))
     return;
 
   client = GetTextInputClient();
-  const uint16 ch = ui::GetCharacterFromKeyCode(key_code, flags);
+  const uint16 ch = ui::GetCharacterFromKeyCode(key_code, event_flags);
   if (client && ch)
-    client->InsertChar(ch, flags);
+    client->InsertChar(ch, event_flags);
 }
 
 bool InputMethodIBus::ProcessUnfilteredKeyPressEventWithCharacterComposer(
     uint32 ibus_keyval,
-    uint32 state) {
+    uint32 ibus_keycode,
+    int event_flags) {
   // We don't filter key presses for inappropriate input types.
   const TextInputType text_input_type = GetTextInputType();
   if (text_input_type == TEXT_INPUT_TYPE_NONE ||
       text_input_type == TEXT_INPUT_TYPE_PASSWORD)
     return false;
 
   // Do nothing if the key press is not filtered by our composer.
-  if (!character_composer_.FilterKeyPress(ibus_keyval, state))
+  if (!character_composer_.FilterKeyPress(ibus_keyval, ibus_keycode,
+                                          event_flags))
     return false;
 
   TextInputClient* client = GetTextInputClient();
   if (!client) // Do nothing if we cannot get the client.
     return true;
 
   // Insert composed character.
   const string16 composed = character_composer_.composed_character();
   if (!composed.empty()) {
     if (composed.size() == 1) {
-      client->InsertChar(composed[0], state);
+      client->InsertChar(composed[0], event_flags);
     } else {
       CompositionText composition;
       composition.text = composed;
       client->SetCompositionText(composition);
       client->ConfirmCompositionText();
     }
   }
   return true;
 }
 
 void InputMethodIBus::ProcessInputMethodResult(
     const base::NativeEvent& native_event,
     bool handled) {
   TextInputClient* client = GetTextInputClient();
   DCHECK(client);
 
   if (result_text_.length()) {
     if (handled && NeedInsertChar()) {
       const uint32 state =
-          EventFlagsFromXFlags(GetKeyEvent(native_event)->state);
+          EventFlagsFromXState(GetKeyEvent(native_event)->state);
       for (string16::const_iterator i = result_text_.begin();
            i != result_text_.end(); ++i) {
         client->InsertChar(*i, state);
       }
     } else {
       client->InsertText(result_text_);
       composing_text_ = false;
     }
   }
 
@@ skipping 54 matching lines @@
   // focused text input client does not support text input.
   if (pending_key_events_.empty() && !IsTextInputTypeNone()) {
     SendFakeProcessKeyEvent(true);
     GetTextInputClient()->InsertText(utf16_text);
     SendFakeProcessKeyEvent(false);
     result_text_.clear();
   }
 }
 
 void InputMethodIBus::ForwardKeyEvent(uint32 keyval,
-                                        uint32 keycode,
-                                        uint32 state) {
+                                      uint32 keycode,
+                                      uint32 state) {
   KeyboardCode ui_key_code = KeyboardCodeFromXKeysym(keyval);
   if (!ui_key_code)
     return;
 
   const EventType event_type =
       (state & kIBusReleaseMask) ? ET_KEY_RELEASED : ET_KEY_PRESSED;
-  const int event_flags = EventFlagsFromXFlags(state);
+  const int event_flags = EventFlagsFromXState(state);
 
   // It is not clear when the input method will forward us a fake key event.
   // If there is a pending key event, then we may already received some input
   // method results, so we dispatch this fake key event directly rather than
   // calling ProcessKeyEventPostIME(), which will clear pending input method
   // results.
   if (event_type == ET_KEY_PRESSED) {
     ProcessUnfilteredFabricatedKeyPressEvent(
-        event_type, ui_key_code, event_flags, keyval);
+        event_type, ui_key_code, event_flags, keyval, keycode);
   } else {
     DispatchFabricatedKeyEventPostIME(event_type, ui_key_code, event_flags);
   }
 }
 
 void InputMethodIBus::ShowPreeditText() {
   if (suppress_next_result_ || IsTextInputTypeNone())
     return;
 
   composing_text_ = true;
@@ skipping 222 matching lines @@
   }
 
   // Use a black thin underline by default.
   if (out_composition->underlines.empty()) {
     out_composition->underlines.push_back(CompositionUnderline(
         0, length, SK_ColorBLACK, false /* thick */));
   }
 }
 
 }  // namespace ui