WIP: Ash IME support

win8/metro_driver/chrome_app_view_ash.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 "win8/metro_driver/stdafx.h"
 #include "win8/metro_driver/chrome_app_view_ash.h"
 
 #include <corewindow.h>
 #include <shellapi.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/gestures/gesture_sequence.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 #include "win8/metro_driver/file_picker_ash.h"
+#include "win8/metro_driver/ime/ime_popup_monitor.h"
+#include "win8/metro_driver/ime/keyevent_filter.h"
+#include "win8/metro_driver/ime/language_profile_monitor.h"
+#include "win8/metro_driver/ime/text_service.h"
 #include "win8/metro_driver/metro_driver.h"
 #include "win8/metro_driver/winrt_utils.h"
 #include "win8/viewer/metro_viewer_constants.h"
 
 typedef winfoundtn::ITypedEventHandler<
     winapp::Core::CoreApplicationView*,
     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
@@ skipping 120 matching lines @@
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_OpenURLOnDesktop,
                           OnOpenURLOnDesktop)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursor, OnSetCursor)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileOpen,
                           OnDisplayFileOpenDialog)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileSaveAs,
                           OnDisplayFileSaveAsDialog)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplaySelectFolder,
                           OnDisplayFolderPicker)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursorPos, OnSetCursorPos)
+      IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCancelComposition,
+                          OnImeCancelComposition)
+      IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeTextInputClientUpdated,
+                          OnImeTextInputClientChanged)
       IPC_MESSAGE_UNHANDLED(__debugbreak())
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   virtual void OnChannelError() OVERRIDE {
     DVLOG(1) << "Channel error. Exiting.";
     MetroExit(app_view_->core_window_hwnd());
     // In early Windows 8 versions the code above sometimes fails so we call
     // it a second time with a NULL window which just calls Exit().
@@ skipping 57 matching lines @@
 
   void OnSetCursorPos(int x, int y) {
     VLOG(1) << "In IPC OnSetCursorPos: " << x << ", " << y;
     ui_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&ChromeAppViewAsh::OnSetCursorPos,
                    base::Unretained(app_view_),
                    x, y));
   }
 
+  void OnImeCancelComposition() {
+    ui_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromeAppViewAsh::OnImeCancelComposition,
+                   base::Unretained(app_view_)));
+  }
+
+  void OnImeTextInputClientChanged(
+      const std::vector<int32>& input_scopes,
+      const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
+    ui_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromeAppViewAsh::OnImeUpdateTextInputClient,
+                   base::Unretained(app_view_),
+                   input_scopes,
+                   character_bounds));
+  }
 
   scoped_refptr<base::MessageLoopProxy> ui_proxy_;
   ChromeAppViewAsh* app_view_;
 };
 
 bool WaitForChromeIPCConnection(const std::string& channel_name) {
   int ms_elapsed = 0;
   while (!IPC::Channel::IsNamedServerInitialized(channel_name) &&
          ms_elapsed < 10000) {
     ms_elapsed += 500;
@@ skipping 174 matching lines @@
   sei.nShow = SW_SHOWNORMAL;
   sei.lpFile = chrome_exe_path.value().c_str();
   sei.lpDirectory = L"";
   sei.lpParameters = parameters.c_str();
   ::ShellExecuteEx(&sei);
   return true;
 }
 
 }  // namespace
 
+struct ChromeAppViewAsh::TextInputClientState {
+  std::vector<int32> input_scopes;
+  std::vector<metro_viewer::CharacterBounds> composition_character_bounds;
+};
+
 ChromeAppViewAsh::ChromeAppViewAsh()
     : mouse_down_flags_(ui::EF_NONE),
       ui_channel_(nullptr),
       core_window_hwnd_(NULL),
