KeyEvent work.

ui/views/widget/desktop_root_window_host_win.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 "ui/views/widget/desktop_root_window_host_win.h"
 
 #include "ui/aura/desktop/desktop_activation_client.h"
 #include "ui/aura/desktop/desktop_dispatcher_client.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
+#include "ui/aura/shared/compound_event_filter.h"
+#include "ui/views/ime/input_method_win.h"
 #include "ui/views/widget/desktop_capture_client.h"
 #include "ui/views/win/hwnd_message_handler.h"
 
 namespace views {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostWin, public:
 
 DesktopRootWindowHostWin::DesktopRootWindowHostWin(
     internal::NativeWidgetDelegate* native_widget_delegate,
@@ skipping 33 matching lines @@
   root_window_->set_focus_manager(focus_manager_.get());
 
   activation_client_.reset(
       new aura::DesktopActivationClient(root_window_->GetFocusManager()));
   aura::client::SetActivationClient(root_window_.get(),
                                     activation_client_.get());
 
   dispatcher_client_.reset(new aura::DesktopDispatcherClient);
   aura::client::SetDispatcherClient(root_window_.get(),
                                     dispatcher_client_.get());
+
+  // CEF sets focus to the window the user clicks down on.
+  // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
+  //             handed way of accomplishing focus.
+  root_window_->SetEventFilter(new aura::shared::CompoundEventFilter);
 }
 
 void DesktopRootWindowHostWin::Close() {
   message_handler_->Close();
 }
 
 void DesktopRootWindowHostWin::CloseNow() {
   message_handler_->CloseNow();
 }
 
 aura::RootWindowHost* DesktopRootWindowHostWin::AsRootWindowHost() {
   return this;
 }
 
 void DesktopRootWindowHostWin::ShowWindowWithState(
     ui::WindowShowState show_state) {
   message_handler_->ShowWindowWithState(show_state);
 }
 
 bool DesktopRootWindowHostWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetClientAreaBoundsInScreen() const {
   return message_handler_->GetClientAreaBoundsInScreen();
 }
 
+InputMethod* DesktopRootWindowHostWin::CreateInputMethod() {
+  return new InputMethodWin(message_handler_.get(), message_handler_->hwnd());
+}
+
+internal::InputMethodDelegate*
+    DesktopRootWindowHostWin::GetInputMethodDelegate() {
+  return message_handler_.get();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostWin, RootWindowHost implementation:
 
 aura::RootWindow* DesktopRootWindowHostWin::GetRootWindow() {
   return root_window_.get();
 }
 
 gfx::AcceleratedWidget DesktopRootWindowHostWin::GetAcceleratedWidget() {
   return message_handler_->hwnd();
 }
@@ skipping 154 matching lines @@
 }
 
 void DesktopRootWindowHostWin::PaintLayeredWindow(gfx::Canvas* canvas) {
 }
 
 gfx::NativeViewAccessible DesktopRootWindowHostWin::GetNativeViewAccessible() {
   return NULL;
 }
 
 InputMethod* DesktopRootWindowHostWin::GetInputMethod() {
-  return NULL;
+  return native_widget_delegate_->AsWidget()->GetInputMethodDirect();
 }
 
 void DesktopRootWindowHostWin::HandleAppDeactivated() {
 }
 
 void DesktopRootWindowHostWin::HandleActivationChanged(bool active) {
 }
 
 bool DesktopRootWindowHostWin::HandleAppCommand(short command) {
   return false;
@@ skipping 57 matching lines @@
   if (root_window_host_delegate_)
     root_window_host_delegate_->OnHostResized(new_size);
   // TODO(beng): replace with a layout manager??
   content_window_->SetBounds(gfx::Rect(new_size));
 }
 
 void DesktopRootWindowHostWin::HandleFrameChanged() {
 }
 
 void DesktopRootWindowHostWin::HandleNativeFocus(HWND last_focused_window) {
+  InputMethod* input_method = GetInputMethod();
+  if (input_method)
+    input_method->OnFocus();
 }
 
 void DesktopRootWindowHostWin::HandleNativeBlur(HWND focused_window) {
+  InputMethod* input_method = GetInputMethod();
+  if (input_method)
+    input_method->OnBlur();
 }
 
 bool DesktopRootWindowHostWin::HandleMouseEvent(const ui::MouseEvent& event) {
   return root_window_host_delegate_->OnHostMouseEvent(
       const_cast<ui::MouseEvent*>(&event));
 }
 
 bool DesktopRootWindowHostWin::HandleKeyEvent(const ui::KeyEvent& event) {
-  return false;
+  return root_window_host_delegate_->OnHostKeyEvent(
+      const_cast<ui::KeyEvent*>(&event));
 }
 
 bool DesktopRootWindowHostWin::HandleUntranslatedKeyEvent(
     const ui::KeyEvent& event) {
-  return false;
+  InputMethod* input_method = GetInputMethod();
+  if (input_method)
+    input_method->DispatchKeyEvent(event);
+  return !!input_method;
 }
 
 bool DesktopRootWindowHostWin::HandleIMEMessage(UINT message,
                                            WPARAM w_param,
                                            LPARAM l_param,
                                            LRESULT* result) {
-  return false;
+  InputMethod* input_method = GetInputMethod();
+  if (!input_method || input_method->IsMock()) {
+    *result = 0;
+    return false;
+  }
+
+  InputMethodWin* ime_win = static_cast<InputMethodWin*>(input_method);
+  BOOL handled = FALSE;
+  *result = ime_win->OnImeMessages(message, w_param, l_param, &handled);
+  return !!handled;
 }
 
 void DesktopRootWindowHostWin::HandleInputLanguageChange(
     DWORD character_set,
     HKL input_language_id) {
+  InputMethod* input_method = GetInputMethod();
+  if (input_method && !input_method->IsMock()) {
+    static_cast<InputMethodWin*>(input_method)->OnInputLangChange(
+        character_set, input_language_id);
+  }
 }
 
 bool DesktopRootWindowHostWin::HandlePaintAccelerated(
     const gfx::Rect& invalid_rect) {
   return native_widget_delegate_->OnNativeWidgetPaintAccelerated(invalid_rect);
 }
 
 void DesktopRootWindowHostWin::HandlePaint(gfx::Canvas* canvas) {
   root_window_host_delegate_->OnHostPaint();
 }
@@ skipping 28 matching lines @@
 // DesktopRootWindowHost, public:
 
 // static
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     const gfx::Rect& initial_bounds) {
   return new DesktopRootWindowHostWin(native_widget_delegate, initial_bounds);
 }
 
 }  // namespace views