Integrate the new input method API for Views into Chromium.

views/widget/widget_gtk.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 "views/widget/widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 
@@ skipping 476 matching lines @@
 void WidgetGtk::Init(GtkWidget* parent,
                      const gfx::Rect& bounds) {
   Widget::Init(parent, bounds);
   if (type_ != TYPE_CHILD)
     ActiveWindowWatcherX::AddObserver(this);
 
   // Make container here.
   CreateGtkWidget(parent, bounds);
   delegate_->OnNativeWidgetCreated();
 
+  // Creates input method for toplevel widget after calling
+  // delegate_->OnNativeWidgetCreated(), to make sure that focus manager is
+  // already created at this point.
+  if (type_ != TYPE_CHILD) {
+    input_method_.reset(new InputMethodGtk(this));
+    input_method_->Init(GetWidget());
+  }
+
   if (opacity_ != 255)
     SetOpacity(opacity_);
 
   // Make sure we receive our motion events.
 
   // In general we register most events on the parent of all widgets. At a
   // minimum we need painting to happen on the parent (otherwise painting
   // doesn't work at all), and similarly we need mouse release events on the
   // parent as windows don't get mouse releases.
   gtk_widget_add_events(window_contents_,
@@ skipping 44 matching lines @@
                    G_CALLBACK(&OnShowThunk), this);
   g_signal_connect(widget_, "map",
                    G_CALLBACK(&OnMapThunk), this);
   g_signal_connect(widget_, "hide",
                    G_CALLBACK(&OnHideThunk), this);
 
   // Views/FocusManager (re)sets the focus to the root window,
   // so we need to connect signal handlers to the gtk window.
   // See views::Views::Focus and views::FocusManager::ClearNativeFocus
   // for more details.
-  g_signal_connect(widget_, "key_press_event",
-                   G_CALLBACK(&OnKeyEventThunk), this);
-  g_signal_connect(widget_, "key_release_event",
-                   G_CALLBACK(&OnKeyEventThunk), this);
+  // Child Widget should never get keyboard focus.
+  if (type_ != TYPE_CHILD) {
+    g_signal_connect(widget_, "key_press_event",
+                     G_CALLBACK(&OnKeyEventThunk), this);
+    g_signal_connect(widget_, "key_release_event",
+                     G_CALLBACK(&OnKeyEventThunk), this);
+  }
 
   // Drag and drop.
   gtk_drag_dest_set(window_contents_, static_cast<GtkDestDefaults>(0),
                     NULL, 0, GDK_ACTION_COPY);
   g_signal_connect(window_contents_, "drag_motion",
                    G_CALLBACK(&OnDragMotionThunk), this);
   g_signal_connect(window_contents_, "drag_data_received",
                    G_CALLBACK(&OnDragDataReceivedThunk), this);
   g_signal_connect(window_contents_, "drag_drop",
                    G_CALLBACK(&OnDragDropThunk), this);
@@ skipping 160 matching lines @@
   if (HasNativeCapture())
     gtk_grab_remove(window_contents_);
 }
 
 bool WidgetGtk::HasNativeCapture() const {
   // TODO(beng): Should be able to use gtk_widget_has_grab() here but the
   //             trybots don't have Gtk 2.18.
   return GTK_WIDGET_HAS_GRAB(window_contents_);
 }
 
+InputMethod* WidgetGtk::GetInputMethodNative() {
+  return input_method_.get();
+}
+
+void WidgetGtk::ReplaceInputMethod(InputMethod* input_method) {
+  input_method_.reset(input_method);
+  if (input_method) {
+    input_method->set_delegate(this);
+    input_method->Init(GetWidget());
+  }
+}
+
 gfx::Rect WidgetGtk::GetWindowScreenBounds() const {
   // Client == Window bounds on Gtk.
   return GetClientAreaScreenBounds();
 }
 
 gfx::Rect WidgetGtk::GetClientAreaScreenBounds() const {
   // Due to timing we can get a request for bounds after Close().
   // TODO(beng): Figure out if this is bogus.
   if (!widget_)
     return gfx::Rect(size_);
@@ skipping 75 matching lines @@
   if (close_widget_factory_.empty()) {
     // And we delay the close just in case we're on the stack.
     MessageLoop::current()->PostTask(FROM_HERE,
         close_widget_factory_.NewRunnableMethod(
             &WidgetGtk::CloseNow));
   }
 }
 
 void WidgetGtk::CloseNow() {
   if (widget_) {
+    input_method_.reset();
     gtk_widget_destroy(widget_);  // Triggers OnDestroy().
   }
 }
 
 void WidgetGtk::Show() {
   if (widget_) {
     gtk_widget_show(widget_);
     if (widget_->window)
       gdk_window_raise(widget_->window);
   }
@@ skipping 315 matching lines @@
   if (type_ == TYPE_CHILD)
     return false;
 
   // The top-level window lost focus, store the focused view.
   GetFocusManager()->StoreFocusedView();
   return false;
 }
 
 gboolean WidgetGtk::OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
   KeyEvent key(reinterpret_cast<NativeEvent>(event));
+  if (input_method_.get())
+    input_method_->DispatchKeyEvent(key);
+  else
+    DispatchKeyEventPostIME(key);

[sadrul, 2011/03/21 19:57:45]

return DispatchKeyEventPostIME(key);

[James Su, 2011/03/21 21:34:07]

It's intentionally to always return true to prevent GtkWindow's default key
event handler.

