Replacing WM_TOUCH with WM_POINTER for touch events on Wins 8+

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <oleacc.h>
 #include <shellapi.h>
 #include <tchar.h>
@@ skipping 205 matching lines @@
 const int kAutoHideTaskbarThicknessPx = 2;
 
 bool IsTopLevelWindow(HWND window) {
   long style = ::GetWindowLong(window, GWL_STYLE);
   if (!(style & WS_CHILD))
     return true;
   HWND parent = ::GetParent(window);
   return !parent || (parent == ::GetDesktopWindow());
 }
 
+ui::EventType GetTouchEventType(POINTER_FLAGS pointer_flags) {
+  if (pointer_flags & POINTER_FLAG_DOWN)
+    return ui::ET_TOUCH_PRESSED;
+  if (pointer_flags & POINTER_FLAG_UPDATE)
+    return ui::ET_TOUCH_MOVED;
+  if (pointer_flags & POINTER_FLAG_UP)
+    return ui::ET_TOUCH_RELEASED;
+  return ui::ET_TOUCH_MOVED;
+}
+
 const int kTouchDownContextResetTimeout = 500;
 
 // Windows does not flag synthesized mouse messages from touch in all cases.
 // This causes us grief as we don't want to process touch and mouse messages
 // concurrently. Hack as per msdn is to check if the time difference between
 // the touch message and the mouse move is within 500 ms and at the same
 // location as the cursor.
 const int kSynthesizedMouseTouchMessagesTimeDifference = 500;
 
 }  // namespace
@@ skipping 1429 matching lines @@
   }
 
   UINT32 pointer_id = GET_POINTERID_WPARAM(w_param);
   using GetPointerTypeFn = BOOL(WINAPI*)(UINT32, POINTER_INPUT_TYPE*);
   POINTER_INPUT_TYPE pointer_type;
   static GetPointerTypeFn get_pointer_type = reinterpret_cast<GetPointerTypeFn>(
       GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerType"));
   // If the WM_POINTER messages are not sent from a stylus device, then we do
   // not handle them to make sure we do not change the current behavior of
   // touch and mouse inputs.
-  if (!get_pointer_type || !get_pointer_type(pointer_id, &pointer_type) ||
-      pointer_type != PT_PEN) {
+  if (!get_pointer_type || !get_pointer_type(pointer_id, &pointer_type)) {
     SetMsgHandled(FALSE);
     return -1;
   }
 
-  using GetPointerPenInfoFn = BOOL(WINAPI*)(UINT32, POINTER_PEN_INFO*);
-  POINTER_PEN_INFO pointer_pen_info;
-  static GetPointerPenInfoFn get_pointer_pen_info =
-      reinterpret_cast<GetPointerPenInfoFn>(
-          GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerPenInfo"));
-  if (!get_pointer_pen_info ||
-      !get_pointer_pen_info(pointer_id, &pointer_pen_info)) {
-    SetMsgHandled(FALSE);
-    return -1;
+  switch (pointer_type) {
+    case PT_TOUCH:
+      return HandlePointerEventTypeTouch(message, w_param, l_param);
+    case PT_PEN:
+      return HandlePointerEventTypePen(message, w_param, l_param);
+    default:
+      SetMsgHandled(FALSE);
+      return -1;
   }
-
-  // We are now creating a fake mouse event with pointer type of pen from
-  // the WM_POINTER message and then setting up an associated pointer
-  // details in the MouseEvent which contains the pen's information.
-  ui::EventPointerType input_type = ui::EventPointerType::POINTER_TYPE_PEN;
-  // TODO(lanwei): penFlags of PEN_FLAG_INVERTED may also indicate we are using
-  // an eraser, but it is under debate. Please see
-  // https://github.com/w3c/pointerevents/issues/134/.
-  if (pointer_pen_info.penFlags & PEN_FLAG_ERASER)
-    input_type = ui::EventPointerType::POINTER_TYPE_ERASER;
-
-  float pressure = static_cast<float>(pointer_pen_info.pressure) / 1024;
-  float rotation = pointer_pen_info.rotation;
-  int tilt_x = pointer_pen_info.tiltX;
-  int tilt_y = pointer_pen_info.tiltY;
-  POINT client_point = pointer_pen_info.pointerInfo.ptPixelLocationRaw;
-  ScreenToClient(hwnd(), &client_point);
-  gfx::Point point = gfx::Point(client_point.x, client_point.y);
-  ui::EventType event_type = ui::ET_MOUSE_MOVED;
-  int flag = 0;
-  int click_count = 0;
-  switch (message) {
-    case WM_POINTERDOWN:
-      event_type = ui::ET_MOUSE_PRESSED;
-      if (pointer_pen_info.pointerInfo.ButtonChangeType ==
-          POINTER_CHANGE_SECONDBUTTON_DOWN) {
-        flag = ui::EF_RIGHT_MOUSE_BUTTON;
-      } else {
-        flag = ui::EF_LEFT_MOUSE_BUTTON;
-      }
-      click_count = 1;
-      break;
-    case WM_POINTERUP:
-      event_type = ui::ET_MOUSE_RELEASED;
-      if (pointer_pen_info.pointerInfo.ButtonChangeType ==
-          POINTER_CHANGE_SECONDBUTTON_UP) {
-        flag = ui::EF_RIGHT_MOUSE_BUTTON;
-      } else {
-        flag = ui::EF_LEFT_MOUSE_BUTTON;
-      }
-      click_count = 1;
-      break;
-    case WM_POINTERUPDATE:
-      event_type = ui::ET_MOUSE_DRAGGED;
-      if (pointer_pen_info.pointerInfo.pointerFlags &
-          POINTER_FLAG_FIRSTBUTTON) {
-        flag = ui::EF_LEFT_MOUSE_BUTTON;
-      } else if (pointer_pen_info.pointerInfo.pointerFlags &
-                 POINTER_FLAG_SECONDBUTTON) {
-        flag = ui::EF_RIGHT_MOUSE_BUTTON;
-      } else {
-        event_type = ui::ET_MOUSE_MOVED;
-      }
-      break;
-    case WM_POINTERENTER:
-      event_type = ui::ET_MOUSE_ENTERED;
-      break;
-    case WM_POINTERLEAVE:
-      event_type = ui::ET_MOUSE_EXITED;
-      break;
-    default:
-      NOTREACHED();
-  }
-  ui::PointerDetails pointer_details(
-      input_type, pointer_id, /* radius_x */ 0.0f, /* radius_y */ 0.0f,
-      pressure, tilt_x, tilt_y, /* tangential_pressure */ 0.0f, rotation);
-  ui::MouseEvent event(event_type, point, point, base::TimeTicks::Now(), flag,
-                       flag, pointer_details);
-  event.SetClickCount(click_count);
-
-  // There are cases where the code handling the message destroys the
-  // window, so use the weak ptr to check if destruction occured or not.
-  base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
-  bool handled = delegate_->HandleMouseEvent(event);
-
-  if (ref)
-    SetMsgHandled(handled);
-  return 0;
 }
 
 void HWNDMessageHandler::OnMove(const gfx::Point& point) {
   delegate_->HandleMove();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnMoving(UINT param, const RECT* new_bounds) {
   delegate_->HandleMove();
 }
@@ skipping 924 matching lines @@
   // Please refer to the HandleMouseInputForCaption() function for more
   // information.
   if (!handled)
     handled = HandleMouseInputForCaption(message, w_param, l_param);
 
   if (ref.get())
     SetMsgHandled(handled);
   return 0;
 }
 
+LRESULT HWNDMessageHandler::HandlePointerEventTypeTouch(UINT message,
+                                                        WPARAM w_param,
+                                                        LPARAM l_param) {
+  UINT32 pointer_id = GET_POINTERID_WPARAM(w_param);
+  using GetPointerTouchInfoFn = BOOL(WINAPI*)(UINT32, POINTER_TOUCH_INFO*);
+  POINTER_TOUCH_INFO pointer_touch_info;
+  static GetPointerTouchInfoFn get_pointer_touch_info =
+      reinterpret_cast<GetPointerTouchInfoFn>(GetProcAddress(
+          GetModuleHandleA("user32.dll"), "GetPointerTouchInfo"));
+  if (!get_pointer_touch_info ||
+      !get_pointer_touch_info(pointer_id, &pointer_touch_info)) {
+    SetMsgHandled(FALSE);
+    return -1;
+  }
+
+  POINTER_INFO pointer_info = pointer_touch_info.pointerInfo;
+
+  POINT client_point = pointer_info.ptPixelLocationRaw;
+  ScreenToClient(hwnd(), &client_point);
+  gfx::Point touch_point = gfx::Point(client_point.x, client_point.y);

[sky, 2017/06/27 02:19:48]

These coordinates are pixels, but views expects DIPs. How are these converted to
dips?

[lanwei, 2017/06/27 18:55:42]

I did not see any conversion to DIPs in HWNDMessageHandler::OnTouchEvent, I
searched that the ConvertPointToDIP is in RenderWidgetHostViewAura:
https://codesearch.chromium.org/chromium/src/content/browser/renderer_host/re...

[sky, 2017/06/27 22:36:42]

I think it's actually done in WindowEventDispatcher.

+
+  POINTER_FLAGS pointer_flags = pointer_info.pointerFlags;
+  ui::EventType event_type = GetTouchEventType(pointer_flags);
+  const base::TimeTicks event_time = ui::EventTimeForNow();
+
+  // The pressure from POINTER_TOUCH_INFO is normalized to a range between 0
+  // and 1024, but we define the pressure of the range of [0,1].
+  float pressure = static_cast<float>(pointer_touch_info.pressure) / 1024;
+  float radius_x =
+      (pointer_touch_info.rcContact.right - pointer_touch_info.rcContact.left) /
+      2.0;
+  float radius_y =
+      (pointer_touch_info.rcContact.bottom - pointer_touch_info.rcContact.top) /
+      2.0;
+  int rotation_angle = pointer_touch_info.orientation;
+  rotation_angle %= 180;
+  if (rotation_angle < 0)
+    rotation_angle += 180;
+
+  ui::TouchEvent event(
+      event_type, touch_point, event_time,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, pointer_id,
+                         radius_x, radius_y, pressure, 0.0f, 0.0f, 0.0f,
+                         pointer_touch_info.orientation),
+      ui::GetModifiersFromKeyState(), rotation_angle);
+
+  event.latency()->AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, 0, event_time, 1);
+
+  // There are cases where the code handling the message destroys the
+  // window, so use the weak ptr to check if destruction occured or not.
+  base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
+  delegate_->HandleTouchEvent(event);
+
+  if (ref)
+    SetMsgHandled(TRUE);
+  return 0;
+}
+
+LRESULT HWNDMessageHandler::HandlePointerEventTypePen(UINT message,
+                                                      WPARAM w_param,
+                                                      LPARAM l_param) {
+  UINT32 pointer_id = GET_POINTERID_WPARAM(w_param);
+  using GetPointerPenInfoFn = BOOL(WINAPI*)(UINT32, POINTER_PEN_INFO*);
+  POINTER_PEN_INFO pointer_pen_info;
+  static GetPointerPenInfoFn get_pointer_pen_info =
+      reinterpret_cast<GetPointerPenInfoFn>(
+          GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerPenInfo"));
+  if (!get_pointer_pen_info ||
+      !get_pointer_pen_info(pointer_id, &pointer_pen_info)) {
+    SetMsgHandled(FALSE);
+    return -1;
+  }
+
+  // We are now creating a fake mouse event with pointer type of pen from
+  // the WM_POINTER message and then setting up an associated pointer
+  // details in the MouseEvent which contains the pen's information.
+  ui::EventPointerType input_type = ui::EventPointerType::POINTER_TYPE_PEN;
+  // TODO(lanwei): penFlags of PEN_FLAG_INVERTED may also indicate we are using
+  // an eraser, but it is under debate. Please see
+  // https://github.com/w3c/pointerevents/issues/134/.
+  if (pointer_pen_info.penFlags & PEN_FLAG_ERASER)
+    input_type = ui::EventPointerType::POINTER_TYPE_ERASER;
+
+  float pressure = static_cast<float>(pointer_pen_info.pressure) / 1024;
+  float rotation = pointer_pen_info.rotation;
+  int tilt_x = pointer_pen_info.tiltX;
+  int tilt_y = pointer_pen_info.tiltY;
+  POINT client_point = pointer_pen_info.pointerInfo.ptPixelLocationRaw;
+  ScreenToClient(hwnd(), &client_point);
+  gfx::Point point = gfx::Point(client_point.x, client_point.y);
+  ui::EventType event_type = ui::ET_MOUSE_MOVED;
+  int flag = 0;
+  int click_count = 0;
+  switch (message) {
+    case WM_POINTERDOWN:
+      event_type = ui::ET_MOUSE_PRESSED;
+      if (pointer_pen_info.pointerInfo.ButtonChangeType ==
+          POINTER_CHANGE_SECONDBUTTON_DOWN) {
+        flag = ui::EF_RIGHT_MOUSE_BUTTON;
+      } else {
+        flag = ui::EF_LEFT_MOUSE_BUTTON;
+      }
+      click_count = 1;
+      break;
+    case WM_POINTERUP:
+      event_type = ui::ET_MOUSE_RELEASED;
+      if (pointer_pen_info.pointerInfo.ButtonChangeType ==
+          POINTER_CHANGE_SECONDBUTTON_UP) {
+        flag = ui::EF_RIGHT_MOUSE_BUTTON;
+      } else {
+        flag = ui::EF_LEFT_MOUSE_BUTTON;
+      }
+      click_count = 1;
+      break;
+    case WM_POINTERUPDATE:
+      event_type = ui::ET_MOUSE_DRAGGED;
+      if (pointer_pen_info.pointerInfo.pointerFlags &
+          POINTER_FLAG_FIRSTBUTTON) {
+        flag = ui::EF_LEFT_MOUSE_BUTTON;
+      } else if (pointer_pen_info.pointerInfo.pointerFlags &
+                 POINTER_FLAG_SECONDBUTTON) {
+        flag = ui::EF_RIGHT_MOUSE_BUTTON;
+      } else {
+        event_type = ui::ET_MOUSE_MOVED;
+      }
+      break;
+    case WM_POINTERENTER:
+      event_type = ui::ET_MOUSE_ENTERED;
+      break;
+    case WM_POINTERLEAVE:
+      event_type = ui::ET_MOUSE_EXITED;
+      break;
+    default:
+      NOTREACHED();
+  }
+  ui::PointerDetails pointer_details(
+      input_type, pointer_id, /* radius_x */ 0.0f, /* radius_y */ 0.0f,
+      pressure, tilt_x, tilt_y, /* tangential_pressure */ 0.0f, rotation);
+  ui::MouseEvent event(event_type, point, point, base::TimeTicks::Now(), flag,
+                       flag, pointer_details);
+  event.SetClickCount(click_count);
+
+  // There are cases where the code handling the message destroys the
+  // window, so use the weak ptr to check if destruction occured or not.
+  base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
+  bool handled = delegate_->HandleMouseEvent(event);
+
+  if (ref)
+    SetMsgHandled(handled);
+  return 0;
+}
+
 bool HWNDMessageHandler::IsSynthesizedMouseMessage(unsigned int message,
                                                    int message_time,
                                                    LPARAM l_param) {
   if (ui::IsMouseEventFromTouch(message))
     return true;
   // Ignore mouse messages which occur at the same location as the current
   // cursor position and within a time difference of 500 ms from the last
   // touch message.
   if (last_touch_message_time_ && message_time >= last_touch_message_time_ &&
       ((message_time - last_touch_message_time_) <=
@@ skipping 190 matching lines @@
   MONITORINFO monitor_info = {sizeof(monitor_info)};
   GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY),
                  &monitor_info);
   gfx::Rect shrunk_rect(monitor_info.rcMonitor);
   shrunk_rect.set_height(shrunk_rect.height() - 1);
   background_fullscreen_hack_ = true;
   SetBoundsInternal(shrunk_rect, false);
 }
 
 }  // namespace views