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>
 
 #include <set>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_gtk.h"
 #include "ui/base/gtk/gtk_windowing.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/path.h"
 #include "views/views_delegate.h"
+#include "views/controls/textfield/native_textfield_views.h"
 #include "views/focus/view_storage.h"
 #include "views/widget/drop_target_gtk.h"
 #include "views/widget/gtk_views_fixed.h"
 #include "views/widget/gtk_views_window.h"
 #include "views/widget/root_view.h"
 #include "views/widget/tooltip_manager_gtk.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/window_gtk.h"
 
 #if defined(TOUCH_UI)
@@ skipping 250 matching lines @@
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
     MessageLoopForUI* loop = MessageLoopForUI::current();
     if (loop)
       loop->AddObserver(DropObserver::GetInstance());
   }
 }
 
 WidgetGtk::~WidgetGtk() {
+  // We need to delete the input method before calling DestroyRootView(),
+  // because it'll set focus_manager_ to NULL.
+  input_method_.reset();
   DestroyRootView();
   DCHECK(delete_on_destroy_ || widget_ == NULL);
   if (type_ != TYPE_CHILD)
     ActiveWindowWatcherX::RemoveObserver(this);
 }
 
 void WidgetGtk::SetCreateParams(const CreateParams& params) {
   // Set non-style attributes.
   set_delete_on_destroy(params.delete_on_destroy);
 
@@ skipping 192 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.
+  // TODO(suzhe): Always enable input method when we start to use
+  // RenderWidgetHostViewViews in normal ChromeOS.
+#if !defined(TOUCH_UI)
+  if (type_ != TYPE_CHILD && NativeTextfieldViews::IsTextfieldViewsEnabled()) {
+#else
+  if (type_ != TYPE_CHILD) {
+#endif
+    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 129 matching lines @@
 
 void WidgetGtk::ClearNativeFocus() {
   DCHECK(type_ != TYPE_CHILD);
   if (!GetNativeView()) {
     NOTREACHED();
     return;
   }
   gtk_window_set_focus(GTK_WINDOW(GetNativeView()), NULL);
 }
 
-bool WidgetGtk::HandleKeyboardEvent(GdkEventKey* event) {
+bool WidgetGtk::HandleKeyboardEvent(const KeyEvent& key) {
   if (!GetFocusManager())
     return false;
 
-  KeyEvent key(reinterpret_cast<NativeEvent>(event));
-  int key_code = key.key_code();
+  const int key_code = key.key_code();
   bool handled = false;
 
   // 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 un-handled VKEY_MENU key press event.
-  if (key_code != ui::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+  if (key_code != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
     should_handle_menu_key_release_ = false;
 
-  if (event->type == GDK_KEY_PRESS) {
+  if (key.type() == ui::ET_KEY_PRESSED) {
     // VKEY_MENU is triggered by key release event.
     // FocusManager::OnKeyEvent() returns false when the key has been consumed.
     if (key_code != ui::VKEY_MENU)
       handled = !GetFocusManager()->OnKeyEvent(key);
     else
       should_handle_menu_key_release_ = true;
   } else if (key_code == ui::VKEY_MENU && should_handle_menu_key_release_ &&
              (key.flags() & ~ui::EF_ALT_DOWN) == 0) {
     // Trigger VKEY_MENU when only this key is pressed and released, and both
     // press and release events are not handled by others.
@@ skipping 63 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 70 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 291 matching lines @@
 gboolean WidgetGtk::OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
   if (has_focus_)
     return false;  // This is the second focus-in event in a row, ignore it.
   has_focus_ = true;
 
   should_handle_menu_key_release_ = false;
 
   if (type_ == TYPE_CHILD)
     return false;
 
+  // Only top-level Widget should have an InputMethod instance.
+  if (input_method_.get())
+    input_method_->OnFocusIn();
+
   // See description of got_initial_focus_in_ for details on this.
   if (!got_initial_focus_in_) {
     got_initial_focus_in_ = true;
     SetInitialFocus();
   } else {
     GetFocusManager()->RestoreFocusedView();
   }
   return false;
 }
 
 gboolean WidgetGtk::OnFocusOut(GtkWidget* widget, GdkEventFocus* event) {
   if (!has_focus_)
     return false;  // This is the second focus-out event in a row, ignore it.
   has_focus_ = false;
 
   if (type_ == TYPE_CHILD)
     return false;
 
+  // Only top-level Widget should have an InputMethod instance.
+  if (input_method_.get())
+    input_method_->OnFocusOut();
+
   // 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);
 
-  // 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);
+
+  if (key.key_code() == ui::VKEY_PROCESSKEY || handled)
+    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.
+  GdkEventKey* event = reinterpret_cast<GdkEventKey*>(key.native_event());
+  if (!handled && event && 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(key);
+
+  // Dispatch the key event for bindings processing.
+  if (!handled && event && GTK_IS_WINDOW(widget_))
+    gtk_bindings_activate_event(GTK_OBJECT(widget_), event);
+}
+
 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 332 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