ui/base/ime/input_method_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/ime/input_method_win.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/profiler/scoped_tracker.h"
   9 #include "ui/base/ime/text_input_client.h"
  10 #include "ui/base/ime/win/tsf_input_scope.h"
  11 #include "ui/events/event.h"
  12 #include "ui/events/event_constants.h"
  13 #include "ui/events/event_utils.h"
  14 #include "ui/events/keycodes/keyboard_codes.h"
  15 #include "ui/gfx/win/dpi.h"
  16 #include "ui/gfx/win/hwnd_util.h"
  17
  18 namespace ui {
  19 namespace {
  20
  21 // Extra number of chars before and after selection (or composition) range which
  22 // is returned to IME for improving conversion accuracy.
  23 static const size_t kExtraNumberOfChars = 20;
  24
  25 }  // namespace
  26
  27 InputMethodWin::InputMethodWin(internal::InputMethodDelegate* delegate,
  28                                HWND toplevel_window_handle)
  29     : toplevel_window_handle_(toplevel_window_handle),
  30       pending_requested_direction_(base::i18n::UNKNOWN_DIRECTION),
  31       accept_carriage_return_(false),
  32       enabled_(false),
  33       is_candidate_popup_open_(false),
  34       composing_window_handle_(NULL),
  35       suppress_next_char_(false) {
  36   SetDelegate(delegate);
  37   OnInputLocaleChanged();
  38 }
  39
  40 void InputMethodWin::OnFocus() {
  41   InputMethodBase::OnFocus();
  42   if (GetTextInputClient())
  43     UpdateIMEState();
  44 }
  45
  46 void InputMethodWin::OnBlur() {
  47   ConfirmCompositionText();
  48   // Gets the focused text input client before calling parent's OnBlur() because
  49   // it will cause GetTextInputClient() returns NULL.
  50   ui::TextInputClient* client = GetTextInputClient();
  51   InputMethodBase::OnBlur();
  52   if (client)
  53     UpdateIMEState();
  54 }
  55
  56 bool InputMethodWin::OnUntranslatedIMEMessage(
  57     const base::NativeEvent& event,
  58     InputMethod::NativeEventResult* result) {
  59   LRESULT original_result = 0;
  60   BOOL handled = FALSE;
  61
  62   switch (event.message) {
  63     case WM_IME_SETCONTEXT:
  64       original_result = OnImeSetContext(
  65           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  66       break;
  67     case WM_IME_STARTCOMPOSITION:
  68       original_result = OnImeStartComposition(
  69           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  70       break;
  71     case WM_IME_COMPOSITION:
  72       original_result = OnImeComposition(
  73           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  74       break;
  75     case WM_IME_ENDCOMPOSITION:
  76       original_result = OnImeEndComposition(
  77           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  78       break;
  79     case WM_IME_REQUEST:
  80       original_result = OnImeRequest(
  81           event.message, event.wParam, event.lParam, &handled);
  82       break;
  83     case WM_CHAR:
  84     case WM_SYSCHAR:
  85       original_result = OnChar(
  86           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  87       break;
  88     case WM_IME_NOTIFY:
  89       original_result = OnImeNotify(
  90           event.message, event.wParam, event.lParam, &handled);
  91       break;
  92     default:
  93       NOTREACHED() << "Unknown IME message:" << event.message;
  94       break;
  95   }
  96   if (result)
  97     *result = original_result;
  98   return !!handled;
  99 }
 100
 101 bool InputMethodWin::DispatchKeyEvent(const ui::KeyEvent& event) {
 102   if (!event.HasNativeEvent())
 103     return DispatchFabricatedKeyEvent(event);
 104
 105   const base::NativeEvent& native_key_event = event.native_event();
 106   if (native_key_event.message == WM_CHAR) {
 107     BOOL handled;
 108     OnChar(native_key_event.hwnd, native_key_event.message,
 109            native_key_event.wParam, native_key_event.lParam, &handled);
 110     return !!handled;  // Don't send WM_CHAR for post event processing.
 111   }
 112   // Handles ctrl-shift key to change text direction and layout alignment.
 113   if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled() &&
 114       !IsTextInputTypeNone()) {
 115     // TODO: shouldn't need to generate a KeyEvent here.
 116     const ui::KeyEvent key(native_key_event);
 117     ui::KeyboardCode code = key.key_code();
 118     if (key.type() == ui::ET_KEY_PRESSED) {
 119       if (code == ui::VKEY_SHIFT) {
 120         base::i18n::TextDirection dir;
 121         if (ui::IMM32Manager::IsCtrlShiftPressed(&dir))
 122           pending_requested_direction_ = dir;
 123       } else if (code != ui::VKEY_CONTROL) {
 124         pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
 125       }
 126     } else if (key.type() == ui::ET_KEY_RELEASED &&
 127                (code == ui::VKEY_SHIFT || code == ui::VKEY_CONTROL) &&
 128                pending_requested_direction_ != base::i18n::UNKNOWN_DIRECTION) {
 129       GetTextInputClient()->ChangeTextDirectionAndLayoutAlignment(
 130           pending_requested_direction_);
 131       pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
 132     }
 133   }
 134
 135   suppress_next_char_ = DispatchKeyEventPostIME(event);
 136   return suppress_next_char_;
 137 }
 138
 139 void InputMethodWin::OnTextInputTypeChanged(const TextInputClient* client) {
 140   if (!IsTextInputClientFocused(client) || !IsWindowFocused(client))
 141     return;
 142   imm32_manager_.CancelIME(toplevel_window_handle_);
 143   UpdateIMEState();
 144 }
 145
 146 void InputMethodWin::OnCaretBoundsChanged(const TextInputClient* client) {
 147   if (!enabled_ || !IsTextInputClientFocused(client) ||
 148       !IsWindowFocused(client)) {
 149     return;
 150   }
 151   // The current text input type should not be NONE if |client| is focused.
 152   DCHECK(!IsTextInputTypeNone());
 153   // Tentatively assume that the returned value is DIP (Density Independent
 154   // Pixel). See the comment in text_input_client.h and http://crbug.com/360334.
 155   const gfx::Rect dip_screen_bounds(GetTextInputClient()->GetCaretBounds());
 156   const gfx::Rect screen_bounds = gfx::win::DIPToScreenRect(dip_screen_bounds);
 157
 158   HWND attached_window = toplevel_window_handle_;
 159   // TODO(ime): see comment in TextInputClient::GetCaretBounds(), this
 160   // conversion shouldn't be necessary.
 161   RECT r = {};
 162   GetClientRect(attached_window, &r);
 163   POINT window_point = { screen_bounds.x(), screen_bounds.y() };
 164   ScreenToClient(attached_window, &window_point);
 165   gfx::Rect caret_rect(gfx::Point(window_point.x, window_point.y),
 166                        screen_bounds.size());
 167   imm32_manager_.UpdateCaretRect(attached_window, caret_rect);
 168 }
 169
 170 void InputMethodWin::CancelComposition(const TextInputClient* client) {
 171   if (enabled_ && IsTextInputClientFocused(client))
 172     imm32_manager_.CancelIME(toplevel_window_handle_);
 173 }
 174
 175 void InputMethodWin::OnInputLocaleChanged() {
 176   locale_ = imm32_manager_.GetInputLanguageName();
 177   OnInputMethodChanged();
 178 }
 179
 180 std::string InputMethodWin::GetInputLocale() {
 181   return locale_;
 182 }
 183
 184 bool InputMethodWin::IsCandidatePopupOpen() const {
 185   return is_candidate_popup_open_;
 186 }
 187
 188 void InputMethodWin::OnWillChangeFocusedClient(TextInputClient* focused_before,
 189                                                TextInputClient* focused) {
 190   if (IsWindowFocused(focused_before))
 191     ConfirmCompositionText();
 192 }
 193
 194 void InputMethodWin::OnDidChangeFocusedClient(
 195     TextInputClient* focused_before,
 196     TextInputClient* focused) {
 197   if (IsWindowFocused(focused)) {
 198     // Force to update the input type since client's TextInputStateChanged()
 199     // function might not be called if text input types before the client loses
 200     // focus and after it acquires focus again are the same.
 201     OnTextInputTypeChanged(focused);
 202
 203     // Force to update caret bounds, in case the client thinks that the caret
 204     // bounds has not changed.
 205     OnCaretBoundsChanged(focused);
 206   }
 207   if (focused_before != focused)
 208     accept_carriage_return_ = false;
 209 }
 210
 211 LRESULT InputMethodWin::OnChar(HWND window_handle,
 212                                UINT message,
 213                                WPARAM wparam,
 214                                LPARAM lparam,
 215                                BOOL* handled) {
 216   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 217   tracked_objects::ScopedTracker tracking_profile(
 218       FROM_HERE_WITH_EXPLICIT_FUNCTION("440919 InputMethodWin::OnChar"));
 219
 220   *handled = TRUE;
 221
 222   if (suppress_next_char_) {
 223     suppress_next_char_ = false;
 224     return 0;
 225   }
 226
 227   // We need to send character events to the focused text input client event if
 228   // its text input type is ui::TEXT_INPUT_TYPE_NONE.
 229   if (GetTextInputClient()) {
 230     const base::char16 kCarriageReturn = L'\r';
 231     const base::char16 ch = static_cast<base::char16>(wparam);
 232     // A mask to determine the previous key state from |lparam|. The value is 1
 233     // if the key is down before the message is sent, or it is 0 if the key is
 234     // up.
 235     const uint32 kPrevKeyDownBit = 0x40000000;
 236     if (ch == kCarriageReturn && !(lparam & kPrevKeyDownBit))
 237       accept_carriage_return_ = true;
 238     // Conditionally ignore '\r' events to work around crbug.com/319100.
 239     // TODO(yukawa, IME): Figure out long-term solution.
 240     if (ch != kCarriageReturn || accept_carriage_return_)
 241       GetTextInputClient()->InsertChar(ch, ui::GetModifiersFromKeyState());
 242   }
 243
 244   // Explicitly show the system menu at a good location on [Alt]+[Space].
 245   // Note: Setting |handled| to FALSE for DefWindowProc triggering of the system
 246   //       menu causes undesirable titlebar artifacts in the classic theme.
 247   if (message == WM_SYSCHAR && wparam == VK_SPACE)
 248     gfx::ShowSystemMenu(window_handle);
 249
 250   return 0;
 251 }
 252
 253 LRESULT InputMethodWin::OnImeSetContext(HWND window_handle,
 254                                         UINT message,
 255                                         WPARAM wparam,
 256                                         LPARAM lparam,
 257                                         BOOL* handled) {
 258   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 259   tracked_objects::ScopedTracker tracking_profile(
 260       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 261           "440919 InputMethodWin::OnImeSetContext"));
 262
 263   if (!!wparam)
 264     imm32_manager_.CreateImeWindow(window_handle);
 265
 266   OnInputMethodChanged();
 267   return imm32_manager_.SetImeWindowStyle(
 268       window_handle, message, wparam, lparam, handled);
 269 }
 270
 271 LRESULT InputMethodWin::OnImeStartComposition(HWND window_handle,
 272                                               UINT message,
 273                                               WPARAM wparam,
 274                                               LPARAM lparam,
 275                                               BOOL* handled) {
 276   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 277   tracked_objects::ScopedTracker tracking_profile(
 278       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 279           "440919 InputMethodWin::OnImeStartComposition"));
 280
 281   // We have to prevent WTL from calling ::DefWindowProc() because the function
 282   // calls ::ImmSetCompositionWindow() and ::ImmSetCandidateWindow() to
 283   // over-write the position of IME windows.
 284   *handled = TRUE;
 285
 286   // Reset the composition status and create IME windows.
 287   composing_window_handle_ = window_handle;
 288   imm32_manager_.CreateImeWindow(window_handle);
 289   imm32_manager_.ResetComposition(window_handle);
 290   return 0;
 291 }
 292
 293 LRESULT InputMethodWin::OnImeComposition(HWND window_handle,
 294                                          UINT message,
 295                                          WPARAM wparam,
 296                                          LPARAM lparam,
 297                                          BOOL* handled) {
 298   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 299   tracked_objects::ScopedTracker tracking_profile(
 300       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 301           "440919 InputMethodWin::OnImeComposition"));
 302
 303   // We have to prevent WTL from calling ::DefWindowProc() because we do not
 304   // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
 305   *handled = TRUE;
 306
 307   // At first, update the position of the IME window.
 308   imm32_manager_.UpdateImeWindow(window_handle);
 309
 310   // Retrieve the result string and its attributes of the ongoing composition
 311   // and send it to a renderer process.
 312   ui::CompositionText composition;
 313   if (imm32_manager_.GetResult(window_handle, lparam, &composition.text)) {
 314     if (!IsTextInputTypeNone())
 315       GetTextInputClient()->InsertText(composition.text);
 316     imm32_manager_.ResetComposition(window_handle);
 317     // Fall though and try reading the composition string.
 318     // Japanese IMEs send a message containing both GCS_RESULTSTR and
 319     // GCS_COMPSTR, which means an ongoing composition has been finished
 320     // by the start of another composition.
 321   }
 322   // Retrieve the composition string and its attributes of the ongoing
 323   // composition and send it to a renderer process.
 324   if (imm32_manager_.GetComposition(window_handle, lparam, &composition) &&
 325       !IsTextInputTypeNone())
 326     GetTextInputClient()->SetCompositionText(composition);
 327
 328   return 0;
 329 }
 330
 331 LRESULT InputMethodWin::OnImeEndComposition(HWND window_handle,
 332                                             UINT message,
 333                                             WPARAM wparam,
 334                                             LPARAM lparam,
 335                                             BOOL* handled) {
 336   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 337   tracked_objects::ScopedTracker tracking_profile(
 338       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 339           "440919 InputMethodWin::OnImeEndComposition"));
 340
 341   // Let WTL call ::DefWindowProc() and release its resources.
 342   *handled = FALSE;
 343
 344   composing_window_handle_ = NULL;
 345
 346   if (!IsTextInputTypeNone() && GetTextInputClient()->HasCompositionText())
 347     GetTextInputClient()->ClearCompositionText();
 348
 349   imm32_manager_.ResetComposition(window_handle);
 350   imm32_manager_.DestroyImeWindow(window_handle);
 351   return 0;
 352 }
 353
 354 LRESULT InputMethodWin::OnImeNotify(UINT message,
 355                                     WPARAM wparam,
 356                                     LPARAM lparam,
 357                                     BOOL* handled) {
 358   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 359   tracked_objects::ScopedTracker tracking_profile(
 360       FROM_HERE_WITH_EXPLICIT_FUNCTION("440919 InputMethodWin::OnImeNotify"));
 361
 362   *handled = FALSE;
 363
 364   // Update |is_candidate_popup_open_|, whether a candidate window is open.
 365   switch (wparam) {
 366   case IMN_OPENCANDIDATE:
 367     is_candidate_popup_open_ = true;
 368     break;
 369   case IMN_CLOSECANDIDATE:
 370     is_candidate_popup_open_ = false;
 371     break;
 372   }
 373
 374   return 0;
 375 }
 376
 377 LRESULT InputMethodWin::OnImeRequest(UINT message,
 378                                      WPARAM wparam,
 379                                      LPARAM lparam,
 380                                      BOOL* handled) {
 381   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
 382   tracked_objects::ScopedTracker tracking_profile(
 383       FROM_HERE_WITH_EXPLICIT_FUNCTION("440919 InputMethodWin::OnImeRequest"));
 384
 385   *handled = FALSE;
 386
 387   // Should not receive WM_IME_REQUEST message, if IME is disabled.
 388   const ui::TextInputType type = GetTextInputType();
 389   if (type == ui::TEXT_INPUT_TYPE_NONE ||
 390       type == ui::TEXT_INPUT_TYPE_PASSWORD) {
 391     return 0;
 392   }
 393
 394   switch (wparam) {
 395     case IMR_RECONVERTSTRING:
 396       *handled = TRUE;
 397       return OnReconvertString(reinterpret_cast<RECONVERTSTRING*>(lparam));
 398     case IMR_DOCUMENTFEED:
 399       *handled = TRUE;
 400       return OnDocumentFeed(reinterpret_cast<RECONVERTSTRING*>(lparam));
 401     case IMR_QUERYCHARPOSITION:
 402       *handled = TRUE;
 403       return OnQueryCharPosition(reinterpret_cast<IMECHARPOSITION*>(lparam));
 404     default:
 405       return 0;
 406   }
 407 }
 408
 409 LRESULT InputMethodWin::OnDocumentFeed(RECONVERTSTRING* reconv) {
 410   ui::TextInputClient* client = GetTextInputClient();
 411   if (!client)
 412     return 0;
 413
 414   gfx::Range text_range;
 415   if (!client->GetTextRange(&text_range) || text_range.is_empty())
 416     return 0;
 417
 418   bool result = false;
 419   gfx::Range target_range;
 420   if (client->HasCompositionText())
 421     result = client->GetCompositionTextRange(&target_range);
 422
 423   if (!result || target_range.is_empty()) {
 424     if (!client->GetSelectionRange(&target_range) ||
 425         !target_range.IsValid()) {
 426       return 0;
 427     }
 428   }
 429
 430   if (!text_range.Contains(target_range))
 431     return 0;
 432
 433   if (target_range.GetMin() - text_range.start() > kExtraNumberOfChars)
 434     text_range.set_start(target_range.GetMin() - kExtraNumberOfChars);
 435
 436   if (text_range.end() - target_range.GetMax() > kExtraNumberOfChars)
 437     text_range.set_end(target_range.GetMax() + kExtraNumberOfChars);
 438
 439   size_t len = text_range.length();
 440   size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
 441
 442   if (!reconv)
 443     return need_size;
 444
 445   if (reconv->dwSize < need_size)
 446     return 0;
 447
 448   base::string16 text;
 449   if (!GetTextInputClient()->GetTextFromRange(text_range, &text))
 450     return 0;
 451   DCHECK_EQ(text_range.length(), text.length());
 452
 453   reconv->dwVersion = 0;
 454   reconv->dwStrLen = len;
 455   reconv->dwStrOffset = sizeof(RECONVERTSTRING);
 456   reconv->dwCompStrLen =
 457       client->HasCompositionText() ? target_range.length() : 0;
 458   reconv->dwCompStrOffset =
 459       (target_range.GetMin() - text_range.start()) * sizeof(WCHAR);
 460   reconv->dwTargetStrLen = target_range.length();
 461   reconv->dwTargetStrOffset = reconv->dwCompStrOffset;
 462
 463   memcpy((char*)reconv + sizeof(RECONVERTSTRING),
 464          text.c_str(), len * sizeof(WCHAR));
 465
 466   // According to Microsoft API document, IMR_RECONVERTSTRING and
 467   // IMR_DOCUMENTFEED should return reconv, but some applications return
 468   // need_size.
 469   return reinterpret_cast<LRESULT>(reconv);
 470 }
 471
 472 LRESULT InputMethodWin::OnReconvertString(RECONVERTSTRING* reconv) {
 473   ui::TextInputClient* client = GetTextInputClient();
 474   if (!client)
 475     return 0;
 476
 477   // If there is a composition string already, we don't allow reconversion.
 478   if (client->HasCompositionText())
 479     return 0;
 480
 481   gfx::Range text_range;
 482   if (!client->GetTextRange(&text_range) || text_range.is_empty())
 483     return 0;
 484
 485   gfx::Range selection_range;
 486   if (!client->GetSelectionRange(&selection_range) ||
 487       selection_range.is_empty()) {
 488     return 0;
 489   }
 490
 491   DCHECK(text_range.Contains(selection_range));
 492
 493   size_t len = selection_range.length();
 494   size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
 495
 496   if (!reconv)
 497     return need_size;
 498
 499   if (reconv->dwSize < need_size)
 500     return 0;
 501
 502   // TODO(penghuang): Return some extra context to help improve IME's
 503   // reconversion accuracy.
 504   base::string16 text;
 505   if (!GetTextInputClient()->GetTextFromRange(selection_range, &text))
 506     return 0;
 507   DCHECK_EQ(selection_range.length(), text.length());
 508
 509   reconv->dwVersion = 0;
 510   reconv->dwStrLen = len;
 511   reconv->dwStrOffset = sizeof(RECONVERTSTRING);
 512   reconv->dwCompStrLen = len;
 513   reconv->dwCompStrOffset = 0;
 514   reconv->dwTargetStrLen = len;
 515   reconv->dwTargetStrOffset = 0;
 516
 517   memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
 518          text.c_str(), len * sizeof(WCHAR));
 519
 520   // According to Microsoft API document, IMR_RECONVERTSTRING and
 521   // IMR_DOCUMENTFEED should return reconv, but some applications return
 522   // need_size.
 523   return reinterpret_cast<LRESULT>(reconv);
 524 }
 525
 526 LRESULT InputMethodWin::OnQueryCharPosition(IMECHARPOSITION* char_positon) {
 527   if (!char_positon)
 528     return 0;
 529
 530   if (char_positon->dwSize < sizeof(IMECHARPOSITION))
 531     return 0;
 532
 533   ui::TextInputClient* client = GetTextInputClient();
 534   if (!client)
 535     return 0;
 536
 537   // Tentatively assume that the returned value from |client| is DIP (Density
 538   // Independent Pixel). See the comment in text_input_client.h and
 539   // http://crbug.com/360334.
 540   gfx::Rect dip_rect;
 541   if (client->HasCompositionText()) {
 542     if (!client->GetCompositionCharacterBounds(char_positon->dwCharPos,
 543                                                &dip_rect)) {
 544       return 0;
 545     }
 546   } else {
 547     // If there is no composition and the first character is queried, returns
 548     // the caret bounds. This behavior is the same to that of RichEdit control.
 549     if (char_positon->dwCharPos != 0)
 550       return 0;
 551     dip_rect = client->GetCaretBounds();
 552   }
 553   const gfx::Rect rect = gfx::win::DIPToScreenRect(dip_rect);
 554
 555   char_positon->pt.x = rect.x();
 556   char_positon->pt.y = rect.y();
 557   char_positon->cLineHeight = rect.height();
 558   return 1;  // returns non-zero value when succeeded.
 559 }
 560
 561 bool InputMethodWin::IsWindowFocused(const TextInputClient* client) const {
 562   if (!client)
 563     return false;
 564   // When Aura is enabled, |attached_window_handle| should always be a top-level
 565   // window. So we can safely assume that |attached_window_handle| is ready for
 566   // receiving keyboard input as long as it is an active window. This works well
 567   // even when the |attached_window_handle| becomes active but has not received
 568   // WM_FOCUS yet.
 569   return toplevel_window_handle_ &&
 570       GetActiveWindow() == toplevel_window_handle_;
 571 }
 572
 573 bool InputMethodWin::DispatchFabricatedKeyEvent(const ui::KeyEvent& event) {
 574   if (event.is_char()) {
 575     if (suppress_next_char_) {
 576       suppress_next_char_ = false;
 577       return true;
 578     }
 579     if (GetTextInputClient()) {
 580       GetTextInputClient()->InsertChar(
 581           static_cast<base::char16>(event.key_code()),
 582           ui::GetModifiersFromKeyState());
 583       return true;
 584     }
 585   }
 586   return DispatchKeyEventPostIME(event);
 587 }
 588
 589 void InputMethodWin::ConfirmCompositionText() {
 590   if (composing_window_handle_)
 591     imm32_manager_.CleanupComposition(composing_window_handle_);
 592
 593   if (!IsTextInputTypeNone()) {
 594     // Though above line should confirm the client's composition text by sending
 595     // a result text to us, in case the input method and the client are in
 596     // inconsistent states, we check the client's composition state again.
 597     if (GetTextInputClient()->HasCompositionText())
 598       GetTextInputClient()->ConfirmCompositionText();
 599   }
 600 }
 601
 602 void InputMethodWin::UpdateIMEState() {
 603   // Use switch here in case we are going to add more text input types.
 604   // We disable input method in password field.
 605   const HWND window_handle = toplevel_window_handle_;
 606   const TextInputType text_input_type = GetTextInputType();
 607   const TextInputMode text_input_mode = GetTextInputMode();
 608   switch (text_input_type) {
 609     case ui::TEXT_INPUT_TYPE_NONE:
 610     case ui::TEXT_INPUT_TYPE_PASSWORD:
 611       imm32_manager_.DisableIME(window_handle);
 612       enabled_ = false;
 613       break;
 614     default:
 615       imm32_manager_.EnableIME(window_handle);
 616       enabled_ = true;
 617       break;
 618   }
 619
 620   imm32_manager_.SetTextInputMode(window_handle, text_input_mode);
 621   tsf_inputscope::SetInputScopeForTsfUnawareWindow(
 622       window_handle, text_input_type, text_input_mode);
 623 }
 624
 625 }  // namespace ui