And child Widget will never get keyboard focus, thus this method will never be
called for child Widget.

It's probably necessary to add a DCHECK() here to enforce it.

 
-  // Always reset |should_handle_menu_key_release_| unless we are handling a
-  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
-  // be activated when handling a VKEY_MENU key release event which is preceded
-  // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
-  if (key.key_code() != ui::VKEY_MENU || event->type != GDK_KEY_RELEASE)
-    should_handle_menu_key_release_ = false;
-
-  bool handled = false;
-
-  // Dispatch the key event to View hierarchy first.
-  handled = GetRootView()->ProcessKeyEvent(key);
-
-  // Dispatch the key event to native GtkWidget hierarchy.
-  // To prevent GtkWindow from handling the key event as a keybinding, we need
-  // to bypass GtkWindow's default key event handler and dispatch the event
-  // here.
-  if (!handled && GTK_IS_WINDOW(widget))
-    handled = gtk_window_propagate_key_event(GTK_WINDOW(widget), event);
-
-  // On Linux, in order to handle VKEY_MENU (Alt) accelerator key correctly and
-  // avoid issues like: http://crbug.com/40966 and http://crbug.com/49701, we
-  // should only send the key event to the focus manager if it's not handled by
-  // any View or native GtkWidget.
-  // The flow is different when the focus is in a RenderWidgetHostViewGtk, which
-  // always consumes the key event and send it back to us later by calling
-  // HandleKeyboardEvent() directly, if it's not handled by webkit.
-  if (!handled)
-    handled = HandleKeyboardEvent(event);
-
-  // Dispatch the key event for bindings processing.
-  if (!handled && GTK_IS_WINDOW(widget))
-    handled = gtk_bindings_activate_event(GTK_OBJECT(widget), event);
-
-  // Always return true for toplevel window to prevents GtkWindow's default key
-  // event handler.
-  return GTK_IS_WINDOW(widget) ? true : handled;
+  // Returns true to prevent GtkWindow's default key event handler.
+  return true;
 }
 
 gboolean WidgetGtk::OnQueryTooltip(GtkWidget* widget,
                                    gint x,
                                    gint y,
                                    gboolean keyboard_mode,
                                    GtkTooltip* tooltip) {
   return tooltip_manager_->ShowTooltip(x, y, keyboard_mode, tooltip);
 }
 
@@ skipping 59 matching lines @@
 
 RootView* WidgetGtk::CreateRootView() {
   return new RootView(this);
 }
 
 gfx::AcceleratedWidget WidgetGtk::GetAcceleratedWidget() {
   DCHECK(window_contents_ && window_contents_->window);
   return GDK_WINDOW_XID(window_contents_->window);
 }
 
+void WidgetGtk::DispatchKeyEventPostIME(const KeyEvent& key) {
+  // Always reset |should_handle_menu_key_release_| unless we are handling a
+  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
+  // be activated when handling a VKEY_MENU key release event which is preceded
+  // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
+  if (key.key_code() != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
+    should_handle_menu_key_release_ = false;
+
+  bool handled = false;
+
+  // Dispatch the key event to View hierarchy first.
+  handled = GetRootView()->ProcessKeyEvent(key);
+
+  GdkEventKey* event = reinterpret_cast<GdkEventKey*>(key.native_event());
+  if (key.key_code() == ui::VKEY_PROCESSKEY || handled || !event)
+    return;
+
+  // Dispatch the key event to native GtkWidget hierarchy.
+  // To prevent GtkWindow from handling the key event as a keybinding, we need
+  // to bypass GtkWindow's default key event handler and dispatch the event
+  // here.
+  if (!handled && GTK_IS_WINDOW(widget_))
+    handled = gtk_window_propagate_key_event(GTK_WINDOW(widget_), event);
+
+  // On Linux, in order to handle VKEY_MENU (Alt) accelerator key correctly and
+  // avoid issues like: http://crbug.com/40966 and http://crbug.com/49701, we
+  // should only send the key event to the focus manager if it's not handled by
+  // any View or native GtkWidget.
+  // The flow is different when the focus is in a RenderWidgetHostViewGtk, which
+  // always consumes the key event and send it back to us later by calling
+  // HandleKeyboardEvent() directly, if it's not handled by webkit.
+  if (!handled)
+    handled = HandleKeyboardEvent(event);
+
+  // Dispatch the key event for bindings processing.
+  if (!handled && GTK_IS_WINDOW(widget_))
+    handled = gtk_bindings_activate_event(GTK_OBJECT(widget_), event);
+}

[sadrul, 2011/03/21 19:57:45]

return GTK_IS_WINDOW(widget) ? true : handled;

[James Su, 2011/03/21 21:34:07]

See my comment in OnKeyEvent().

+
 gboolean WidgetGtk::OnWindowPaint(GtkWidget* widget, GdkEventExpose* event) {
   // Clear the background to be totally transparent. We don't need to
   // paint the root view here as that is done by OnPaint.
   DCHECK(transparent_);
   DrawTransparentBackground(widget, event);
   return false;
 }
 
 bool WidgetGtk::ProcessMousePressed(GdkEventButton* event) {
   if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) {
@@ skipping 313 matching lines @@
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   gtk_container_foreach(GTK_CONTAINER(native_view),
                         EnumerateChildWidgetsForNativeWidgets,
                         reinterpret_cast<gpointer>(children));
 }
 
 }  // namespace views