Support TSF related event handling on NativeTextField

ui/views/controls/textfield/native_textfield_win.cc

 // Copyright (c) 2012 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 "ui/views/controls/textfield/native_textfield_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/windows_version.h"
 #include "grit/ui_strings.h"
 #include "skia/ext/skia_utils_win.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/events/event.h"
 #include "ui/base/keycodes/keyboard_codes.h"
+#include "ui/base/ime/win/tsf_bridge.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/native_theme/native_theme_win.h"
 #include "ui/base/range/range.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/native/native_view_host.h"
@@ skipping 56 matching lines @@
 NativeTextfieldWin::NativeTextfieldWin(Textfield* textfield)
     : textfield_(textfield),
       tracking_double_click_(false),
       double_click_time_(0),
       can_discard_mousemove_(false),
       contains_mouse_(false),
       ime_discard_composition_(false),
       ime_composition_start_(0),
       ime_composition_length_(0),
       container_view_(new NativeViewHost),
-      bg_color_(0) {
+      bg_color_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          tsf_event_router_(base::win::IsTsfAwareRequired() ?
+              new ui::TsfEventRouter(this) : NULL)) {
   if (!loaded_libarary_module_) {
     // msftedit.dll is RichEdit ver 4.1.
     // This version is available from WinXP SP1 and has TSF support.
     loaded_libarary_module_ = LoadLibrary(L"msftedit.dll");
   }
 
   DWORD style = kDefaultEditStyle | ES_AUTOHSCROLL;
   if (textfield_->style() & Textfield::STYLE_OBSCURED)
     style |= ES_PASSWORD;
 
@@ skipping 228 matching lines @@
 }
 
 gfx::NativeView NativeTextfieldWin::GetTestingHandle() const {
   return m_hWnd;
 }
 
 bool NativeTextfieldWin::IsIMEComposing() const {
   // Retrieve the length of the composition string to check if an IME is
   // composing text. (If this length is > 0 then an IME is being used to compose
   // text.)
+  if (base::win::IsTsfAwareRequired())
+    return tsf_event_router_->IsImeComposing();
+
   HIMC imm_context = ImmGetContext(m_hWnd);
   if (!imm_context)
     return false;
 
   const int composition_size = ImmGetCompositionString(imm_context, GCS_COMPSTR,
                                                        NULL, 0);
   ImmReleaseContext(m_hWnd, imm_context);
   return composition_size > 0;
 }
 
 void NativeTextfieldWin::GetSelectedRange(ui::Range* range) const {
   // TODO(tommi): Implement.
-  NOTIMPLEMENTED();
+  //NOTIMPLEMENTED();

[Peter Kasting, 2012/10/27 22:29:50]

This shouldn't be checked in.  Either remove both comments and implement
properly or leave this alone.

[Seigo Nonaka, 2012/10/28 01:50:44]

Opps, sorry reverted.
On 2012/10/27 22:29:50, Peter Kasting wrote:

   range->set_start(0);
   range->set_end(0);
 }
 
 void NativeTextfieldWin::SelectRange(const ui::Range& range) {
   // TODO(tommi): Implement.
   NOTIMPLEMENTED();
 }
 
 void NativeTextfieldWin::GetSelectionModel(gfx::SelectionModel* sel) const {
@@ skipping 91 matching lines @@
     case IDS_APP_UNDO:       Undo();           break;
     case IDS_APP_CUT:        Cut();            break;
     case IDS_APP_COPY:       Copy();           break;
     case IDS_APP_PASTE:      Paste();          break;
     case IDS_APP_SELECT_ALL: SelectAll(false); break;
     default:                 NOTREACHED();     break;
   }
   OnAfterPossibleChange(true);
 }
 
+void NativeTextfieldWin::OnTextUpdated(const ui::Range& composition_range) {
+  if (ime_discard_composition_) {
+    ime_composition_start_ = composition_range.start();
+    ime_composition_length_ = composition_range.length();
+  } else {
+    ime_composition_start_ = 0;
+    ime_composition_length_ = 0;
+  }
+  OnAfterPossibleChange(false);
+  text_before_change_.clear();
+}
+
+void NativeTextfieldWin::OnCandidateWindowCountChanged(size_t window_count) {
+}
+
+void NativeTextfieldWin::OnImeStartCompositionInternal() {
+  // Users may press alt+shift or control+shift keys to change their keyboard
+  // layouts. So, we retrieve the input locale identifier everytime we start
+  // an IME composition.
+  int language_id = PRIMARYLANGID(GetKeyboardLayout(0));
+  ime_discard_composition_ =
+      language_id == LANG_JAPANESE || language_id == LANG_CHINESE;
+  ime_composition_start_ = 0;
+  ime_composition_length_ = 0;
+}
+
+void NativeTextfieldWin::OnImeEndCompositionInternal() {
+  // Bug 11863: Korean IMEs send a WM_IME_ENDCOMPOSITION message without
+  // sending any WM_IME_COMPOSITION messages when a user deletes all
+  // composition characters, i.e. a composition string becomes empty. To handle
+  // this case, we need to update the find results when a composition is
+  // finished or canceled.
+  textfield_->SyncText();
+}
+
+void NativeTextfieldWin::OnTsfStartComposition() {
+  OnImeStartCompositionInternal();
+}
+
+void NativeTextfieldWin::OnTsfEndComposition() {
+  OnImeEndCompositionInternal();
+}
+
 void NativeTextfieldWin::InitializeAccessibilityInfo() {
   // Set the accessible state.
   accessibility_state_ = 0;
 
   base::win::ScopedComPtr<IAccPropServices> pAccPropServices;
   HRESULT hr = CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER,
       IID_IAccPropServices, reinterpret_cast<void**>(&pAccPropServices));
   if (!SUCCEEDED(hr))
     return;
 
