Add input method support for views and integrate ibus input framework

chrome/browser/renderer_host/render_widget_host_view_views.cc

 // Copyright (c) 2010 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/renderer_host/render_widget_host_view_views.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/renderer_host/backing_store_x.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/common/native_web_keyboard_event.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas.h"
 #include "views/events/event.h"
+#include "views/ime/ime_context.h"
 #include "views/widget/widget.h"
 #include "views/widget/widget_gtk.h"
 
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
 static const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
 
+// Copied from third_party/WebKit/Source/WebCore/page/EventHandler.cpp
+//
+// Match key code of composition keydown event on windows.
+// IE sends VK_PROCESSKEY which has value 229;
+//
+// Please refer to following documents for detals:
+// - Virtual-Key Codes
+//   http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
+// - How the IME System Works
+//   http://msdn.microsoft.com/en-us/library/cc194848.aspx
+// - ImmGetVirtualKey Function
+//   http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
+static const int kCompositionEventKeyCode = 229;
+
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTouchEvent;
 
 const char RenderWidgetHostViewViews::kViewClassName[] =
     "browser/renderer_host/RenderWidgetHostViewViews";
 
 namespace {
 
 int WebInputEventFlagsFromViewsEvent(const views::Event& event) {
@@ skipping 60 matching lines @@
   wmevent->modifiers = WebInputEventFlagsFromViewsEvent(e);
 
   wmevent->windowX = wmevent->x = e.x();
   wmevent->windowY = wmevent->y = e.y();
   wmevent->globalX = wmevent->x + origin.x();
   wmevent->globalY = wmevent->y + origin.y();
 }
 
 }  // namespace
 
