New InputMethod api for Views.

views/ime/input_method_gtk.cc

Index: views/ime/input_method_gtk.cc
diff --git a/views/ime/input_method_gtk.cc b/views/ime/input_method_gtk.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c6f64c87c3c61092c1732db4476d1db91bac871d
--- /dev/null
+++ b/views/ime/input_method_gtk.cc
@@ -0,0 +1,470 @@
+// 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 "views/ime/input_method_gtk.h"
+
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include <algorithm>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "base/third_party/icu/icu_utf.h"
+#include "base/utf_string_conversions.h"
+#include "ui/base/gtk/event_synthesis_gtk.h"
+#include "ui/base/gtk/gtk_im_context_util.h"
+#include "ui/base/keycodes/keyboard_codes.h"
+#include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
+#include "views/events/event.h"
+#include "views/widget/widget.h"
+
+namespace views {
+
+InputMethodGtk::InputMethodGtk(internal::InputMethodDelegate* delegate)
+    : context_(NULL),
+      context_simple_(NULL),
+      widget_realize_id_(0),
+      widget_unrealize_id_(0),
+      widget_focus_in_id_(0),
+      widget_focus_out_id_(0),
+      context_focused_(false),
+      handling_key_event_(false),
+      composing_text_(false),
+      composition_changed_(false),
+      suppress_next_result_(false) {
+  set_delegate(delegate);
+}
+
+InputMethodGtk::~InputMethodGtk() {
+  if (widget()) {
+    GtkWidget* native_view = widget()->GetNativeView();
+    if (native_view) {
+      g_signal_handler_disconnect(native_view, widget_realize_id_);
+      g_signal_handler_disconnect(native_view, widget_unrealize_id_);
+      g_signal_handler_disconnect(native_view, widget_focus_in_id_);
+      g_signal_handler_disconnect(native_view, widget_focus_out_id_);
+    }
+  }
+  if (context_) {
+    g_object_unref(context_);
+    context_ = NULL;
+  }
+  if (context_simple_) {
+    g_object_unref(context_simple_);
+    context_simple_ = NULL;
+  }
+}
+
+void InputMethodGtk::Init(Widget* widget) {
+  InputMethodBase::Init(widget);
+
+  DCHECK(GTK_IS_WIDGET(widget->GetNativeView()));
+
+  widget_realize_id_ =
+      g_signal_connect(widget->GetNativeView(), "realize",
+                       G_CALLBACK(OnWidgetRealizeThunk), this);
+  widget_unrealize_id_ =
+      g_signal_connect(widget->GetNativeView(), "unrealize",
+                       G_CALLBACK(OnWidgetUnrealizeThunk), this);
+  widget_focus_in_id_ =
+      g_signal_connect(widget->GetNativeView(), "focus-in-event",
+                       G_CALLBACK(OnWidgetFocusInThunk), this);
+  widget_focus_out_id_ =
+      g_signal_connect(widget->GetNativeView(), "focus-out-event",
+                       G_CALLBACK(OnWidgetFocusOutThunk), this);
+
+  context_ = gtk_im_multicontext_new();
+  context_simple_ = gtk_im_context_simple_new();
+
+  // context_ and context_simple_ share the same callback handlers.
+  // All data come from them are treated equally.
+  // context_ is for full input method support.
+  // context_simple_ is for supporting dead/compose keys when input method is
+  // disabled, eg. in password input box.
+  g_signal_connect(context_, "commit",
+                   G_CALLBACK(OnCommitThunk), this);
+  g_signal_connect(context_, "preedit_start",
+                   G_CALLBACK(OnPreeditStartThunk), this);
+  g_signal_connect(context_, "preedit_end",
+                   G_CALLBACK(OnPreeditEndThunk), this);
+  g_signal_connect(context_, "preedit_changed",
+                   G_CALLBACK(OnPreeditChangedThunk), this);
+
+  g_signal_connect(context_simple_, "commit",
+                   G_CALLBACK(OnCommitThunk), this);
+  g_signal_connect(context_simple_, "preedit_start",
+                   G_CALLBACK(OnPreeditStartThunk), this);
+  g_signal_connect(context_simple_, "preedit_end",
+                   G_CALLBACK(OnPreeditEndThunk), this);
+  g_signal_connect(context_simple_, "preedit_changed",
+                   G_CALLBACK(OnPreeditChangedThunk), this);
+
+  // Set client window if the widget is already realized.
+  OnWidgetRealize(widget->GetNativeView());
+}
+
+void InputMethodGtk::DispatchKeyEvent(const KeyEvent& key) {
+  suppress_next_result_ = false;
+
+  // We should bypass |context_| and |context_simple_| only if there is no
+  // text input client is focused at all. Otherwise, we should always send the
+  // key event to either |context_| or |context_simple_| even if the text input
+  // type is ui::TEXT_INPUT_TYPE_NONE, to make sure we can get correct character
+  // result.
+  if (!GetTextInputClient()) {
+    DispatchKeyEventPostIME(key);
+    return;
+  }
+
+  handling_key_event_ = true;
+  composition_changed_ = false;
+  result_text_.clear();
+
+  GdkEvent* event = key.native_event();
+  DCHECK(!event || event->type == GDK_KEY_PRESS ||
+         event->type == GDK_KEY_RELEASE);
+
+  // If it's a fake key event, then we need to synthesis a GdkEventKey.
+  bool need_free_event = false;
+  if (!event) {
+    event = SynthesizeGdkEventKey(key);
+    need_free_event = true;
+  }
+
+  gboolean filtered = false;
+  if (context_focused_)
+    filtered = gtk_im_context_filter_keypress(context_, &event->key);
+  else
+    filtered = gtk_im_context_filter_keypress(context_simple_, &event->key);
+
+  handling_key_event_ = false;
+
+  View* old_focused_view = focused_view();
+  if (key.type() == ui::ET_KEY_PRESSED && filtered)
+    ProcessFilteredKeyPressEvent(key);
+
+  // In case the focus was changed by the key event.
+  if (old_focused_view != focused_view())
+    return;
+
+  if (HasInputMethodResult())
+    ProcessInputMethodResult(key, filtered);
+
+  // In case the focus was changed when sending input method results to the
+  // focused View.
+  if (old_focused_view != focused_view())
+    return;
+
+  if (key.type() == ui::ET_KEY_PRESSED && !filtered)

[Peng, 2011/03/24 20:26:48]

I mean, if the event is not not filtered by imcontext, it calls
ProcessUnfilteredKeyPressEvent(), and then should it call
DispatchKeyEventPostIME(key)? View may want to handle some key events by self.

+    ProcessUnfilteredKeyPressEvent(key);
+  else if (key.type() == ui::ET_KEY_RELEASED)
+    DispatchKeyEventPostIME(key);
+
+  if (need_free_event)
+    gdk_event_free(event);
+}
+
+void InputMethodGtk::OnTextInputTypeChanged(View* view) {
+  if (IsViewFocused(view))
+    UpdateContextFocusState();
+}
+
+void InputMethodGtk::OnCaretBoundsChanged(View* view) {
+  gfx::Rect rect;
+  if (!IsViewFocused(view) || !GetCaretBoundsInWidget(&rect))
+    return;
+
+  GdkRectangle gdk_rect = rect.ToGdkRectangle();
+  gtk_im_context_set_cursor_location(context_, &gdk_rect);
+}
+
+void InputMethodGtk::CancelComposition(View* view) {
+  if (IsViewFocused(view))
+    ResetContext();
+}
+
+std::string InputMethodGtk::GetInputLocale() {
+  // Not supported.
+  return std::string("");
+}
+
+base::i18n::TextDirection InputMethodGtk::GetInputTextDirection() {
+  // Not supported.
+  return base::i18n::UNKNOWN_DIRECTION;
+}
+
+bool InputMethodGtk::IsActive() {
+  // We always need to send keyboard events to either |context_| or
+  // |context_simple_|, so just return true here.
+  return true;
+}
+
+void InputMethodGtk::FocusedViewWillChange() {
+  ConfirmCompositionText();
+}
+
+void InputMethodGtk::FocusedViewDidChange() {
+  UpdateContextFocusState();
+}
+
+void InputMethodGtk::ConfirmCompositionText() {
+  TextInputClient* client = GetTextInputClient();
+  if (client && client->HasCompositionText())
+    client->ConfirmCompositionText();
+
+  ResetContext();
+}
+
+void InputMethodGtk::ResetContext() {
+  if (!GetTextInputClient())
+    return;
+
+  DCHECK(widget_focused());
+  DCHECK(focused_view());
+  DCHECK(!handling_key_event_);
+
+  // To prevent any text from being committed when resetting the |context_|;
+  handling_key_event_ = true;
+  suppress_next_result_ = true;
+
+  gtk_im_context_reset(context_);
+  gtk_im_context_reset(context_simple_);
+
+  // Some input methods may not honour the reset call. Focusing out/in the
+  // |context_| to make sure it gets reset correctly.
+  if (context_focused_) {
+    gtk_im_context_focus_out(context_);
+    gtk_im_context_focus_in(context_);
+  }
+
+  composition_.Clear();
+  result_text_.clear();
+  handling_key_event_ = false;
+  composing_text_ = false;
+  composition_changed_ = false;
+}
+
+void InputMethodGtk::UpdateContextFocusState() {
+  bool old_context_focused = context_focused_;
+  // Use switch here in case we are going to add more text input types.
+  switch (GetTextInputType()) {
+    case ui::TEXT_INPUT_TYPE_NONE:
+    case ui::TEXT_INPUT_TYPE_PASSWORD:
+      context_focused_ = false;
+      break;
+    default:
+      context_focused_ = true;
+      break;
+  }
+
+  // We only focus in |context_| when the focus in in a normal textfield.
+  if (old_context_focused && !context_focused_)
+    gtk_im_context_focus_out(context_);
+  else if (!old_context_focused && context_focused_)
+    gtk_im_context_focus_in(context_);
+
+  // |context_simple_| can be used in any textfield, including password box, and
+  // even if the focused text input client's text input type is
+  // ui::TEXT_INPUT_TYPE_NONE.
+  if (GetTextInputClient())
+    gtk_im_context_focus_in(context_simple_);
+  else
+    gtk_im_context_focus_out(context_simple_);
+}
+
+void InputMethodGtk::ProcessFilteredKeyPressEvent(const KeyEvent& key) {
+  if (NeedInsertChar()) {
+    DispatchKeyEventPostIME(key);
+  } else {
+    KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_PROCESSKEY, key.flags());
+    DispatchKeyEventPostIME(key);
+  }
+}
+
+void InputMethodGtk::ProcessUnfilteredKeyPressEvent(const KeyEvent& key) {
+  DispatchKeyEventPostIME(key);
+
+  // If a key event was not filtered by |context_| or |context_simple_|, then
+  // it means the key event didn't generate any result text. For some cases,
+  // the key event may still generate a valid character, eg. a control-key
+  // event (ctrl-a, return, tab, etc.). We need to send the character to the
+  // focused text input client by calling TextInputClient::InsertChar().

[Peng, 2011/03/24 03:49:02]

Should do this? Maybe some view will handle them by self.

[James Su, 2011/03/24 18:01:35]

We need it to keep consistent with Windows. And a View may not have enough
information to get the correct character out of a keyboard event.
See ProcessFilteredKeyPressEvent() above and ProcessInputMethodResult() below.
If the input method returns a result text with only one character, and there is
no composition text change, then the key event will be treated as if it's not
handled by the input method, and the only character in the result text will be
sent to the View by calling InsertChar(), the same way here.

[Peng, 2011/03/24 18:39:03]

I do not understand. I am thinking in some cases, IME is disabled, and view want
to handle some special key by self. For example a view want to handle 'Ctrl + o'
by self, and do not want to insert a char \0xxx. Is it OK?

[James Su, 2011/03/24 18:56:28]

Of course, it's free for a View to ignore any character and text inside its own
InsertChar() and InsertText() implementation. Check my CL to see how
NativeTextfieldViews ignores control characters.

[Peng, 2011/03/24 19:25:08]

So do you mean the view can still receive this event? But I can not find calling
DispatchPostIMEKeyEvent after this function. Please point it out. Thanks.

And for InsertChar(), it is not very reasonable to let view ignore some chars in
InsertChar() function. Or maybe the name InsertChar() is not good, need rename
it. for example OnChar() like WM_CHAR on windows.

[James Su, 2011/03/24 19:48:49]

I don't understand your question. Which event do you mean?
It's just about method name, I actually have no preference. I can rename it to
OnChar if you insist. The reason to use InsertChar is to keep in sync with
InsertText.
Regardless of the name, it's of course reasonable for the View to decided its
behavior freely. Not only for InsertChar, but also for InsertText.

[Peng, 2011/03/24 20:26:48]

I think InsertChar() & InsertText() are very clear meaning for InputClient.

I did not say only renaming is OK. I believe InsertText() and InsertChar()
should be only for result from IME. For unfiltered key events, that should be
handled by view self. view could call keyevent.GetCharacter() to get char or do
other things as well. right?

[James Su, 2011/03/24 21:01:23]

DispatchKeyEventPostIME() is called 7 lines above in the code, didn't you see
it?

+  char16 ch = key.GetCharacter();
+  TextInputClient* client = GetTextInputClient();
+  if (ch && client)
+    client->InsertChar(ch, key.flags());
+}
+
+void InputMethodGtk::ProcessInputMethodResult(const KeyEvent& key,
+                                              bool filtered) {
+  TextInputClient* client = GetTextInputClient();
+  DCHECK(client);
+
+  if (result_text_.length()) {
+    if (filtered && NeedInsertChar()) {
+      for (string16::const_iterator i = result_text_.begin();
+           i != result_text_.end(); ++i) {
+        client->InsertChar(*i, key.flags());
+      }
+    } else {
+      client->InsertText(result_text_);
+      composing_text_ = false;
+    }
+  }
+
+  if (composition_changed_ && !IsTextInputTypeNone()) {
+    if (composition_.text.length()) {
+      composing_text_ = true;
+      client->SetCompositionText(composition_);
+    } else if (result_text_.empty()) {
+      client->ClearCompositionText();
+    }
+  }
+}
+
+bool InputMethodGtk::NeedInsertChar() const {
+  return IsTextInputTypeNone() ||
+      (!composing_text_ && result_text_.length() == 1);
+}
+
+bool InputMethodGtk::HasInputMethodResult() const {
+  return result_text_.length() || composition_changed_;
+}
+
+void InputMethodGtk::SendFakeProcessKeyEvent(bool pressed) const {
+  KeyEvent key(pressed ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
+               ui::VKEY_PROCESSKEY, 0);
+  DispatchKeyEventPostIME(key);
+}
+
+GdkEvent* InputMethodGtk::SynthesizeGdkEventKey(const KeyEvent& key) const {
+  guint keyval =
+      ui::GdkKeyCodeForWindowsKeyCode(key.key_code(), key.IsShiftDown());
+  guint state = 0;
+  if (key.IsShiftDown())
+    state |= GDK_SHIFT_MASK;
+  if (key.IsControlDown())
+    state |= GDK_CONTROL_MASK;
+  if (key.IsAltDown())
+    state |= GDK_MOD1_MASK;
+  if (key.IsCapsLockDown())
+    state |= GDK_LOCK_MASK;
+
+  DCHECK(widget()->GetNativeView()->window);
+  return ui::SynthesizeKeyEvent(widget()->GetNativeView()->window,
+                                key.type() == ui::ET_KEY_PRESSED,
+                                keyval, state);
+}
+
+void InputMethodGtk::OnCommit(GtkIMContext* context, gchar* text) {
+  if (suppress_next_result_) {
+    suppress_next_result_ = false;
+    return;
+  }
+
+  // We need to receive input method result even if the text input type is
+  // ui::TEXT_INPUT_TYPE_NONE, to make sure we can always send correct
+  // character for each key event to the focused text input client.
+  if (!GetTextInputClient())
+    return;
+
+  string16 utf16_text(UTF8ToUTF16(text));
+
+  // Append the text to the buffer, because commit signal might be fired
+  // multiple times when processing a key event.
+  result_text_.append(utf16_text);
+
+  // If we are not handling key event, do not bother sending text result if the
+  // focused text input client does not support text input.
+  if (!handling_key_event_ && !IsTextInputTypeNone()) {
+    SendFakeProcessKeyEvent(true);
+    GetTextInputClient()->InsertText(utf16_text);
+    SendFakeProcessKeyEvent(false);
+  }
+}
+
+void InputMethodGtk::OnPreeditStart(GtkIMContext* context) {
+  if (suppress_next_result_ || IsTextInputTypeNone())
+    return;
+
+  composing_text_ = true;
+}
+
+void InputMethodGtk::OnPreeditChanged(GtkIMContext* context) {
+  if (suppress_next_result_ || IsTextInputTypeNone())
+    return;
+
+  gchar* text = NULL;
+  PangoAttrList* attrs = NULL;
+  gint cursor_position = 0;
+  gtk_im_context_get_preedit_string(context, &text, &attrs, &cursor_position);
+
+  ui::ExtractCompositionTextFromGtkPreedit(text, attrs, cursor_position,
+                                           &composition_);
+  composition_changed_ = true;
+
+  g_free(text);
+  pango_attr_list_unref(attrs);
+
+  if (composition_.text.length())
+    composing_text_ = true;
+
+  if (!handling_key_event_ && !IsTextInputTypeNone()) {

[Peng, 2011/03/24 03:49:02]

I suggest always send the fake key event, even if handling_key_event_ is true.
So that the logic will be simpler.

[James Su, 2011/03/24 18:01:35]

No. This method could be called for multiple times when handling a key event, it
makes no sense to send multiple VKEY_PROCESSKEY events for one real key event.

+    SendFakeProcessKeyEvent(true);
+    GetTextInputClient()->SetCompositionText(composition_);
+    SendFakeProcessKeyEvent(false);
+  }
+}
+
+void InputMethodGtk::OnPreeditEnd(GtkIMContext* context) {
+  if (composition_.text.empty() || IsTextInputTypeNone())
+    return;
+
+  composition_changed_ = true;
+  composition_.Clear();
+
+  if (!handling_key_event_) {
+    TextInputClient* client = GetTextInputClient();
+    if (client && client->HasCompositionText())
+      client->ClearCompositionText();
+  }
+}
+
+void InputMethodGtk::OnWidgetRealize(GtkWidget* widget) {
+  // We should only set im context's client window once, because when setting
+  // client window, im context may destroy and recreate its internal states and
+  // objects.
+  if (widget->window) {

[Peng, 2011/03/24 03:49:02]

How about create GtkIMContext here?

[James Su, 2011/03/24 18:01:35]

If the creation of GtkIMContext happens here, then I need to check if the
pointers are NULL in other places. And I don't think there is much difference by
creating the object at very beginning. Because the Widget will usually be
realized immediately after creation.

Actually I was thinking about delaying the creation of InputMethodGtk object
until the first key event, but as the creation may need some time, it may affect
the user experience because when the user starts typing the browser may be stuck
for a short period.

+    gtk_im_context_set_client_window(context_, widget->window);
+    gtk_im_context_set_client_window(context_simple_, widget->window);
+  }
+}
+
+void InputMethodGtk::OnWidgetUnrealize(GtkWidget* widget) {

[Peng, 2011/03/24 03:49:02]

And destroy IMContext here?

+  gtk_im_context_set_client_window(context_, NULL);
+  gtk_im_context_set_client_window(context_simple_, NULL);
+}
+
+gboolean InputMethodGtk::OnWidgetFocusIn(GtkWidget* widget,
+                                         GdkEventFocus* event) {
+  if (!widget_focused()) {
+    set_widget_focused(true);
+    UpdateContextFocusState();
+  }
+  return false;
+}
+
+gboolean InputMethodGtk::OnWidgetFocusOut(GtkWidget* widget,
+                                          GdkEventFocus* event) {
+  if (widget_focused()) {
+    ConfirmCompositionText();
+    set_widget_focused(false);
+    UpdateContextFocusState();
+  }
+  return false;
+}
+
+}  // namespace views