exo: Implement support for zwp_stylus_v1 protocol

components/exo/pointer.cc

 // Copyright 2015 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 "components/exo/pointer.h"
 
 #include "ash/common/display/display_info.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "components/exo/pointer_delegate.h"
+#include "components/exo/pointer_stylus_delegate.h"
 #include "components/exo/surface.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/views/widget/widget.h"
 
 namespace exo {
 namespace {
 
@@ skipping 22 matching lines @@
   ash::Shell* ash_shell = ash::Shell::GetInstance();
   ash_shell->AddPreTargetHandler(this);
 
   wm::CursorManager* cursor_manager = ash_shell->cursor_manager();
   DCHECK(cursor_manager);
   cursor_manager->AddObserver(this);
 }
 
 Pointer::~Pointer() {
   delegate_->OnPointerDestroying(this);
+  if (stylus_delegate_)
+    stylus_delegate_->OnPointerDestroying(this);
   if (surface_)
     surface_->RemoveSurfaceObserver(this);
   if (focus_) {
     focus_->RemoveSurfaceObserver(this);
     focus_->UnregisterCursorProvider(this);
   }
   if (widget_)
     widget_->CloseNow();
 
   ash::Shell* ash_shell = ash::Shell::GetInstance();
@@ skipping 48 matching lines @@
 
   // Update cursor in case the registration of pointer as cursor provider
   // caused the cursor to change.
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(focus_->window()->GetRootWindow());
   if (cursor_client)
     cursor_client->SetCursor(
         focus_->window()->GetCursor(gfx::ToFlooredPoint(location_)));
 }
 
+void Pointer::SetStylusDelegate(PointerStylusDelegate* delegate) {
+  stylus_delegate_ = delegate;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void Pointer::OnMouseEvent(ui::MouseEvent* event) {
   Surface* target = GetEffectiveTargetForEvent(event);
 
   // If target is different than the current pointer focus then we need to
   // generate enter and leave events.
   if (target != focus_) {
     // First generate a leave event if we currently have a target in focus.
     if (focus_) {
       delegate_->OnPointerLeave(focus_);
       focus_->RemoveSurfaceObserver(this);
       // Require SetCursor() to be called and cursor to be re-defined in
       // response to each OnPointerEnter() call.
       focus_->UnregisterCursorProvider(this);
       focus_ = nullptr;
     }
     // Second generate an enter event if focus moved to a new target.
     if (target) {
       delegate_->OnPointerEnter(target, event->location_f(),
                                 event->button_flags());
       location_ = event->location_f();
+      // Defaulting pointer_type to POINTER_TYPE_MOUSE prevents the tool change
+      // event from being fired when using a mouse.
+      pointer_type_ = ui::EventPointerType::POINTER_TYPE_MOUSE;
+
       focus_ = target;
       focus_->AddSurfaceObserver(this);
     }
     delegate_->OnPointerFrame();
   }
 
+  // Report changes in pointer type. We treat unknown devices as a mouse.
+  auto new_pointer_type = event->pointer_details().pointer_type;
+  if (new_pointer_type == ui::EventPointerType::POINTER_TYPE_UNKNOWN)
+    new_pointer_type = ui::EventPointerType::POINTER_TYPE_MOUSE;
+  if (focus_ && stylus_delegate_ && new_pointer_type != pointer_type_) {
+    stylus_delegate_->OnPointerToolChange(new_pointer_type);
+    pointer_type_ = new_pointer_type;
+  }
+
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_MOUSE_RELEASED:
       if (focus_) {
         delegate_->OnPointerButton(event->time_stamp(),
                                    event->changed_button_flags(),
                                    event->type() == ui::ET_MOUSE_PRESSED);
         delegate_->OnPointerFrame();
       }
       break;
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
-      // Generate motion event if location changed. We need to check location
-      // here as mouse movement can generate both "moved" and "entered" events
-      // but OnPointerMotion should only be called if location changed since
-      // OnPointerEnter was called.
-      if (focus_ && !SameLocation(event, location_)) {
-        delegate_->OnPointerMotion(event->time_stamp(), event->location_f());
-        delegate_->OnPointerFrame();
-        location_ = event->location_f();
+      if (focus_) {
+        bool send_frame = false;
+        // Generate motion event if location changed. We need to check location
+        // here as mouse movement can generate both "moved" and "entered" events
+        // but OnPointerMotion should only be called if location changed since
+        // OnPointerEnter was called.
+        if (!SameLocation(event, location_)) {
+          location_ = event->location_f();
+          delegate_->OnPointerMotion(event->time_stamp(), location_);
+          send_frame = true;
+        }
+        if (stylus_delegate_ &&
+            pointer_type_ != ui::EventPointerType::POINTER_TYPE_MOUSE) {
+          constexpr float kEpsilon = std::numeric_limits<float>::epsilon();

[reveman, 2016/07/28 04:01:45]

is this useful? why are these type of events not filtered out at a much lower
level?

[denniskempin, 2016/07/28 17:17:39]

as discussed we will keep this for consistency with OnPointerMotion.

+          gfx::Vector2dF new_tilt = gfx::Vector2dF(
+              event->pointer_details().tilt_x, event->pointer_details().tilt_y);
+          if (std::abs(new_tilt.x() - tilt_.x()) > kEpsilon ||
+              std::abs(new_tilt.y() - tilt_.y()) > kEpsilon) {
+            tilt_ = new_tilt;
+            stylus_delegate_->OnPointerTilt(event->time_stamp(), new_tilt);
+            send_frame = true;
+          }
+
+          float new_force = event->pointer_details().force;
+          if (std::abs(new_force - force_) > kEpsilon) {
+            force_ = new_force;
+            stylus_delegate_->OnPointerForce(event->time_stamp(), new_force);
+            send_frame = true;
+          }
+        }
+        if (send_frame)
+          delegate_->OnPointerFrame();
       }
       break;
     case ui::ET_SCROLL:
       if (focus_) {
         ui::ScrollEvent* scroll_event = static_cast<ui::ScrollEvent*>(event);
         delegate_->OnPointerScroll(
             event->time_stamp(),
             gfx::Vector2dF(scroll_event->x_offset(), scroll_event->y_offset()),
             false);
         delegate_->OnPointerFrame();
@@ skipping 133 matching lines @@
 
   if (ui_scale != cursor_scale_) {
     gfx::Transform transform;
     transform.Scale(ui_scale, ui_scale);
     widget_->GetNativeWindow()->SetTransform(transform);
     cursor_scale_ = ui_scale;
   }
 }
 
 }  // namespace exo