Implement PointerEvent#dx

sky/engine/core/frame/NewEventHandler.cpp

 // 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 "sky/engine/config.h"
 #include "sky/engine/core/frame/NewEventHandler.h"
 
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/NodeRenderingTraversal.h"
 #include "sky/engine/core/editing/Editor.h"
@@ skipping 58 matching lines @@
 
 HitTestResult NewEventHandler::performHitTest(const LayoutPoint& point)
 {
     HitTestResult result(point);
     if (!m_frame.contentRenderer())
         return result;
     m_frame.contentRenderer()->hitTest(HitTestRequest(HitTestRequest::ReadOnly), result);
     return result;
 }
 
-bool NewEventHandler::dispatchPointerEvent(Node& target, const WebPointerEvent& event)
+bool NewEventHandler::dispatchPointerEvent(PointerState& state, const WebPointerEvent& event)
 {
     RefPtr<PointerEvent> pointerEvent = PointerEvent::create(event);
+    pointerEvent->setDX(event.x - state.x);
+    pointerEvent->setDY(event.y - state.y);
+    state.x = event.x;
+    state.y = event.y;
     // TODO(abarth): Keep track of how many pointers are targeting the same node
     // and only mark the first one as primary.
-    return target.dispatchEvent(pointerEvent.release());
+    return state.target->dispatchEvent(pointerEvent.release());
 }
 
 bool NewEventHandler::dispatchGestureEvent(Node& target, const WebGestureEvent& event)
 {
     RefPtr<GestureEvent> gestureEvent = GestureEvent::create(event);
     return target.dispatchEvent(gestureEvent.release());
 }
 
 bool NewEventHandler::dispatchKeyboardEvent(Node& target, const WebKeyboardEvent& event)
 {
@@ skipping 86 matching lines @@
     return target && !dispatchWheelEvent(*target, event);
 }
 
 bool NewEventHandler::handlePointerDownEvent(const WebPointerEvent& event)
 {
     // In principle, we shouldn't get another pointer down for the same
     // pointer ID, but for mice, we don't get a pointer cancel when you
     // drag outside the window frame on Linux. For now, send the pointer
     // cancel at this point.
     if (event.kind == WebPointerEvent::Mouse
-        && m_targetForPointer.find(event.pointer) != m_targetForPointer.end()) {
+        && m_stateForPointer.find(event.pointer) != m_stateForPointer.end()) {
         WebPointerEvent fakeCancel = event;
         fakeCancel.type = WebInputEvent::PointerCancel;
         handlePointerCancelEvent(fakeCancel);
     }
 
-    ASSERT(m_targetForPointer.find(event.pointer) == m_targetForPointer.end());
+    ASSERT(m_stateForPointer.find(event.pointer) == m_stateForPointer.end());
     HitTestResult hitTestResult = performHitTest(positionForEvent(event));
     RefPtr<Node> target = targetForHitTestResult(hitTestResult);
     if (!target)
         return false;
-    m_targetForPointer[event.pointer] = target;
-    bool eventSwallowed = !dispatchPointerEvent(*target, event);
+    PointerState& state = m_stateForPointer[event.pointer];
+    state.target = target;
+    bool eventSwallowed = !dispatchPointerEvent(state, event);
     // TODO(abarth): Set the target for the pointer to something determined when
     // dispatching the event.
     updateSelectionForPointerDown(hitTestResult, event);
     return eventSwallowed;
 }
 
 bool NewEventHandler::handlePointerUpEvent(const WebPointerEvent& event)
 {
-    auto it = m_targetForPointer.find(event.pointer);
-    if (it == m_targetForPointer.end())
+    auto it = m_stateForPointer.find(event.pointer);
+    if (it == m_stateForPointer.end())
         return false;
-    RefPtr<Node> target = it->second;
-    m_targetForPointer.erase(it);
-    ASSERT(target);
-    bool eventSwallowed = !dispatchPointerEvent(*target, event);
+    PointerState stateCopy = it->second;
+    m_stateForPointer.erase(it);
+    ASSERT(stateCopy.target);
+    bool eventSwallowed = !dispatchPointerEvent(stateCopy, event);
     // When the user releases the primary pointer, we need to dispatch a tap
     // event to the common ancestor for where the pointer went down and where
     // it came up.
-    if (!dispatchClickEvent(*target, event))
+    if (!eventSwallowed && !dispatchClickEvent(*stateCopy.target, event))
         eventSwallowed = true;
     return eventSwallowed;
 }
 
 bool NewEventHandler::handlePointerMoveEvent(const WebPointerEvent& event)
 {
-    auto it = m_targetForPointer.find(event.pointer);
-    if (it == m_targetForPointer.end())
+    auto it = m_stateForPointer.find(event.pointer);
+    if (it == m_stateForPointer.end())
         return false;
-    RefPtr<Node> target = it->second;
-    ASSERT(target);
-    return dispatchPointerEvent(*target.get(), event);
+    PointerState& state = it->second;
+    ASSERT(state.target);
+    return dispatchPointerEvent(state, event);
 }
 
 bool NewEventHandler::handlePointerCancelEvent(const WebPointerEvent& event)
 {
-    auto it = m_targetForPointer.find(event.pointer);
-    if (it == m_targetForPointer.end())
+    auto it = m_stateForPointer.find(event.pointer);
+    if (it == m_stateForPointer.end())
         return false;
-    RefPtr<Node> target = it->second;
-    m_targetForPointer.erase(it);
-    ASSERT(target);
-    return dispatchPointerEvent(*target, event);
+    PointerState stateCopy = it->second;
+    m_stateForPointer.erase(it);
+    ASSERT(stateCopy.target);
+    return dispatchPointerEvent(stateCopy, event);
 }
 
 }