| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 166063002:
Unify InputMethodIMM32 into InputMethodWin again (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src