Support IMM32 reconversion on Windows

views/ime/input_method_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/ime/input_method_win.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "ui/base/keycodes/keyboard_codes.h"
@@ skipping 97 matching lines @@
       break;
     case WM_IME_STARTCOMPOSITION:
       result = OnImeStartComposition(message, w_param, l_param, handled);
       break;
     case WM_IME_COMPOSITION:
       result = OnImeComposition(message, w_param, l_param, handled);
       break;
     case WM_IME_ENDCOMPOSITION:
       result = OnImeEndComposition(message, w_param, l_param, handled);
       break;
+    case WM_IME_REQUEST:
+      result = OnImeRequest(message, w_param, l_param, handled);
+      break;
     case WM_CHAR:
     case WM_SYSCHAR:
       result = OnChar(message, w_param, l_param, handled);
       break;
     case WM_DEADCHAR:
     case WM_SYSDEADCHAR:
       result = OnDeadChar(message, w_param, l_param, handled);
       break;
     default:
       NOTREACHED() << "Unknown IME message:" << message;
@@ skipping 84 matching lines @@
     return 0;
 
   if (GetTextInputClient()->HasCompositionText())
     GetTextInputClient()->ClearCompositionText();
 
   ime_input_.ResetComposition(hwnd());
   ime_input_.DestroyImeWindow(hwnd());
   return 0;
 }
 
+LRESULT InputMethodWin::OnImeRequest(
+    UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
+  *handled = FALSE;
+
+  // Should not receive WM_IME_REQUEST message, if IME is disabled.
+  ui::TextInputType type = GetTextInputType();

[James Su, 2011/10/26 18:41:57]

nit: const ui::TextInputType

+  if (type == ui::TEXT_INPUT_TYPE_NONE ||
+      type == ui::TEXT_INPUT_TYPE_PASSWORD) {
+    return 0;
+  }
+
+  switch (wparam) {
+    case IMR_RECONVERTSTRING:
+      *handled = TRUE;
+      return OnReconvertString(reinterpret_cast<RECONVERTSTRING*>(lparam));
+    case IMR_DOCUMENTFEED:
+      *handled = TRUE;
+      return OnDocumentFeed(reinterpret_cast<RECONVERTSTRING*>(lparam));
+    default:
+      return 0;
+  }
+}
+
 LRESULT InputMethodWin::OnChar(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   *handled = TRUE;
 
   // We need to send character events to the focused text input client event if
   // its text input type is ui::TEXT_INPUT_TYPE_NONE.
   if (!GetTextInputClient())
     return 0;
 
   int flags = 0;
@@ skipping 15 matching lines @@
   // what dead key was pressed.
   ui::CompositionText composition;
   composition.text.assign(1, static_cast<char16>(wparam));
   composition.selection = ui::Range(0, 1);
   composition.underlines.push_back(
       ui::CompositionUnderline(0, 1, SK_ColorBLACK, false));
   GetTextInputClient()->SetCompositionText(composition);
   return 0;
 }
 
+LRESULT InputMethodWin::OnDocumentFeed(RECONVERTSTRING *reconv) {
+  TextInputClient* client = GetTextInputClient();
+  if (!client)
+    return 0;
+
+  ui::Range text_range;
+  if (!client->GetTextRange(&text_range) || text_range.is_empty())
+    return 0;
+
+  ui::Range target_range;
+  do {
+    if (client->HasCompositionText() &&
+        client->GetCompositionTextRange(&target_range) &&
+        !target_range.is_empty()) {
+      break;
+    }
+    if (client->GetSelectionRange(&target_range))
+      break;
+    return 0;
+  } while (0);
+
+  if (!text_range.Contains(target_range))
+    return 0;
+
+  size_t len = text_range.length();
+  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
+
+  if (!reconv)
+    return need_size;
+
+  if (reconv->dwSize < need_size)
+    return 0;
+
+  string16 text;
+  ui::Range actual_range;
+  if (!GetTextInputClient()->GetTextFromRange(
+      text_range, &text, &actual_range)) {
+    return 0;
+  }
+
+  DCHECK(text_range == actual_range);
+
+  reconv->dwVersion = 0;
+  reconv->dwStrLen = len;
+  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
+  reconv->dwCompStrLen =
+      client->HasCompositionText() ? reconv->dwTargetStrOffset : 0;
+  reconv->dwCompStrOffset =
+      (target_range.GetMin() - text_range.start()) * sizeof(WCHAR);
+  reconv->dwTargetStrLen = target_range.length();
+  reconv->dwTargetStrOffset = reconv->dwCompStrOffset;
+
+  memcpy((char*)reconv + sizeof(RECONVERTSTRING),
+      text.c_str(), len * sizeof(WCHAR));
+
+  return need_size;
+}
+
+LRESULT InputMethodWin::OnReconvertString(RECONVERTSTRING *reconv) {
+  TextInputClient* client = GetTextInputClient();
+  if (!client)
+    return 0;
+
+  // If there is a composition string already, we don't allow reconversion.
+  if (client->HasCompositionText())
+    return 0;
+
+  ui::Range text_range;
+  if (!client->GetTextRange(&text_range) || text_range.is_empty())
+    return 0;
+
+  ui::Range selection_range;
+  if (!client->GetSelectionRange(&selection_range) ||
+      selection_range.is_empty()) {
+    return 0;
+  }
+
+  if (!text_range.Contains(selection_range))
+    return 0;
+
+  size_t len = text_range.length();

[James Su, 2011/10/26 18:41:57]

It's better not to return all text content, because it'll be wasteful if it's
too large.

+  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
+
+  if (!reconv)
+    return need_size;
+
+  if (reconv->dwSize < need_size)
+    return 0;
+
+  string16 text;
+  ui::Range actual_range;
+  if (!GetTextInputClient()->GetTextFromRange(
+      text_range, &text, &actual_range))
+    return 0;
+
+  reconv->dwVersion = 0;
+  reconv->dwStrLen = len;
+  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
+  reconv->dwCompStrLen = selection_range.length();
+  reconv->dwCompStrOffset =
+      (selection_range.GetMin() - text_range.start()) * sizeof(WCHAR);
+  reconv->dwTargetStrLen = reconv->dwCompStrLen;
+  reconv->dwTargetStrOffset = reconv->dwCompStrOffset;
+  memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
+      text.c_str(), len * sizeof(WCHAR));
+
+  return need_size;
+}
+
 void InputMethodWin::ConfirmCompositionText() {
   if (!IsTextInputTypeNone()) {
     ime_input_.CleanupComposition(hwnd());
     // Though above line should confirm the client's composition text by sending
     // a result text to us, in case the input method and the client are in
     // inconsistent states, we check the client's composition state again.
     if (GetTextInputClient()->HasCompositionText())
       GetTextInputClient()->ConfirmCompositionText();
   }
 }
 
 void InputMethodWin::UpdateIMEState() {
   // Use switch here in case we are going to add more text input types.
   // We disable input method in password field.
   switch (GetTextInputType()) {
     case ui::TEXT_INPUT_TYPE_NONE:
     case ui::TEXT_INPUT_TYPE_PASSWORD:
       ime_input_.DisableIME(hwnd());
       break;
     default:
       ime_input_.EnableIME(hwnd());
       break;
   }
 }
 
 }  // namespace views