New method: InputMethod::IsCandidatePopupOpen()

ui/base/ime/input_method_imm32.cc

 // Copyright (c) 2013 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/base/ime/input_method_imm32.h"
 
 #include "base/basictypes.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/text_input_client.h"
 
 
 namespace ui {
 
 InputMethodIMM32::InputMethodIMM32(internal::InputMethodDelegate* delegate,
                                    HWND toplevel_window_handle)
     : InputMethodWin(delegate, toplevel_window_handle),
-      enabled_(false),
+      enabled_(false), is_candidate_popup_open_(false),
       composing_window_handle_(NULL) {
   // In non-Aura environment, appropriate callbacks to OnFocus() and OnBlur()
   // are not implemented yet. To work around this limitation, here we use
   // "always focused" model.
   // TODO(ime): Fix the caller of OnFocus() and OnBlur() so that appropriate
   // focus event will be passed.
   InputMethodWin::OnFocus();
 }
 
 void InputMethodIMM32::OnFocus() {
@@ skipping 36 matching lines @@
     case WM_CHAR:
     case WM_SYSCHAR:
       original_result = OnChar(
           event.message, event.wParam, event.lParam, &handled);
       break;
     case WM_DEADCHAR:
     case WM_SYSDEADCHAR:
       original_result = OnDeadChar(
           event.message, event.wParam, event.lParam, &handled);
       break;
+    case WM_IME_NOTIFY:
+      original_result = OnImeNotify(
+          event.message, event.wParam, event.lParam, &handled);
+      break;
     default:
       NOTREACHED() << "Unknown IME message:" << event.message;
       break;
   }
   if (result)
     *result = original_result;
   return !!handled;
 }
 
 void InputMethodIMM32::OnTextInputTypeChanged(const TextInputClient* client) {
@@ skipping 30 matching lines @@
 void InputMethodIMM32::CancelComposition(const TextInputClient* client) {
   if (enabled_ && IsTextInputClientFocused(client))
     ime_input_.CancelIME(GetAttachedWindowHandle(client));
 }
 
 void InputMethodIMM32::SetFocusedTextInputClient(TextInputClient* client) {
   ConfirmCompositionText();
   InputMethodWin::SetFocusedTextInputClient(client);
 }
 
+bool InputMethodIMM32::IsCandidatePopupOpen() const {
+  return is_candidate_popup_open_;
+}
+
 void InputMethodIMM32::OnWillChangeFocusedClient(
     TextInputClient* focused_before,
     TextInputClient* focused) {
   if (IsWindowFocused(focused_before)) {
     ConfirmCompositionText();
   }
 }
 
 void InputMethodIMM32::OnDidChangeFocusedClient(TextInputClient* focused_before,
                                                 TextInputClient* focused) {
@@ skipping 86 matching lines @@
   composing_window_handle_ = NULL;
 
   if (!IsTextInputTypeNone() && GetTextInputClient()->HasCompositionText())
     GetTextInputClient()->ClearCompositionText();
 
   ime_input_.ResetComposition(window_handle);
   ime_input_.DestroyImeWindow(window_handle);
   return 0;
 }
 
+LRESULT InputMethodIMM32::OnImeNotify(UINT message,
+                                      WPARAM wparam,
+                                      LPARAM lparam,
+                                      BOOL* handled) {
+  *handled = FALSE;
+
+  // Update |is_candidate_popup_open_|, whether a candidate window is open.
+  switch (wparam) {
+  case IMN_OPENCANDIDATE:
+    is_candidate_popup_open_ = true;
+    break;
+  case IMN_CLOSECANDIDATE:
+    is_candidate_popup_open_ = false;
+    break;
+  }
+
+  return 0;
+}
+
 void InputMethodIMM32::ConfirmCompositionText() {
   if (composing_window_handle_)
     ime_input_.CleanupComposition(composing_window_handle_);
 
   if (!IsTextInputTypeNone()) {
     // 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();
@@ skipping 17 matching lines @@
 }
 
 bool InputMethodIMM32::IsWindowFocused(const TextInputClient* client) const {
   if (!client)
     return false;
   HWND attached_window_handle = GetAttachedWindowHandle(client);
   return attached_window_handle && GetFocus() == attached_window_handle;
 }
 
 }  // namespace ui