Support pen in TouchEventConverterEvdev

ui/events/ozone/evdev/event_factory_evdev.cc

 // Copyright 2014 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/events/ozone/evdev/event_factory_evdev.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 104 matching lines @@
     ui_thread_runner_->PostTask(
         FROM_HERE, base::Bind(&EventFactoryEvdev::DispatchDeviceListsComplete,
                               event_factory_evdev_));
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_runner_;
   base::WeakPtr<EventFactoryEvdev> event_factory_evdev_;
 };
 
+template <typename T>
+gfx::PointF GetTransformedEventLocation(const T& params) {
+  float x = params.location.x();
+  float y = params.location.y();
+
+  // Transform the event to align touches to the image based on display mode.
+  DeviceDataManager::GetInstance()->ApplyTouchTransformer(params.device_id, &x,
+                                                          &y);
+  return gfx::PointF(x, y);
+}
+
+template <typename T>
+PointerDetails GetTransformedEventPointerDetails(const T& params) {
+  double radius_x = params.pointer_details.radius_x;
+  double radius_y = params.pointer_details.radius_y;
+  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
+                                                          &radius_x);
+  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
+                                                          &radius_y);
+
+  PointerDetails details = params.pointer_details;
+  details.radius_x = radius_x;
+  details.radius_y = radius_y;
+  return details;
+}
+
 }  // namespace
 
 EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor,
                                      DeviceManager* device_manager,
                                      KeyboardLayoutEngine* keyboard_layout)
     : device_manager_(device_manager),
       keyboard_(&modifiers_,
                 keyboard_layout,
                 base::Bind(&EventFactoryEvdev::DispatchUiEvent,
                            base::Unretained(this))),