+class IMEContextHandler : public views::CommitTextListener,
+                          public views::CompositionListener,
+                          public views::ForwardKeyEventListener {
+ public:
+  explicit IMEContextHandler(
+      RenderWidgetHostViewViews* host_view)
+    : host_view_(host_view),
+      is_enabled_(false),
+      is_focused_(false),
+      ime_context_(views::IMEContext::Create(host_view_)) {
+    ime_context_->set_commit_text_listener(this);
+    ime_context_->set_composition_listener(this);
+    ime_context_->set_forward_key_event_listener(this);
+  }
+
+  // IMEContext Listeners implementation
+  virtual void OnCommitText(views::IMEContext* sender,
+                            const string16& text) {
+    DCHECK(ime_context_ == sender);
+
+    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+    if (host) {
+      SendFakeCompositionWebKeyboardEvent(WebKit::WebInputEvent::RawKeyDown);
+      host->ImeConfirmComposition(text);
+      SendFakeCompositionWebKeyboardEvent(WebKit::WebInputEvent::KeyUp);
+    }
+  }
+
+  virtual void OnStartComposition(views::IMEContext* sender) {
+    DCHECK(ime_context_ == sender);
+  }
+
+  virtual void OnEndComposition(views::IMEContext* sender) {
+    DCHECK(ime_context_ == sender);
+
+    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+    if (host)
+      host->ImeCancelComposition();
+  }
+
+  virtual void OnSetComposition(views::IMEContext* sender,
+      const string16& text,
+      const views::CompositionAttributeList& attributes,
+      uint32 cursor_pos) {
+    DCHECK(ime_context_ == sender);
+
+    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+    if (host) {
+      SendFakeCompositionWebKeyboardEvent(WebKit::WebInputEvent::RawKeyDown);
+
+      // Cast CompositonAttribute to WebKit::WebCompositionUnderline directly,
+      // becasue CompositionAttribute is duplicated from
+      // WebKit::WebCompositionUnderline.
+      const std::vector<WebKit::WebCompositionUnderline>& underlines =
+          reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+              attributes);
+      host->ImeSetComposition(text, underlines, cursor_pos, cursor_pos);
+      SendFakeCompositionWebKeyboardEvent(WebKit::WebInputEvent::KeyUp);
+    }
+  }
+
+  virtual void OnForwardKeyEvent(views::IMEContext* sender,
+                                 const views::KeyEvent& event) {
+    DCHECK(ime_context_ == sender);
+
+    host_view_->ForwardKeyEvent(event);
+  }
+
+  bool FilterKeyEvent(const views::KeyEvent& event) {
+    return is_enabled_ && ime_context_->FilterKeyEvent(event);
+  }
+
+  void Focus() {
+    if (!is_focused_) {
+      ime_context_->Focus();
+      is_focused_ = true;
+    }
+
+    // Enables RenderWidget's IME related events, so that we can be notified
+    // when WebKit wants to enable or disable IME.
+    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+    if (host)
+      host->SetInputMethodActive(true);
+  }
+
+  void Blur() {
+    if (is_focused_) {
+      ime_context_->Blur();
+      is_focused_ = false;
+    }
+
+    // Disable RenderWidget's IME related events to save bandwidth.
+    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+    if (host)
+      host->SetInputMethodActive(false);
+  }
+
+  void ImeUpdateTextInputState(WebKit::WebTextInputType type,
+                               const gfx::Rect& caret_rect) {
+    bool enable =
+        (type != WebKit::WebTextInputTypeNone) &&
+        (type != WebKit::WebTextInputTypePassword);
+
+    if (is_enabled_ != enable) {
+      is_enabled_ = enable;
+      if (is_focused_) {
+        if (is_enabled_)
+          ime_context_->Focus();
+        else
+          ime_context_->Blur();
+      }
+    }
+
+    if (is_enabled_) {
+      gfx::Point p(caret_rect.origin());
+      views::View::ConvertPointToScreen(host_view_, &p);
+
+      ime_context_->SetCursorLocation(gfx::Rect(p, caret_rect.size()));
+    }
+  }
+
+  void Reset() {
+    ime_context_->Reset();
+  }
+
+ private:
+  void SendFakeCompositionWebKeyboardEvent(WebKit::WebInputEvent::Type type) {
+    NativeWebKeyboardEvent fake_event;
+    fake_event.windowsKeyCode = kCompositionEventKeyCode;
+    fake_event.skip_in_browser = true;
+    fake_event.type = type;
+    host_view_->ForwardWebKeyboardEvent(fake_event);
+  }
+
+ private:
+  RenderWidgetHostViewViews* host_view_;
+  bool is_enabled_;
+  bool is_focused_;
+  scoped_ptr<views::IMEContext> ime_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(IMEContextHandler);
+};
+
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewViews(widget);
 }
 
 RenderWidgetHostViewViews::RenderWidgetHostViewViews(RenderWidgetHost* host)
     : host_(host),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       native_cursor_(NULL),
       is_showing_context_menu_(false),
       visually_deemphasized_(false),
       touch_event_() {
   SetFocusable(true);
   host_->set_view(this);
 }
 
 RenderWidgetHostViewViews::~RenderWidgetHostViewViews() {
 }
 
 void RenderWidgetHostViewViews::InitAsChild() {
   Show();
+  ime_context_.reset(new IMEContextHandler(this));
 }
 
 RenderWidgetHost* RenderWidgetHostViewViews::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewViews::InitAsPopup(
     RenderWidgetHostView* parent_host_view,
     const gfx::Rect& pos) {
   // TODO(anicolao): figure out cases where popups occur and implement
@@ skipping 92 matching lines @@
 void RenderWidgetHostViewViews::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
   // Only call ShowCurrentCursor() when it will actually change the cursor.
   if (current_cursor_.GetCursorType() == GDK_LAST_CURSOR)
     ShowCurrentCursor();
 }
 
 void RenderWidgetHostViewViews::ImeUpdateTextInputState(
     WebKit::WebTextInputType type,
     const gfx::Rect& caret_rect) {
-  // TODO(bryeung): im_context_->UpdateInputMethodState(type, caret_rect);
-  NOTIMPLEMENTED();
+  ime_context_->ImeUpdateTextInputState(type, caret_rect);
 }
 
 void RenderWidgetHostViewViews::ImeCancelComposition() {
-  // TODO(bryeung): im_context_->CancelComposition();
-  NOTIMPLEMENTED();
+  ime_context_->Reset();
 }
 
 void RenderWidgetHostViewViews::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
     const std::vector<gfx::Rect>& copy_rects) {
   if (is_hidden_)
     return;
 
   // TODO(darin): Implement the equivalent of Win32's ScrollWindowEX.  Can that
   // be done using XCopyArea?  Perhaps similar to
@@ skipping 233 matching lines @@
   wmwe.button = WebKit::WebMouseEvent::ButtonNone;
 
   // TODO(sadrul): How do we determine if it's a horizontal scroll?
   wmwe.deltaY = e.offset();
   wmwe.wheelTicksY = wmwe.deltaY > 0 ? 1 : -1;
 
   GetRenderWidgetHost()->ForwardWheelEvent(wmwe);
   return true;
 }
 
-bool RenderWidgetHostViewViews::OnKeyPressed(const views::KeyEvent &e) {
-  // Send key event to input method.
-  // TODO host_view->im_context_->ProcessKeyEvent(event);
-
-  // This is how it works:
-  // (1) If a RawKeyDown event is an accelerator for a reserved command (see
-  //     Browser::IsReservedCommand), then the command is executed. Otherwise,
-  //     the event is first sent off to the renderer. The renderer is also
-  //     notified whether the event would trigger an accelerator in the browser.
-  // (2) A Char event is then sent to the renderer.
-  // (3) If the renderer does not process the event in step (1), and the event
-  //     triggers an accelerator, then it will ignore the event in step (2). The
-  //     renderer also sends back notification to the browser for both steps (1)
-  //     and (2) about whether the events were processed or not. If the event
-  //     for (1) is not processed by the renderer, then it is processed by the
-  //     browser, and (2) is ignored.
-
-  NativeWebKeyboardEvent wke;
-  wke.type = WebKit::WebInputEvent::RawKeyDown;
-  wke.windowsKeyCode = e.key_code();
-  wke.setKeyIdentifierFromWindowsKeyCode();
-
-  wke.text[0] = wke.unmodifiedText[0] =
-    static_cast<unsigned short>(gdk_keyval_to_unicode(
-          ui::GdkKeyCodeForWindowsKeyCode(e.key_code(),
-              e.IsShiftDown() ^ e.IsCapsLockDown())));
-
-  wke.modifiers = WebInputEventFlagsFromViewsEvent(e);
-  ForwardKeyboardEvent(wke);
-
-  // send the keypress event
-  wke.type = WebKit::WebInputEvent::Char;
-  ForwardKeyboardEvent(wke);
-
+bool RenderWidgetHostViewViews::OnKeyPressed(const views::KeyEvent& e) {
+  if (!ime_context_->FilterKeyEvent(e))
+    ForwardKeyEvent(e);
   return TRUE;
 }
 
-bool RenderWidgetHostViewViews::OnKeyReleased(const views::KeyEvent &e) {
-  // TODO(bryeung): deal with input methods
-  NativeWebKeyboardEvent wke;
-
-  wke.type = WebKit::WebInputEvent::KeyUp;
-  wke.windowsKeyCode = e.key_code();
-  wke.setKeyIdentifierFromWindowsKeyCode();
-
-  ForwardKeyboardEvent(wke);
-
+bool RenderWidgetHostViewViews::OnKeyReleased(const views::KeyEvent& e) {
+  if (!ime_context_->FilterKeyEvent(e))
+    ForwardKeyEvent(e);
   return TRUE;
 }
 
 void RenderWidgetHostViewViews::DidGainFocus() {
 #if 0
   // TODO(anicolao): - is this needed/replicable?
   // Comes from the GTK equivalent.
 
   int x, y;
   gtk_widget_get_pointer(native_view(), &x, &y);
   // http://crbug.com/13389
   // If the cursor is in the render view, fake a mouse move event so that
   // webkit updates its state. Otherwise webkit might think the cursor is
   // somewhere it's not.
   if (x >= 0 && y >= 0 && x < native_view()->allocation.width &&
       y < native_view()->allocation.height) {
     WebKit::WebMouseEvent fake_event;
     fake_event.timeStampSeconds = base::Time::Now().ToDoubleT();
     fake_event.modifiers = 0;
     fake_event.windowX = fake_event.x = x;
     fake_event.windowY = fake_event.y = y;
     gdk_window_get_origin(native_view()->window, &x, &y);
     fake_event.globalX = fake_event.x + x;
     fake_event.globalY = fake_event.y + y;
     fake_event.type = WebKit::WebInputEvent::MouseMove;
     fake_event.button = WebKit::WebMouseEvent::ButtonNone;
     GetRenderWidgetHost()->ForwardMouseEvent(fake_event);
   }
 #endif
-
+  ime_context_->Focus();
   ShowCurrentCursor();
   GetRenderWidgetHost()->GotFocus();
 }
 
 void RenderWidgetHostViewViews::WillLoseFocus() {
   // If we are showing a context menu, maintain the illusion that webkit has
   // focus.
   if (!is_showing_context_menu_ && !is_hidden_)
     GetRenderWidgetHost()->Blur();
+  ime_context_->Blur();
 }
 
 
 void RenderWidgetHostViewViews::ShowCurrentCursor() {
   // The widget may not have a window. If that's the case, abort mission. This
   // is the same issue as that explained above in Paint().
   if (!GetInnerNativeView() || !GetInnerNativeView()->window)
     return;
 
   native_cursor_ = current_cursor_.GetNativeCursor();
@@ skipping 45 matching lines @@
     wmevent.button = WebKit::WebMouseEvent::ButtonRight;
   }
   if (event.IsLeftMouseButton()) {
     wmevent.modifiers |= WebKit::WebInputEvent::LeftButtonDown;
     wmevent.button = WebKit::WebMouseEvent::ButtonLeft;
   }
 
   return wmevent;
 }
 
-void RenderWidgetHostViewViews::ForwardKeyboardEvent(
+void RenderWidgetHostViewViews::ForwardKeyEvent(
+    const views::KeyEvent& event) {
+  // This is how it works:
+  // (1) If a RawKeyDown event is an accelerator for a reserved command (see
+  //     Browser::IsReservedCommand), then the command is executed. Otherwise,
+  //     the event is first sent off to the renderer. The renderer is also
+  //     notified whether the event would trigger an accelerator in the browser.
+  // (2) A Char event is then sent to the renderer.
+  // (3) If the renderer does not process the event in step (1), and the event
+  //     triggers an accelerator, then it will ignore the event in step (2). The
+  //     renderer also sends back notification to the browser for both steps (1)
+  //     and (2) about whether the events were processed or not. If the event
+  //     for (1) is not processed by the renderer, then it is processed by the
+  //     browser, and (2) is ignored.
+  if (event.type() == ui::ET_KEY_PRESSED) {
+    NativeWebKeyboardEvent wke;
+
+    wke.type = WebKit::WebInputEvent::RawKeyDown;
+    wke.windowsKeyCode = event.key_code();
+    wke.setKeyIdentifierFromWindowsKeyCode();
+
+    int keyval = ui::GdkKeyCodeForWindowsKeyCode(event.key_code(),
+        event.IsShiftDown() ^ event.IsCapsLockDown());
+
+    wke.text[0] = wke.unmodifiedText[0] =
+        static_cast<unsigned short>(gdk_keyval_to_unicode(keyval));
+
+    wke.modifiers = WebInputEventFlagsFromViewsEvent(event);
+
+    ForwardWebKeyboardEvent(wke);
+
+    wke.type = WebKit::WebInputEvent::Char;
+    ForwardWebKeyboardEvent(wke);
+  } else {
+    NativeWebKeyboardEvent wke;
+
+    wke.type = WebKit::WebInputEvent::KeyUp;
+    wke.windowsKeyCode = event.key_code();
+    wke.setKeyIdentifierFromWindowsKeyCode();
+    ForwardWebKeyboardEvent(wke);
+  }
+}
+
+void RenderWidgetHostViewViews::ForwardWebKeyboardEvent(
     const NativeWebKeyboardEvent& event) {
   if (!host_)
     return;
 
   EditCommands edit_commands;
 #if 0
-TODO(bryeung): key bindings
+  // TODO(bryeung): key bindings
   if (!event.skip_in_browser &&
       key_bindings_handler_->Match(event, &edit_commands)) {
     host_->ForwardEditCommandsForNextKeyEvent(edit_commands);
   }
 #endif
+
   host_->ForwardKeyboardEvent(event);
 }
 
 views::View::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
     const views::TouchEvent& e) {
   // Update the list of touch points first.
   WebKit::WebTouchPoint* point = NULL;
   TouchStatus status = TOUCH_STATUS_UNKNOWN;
 
   switch (e.type()) {
@@ skipping 89 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }