Integrate the new input method API for Views into Chromium.

views/widget/widget_win.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_win.h"
 
 #include <dwmapi.h>
 
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_source.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/system_monitor/system_monitor.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/native_theme_win.h"
 #include "ui/gfx/path.h"
 #include "views/accessibility/native_view_accessibility_win.h"
 #include "views/controls/native_control_win.h"
+#include "views/controls/textfield/native_textfield_views.h"
 #include "views/focus/accelerator_handler.h"
 #include "views/focus/focus_util_win.h"
 #include "views/focus/view_storage.h"
+#include "views/ime/input_method_win.h"
 #include "views/views_delegate.h"
 #include "views/widget/aero_tooltip_manager.h"
 #include "views/widget/child_window_message_processor.h"
 #include "views/widget/drop_target_win.h"
 #include "views/widget/native_widget_delegate.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/window_win.h"
 
 #pragma comment(lib, "dwmapi.lib")
@@ skipping 99 matching lines @@
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       last_mouse_event_was_move_(false),
       is_mouse_down_(false),
       is_window_(false),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
-      previous_cursor_(NULL) {
+      previous_cursor_(NULL),
+      is_input_method_win_(false) {
   set_native_widget(this);
 }
 
 WidgetWin::~WidgetWin() {
+  // We need to delete the input method before calling DestroyRootView(),
+  // because it'll set focus_manager_ to NULL.
+  input_method_.reset();
   DestroyRootView();
 }
 
 void WidgetWin::SetCreateParams(const CreateParams& params) {
   // Set non-style attributes.
   set_delete_on_destroy(params.delete_on_destroy);
 
   DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
   DWORD ex_style = 0;
   DWORD class_style = CS_DBLCLKS;
@@ skipping 165 matching lines @@
 }
 
 void WidgetWin::ReleaseNativeCapture() {
   ReleaseCapture();
 }
 
 bool WidgetWin::HasNativeCapture() const {
   return GetCapture() == hwnd();
 }
 
+InputMethod* WidgetWin::GetInputMethodNative() {
+  return input_method_.get();
+}
+
+void WidgetWin::ReplaceInputMethod(InputMethod* input_method) {
+  input_method_.reset(input_method);
+  if (input_method) {
+    input_method->set_delegate(this);
+    input_method->Init(GetWidget());
+  }
+  is_input_method_win_ = false;
+}
+
 gfx::Rect WidgetWin::GetWindowScreenBounds() const {
   RECT r;
   GetWindowRect(&r);
   return gfx::Rect(r);
 }
 
 gfx::Rect WidgetWin::GetClientAreaScreenBounds() const {
   RECT r;
   GetClientRect(&r);
   POINT point = { r.left, r.top };
@@ skipping 30 matching lines @@
     // we don't destroy the window before the callback returned (as the caller
     // may delete ourselves on destroy and the ATL callback would still
     // dereference us when the callback returns).
     MessageLoop::current()->PostTask(FROM_HERE,
         close_widget_factory_.NewRunnableMethod(
             &WidgetWin::CloseNow));
   }
 }
 
 void WidgetWin::CloseNow() {
+  // Destroys the input method before closing the window so that it can be
+  // detached from the widget correctly.
+  input_method_.reset();
+  is_input_method_win_ = false;
+
   // We may already have been destroyed if the selection resulted in a tab
   // switch which will have reactivated the browser window and closed us, so
   // we need to check to see if we're still a window before trying to destroy
   // ourself.
   if (IsWindow())
     DestroyWindow(hwnd());
 }
 
 void WidgetWin::Show() {
   if (IsWindow())
@@ skipping 219 matching lines @@
   // Bug 964884: detach the IME attached to this window.
   // We should attach IMEs only when we need to input CJK strings.
   ImmAssociateContextEx(hwnd(), NULL, 0);
 
   // We need to allow the delegate to size its contents since the window may not
   // receive a size notification when its initial bounds are specified at window
   // creation time.
   ClientAreaSizeChanged();
 
   delegate_->OnNativeWidgetCreated();
+
+  // delegate_->OnNativeWidgetCreated() creates the focus manager for top-level
+  // widget. Only top-level widget should have an input method.
+  if (delegate_->HasFocusManager() &&
+      NativeTextfieldViews::IsTextfieldViewsEnabled()) {
+    input_method_.reset(new InputMethodWin(this));
+    input_method_->Init(GetWidget());
+    is_input_method_win_ = true;
+  }
   return 0;
 }
 
 void WidgetWin::OnDestroy() {
   if (drop_target_.get()) {
     RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 
   props_.reset();
@@ skipping 59 matching lines @@
 }
 
 void WidgetWin::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   SetMsgHandled(FALSE);
 }
 
 void WidgetWin::OnHScroll(int scroll_type, short position, HWND scrollbar) {
   SetMsgHandled(FALSE);
 }
 