-      ui_loop_(base::MessageLoop::TYPE_UI) {
+      ui_loop_(base::MessageLoop::TYPE_UI),
+      text_input_client_state_(new TextInputClientState) {
   DVLOG(1) << __FUNCTION__;
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
 }
 
 ChromeAppViewAsh::~ChromeAppViewAsh() {
   DVLOG(1) << __FUNCTION__;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Initialize(winapp::Core::ICoreApplicationView* view) {
   view_ = view;
   DVLOG(1) << __FUNCTION__;
   HRESULT hr = view_->add_Activated(mswr::Callback<ActivatedHandler>(
       this, &ChromeAppViewAsh::OnActivate).Get(),
       &activated_token_);
   CheckHR(hr);
+  if (!metro_driver::InstallKeyEventFilter())
+    return E_FAIL;
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::SetWindow(winui::Core::ICoreWindow* window) {
   window_ = window;
   DVLOG(1) << __FUNCTION__;
 
   // Retrieve the native window handle via the interop layer.
   mswr::ComPtr<ICoreWindowInterop> interop;
   HRESULT hr = window->QueryInterface(interop.GetAddressOf());
   CheckHR(hr);
   hr = interop->get_WindowHandle(&core_window_hwnd_);
   CheckHR(hr);
 
+  text_service_.reset(new metro_driver::TextService(core_window_hwnd_, this));
+  metro_driver::AddImePopupObserver(this);
+  metro_driver::AddLanguageProfileObserver(this);
+
   hr = window_->add_SizeChanged(mswr::Callback<SizeChangedHandler>(
       this, &ChromeAppViewAsh::OnSizeChanged).Get(),
       &sizechange_token_);
   CheckHR(hr);
 
   // Register for pointer and keyboard notifications. We forward
   // them to the browser process via IPC.
   hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppViewAsh::OnPointerMoved).Get(),
       &pointermoved_token_);
@@ skipping 127 matching lines @@
   ui_loop_.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
   ui_loop_.Run();
 
   DVLOG(0) << "ProcessEvents done, hr=" << hr;
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Uninitialize() {
   DVLOG(1) << __FUNCTION__;
+  metro_driver::UninstallKeyEventFilter();
+  metro_driver::RemoveImePopupObserver(this);
+  metro_driver::RemoveLanguageProfileObserver(this);
   window_ = nullptr;
   view_ = nullptr;
   core_window_hwnd_ = NULL;
   return S_OK;
 }
 
 // static
 HRESULT ChromeAppViewAsh::Unsnap() {
   mswr::ComPtr<winui::ViewManagement::IApplicationViewStatics> view_statics;
   HRESULT hr = winrt_utils::CreateActivationFactory(
@@ skipping 148 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DVLOG(1) << "Success: " << success;
   if (ui_channel_) {
     ui_channel_->Send(new MetroViewerHostMsg_SelectFolderDone(
         success,
         base::FilePath(folder_picker->result())));
   }
   delete folder_picker;
 }
 
+void ChromeAppViewAsh::OnImeCancelComposition() {
+  text_service_->CancelComposition();
+}
+
+void ChromeAppViewAsh::OnImeUpdateTextInputClient(
+    const std::vector<int32>& input_scopes,
+    const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
+  if (text_input_client_state_->input_scopes != input_scopes) {
+    text_service_->OnDocumentTypeChanged(input_scopes);
+    text_input_client_state_->input_scopes = input_scopes;
+  }
+  text_input_client_state_->composition_character_bounds = character_bounds;
+}
+
+void ChromeAppViewAsh::OnCandidatePopupChanged(bool shown) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeCandidatePopupChanged(shown));
+}
+
+void ChromeAppViewAsh::OnInputSourceChanged(LANGID langid, bool is_ime) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeInputSourceChanged(
+      langid, is_ime));
+}
+
+void ChromeAppViewAsh::OnCompositionChanged(
+    const string16& text,
+    int32 selection_start,
+    int32 selection_end,
+    const std::vector<metro_viewer::UnderlineInfo>& underlines) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeCompositionChanged(
+      text, selection_start, selection_end, underlines));
+}
+
+void ChromeAppViewAsh::OnTextCommitted(const string16& text) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeTextCommitted(text));
+}
+
+RECT ChromeAppViewAsh::GetCaretBounds() {
+  if (text_input_client_state_->composition_character_bounds.empty()) {
+    const RECT rect = {};
+    return rect;
+  }
+  const metro_viewer::CharacterBounds& bounds =
+      text_input_client_state_->composition_character_bounds[0];
+  POINT left_top = {bounds.left, bounds.top};
+  POINT right_bottom = {bounds.right, bounds.bottom};
+  ::ClientToScreen(this->core_window_hwnd_, &left_top);
+  ::ClientToScreen(this->core_window_hwnd_, &right_bottom);
+  const RECT rect = {
+    left_top.x,
+    left_top.y,
+    right_bottom.x,
+    right_bottom.y,
+  };
+  return rect;
+}
+
+bool ChromeAppViewAsh::GetCompositionCharacterBounds(uint32 index, RECT* rect) {
+  if (index >= text_input_client_state_->composition_character_bounds.size()) {
+    return false;
+  }
+  const metro_viewer::CharacterBounds& bounds =
+      text_input_client_state_->composition_character_bounds[index];
+  POINT left_top = {bounds.left, bounds.top};
+  POINT right_bottom = {bounds.right, bounds.bottom};
+  ::ClientToScreen(this->core_window_hwnd_, &left_top);
+  ::ClientToScreen(this->core_window_hwnd_, &right_bottom);
+  ::SetRect(rect, left_top.x, left_top.y, right_bottom.x, right_bottom.y);
+  return true;
+}
+
 HRESULT ChromeAppViewAsh::OnActivate(
     winapp::Core::ICoreApplicationView*,
     winapp::Activation::IActivatedEventArgs* args) {
   DVLOG(1) << __FUNCTION__;
   // Note: If doing more work in this function, you migth need to call
   // get_PreviousExecutionState() and skip the work if  the result is
   // ApplicationExecutionState_Running and globals.previous_state is too.
   args->get_PreviousExecutionState(&globals.previous_state);
   DVLOG(1) << "Previous Execution State: " << globals.previous_state;
 
@@ skipping 226 matching lines @@
   winui::Core::CoreWindowActivationState state;
   HRESULT hr = args->get_WindowActivationState(&state);
   if (FAILED(hr))
     return hr;
 
   // Treat both full activation (Ash was reopened from the Start Screen or from
   // any other Metro entry point in Windows) and pointer activation (user
   // clicked back in Ash after using another app on another monitor) the same.
   if (state == winui::Core::CoreWindowActivationState_CodeActivated ||
       state == winui::Core::CoreWindowActivationState_PointerActivated) {
+    switch (state) {
+      case winui::Core::CoreWindowActivationState_CodeActivated:
+      case winui::Core::CoreWindowActivationState_PointerActivated:
+        text_service_->OnWindowActivated();
+        break;
+    }
     ui_channel_->Send(new MetroViewerHostMsg_WindowActivated());
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::HandleSearchRequest(
     winapp::Activation::IActivatedEventArgs* args) {
   mswr::ComPtr<winapp::Activation::ISearchActivatedEventArgs> search_args;
   CheckHR(args->QueryInterface(
           winapp::Activation::IID_ISearchActivatedEventArgs, &search_args));
@@ skipping 90 matching lines @@
   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   *view = mswr::Make<ChromeAppViewAsh>().Detach();
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }