Add keyboard events to metro aura

win8/metro_driver/chrome_app_view.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.h"
 #include "win8/metro_driver/direct3d_helper.h"
 
 #include <algorithm>
 #include <windows.applicationModel.datatransfer.h>
@@ skipping 34 matching lines @@
 
 typedef winfoundtn::ITypedEventHandler<
     winui::ViewManagement::InputPane*,
     winui::ViewManagement::InputPaneVisibilityEventArgs*>
     InputPaneEventHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
     winui::Core::PointerEventArgs*> PointerEventHandler;
 
+typedef winfoundtn::ITypedEventHandler<
+    winui::Core::CoreWindow*,
+    winui::Core::KeyEventArgs*> KeyEventHandler;
+
 struct Globals globals;
 
 // TODO(ananta)
 // Remove this once we consolidate metro driver with chrome.
 const wchar_t kMetroGetCurrentTabInfoMessage[] =
     L"CHROME_METRO_GET_CURRENT_TAB_INFO";
 
 static const int kFlipWindowsHotKeyId = 0x0000baba;
 
 static const int kAnimateWindowTimeoutMs = 200;
@@ skipping 630 matching lines @@
 }
 
 IFACEMETHODIMP
 ChromeAppView::SetWindow(winui::Core::ICoreWindow* window) {
   window_ = window;
   DVLOG(1) << __FUNCTION__;
 
   HRESULT hr = url_launch_handler_.Initialize();
   CheckHR(hr, "Failed to initialize url launch handler.");
 
-  // Register for size notifications.
-  hr = window_->add_SizeChanged(mswr::Callback<SizeChangedHandler>(
-      this, &ChromeAppView::OnSizeChanged).Get(),
-      &sizechange_token_);
-  CheckHR(hr);
-
 #if defined(USE_AURA)
-  // Register for pointer notifications.
+  // Register for pointer and keyboard notifications. We forward
+  // them to the browser process via IPC.
   hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppView::OnPointerMoved).Get(),
       &pointermoved_token_);
   CheckHR(hr);
 
   hr = window_->add_PointerPressed(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppView::OnPointerPressed).Get(),
       &pointerpressed_token_);
   CheckHR(hr);
 
   hr = window_->add_PointerReleased(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppView::OnPointerReleased).Get(),
       &pointerreleased_token_);
   CheckHR(hr);
-#endif
+
+  hr = window_->add_KeyDown(mswr::Callback<KeyEventHandler>(
+      this, &ChromeAppView::OnKeyDown).Get(),
+      &keydown_token_);
+  CheckHR(hr);
+
+  hr = window_->add_KeyUp(mswr::Callback<KeyEventHandler>(
+      this, &ChromeAppView::OnKeyUp).Get(),
+      &keyup_token_);
+  CheckHR(hr);
+
+  // By initializing the direct 3D swap chain with the corewindow
+  // we can now directly blit to it from the browser process.
+  direct3d_helper_.Initialize(window);
+  DVLOG(1) << "Initialized Direct3D.";
+#else
+  // Register for size notifications.
+  hr = window_->add_SizeChanged(mswr::Callback<SizeChangedHandler>(
+      this, &ChromeAppView::OnSizeChanged).Get(),

[scottmg, 2012/10/18 00:53:19]

don't we still need this if we get snapped, etc?

[cpu_(ooo_6.6-7.5), 2012/10/18 20:15:26]

Yes we will, but the current impl assumes we have chrome.dll loaded and we
don't, so its mostly luck that we snap without crashing today.

The next change from me is probably splitting ChromeAppView in two classes so we
can do metro-ash and and legacy-metro without ifdefs everywhere.

+      &sizechange_token_);
+  CheckHR(hr);
 
   // Register for edge gesture notifications.
   mswr::ComPtr<winui::Input::IEdgeGestureStatics> edge_gesture_statics;
   hr = winrt_utils::CreateActivationFactory(
       RuntimeClass_Windows_UI_Input_EdgeGesture,
       edge_gesture_statics.GetAddressOf());
   CheckHR(hr, "Failed to activate IEdgeGestureStatics.");
 
   mswr::ComPtr<winui::Input::IEdgeGesture> edge_gesture;
   hr = edge_gesture_statics->GetForCurrentView(&edge_gesture);
@@ skipping 27 matching lines @@
   // chrome. Uncomment this once we figure out why they don't fire.
   // RegisterInputPaneNotifications();
 
   hr = winrt_utils::CreateActivationFactory(
       RuntimeClass_Windows_UI_ViewManagement_ApplicationView,
       app_view_.GetAddressOf());
   CheckHR(hr);
 
   DVLOG(1) << "Created appview instance.";
 
-  direct3d_helper_.Initialize(window);
-
-  DVLOG(1) << "Initialized Direct3D.";
-
   hr = devices_handler_.Initialize(window);
   // Don't check or return the failure here, we need to let the app
   // initialization succeed. Even if we won't be able to access devices
   // we still want to allow the app to start.
   LOG_IF(ERROR, FAILED(hr)) << "Failed to initialize devices handler.";
+#endif
+
   return S_OK;
 }
 
 IFACEMETHODIMP
 ChromeAppView::Load(HSTRING entryPoint) {
   DVLOG(1) << __FUNCTION__;
   return S_OK;
 }
 
 void RunMessageLoop(winui::Core::ICoreDispatcher* dispatcher) {
@@ skipping 210 matching lines @@
     DWORD chrome_ui_thread_id = 0;
     globals.host_thread =
         ::CreateThread(NULL, 0, HostMainThreadProc, NULL, 0,
                       &chrome_ui_thread_id);
 
     if (!globals.host_thread) {
       NOTREACHED() << "thread creation failed.";
       return E_UNEXPECTED;
     }
   }
-#endif
 
   if (RegisterHotKey(globals.core_window, kFlipWindowsHotKeyId,
                      MOD_CONTROL, VK_F12)) {
     DVLOG(1) << "Registered flip window hotkey.";
   } else {
     VPLOG(1) << "Failed to register flip window hotkey.";
   }
   HRESULT hr = settings_handler_.Initialize();
   CheckHR(hr,"Failed to initialize settings handler.");
   return hr;
+#else
+  return S_OK;
+#endif
 }
 
 // We subclass the core window for moving the associated chrome window when the
 // core window is moved around, typically in the snap view operation. The
 // size changes are handled in the documented size changed event.
 LRESULT CALLBACK ChromeAppView::CoreWindowProc(
     HWND window, UINT message, WPARAM wp, LPARAM lp) {
 
   static const UINT kBrowserClosingMessage =
       ::RegisterWindowMessage(L"DefaultBrowserClosing");
@@ skipping 90 matching lines @@
     return hr;
   if (!pointer.is_mouse())
     return S_OK;
 
   ui_channel_->Send(new MetroViewerHostMsg_MouseButton(pointer.x(),
                                                        pointer.y(),
                                                        0));
   return S_OK;
 }
 
+HRESULT ChromeAppView::OnKeyDown(winui::Core::ICoreWindow* sender,
+                                 winui::Core::IKeyEventArgs* args) {
+  winsys::VirtualKey virtual_key;
+  HRESULT hr = args->get_VirtualKey(&virtual_key);
+  if (FAILED(hr))
+    return hr;
+  winui::Core::CorePhysicalKeyStatus status;
+  hr = args->get_KeyStatus(&status);
+  if (FAILED(hr))
+    return hr;
+
+  ui_channel_->Send(new MetroViewerHostMsg_KeyDown(virtual_key,
+                                                   status.RepeatCount,
+                                                   status.ScanCode));
+  return S_OK;
+}
+
+HRESULT ChromeAppView::OnKeyUp(winui::Core::ICoreWindow* sender,
+                               winui::Core::IKeyEventArgs* args) {
+  winsys::VirtualKey virtual_key;
+  HRESULT hr = args->get_VirtualKey(&virtual_key);
+  if (FAILED(hr))
+    return hr;
+  winui::Core::CorePhysicalKeyStatus status;
+  hr = args->get_KeyStatus(&status);
+  if (FAILED(hr))
+    return hr;
+
+  ui_channel_->Send(new MetroViewerHostMsg_KeyUp(virtual_key,
+                                                 status.RepeatCount,
+                                                 status.ScanCode));
+  return S_OK;
+}
+
 HRESULT ChromeAppView::OnPositionChanged(int x, int y) {
   DVLOG(1) << __FUNCTION__;
 
   ::SetWindowPos(globals.host_windows.front().first, NULL, x, y, 0, 0,
                  SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSIZE);
   return S_OK;
 }
 
 HRESULT ChromeAppView::OnEdgeGestureCompleted(
     winui::Input::IEdgeGesture* gesture,
@@ skipping 183 matching lines @@
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   globals.view = mswr::Make<ChromeAppView>().Detach();
   *view = globals.view;
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }