src/ui/base/ime/input_method_imm32.cc

   1 // Copyright (c) 2013 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_imm32.h"
   6
   7 #include "base/basictypes.h"
   8 #include "ui/base/ime/composition_text.h"
   9 #include "ui/base/ime/text_input_client.h"
  10 #include "ui/base/ime/win/tsf_input_scope.h"
  11
  12
  13 namespace ui {
  14
  15 InputMethodIMM32::InputMethodIMM32(internal::InputMethodDelegate* delegate,
  16                                    HWND toplevel_window_handle)
  17     : InputMethodWin(delegate, toplevel_window_handle),
  18       enabled_(false), is_candidate_popup_open_(false),
  19       composing_window_handle_(NULL) {
  20   // In non-Aura environment, appropriate callbacks to OnFocus() and OnBlur()
  21   // are not implemented yet. To work around this limitation, here we use
  22   // "always focused" model.
  23   // TODO(ime): Fix the caller of OnFocus() and OnBlur() so that appropriate
  24   // focus event will be passed.
  25   InputMethodWin::OnFocus();
  26 }
  27
  28 void InputMethodIMM32::OnFocus() {
  29   // Ignore OnFocus event for "always focused" model. See the comment in the
  30   // constructor.
  31   // TODO(ime): Implement OnFocus once the callers are fixed.
  32 }
  33
  34 void InputMethodIMM32::OnBlur() {
  35   // Ignore OnBlur event for "always focused" model. See the comment in the
  36   // constructor.
  37   // TODO(ime): Implement OnFocus once the callers are fixed.
  38 }
  39
  40 bool InputMethodIMM32::OnUntranslatedIMEMessage(
  41     const base::NativeEvent& event, InputMethod::NativeEventResult* result) {
  42   LRESULT original_result = 0;
  43   BOOL handled = FALSE;
  44   switch (event.message) {
  45     case WM_IME_SETCONTEXT:
  46       original_result = OnImeSetContext(
  47           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  48       break;
  49     case WM_IME_STARTCOMPOSITION:
  50       original_result = OnImeStartComposition(
  51           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  52       break;
  53     case WM_IME_COMPOSITION:
  54       original_result = OnImeComposition(
  55           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  56       break;
  57     case WM_IME_ENDCOMPOSITION:
  58       original_result = OnImeEndComposition(
  59           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  60       break;
  61     case WM_IME_REQUEST:
  62       original_result = OnImeRequest(
  63           event.message, event.wParam, event.lParam, &handled);
  64       break;
  65     case WM_CHAR:
  66     case WM_SYSCHAR:
  67       original_result = OnChar(
  68           event.hwnd, event.message, event.wParam, event.lParam, &handled);
  69       break;
  70     case WM_IME_NOTIFY:
  71       original_result = OnImeNotify(
  72           event.message, event.wParam, event.lParam, &handled);
  73       break;
  74     default:
  75       NOTREACHED() << "Unknown IME message:" << event.message;
  76       break;
  77   }
  78   if (result)
  79     *result = original_result;
  80   return !!handled;
  81 }
  82
  83 void InputMethodIMM32::OnTextInputTypeChanged(const TextInputClient* client) {
  84   if (IsTextInputClientFocused(client) && IsWindowFocused(client)) {
  85     imm32_manager_.CancelIME(GetAttachedWindowHandle(client));
  86     UpdateIMEState();
  87   }
  88   InputMethodWin::OnTextInputTypeChanged(client);
  89 }
  90
  91 void InputMethodIMM32::OnCaretBoundsChanged(const TextInputClient* client) {
  92   if (!enabled_ || !IsTextInputClientFocused(client) ||
  93       !IsWindowFocused(client)) {
  94     return;
  95   }
  96   // The current text input type should not be NONE if |client| is focused.
  97   DCHECK(!IsTextInputTypeNone());
  98   gfx::Rect screen_bounds(GetTextInputClient()->GetCaretBounds());
  99
 100   HWND attached_window = GetAttachedWindowHandle(client);
 101   // TODO(ime): see comment in TextInputClient::GetCaretBounds(), this
 102   // conversion shouldn't be necessary.
 103   RECT r = {};
 104   GetClientRect(attached_window, &r);
 105   POINT window_point = { screen_bounds.x(), screen_bounds.y() };
 106   ScreenToClient(attached_window, &window_point);
 107   gfx::Rect caret_rect(gfx::Point(window_point.x, window_point.y),
 108                        screen_bounds.size());
 109   imm32_manager_.UpdateCaretRect(attached_window, caret_rect);
 110 }
 111
 112 void InputMethodIMM32::CancelComposition(const TextInputClient* client) {
 113   if (enabled_ && IsTextInputClientFocused(client))
 114     imm32_manager_.CancelIME(GetAttachedWindowHandle(client));
 115 }
 116
 117 bool InputMethodIMM32::IsCandidatePopupOpen() const {
 118   return is_candidate_popup_open_;
 119 }
 120
 121 void InputMethodIMM32::OnWillChangeFocusedClient(
 122     TextInputClient* focused_before,
 123     TextInputClient* focused) {
 124   if (IsWindowFocused(focused_before)) {
 125     ConfirmCompositionText();
 126   }
 127 }
 128
 129 void InputMethodIMM32::OnDidChangeFocusedClient(TextInputClient* focused_before,
 130                                                 TextInputClient* focused) {
 131   if (IsWindowFocused(focused)) {
 132     // Force to update the input type since client's TextInputStateChanged()
 133     // function might not be called if text input types before the client loses
 134     // focus and after it acquires focus again are the same.
 135     OnTextInputTypeChanged(focused);
 136
 137     UpdateIMEState();
 138
 139     // Force to update caret bounds, in case the client thinks that the caret
 140     // bounds has not changed.
 141     OnCaretBoundsChanged(focused);
 142   }
 143   InputMethodWin::OnDidChangeFocusedClient(focused_before, focused);
 144 }
 145
 146 LRESULT InputMethodIMM32::OnImeSetContext(HWND window_handle,
 147                                           UINT message,
 148                                           WPARAM wparam,
 149                                           LPARAM lparam,
 150                                           BOOL* handled) {
 151   if (!!wparam)
 152     imm32_manager_.CreateImeWindow(window_handle);
 153
 154   OnInputMethodChanged();
 155   return imm32_manager_.SetImeWindowStyle(
 156       window_handle, message, wparam, lparam, handled);
 157 }
 158
 159 LRESULT InputMethodIMM32::OnImeStartComposition(HWND window_handle,
 160                                                 UINT message,
 161                                                 WPARAM wparam,
 162                                                 LPARAM lparam,
 163                                                 BOOL* handled) {
 164   // We have to prevent WTL from calling ::DefWindowProc() because the function
 165   // calls ::ImmSetCompositionWindow() and ::ImmSetCandidateWindow() to
 166   // over-write the position of IME windows.
 167   *handled = TRUE;
 168
 169   // Reset the composition status and create IME windows.
 170   composing_window_handle_ = window_handle;
 171   imm32_manager_.CreateImeWindow(window_handle);
 172   imm32_manager_.ResetComposition(window_handle);
 173   return 0;
 174 }
 175
 176 LRESULT InputMethodIMM32::OnImeComposition(HWND window_handle,
 177                                            UINT message,
 178                                            WPARAM wparam,
 179                                            LPARAM lparam,
 180                                            BOOL* handled) {
 181   // We have to prevent WTL from calling ::DefWindowProc() because we do not
 182   // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
 183   *handled = TRUE;
 184
 185   // At first, update the position of the IME window.
 186   imm32_manager_.UpdateImeWindow(window_handle);
 187
 188   // Retrieve the result string and its attributes of the ongoing composition
 189   // and send it to a renderer process.
 190   ui::CompositionText composition;
 191   if (imm32_manager_.GetResult(window_handle, lparam, &composition.text)) {
 192     if (!IsTextInputTypeNone())
 193       GetTextInputClient()->InsertText(composition.text);
 194     imm32_manager_.ResetComposition(window_handle);
 195     // Fall though and try reading the composition string.
 196     // Japanese IMEs send a message containing both GCS_RESULTSTR and
 197     // GCS_COMPSTR, which means an ongoing composition has been finished
 198     // by the start of another composition.
 199   }
 200   // Retrieve the composition string and its attributes of the ongoing
 201   // composition and send it to a renderer process.
 202   if (imm32_manager_.GetComposition(window_handle, lparam, &composition) &&
 203       !IsTextInputTypeNone())
 204     GetTextInputClient()->SetCompositionText(composition);
 205
 206   return 0;
 207 }
 208
 209 LRESULT InputMethodIMM32::OnImeEndComposition(HWND window_handle,
 210                                               UINT message,
 211                                               WPARAM wparam,
 212                                               LPARAM lparam,
 213                                               BOOL* handled) {
 214   // Let WTL call ::DefWindowProc() and release its resources.
 215   *handled = FALSE;
 216
 217   composing_window_handle_ = NULL;
 218
 219   if (!IsTextInputTypeNone() && GetTextInputClient()->HasCompositionText())
 220     GetTextInputClient()->ClearCompositionText();
 221
 222   imm32_manager_.ResetComposition(window_handle);
 223   imm32_manager_.DestroyImeWindow(window_handle);
 224   return 0;
 225 }
 226
 227 LRESULT InputMethodIMM32::OnImeNotify(UINT message,
 228                                       WPARAM wparam,
 229                                       LPARAM lparam,
 230                                       BOOL* handled) {
 231   *handled = FALSE;
 232
 233   bool previous_state = is_candidate_popup_open_;
 234
 235   // Update |is_candidate_popup_open_|, whether a candidate window is open.
 236   switch (wparam) {
 237   case IMN_OPENCANDIDATE:
 238     is_candidate_popup_open_ = true;
 239     if (!previous_state)
 240       OnCandidateWindowShown();
 241     break;
 242   case IMN_CLOSECANDIDATE:
 243     is_candidate_popup_open_ = false;
 244     if (previous_state)
 245       OnCandidateWindowHidden();
 246     break;
 247   case IMN_CHANGECANDIDATE:
 248     // TODO(kochi): The IME API expects this event to notify window size change,
 249     // while this may fire more often without window resize. There is no generic
 250     // way to get bounds of candidate window.
 251     OnCandidateWindowUpdated();
 252     break;
 253   }
 254
 255   return 0;
 256 }
 257
 258 void InputMethodIMM32::ConfirmCompositionText() {
 259   if (composing_window_handle_)
 260     imm32_manager_.CleanupComposition(composing_window_handle_);
 261
 262   if (!IsTextInputTypeNone()) {
 263     // Though above line should confirm the client's composition text by sending
 264     // a result text to us, in case the input method and the client are in
 265     // inconsistent states, we check the client's composition state again.
 266     if (GetTextInputClient()->HasCompositionText())
 267       GetTextInputClient()->ConfirmCompositionText();
 268   }
 269 }
 270
 271 void InputMethodIMM32::UpdateIMEState() {
 272   // Use switch here in case we are going to add more text input types.
 273   // We disable input method in password field.
 274   const HWND window_handle = GetAttachedWindowHandle(GetTextInputClient());
 275   const TextInputType text_input_type = GetTextInputType();
 276   const TextInputMode text_input_mode = GetTextInputMode();
 277   switch (text_input_type) {
 278     case ui::TEXT_INPUT_TYPE_NONE:
 279     case ui::TEXT_INPUT_TYPE_PASSWORD:
 280       imm32_manager_.DisableIME(window_handle);
 281       enabled_ = false;
 282       break;
 283     default:
 284       imm32_manager_.EnableIME(window_handle);
 285       enabled_ = true;
 286       break;
 287   }
 288
 289   imm32_manager_.SetTextInputMode(window_handle, text_input_mode);
 290   tsf_inputscope::SetInputScopeForTsfUnawareWindow(
 291       window_handle, text_input_type, text_input_mode);
 292 }
 293
 294 }  // namespace ui