@@ skipping 88 matching lines @@
         ui::Clipboard::GetForCurrentThread(),
         ui::Clipboard::BUFFER_STANDARD);
     scw.WriteText(text);
   }
 }
 
 LRESULT NativeTextfieldWin::OnCreate(const CREATESTRUCTW* /*create_struct*/) {
   if (base::win::IsTsfAwareRequired()) {
     // Enable TSF support of RichEdit.
     SetEditStyle(SES_USECTF, SES_USECTF);
+
+    // When TSF is enabled, OnTextUpdated() may be called without any previous
+    // call that would have indicated the start of an editing session.  In order
+    // to guarantee we've always called OnBeforePossibleChange() before
+    // OnAfterPossibleChange(), we therefore call that here.  Note that multiple
+    // (i.e. unmatched) calls to this function in a row are safe.
+    OnBeforePossibleChange();
   }
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void NativeTextfieldWin::OnCut() {
   if (textfield_->read_only() || textfield_->IsObscured())
     return;
 
   OnCopy();
@@ skipping 21 matching lines @@
   // WM_IME_CHAR message while it is processing a WM_IME_COMPOSITION message.
   // Since view controls don't need WM_IME_CHAR messages, we prevent WM_IME_CHAR
   // messages from being dispatched to view controls via the CallWindowProc()
   // call.
   return 0;
 }
 
 LRESULT NativeTextfieldWin::OnImeStartComposition(UINT message,
                                                   WPARAM wparam,
                                                   LPARAM lparam) {
-  // Users may press alt+shift or control+shift keys to change their keyboard
-  // layouts. So, we retrieve the input locale identifier everytime we start
-  // an IME composition.
-  int language_id = PRIMARYLANGID(GetKeyboardLayout(0));
-  ime_discard_composition_ =
-      language_id == LANG_JAPANESE || language_id == LANG_CHINESE;
-  ime_composition_start_ = 0;
-  ime_composition_length_ = 0;
-
+  OnImeStartCompositionInternal();
   return DefWindowProc(message, wparam, lparam);
 }
 
 LRESULT NativeTextfieldWin::OnImeComposition(UINT message,
                                              WPARAM wparam,
                                              LPARAM lparam) {
   text_before_change_.clear();
   LRESULT result = DefWindowProc(message, wparam, lparam);
 
   ime_composition_start_ = 0;
@@ skipping 26 matching lines @@
   // setting the edit's text directly, which can cancel the current IME
   // composition or cause other adverse affects. So we set |should_redraw_text|
   // to false.
   OnAfterPossibleChange(false);
   return result;
 }
 
 LRESULT NativeTextfieldWin::OnImeEndComposition(UINT message,
                                                 WPARAM wparam,
                                                 LPARAM lparam) {
-  // Bug 11863: Korean IMEs send a WM_IME_ENDCOMPOSITION message without
-  // sending any WM_IME_COMPOSITION messages when a user deletes all
-  // composition characters, i.e. a composition string becomes empty. To handle
-  // this case, we need to update the find results when a composition is
-  // finished or canceled.
-  textfield_->SyncText();
+  OnImeEndCompositionInternal();
   return DefWindowProc(message, wparam, lparam);
 }
 
 LRESULT NativeTextfieldWin::OnPointerDown(UINT message, WPARAM wparam,
                                           LPARAM lparam) {
   SetFocus();
   SetMsgHandled(FALSE);
   return 0;
 }
 
@@ skipping 313 matching lines @@
 
 void NativeTextfieldWin::OnSetFocus(HWND hwnd) {
   SetMsgHandled(FALSE);  // We still want the default processing of the message.
 
   views::FocusManager* focus_manager = textfield_->GetFocusManager();
   if (!focus_manager) {
     NOTREACHED();
     return;
   }
   focus_manager->SetFocusedView(textfield_);
+
+  if (!base::win::IsTsfAwareRequired()) {
+    return;
+  }
+
+  DefWindowProc();
+
+  // Document manager created by RichEdit can be obtained only after
+  // WM_SET_FOCUS event is handled.
+  tsf_event_router_->SetManager(
+      ui::TsfBridge::GetInstance()->GetThreadManager());
+  SetMsgHandled(TRUE);
+}
+
+void NativeTextfieldWin::OnKillFocus(HWND hwnd) {
+  if(tsf_event_router_)
+    tsf_event_router_->SetManager(NULL);
 }
 
 void NativeTextfieldWin::OnSysChar(TCHAR ch, UINT repeat_count, UINT flags) {
   // Nearly all alt-<xxx> combos result in beeping rather than doing something
   // useful, so we discard most.  Exceptions:
   //   * ctrl-alt-<xxx>, which is sometimes important, generates WM_CHAR instead
   //     of WM_SYSCHAR, so it doesn't need to be handled here.
   //   * alt-space gets translated by the default WM_SYSCHAR handler to a
   //     WM_SYSCOMMAND to open the application context menu, so we need to allow
   //     it through.
@@ skipping 192 matching lines @@
   context_menu_contents_->AddSeparator(ui::NORMAL_SEPARATOR);
   context_menu_contents_->AddItemWithStringId(IDS_APP_CUT, IDS_APP_CUT);
   context_menu_contents_->AddItemWithStringId(IDS_APP_COPY, IDS_APP_COPY);
   context_menu_contents_->AddItemWithStringId(IDS_APP_PASTE, IDS_APP_PASTE);
   context_menu_contents_->AddSeparator(ui::NORMAL_SEPARATOR);
   context_menu_contents_->AddItemWithStringId(IDS_APP_SELECT_ALL,
                                               IDS_APP_SELECT_ALL);
 }
 
 }  // namespace views