+LRESULT WidgetWin::OnImeMessages(UINT message, WPARAM w_param, LPARAM l_param) {
+  if (!is_input_method_win_) {
+    SetMsgHandled(FALSE);
+    return 0;
+  }
+
+  InputMethodWin* ime = static_cast<InputMethodWin*>(input_method_.get());
+  BOOL handled = FALSE;
+  LRESULT result = 0;
+  switch (message) {
+    case WM_IME_SETCONTEXT:
+      result = ime->OnImeSetContext(message, w_param, l_param, &handled);
+      break;
+    case WM_IME_STARTCOMPOSITION:
+      result = ime->OnImeStartComposition(message, w_param, l_param, &handled);
+      break;
+    case WM_IME_COMPOSITION:
+      result = ime->OnImeComposition(message, w_param, l_param, &handled);
+      break;
+    case WM_IME_ENDCOMPOSITION:
+      result = ime->OnImeEndComposition(message, w_param, l_param, &handled);
+      break;
+    case WM_CHAR:
+    case WM_SYSCHAR:
+      result = ime->OnChar(message, w_param, l_param, &handled);
+      break;
+    case WM_DEADCHAR:
+    case WM_SYSDEADCHAR:
+      result = ime->OnDeadChar(message, w_param, l_param, &handled);
+      break;
+    default:
+      NOTREACHED() << "Unknown IME message:" << message;
+      break;
+  }
+
+  SetMsgHandled(handled);
+  return result;
+}
+
 void WidgetWin::OnInitMenu(HMENU menu) {
   SetMsgHandled(FALSE);
 }
 
 void WidgetWin::OnInitMenuPopup(HMENU menu,
                                 UINT position,
                                 BOOL is_system_menu) {
   SetMsgHandled(FALSE);
 }
 
+void WidgetWin::OnInputLangChange(DWORD character_set, HKL input_language_id) {
+  if (is_input_method_win_) {
+    static_cast<InputMethodWin*>(input_method_.get())->OnInputLangChange(
+        character_set, input_language_id);
+  }
+}
+
 LRESULT WidgetWin::OnKeyDown(UINT message, WPARAM w_param, LPARAM l_param) {
-  RootView* root_view = GetFocusedViewRootView();
-  if (!root_view)
-    root_view = GetRootView();
-
   MSG msg;
   MakeMSG(&msg, message, w_param, l_param);
-  SetMsgHandled(root_view->ProcessKeyEvent(KeyEvent(msg)));
+  KeyEvent key(msg);
+  if (input_method_.get())
+    input_method_->DispatchKeyEvent(key);
+  else
+    DispatchKeyEventPostIME(key);
   return 0;
 }
 
 LRESULT WidgetWin::OnKeyUp(UINT message, WPARAM w_param, LPARAM l_param) {
-  RootView* root_view = GetFocusedViewRootView();
-  if (!root_view)
-    root_view = GetRootView();
-
   MSG msg;
   MakeMSG(&msg, message, w_param, l_param);
-  SetMsgHandled(root_view->ProcessKeyEvent(KeyEvent(msg)));
+  KeyEvent key(msg);
+  if (input_method_.get())
+    input_method_->DispatchKeyEvent(key);
+  else
+    DispatchKeyEventPostIME(key);
   return 0;
 }
 
 void WidgetWin::OnKillFocus(HWND focused_window) {
   delegate_->OnNativeBlur(focused_window);
+  if (input_method_.get())
+    input_method_->OnFocusOut();
   SetMsgHandled(FALSE);
 }
 
 LRESULT WidgetWin::OnMouseActivate(UINT message,
                                    WPARAM w_param,
                                    LPARAM l_param) {
   if (GetWindowLong(GWL_EXSTYLE) & WS_EX_NOACTIVATE)
     return MA_NOACTIVATE;
   SetMsgHandled(FALSE);
   return MA_ACTIVATE;
@@ skipping 159 matching lines @@
 
 LRESULT WidgetWin::OnReflectedMessage(UINT msg,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnSetFocus(HWND focused_window) {
   delegate_->OnNativeFocus(focused_window);
+  if (input_method_.get())
+    input_method_->OnFocusIn();
   SetMsgHandled(FALSE);
 }
 
 LRESULT WidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT WidgetWin::OnSetText(const wchar_t* text) {
   SetMsgHandled(FALSE);
@@ skipping 262 matching lines @@
     layered_window_contents_.reset(
         new gfx::CanvasSkia(s.width(), s.height(), false));
   }
 }
 
 gfx::AcceleratedWidget WidgetWin::GetAcceleratedWidget() {
   // TODO(beng):
   return gfx::kNullAcceleratedWidget;
 }
 
+void WidgetWin::DispatchKeyEventPostIME(const KeyEvent& key) {
+  RootView* root_view = GetFocusedViewRootView();
+  if (!root_view)
+    root_view = GetRootView();
+
+  SetMsgHandled(root_view->ProcessKeyEvent(key));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 Widget* Widget::CreateWidget(const CreateParams& params) {
   WidgetWin* widget = new WidgetWin;
   widget->SetCreateParams(params);
   return widget;
 }
 
@@ skipping 74 matching lines @@
     return;
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   EnumChildWindows(native_view, EnumerateChildWindowsForNativeWidgets,
       reinterpret_cast<LPARAM>(children));
 }
 
 }  // namespace views