@@ skipping 31 matching lines @@
   TRACE_EVENT1("evdev", "EventFactoryEvdev::DispatchKeyEvent", "device",
                params.device_id);
   keyboard_.OnKeyChange(params.code, params.down, params.suppress_auto_repeat,
                         params.timestamp, params.device_id);
 }
 
 void EventFactoryEvdev::DispatchMouseMoveEvent(
     const MouseMoveEventParams& params) {
   TRACE_EVENT1("evdev", "EventFactoryEvdev::DispatchMouseMoveEvent", "device",
                params.device_id);
+
+  gfx::PointF location = params.location;
+  PointerDetails details = params.pointer_details;
+
+  if (params.flags & EF_DIRECT_INPUT) {
+    details = GetTransformedEventPointerDetails(params);
+    cursor_->MoveCursorTo(GetTransformedEventLocation(params));
+    location = cursor_->GetLocation();
+  }
+
   MouseEvent event(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
-                   params.timestamp, modifiers_.GetModifierFlags(),
+                   params.timestamp,
+                   modifiers_.GetModifierFlags() | params.flags,
                    /* changed_button_flags */ 0);
-  event.set_location_f(params.location);
-  event.set_root_location_f(params.location);
+  event.set_location_f(location);
+  event.set_root_location_f(location);
   event.set_source_device_id(params.device_id);
-  event.set_pointer_details(params.pointer_details);
+  event.set_pointer_details(details);
   DispatchUiEvent(&event);
 }
 
 void EventFactoryEvdev::DispatchMouseButtonEvent(
     const MouseButtonEventParams& params) {
   TRACE_EVENT1("evdev", "EventFactoryEvdev::DispatchMouseButtonEvent", "device",
                params.device_id);
 
+  gfx::PointF location = params.location;
+  PointerDetails details = params.pointer_details;
+
+  if (params.flags & EF_DIRECT_INPUT) {
+    details = GetTransformedEventPointerDetails(params);
+    cursor_->MoveCursorTo(GetTransformedEventLocation(params));
+    location = cursor_->GetLocation();
+  }
+
   // Mouse buttons can be remapped, touchpad taps & clicks cannot.
   unsigned int button = params.button;
   if (params.allow_remap)
     button = button_map_.GetMappedButton(button);
 
   int modifier = EVDEV_MODIFIER_NONE;
   switch (button) {
     case BTN_LEFT:
       modifier = EVDEV_MODIFIER_LEFT_MOUSE_BUTTON;
       break;
@@ skipping 18 matching lines @@
   modifiers_.UpdateModifier(modifier, params.down);
   bool down = modifiers_.GetModifierFlags() & flag;
 
   // Suppress nested clicks. EventModifiersEvdev counts presses, we only
   // dispatch an event on 0-1 (first press) and 1-0 (last release) transitions.
   if (down == was_down)
     return;
 
   MouseEvent event(params.down ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED,
                    gfx::Point(), gfx::Point(), params.timestamp,
-                   modifiers_.GetModifierFlags() | flag,
+                   modifiers_.GetModifierFlags() | flag | params.flags,
                    /* changed_button_flags */ flag);
-  event.set_location_f(params.location);
-  event.set_root_location_f(params.location);
+  event.set_location_f(location);
+  event.set_root_location_f(location);
   event.set_source_device_id(params.device_id);
-  event.set_pointer_details(params.pointer_details);
+  event.set_pointer_details(details);
   DispatchUiEvent(&event);
 }
 
 void EventFactoryEvdev::DispatchMouseWheelEvent(
     const MouseWheelEventParams& params) {
   TRACE_EVENT1("evdev", "EventFactoryEvdev::DispatchMouseWheelEvent", "device",
                params.device_id);
   MouseWheelEvent event(params.delta, gfx::Point(), gfx::Point(),
                         params.timestamp, modifiers_.GetModifierFlags(),
                         0 /* changed_button_flags */);
@@ skipping 25 matching lines @@
   event.set_location_f(params.location);
   event.set_root_location_f(params.location);
   event.set_source_device_id(params.device_id);
   DispatchUiEvent(&event);
 }
 
 void EventFactoryEvdev::DispatchTouchEvent(const TouchEventParams& params) {
   TRACE_EVENT1("evdev", "EventFactoryEvdev::DispatchTouchEvent", "device",
                params.device_id);
 
-  float x = params.location.x();
-  float y = params.location.y();
-  double radius_x = params.pointer_details.radius_x;
-  double radius_y = params.pointer_details.radius_y;
-
-  // Transform the event to align touches to the image based on display mode.
-  DeviceDataManager::GetInstance()->ApplyTouchTransformer(params.device_id, &x,
-                                                          &y);
-  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
-                                                          &radius_x);
-  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
-                                                          &radius_y);
-
-  PointerDetails details = params.pointer_details;
-  details.radius_x = radius_x;
-  details.radius_y = radius_y;
+  gfx::PointF location = GetTransformedEventLocation(params);
+  PointerDetails details = GetTransformedEventPointerDetails(params);
 
   // params.slot is guaranteed to be < kNumTouchEvdevSlots.
   int touch_id = touch_id_generator_.GetGeneratedID(
       params.device_id * kNumTouchEvdevSlots + params.slot);
   TouchEvent touch_event(
       params.type, gfx::Point(), modifiers_.GetModifierFlags(), touch_id,
       params.timestamp, /* radius_x */ 0.f, /* radius_y */ 0.f,
       /* angle */ 0.f, /* force */ 0.f);
-  touch_event.set_location_f(gfx::PointF(x, y));
-  touch_event.set_root_location_f(gfx::PointF(x, y));
+  touch_event.set_location_f(location);
+  touch_event.set_root_location_f(location);
   touch_event.set_source_device_id(params.device_id);
   touch_event.set_pointer_details(details);
   DispatchUiEvent(&touch_event);
 
   if (params.type == ET_TOUCH_RELEASED || params.type == ET_TOUCH_CANCELLED) {
     touch_id_generator_.ReleaseGeneratedID(touch_event.touch_id());
   }
 }
 
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
@@ skipping 73 matching lines @@
   if (!cursor_)
     return;
 
   cursor_->MoveCursorTo(widget, location);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EventFactoryEvdev::DispatchMouseMoveEvent,
                  weak_ptr_factory_.GetWeakPtr(),
                  MouseMoveEventParams(
-                     -1 /* device_id */, cursor_->GetLocation(),
+                     -1 /* device_id */, EF_NONE, cursor_->GetLocation(),
                      PointerDetails(EventPointerType::POINTER_TYPE_MOUSE),
                      EventTimeForNow())));
 }
 
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 void EventFactoryEvdev::StartThread() {
   // Set up device factory.
@@ skipping 15 matching lines @@
 
   // Scan & monitor devices.
   device_manager_->AddObserver(this);
   device_manager_->ScanDevices(this);
 
   // Notify device thread that initial scan is done.
   input_device_factory_proxy_->OnStartupScanComplete();
 }
 
 }  // namespace ui