Refactoring for InputMethodAuraLinux.

chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.cc

 // Copyright 2013 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/ui/libgtk2ui/x11_input_method_context_impl_gtk2.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 
 #include <gtk/gtk.h>
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/composition_text_util_pango.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace libgtk2ui {
 
 X11InputMethodContextImplGtk2::X11InputMethodContextImplGtk2(
-    ui::LinuxInputMethodContextDelegate* delegate)
-    : delegate_(delegate),
-      gtk_context_simple_(NULL),
-      gtk_multicontext_(NULL),
-      gtk_context_(NULL),
+    ui::LinuxInputMethodContextDelegate* delegate, bool is_simple)
+    : delegate_(delegate), gtk_context_(NULL),
       gdk_last_set_client_window_(NULL) {
   CHECK(delegate_);
 
   ResetXModifierKeycodesCache();
 
-  gtk_context_simple_ = gtk_im_context_simple_new();
-  gtk_multicontext_ = gtk_im_multicontext_new();
+  if (is_simple)
+    gtk_context_ = gtk_im_context_simple_new();
+  else
+    gtk_context_ = gtk_im_multicontext_new();
 
-  GtkIMContext* contexts[] = {gtk_context_simple_, gtk_multicontext_};
-  for (size_t i = 0; i < arraysize(contexts); ++i) {
-    g_signal_connect(contexts[i], "commit",
-                     G_CALLBACK(OnCommitThunk), this);
-    g_signal_connect(contexts[i], "preedit-changed",
-                     G_CALLBACK(OnPreeditChangedThunk), this);
-    g_signal_connect(contexts[i], "preedit-end",
-                     G_CALLBACK(OnPreeditEndThunk), this);
-    g_signal_connect(contexts[i], "preedit-start",
-                     G_CALLBACK(OnPreeditStartThunk), this);
-    // TODO(yukishiino): Handle operations on surrounding text.
-    // "delete-surrounding" and "retrieve-surrounding" signals should be
-    // handled.
+  g_signal_connect(gtk_context_, "commit",
+                   G_CALLBACK(OnCommitThunk), this);
+  g_signal_connect(gtk_context_, "preedit-changed",
+                   G_CALLBACK(OnPreeditChangedThunk), this);
+  g_signal_connect(gtk_context_, "preedit-end",
+                   G_CALLBACK(OnPreeditEndThunk), this);
+  g_signal_connect(gtk_context_, "preedit-start",
+                   G_CALLBACK(OnPreeditStartThunk), this);
+  // TODO(yukishiino): Handle operations on surrounding text.
+  // "delete-surrounding" and "retrieve-surrounding" signals should be
+  // handled.
+}
+
+X11InputMethodContextImplGtk2::~X11InputMethodContextImplGtk2() {
+  if (gtk_context_) {
+    g_object_unref(gtk_context_);
+    gtk_context_ = NULL;
   }
 }
 
-X11InputMethodContextImplGtk2::~X11InputMethodContextImplGtk2() {
-  gtk_context_ = NULL;
-  if (gtk_context_simple_) {
-    g_object_unref(gtk_context_simple_);
-    gtk_context_simple_ = NULL;
-  }
-  if (gtk_multicontext_) {
-    g_object_unref(gtk_multicontext_);
-    gtk_multicontext_ = NULL;
-  }
-}
-
 // Overriden from ui::LinuxInputMethodContext
 
 bool X11InputMethodContextImplGtk2::DispatchKeyEvent(
     const ui::KeyEvent& key_event) {
-  if (!key_event.HasNativeEvent())
-    return false;
-
-  // The caller must call Focus() first.
-  if (!gtk_context_)
+  if (!key_event.HasNativeEvent() || !gtk_context_)
     return false;
 
   // Translate a XKeyEvent to a GdkEventKey.
   GdkEvent* event = GdkEventFromNativeEvent(key_event.native_event());
   if (!event) {
     LOG(ERROR) << "Cannot translate a XKeyEvent to a GdkEvent.";
     return false;
   }
 
-  // Set the client window and cursor location.
   if (event->key.window != gdk_last_set_client_window_) {
     gtk_im_context_set_client_window(gtk_context_, event->key.window);
     gdk_last_set_client_window_ = event->key.window;
   }
+
   // Convert the last known caret bounds relative to the screen coordinates
   // to a GdkRectangle relative to the client window.
   gint x = 0;
   gint y = 0;
   gdk_window_get_origin(event->key.window, &x, &y);
   GdkRectangle rect = {last_caret_bounds_.x() - x,
                        last_caret_bounds_.y() - y,
                        last_caret_bounds_.width(),
                        last_caret_bounds_.height()};
   gtk_im_context_set_cursor_location(gtk_context_, &rect);
 
-  // Let an IME handle the key event.
-  commit_signal_trap_.StartTrap(event->key.keyval);
-  const gboolean handled = gtk_im_context_filter_keypress(gtk_context_,
-                                                          &event->key);
-  commit_signal_trap_.StopTrap();
+  const bool handled = gtk_im_context_filter_keypress(gtk_context_,
+                                                      &event->key);
   gdk_event_free(event);
-
-  return handled && !commit_signal_trap_.IsSignalCaught();
+  return handled;
 }
 
 void X11InputMethodContextImplGtk2::Reset() {
-  // Reset all the states of the context, not only preedit, caret but also
-  // focus.
-  gtk_context_ = NULL;
-  gtk_im_context_reset(gtk_context_simple_);
-  gtk_im_context_reset(gtk_multicontext_);
-  gtk_im_context_focus_out(gtk_context_simple_);
-  gtk_im_context_focus_out(gtk_multicontext_);
-  gdk_last_set_client_window_ = NULL;
+  gtk_im_context_reset(gtk_context_);
 }
 
-void X11InputMethodContextImplGtk2::OnTextInputTypeChanged(
-    ui::TextInputType text_input_type) {
-  switch (text_input_type) {
-    case ui::TEXT_INPUT_TYPE_NONE:
-    case ui::TEXT_INPUT_TYPE_PASSWORD:
-      gtk_context_ = gtk_context_simple_;
-      break;
-    default:
-      gtk_context_ = gtk_multicontext_;
-  }
+void X11InputMethodContextImplGtk2::Focus() {
   gtk_im_context_focus_in(gtk_context_);
 }
 
-void X11InputMethodContextImplGtk2::OnCaretBoundsChanged(
-    const gfx::Rect& caret_bounds) {
+void X11InputMethodContextImplGtk2::Blur() {
+  gtk_im_context_focus_out(gtk_context_);
+}
+
+void X11InputMethodContextImplGtk2::SetCursorLocation(const gfx::Rect& rect) {
   // Remember the caret bounds so that we can set the cursor location later.
   // gtk_im_context_set_cursor_location() takes the location relative to the
   // client window, which is unknown at this point.  So we'll call
   // gtk_im_context_set_cursor_location() later in ProcessKeyEvent() where
   // (and only where) we know the client window.
-  last_caret_bounds_ = caret_bounds;
+  last_caret_bounds_ = rect;
 }
 
 // private:
 
 void X11InputMethodContextImplGtk2::ResetXModifierKeycodesCache() {
   modifier_keycodes_.clear();
   meta_keycodes_.clear();
   super_keycodes_.clear();
   hyper_keycodes_.clear();
 
@@ skipping 147 matching lines @@
   return false;
 }
 
 // GtkIMContext event handlers.
 
 void X11InputMethodContextImplGtk2::OnCommit(GtkIMContext* context,
                                              gchar* text) {
   if (context != gtk_context_)
     return;
 
-  const base::string16& text_in_utf16 = base::UTF8ToUTF16(text);
-  // If an underlying IME is emitting the "commit" signal to insert a character
-  // for a direct input key event, ignores the insertion of the character at
-  // this point, because we have to call DispatchKeyEventPostIME() for direct
-  // input key events.  DispatchKeyEvent() takes care of the trapped character
-  // and calls DispatchKeyEventPostIME().
-  if (commit_signal_trap_.Trap(text_in_utf16))
-    return;
-
-  delegate_->OnCommit(text_in_utf16);
+  delegate_->OnCommit(base::UTF8ToUTF16(text));
 }
 
 void X11InputMethodContextImplGtk2::OnPreeditChanged(GtkIMContext* context) {
   if (context != gtk_context_)
     return;
 
   gchar* str = NULL;
   PangoAttrList* attrs = NULL;
   gint cursor_pos = 0;
   gtk_im_context_get_preedit_string(context, &str, &attrs, &cursor_pos);
@@ skipping 13 matching lines @@
   delegate_->OnPreeditEnd();
 }
 
 void X11InputMethodContextImplGtk2::OnPreeditStart(GtkIMContext* context) {
   if (context != gtk_context_)
     return;
 
   delegate_->OnPreeditStart();
 }
 
-// GtkCommitSignalTrap
-
-X11InputMethodContextImplGtk2::GtkCommitSignalTrap::GtkCommitSignalTrap()
-    : is_trap_enabled_(false),
-#if GTK_CHECK_VERSION (2,22,0)
-      gdk_event_key_keyval_(GDK_KEY_VoidSymbol),
-#else
-      gdk_event_key_keyval_(GDK_VoidSymbol),
-#endif
-      is_signal_caught_(false) {}
-
-void X11InputMethodContextImplGtk2::GtkCommitSignalTrap::StartTrap(
-    guint keyval) {
-  is_signal_caught_ = false;
-  gdk_event_key_keyval_ = keyval;
-  is_trap_enabled_ = true;
-}
-
-void X11InputMethodContextImplGtk2::GtkCommitSignalTrap::StopTrap() {
-  is_trap_enabled_ = false;
-}
-
-bool X11InputMethodContextImplGtk2::GtkCommitSignalTrap::Trap(
-    const base::string16& text) {
-  DCHECK(!is_signal_caught_);
-  if (is_trap_enabled_ &&
-      text.length() == 1 &&
-      text[0] == gdk_keyval_to_unicode(gdk_event_key_keyval_)) {
-    is_signal_caught_ = true;
-    return true;
-  } else {
-    return false;
-  }
-}
-
 }  // namespace libgtk2ui