KeyEvent work.

ui/views/ime/input_method_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/ime/input_method_win.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 // Extra number of chars before and after selection (or composition) range which
 // is returned to IME for improving conversion accuracy.
 static const size_t kExtraNumberOfChars = 20;
 
 namespace views {
 
-InputMethodWin::InputMethodWin(internal::InputMethodDelegate* delegate)
-    : active_(false),
+InputMethodWin::InputMethodWin(internal::InputMethodDelegate* delegate,
+                               HWND hwnd)
+    : hwnd_(hwnd),
+      active_(false),
       direction_(base::i18n::UNKNOWN_DIRECTION),
       pending_requested_direction_(base::i18n::UNKNOWN_DIRECTION) {
   set_delegate(delegate);
 }
 
 InputMethodWin::~InputMethodWin() {
   if (widget())
-    ime_input_.DisableIME(hwnd());
+    ime_input_.DisableIME(hwnd_);
 }
 
 void InputMethodWin::Init(Widget* widget) {
   // Gets the initial input locale and text direction information.
   OnInputLangChange(0, 0);
 
   InputMethodBase::Init(widget);
 }
 
 void InputMethodWin::OnFocus() {
@@ skipping 27 matching lines @@
           pending_requested_direction_);
       pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
     }
   }
 
   DispatchKeyEventPostIME(key);
 }
 
 void InputMethodWin::OnTextInputTypeChanged(View* view) {
   if (IsViewFocused(view)) {
-    ime_input_.CancelIME(hwnd());
+    ime_input_.CancelIME(hwnd_);
     UpdateIMEState();
   }
   InputMethodBase::OnTextInputTypeChanged(view);
 }
 
 void InputMethodWin::OnCaretBoundsChanged(View* view) {
   gfx::Rect rect;
   if (!IsViewFocused(view) || !GetCaretBoundsInWidget(&rect))
     return;
-  ime_input_.UpdateCaretRect(hwnd(), rect);
+  ime_input_.UpdateCaretRect(hwnd_, rect);
 }
 
 void InputMethodWin::CancelComposition(View* view) {
   if (IsViewFocused(view))
-    ime_input_.CancelIME(hwnd());
+    ime_input_.CancelIME(hwnd_);
 }
 
 std::string InputMethodWin::GetInputLocale() {
   return locale_;
 }
 
 base::i18n::TextDirection InputMethodWin::GetInputTextDirection() {
   return direction_;
 }
 
@@ skipping 48 matching lines @@
   active_ = ime_input_.SetInputLanguage();
   locale_ = ime_input_.GetInputLanguageName();
   direction_ = ime_input_.GetTextDirection();
   OnInputMethodChanged();
 }
 
 LRESULT InputMethodWin::OnImeSetContext(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   active_ = (wparam == TRUE);
   if (active_)
-    ime_input_.CreateImeWindow(hwnd());
+    ime_input_.CreateImeWindow(hwnd_);
 
   OnInputMethodChanged();
-  return ime_input_.SetImeWindowStyle(hwnd(), message, wparam, lparam, handled);
+  return ime_input_.SetImeWindowStyle(hwnd_, message, wparam, lparam, handled);
 }
 
 LRESULT InputMethodWin::OnImeStartComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   // We have to prevent WTL from calling ::DefWindowProc() because the function
   // calls ::ImmSetCompositionWindow() and ::ImmSetCandidateWindow() to
   // over-write the position of IME windows.
   *handled = TRUE;
 
   if (IsTextInputTypeNone())
     return 0;
 
   // Reset the composition status and create IME windows.
-  ime_input_.CreateImeWindow(hwnd());
-  ime_input_.ResetComposition(hwnd());
+  ime_input_.CreateImeWindow(hwnd_);
+  ime_input_.ResetComposition(hwnd_);
   return 0;
 }
 
 LRESULT InputMethodWin::OnImeComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   // We have to prevent WTL from calling ::DefWindowProc() because we do not
   // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
   *handled = TRUE;
 
   if (IsTextInputTypeNone())
     return 0;
 
   // At first, update the position of the IME window.
-  ime_input_.UpdateImeWindow(hwnd());
+  ime_input_.UpdateImeWindow(hwnd_);
 
   // Retrieve the result string and its attributes of the ongoing composition
   // and send it to a renderer process.
   ui::CompositionText composition;
-  if (ime_input_.GetResult(hwnd(), lparam, &composition.text)) {
+  if (ime_input_.GetResult(hwnd_, lparam, &composition.text)) {
     GetTextInputClient()->InsertText(composition.text);
-    ime_input_.ResetComposition(hwnd());
+    ime_input_.ResetComposition(hwnd_);
     // Fall though and try reading the composition string.
     // Japanese IMEs send a message containing both GCS_RESULTSTR and
     // GCS_COMPSTR, which means an ongoing composition has been finished
     // by the start of another composition.
   }
   // Retrieve the composition string and its attributes of the ongoing
   // composition and send it to a renderer process.
-  if (ime_input_.GetComposition(hwnd(), lparam, &composition))
+  if (ime_input_.GetComposition(hwnd_, lparam, &composition))
     GetTextInputClient()->SetCompositionText(composition);
 
   return 0;
 }
 
 LRESULT InputMethodWin::OnImeEndComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL* handled) {
   // Let WTL call ::DefWindowProc() and release its resources.
   *handled = FALSE;
 
   if (IsTextInputTypeNone())
     return 0;
 
   if (GetTextInputClient()->HasCompositionText())
     GetTextInputClient()->ClearCompositionText();
 
-  ime_input_.ResetComposition(hwnd());
-  ime_input_.DestroyImeWindow(hwnd());
+  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.
   const ui::TextInputType type = GetTextInputType();
   if (type == ui::TEXT_INPUT_TYPE_NONE ||
@@ skipping 157 matching lines @@
          text.c_str(), len * sizeof(WCHAR));
 
   // According to Microsft API document, IMR_RECONVERTSTRING and
   // IMR_DOCUMENTFEED should return reconv, but some applications return
   // need_size.
   return reinterpret_cast<LRESULT>(reconv);
 }
 
 void InputMethodWin::ConfirmCompositionText() {
   if (!IsTextInputTypeNone()) {
-    ime_input_.CleanupComposition(hwnd());
+    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());
+      ime_input_.DisableIME(hwnd_);
       break;
     default:
-      ime_input_.EnableIME(hwnd());
+      ime_input_.EnableIME(hwnd_);
       break;
   }
 }
 
 }  // namespace views