Web Automation: elements larger than the viewport have incorrect in-view center point
[WebKit-https.git] / Source / WebCore / platform / PlatformWheelEvent.h
index 071355c..a2f9bc4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2004-2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -23,9 +23,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef PlatformWheelEvent_h
-#define PlatformWheelEvent_h
+#pragma once
 
+#include "FloatPoint.h"
 #include "IntPoint.h"
 #include "PlatformEvent.h"
 #include <wtf/WindowsExtras.h>
 typedef struct _GdkEventScroll GdkEventScroll;
 #endif
 
-#if PLATFORM(EFL)
-typedef struct _Evas_Event_Mouse_Wheel Evas_Event_Mouse_Wheel;
-#endif
-
 namespace WebCore {
 
-    class FloatPoint;
-    class FloatSize;
-
-    // Wheel events come in two flavors:
-    // The ScrollByPixelWheelEvent is a fine-grained event that specifies the precise number of pixels to scroll.  It is sent directly by MacBook touchpads on OS X,
-    // and synthesized in other cases where platforms generate line-by-line scrolling events.
-    // The ScrollByPageWheelEvent indicates that the wheel event should scroll an entire page.  In this case WebCore's built in paging behavior is used to page
-    // up and down (you get the same behavior as if the user was clicking in a scrollbar track to page up or page down).
-    enum PlatformWheelEventGranularity : uint8_t {
-        ScrollByPageWheelEvent,
-        ScrollByPixelWheelEvent,
-    };
+// The ScrollByPixelWheelEvent is a fine-grained event that specifies the precise number of pixels to scroll.
+// It is sent directly by touch pads on macOS, or synthesized when platforms generate line-by-line scrolling events.
+//
+// The ScrollByPageWheelEvent indicates that the wheel event should scroll an entire page.
+// In this case, WebKit built in paging behavior is used to page up and down.
+// This yields the same behavior as clicking in a scrollbar track to page up and down.
+
+enum PlatformWheelEventGranularity : uint8_t {
+    ScrollByPageWheelEvent,
+    ScrollByPixelWheelEvent,
+};
+
+#if ENABLE(ASYNC_SCROLLING)
+
+enum PlatformWheelEventPhase : uint8_t {
+    PlatformWheelEventPhaseNone = 0,
+    PlatformWheelEventPhaseBegan = 1 << 0,
+    PlatformWheelEventPhaseStationary = 1 << 1,
+    PlatformWheelEventPhaseChanged = 1 << 2,
+    PlatformWheelEventPhaseEnded = 1 << 3,
+    PlatformWheelEventPhaseCancelled = 1 << 4,
+    PlatformWheelEventPhaseMayBegin = 1 << 5,
+};
 
-#if PLATFORM(COCOA)
-    enum PlatformWheelEventPhase : uint8_t {
-        PlatformWheelEventPhaseNone        = 0,
-        PlatformWheelEventPhaseBegan       = 1 << 0,
-        PlatformWheelEventPhaseStationary  = 1 << 1,
-        PlatformWheelEventPhaseChanged     = 1 << 2,
-        PlatformWheelEventPhaseEnded       = 1 << 3,
-        PlatformWheelEventPhaseCancelled   = 1 << 4,
-        PlatformWheelEventPhaseMayBegin    = 1 << 5,
-    };
 #endif
 
-    class PlatformWheelEvent : public PlatformEvent {
-    public:
-        PlatformWheelEvent()
-            : PlatformEvent(PlatformEvent::Wheel)
-            , m_deltaX(0)
-            , m_deltaY(0)
-            , m_wheelTicksX(0)
-            , m_wheelTicksY(0)
-            , m_granularity(ScrollByPixelWheelEvent)
-            , m_directionInvertedFromDevice(false)
-#if PLATFORM(COCOA)
-            , m_hasPreciseScrollingDeltas(false)
-            , m_phase(PlatformWheelEventPhaseNone)
-            , m_momentumPhase(PlatformWheelEventPhaseNone)
-            , m_scrollCount(0)
-            , m_unacceleratedScrollingDeltaX(0)
-            , m_unacceleratedScrollingDeltaY(0)
-#endif
-        {
-        }
-
-        PlatformWheelEvent(IntPoint position, IntPoint globalPosition, float deltaX, float deltaY, float wheelTicksX, float wheelTicksY, PlatformWheelEventGranularity granularity, bool shiftKey, bool ctrlKey, bool altKey, bool metaKey)
-            : PlatformEvent(PlatformEvent::Wheel, shiftKey, ctrlKey, altKey, metaKey, 0)
-            , m_position(position)
-            , m_globalPosition(globalPosition)
-            , m_deltaX(deltaX)
-            , m_deltaY(deltaY)
-            , m_wheelTicksX(wheelTicksX)
-            , m_wheelTicksY(wheelTicksY)
-            , m_granularity(granularity)
-            , m_directionInvertedFromDevice(false)
-#if PLATFORM(COCOA)
-            , m_hasPreciseScrollingDeltas(false)
-            , m_phase(PlatformWheelEventPhaseNone)
-            , m_momentumPhase(PlatformWheelEventPhaseNone)
-            , m_scrollCount(0)
-            , m_unacceleratedScrollingDeltaX(0)
-            , m_unacceleratedScrollingDeltaY(0)
+#if PLATFORM(WIN)
+// How many pixels should we scroll per line? Gecko uses the height of the
+// current line, which means scroll distance changes as you go through the
+// page or go to different pages. IE 7 is ~50 px/line, although the value
+// seems to vary slightly by page and zoom level. Since IE 7 has a
+// smoothing algorithm on scrolling, it can get away with slightly larger
+// scroll values without feeling jerky. Here we use 100 px per three lines
+// (the default scroll amount on Windows is three lines per wheel tick).
+const float cScrollbarPixelsPerLine = 100.0f / 3.0f;
 #endif
-        {
-        }
 
-        PlatformWheelEvent copyTurningVerticalTicksIntoHorizontalTicks() const
-        {
-            PlatformWheelEvent copy = *this;
+class PlatformWheelEvent : public PlatformEvent {
+public:
+    PlatformWheelEvent()
+        : PlatformEvent(PlatformEvent::Wheel)
+    {
+    }
 
-            copy.m_deltaX = copy.m_deltaY;
-            copy.m_deltaY = 0;
-            copy.m_wheelTicksX = copy.m_wheelTicksY;
-            copy.m_wheelTicksY = 0;
+    PlatformWheelEvent(IntPoint position, IntPoint globalPosition, float deltaX, float deltaY, float wheelTicksX, float wheelTicksY, PlatformWheelEventGranularity granularity, bool shiftKey, bool ctrlKey, bool altKey, bool metaKey)
+        : PlatformEvent(PlatformEvent::Wheel, shiftKey, ctrlKey, altKey, metaKey, { })
+        , m_position(position)
+        , m_globalPosition(globalPosition)
+        , m_deltaX(deltaX)
+        , m_deltaY(deltaY)
+        , m_wheelTicksX(wheelTicksX)
+        , m_wheelTicksY(wheelTicksY)
+        , m_granularity(granularity)
+    {
+    }
 
-            return copy;
-        }
+    PlatformWheelEvent copySwappingDirection() const
+    {
+        PlatformWheelEvent copy = *this;
+        std::swap(copy.m_deltaX, copy.m_deltaY);
+        std::swap(copy.m_wheelTicksX, copy.m_wheelTicksY);
+        return copy;
+    }
+
+    PlatformWheelEvent copyWithDeltasAndVelocity(float deltaX, float deltaY, const FloatSize& velocity) const
+    {
+        PlatformWheelEvent copy = *this;
+        copy.m_deltaX = deltaX;
+        copy.m_deltaY = deltaY;
+        copy.m_scrollingVelocity = velocity;
+        return copy;
+    }
 
-        PlatformWheelEvent copyWithDeltas(float deltaX, float deltaY) const
-        {
-            PlatformWheelEvent copy = *this;
-            copy.m_deltaX = deltaX;
-            copy.m_deltaY = deltaY;
-            return copy;
-        }
+    const IntPoint& position() const { return m_position; } // PlatformWindow coordinates.
+    const IntPoint& globalPosition() const { return m_globalPosition; } // Screen coordinates.
 
-        const IntPoint& position() const { return m_position; } // PlatformWindow coordinates.
-        const IntPoint& globalPosition() const { return m_globalPosition; } // Screen coordinates.
+    float deltaX() const { return m_deltaX; }
+    float deltaY() const { return m_deltaY; }
+    FloatSize delta() const { return { m_deltaX, m_deltaY}; }
 
-        float deltaX() const { return m_deltaX; }
-        float deltaY() const { return m_deltaY; }
+    float wheelTicksX() const { return m_wheelTicksX; }
+    float wheelTicksY() const { return m_wheelTicksY; }
 
-        float wheelTicksX() const { return m_wheelTicksX; }
-        float wheelTicksY() const { return m_wheelTicksY; }
+    PlatformWheelEventGranularity granularity() const { return m_granularity; }
 
-        PlatformWheelEventGranularity granularity() const { return m_granularity; }
+    bool directionInvertedFromDevice() const { return m_directionInvertedFromDevice; }
 
-        bool directionInvertedFromDevice() const { return m_directionInvertedFromDevice; }
+    const FloatSize& scrollingVelocity() const { return m_scrollingVelocity; }
 
 #if PLATFORM(GTK)
-        explicit PlatformWheelEvent(GdkEventScroll*);
+    explicit PlatformWheelEvent(GdkEventScroll*);
 #endif
 
-#if PLATFORM(EFL)
-        explicit PlatformWheelEvent(const Evas_Event_Mouse_Wheel*);
+#if PLATFORM(COCOA)
+    bool hasPreciseScrollingDeltas() const { return m_hasPreciseScrollingDeltas; }
+    void setHasPreciseScrollingDeltas(bool hasPreciseScrollingDeltas) { m_hasPreciseScrollingDeltas = hasPreciseScrollingDeltas; }
+    unsigned scrollCount() const { return m_scrollCount; }
+    float unacceleratedScrollingDeltaX() const { return m_unacceleratedScrollingDeltaX; }
+    float unacceleratedScrollingDeltaY() const { return m_unacceleratedScrollingDeltaY; }
 #endif
 
-#if PLATFORM(COCOA)
-        bool hasPreciseScrollingDeltas() const { return m_hasPreciseScrollingDeltas; }
-        void setHasPreciseScrollingDeltas(bool b) { m_hasPreciseScrollingDeltas = b; }
-        PlatformWheelEventPhase phase() const { return m_phase; }
-        PlatformWheelEventPhase momentumPhase() const { return m_momentumPhase; }
-        unsigned scrollCount() const { return m_scrollCount; }
-        float unacceleratedScrollingDeltaX() const { return m_unacceleratedScrollingDeltaX; }
-        float unacceleratedScrollingDeltaY() const { return m_unacceleratedScrollingDeltaY; }
-        bool useLatchedEventElement() const;
-        bool shouldConsiderLatching() const;
-        bool shouldResetLatching() const;
-        bool isEndOfMomentumScroll() const;
-        bool isEndOfNonMomentumScroll() const;
-        bool isTransitioningToMomentumScroll() const;
+#if ENABLE(ASYNC_SCROLLING)
+    bool useLatchedEventElement() const;
+    bool shouldConsiderLatching() const;
+    bool shouldResetLatching() const;
+    bool isEndOfMomentumScroll() const;
 #else
-        bool useLatchedEventElement() const { return false; }
+    bool useLatchedEventElement() const { return false; }
+#endif
+
+#if ENABLE(ASYNC_SCROLLING)
+    PlatformWheelEventPhase phase() const { return m_phase; }
+    PlatformWheelEventPhase momentumPhase() const { return m_momentumPhase; }
+    bool isEndOfNonMomentumScroll() const;
+    bool isTransitioningToMomentumScroll() const;
+    FloatPoint swipeVelocity() const;
 #endif
 
 #if PLATFORM(WIN)
-        PlatformWheelEvent(HWND, WPARAM, LPARAM, bool isMouseHWheel);
-        PlatformWheelEvent(HWND, const FloatSize& delta, const FloatPoint& location);
+    PlatformWheelEvent(HWND, WPARAM, LPARAM, bool isMouseHWheel);
+    PlatformWheelEvent(HWND, const FloatSize& delta, const FloatPoint& location);
 #endif
 
-    protected:
-        IntPoint m_position;
-        IntPoint m_globalPosition;
-        float m_deltaX;
-        float m_deltaY;
-        float m_wheelTicksX;
-        float m_wheelTicksY;
-        PlatformWheelEventGranularity m_granularity;
-        bool m_directionInvertedFromDevice;
+protected:
+    IntPoint m_position;
+    IntPoint m_globalPosition;
+    float m_deltaX { 0 };
+    float m_deltaY { 0 };
+    float m_wheelTicksX { 0 };
+    float m_wheelTicksY { 0 };
+    PlatformWheelEventGranularity m_granularity { ScrollByPixelWheelEvent };
+    bool m_directionInvertedFromDevice { false };
+
+    // Scrolling velocity in pixels per second.
+    FloatSize m_scrollingVelocity;
+
+#if ENABLE(ASYNC_SCROLLING)
+    PlatformWheelEventPhase m_phase { PlatformWheelEventPhaseNone };
+    PlatformWheelEventPhase m_momentumPhase { PlatformWheelEventPhaseNone };
+#endif
 #if PLATFORM(COCOA)
-        bool m_hasPreciseScrollingDeltas;
-        PlatformWheelEventPhase m_phase;
-        PlatformWheelEventPhase m_momentumPhase;
-        unsigned m_scrollCount;
-        float m_unacceleratedScrollingDeltaX;
-        float m_unacceleratedScrollingDeltaY;
+    bool m_hasPreciseScrollingDeltas { false };
+    unsigned m_scrollCount { 0 };
+    float m_unacceleratedScrollingDeltaX { 0 };
+    float m_unacceleratedScrollingDeltaY { 0 };
 #endif
-    };
+};
 
-#if PLATFORM(COCOA)
-    inline bool PlatformWheelEvent::useLatchedEventElement() const
-    {
-        return m_phase == PlatformWheelEventPhaseBegan || m_phase == PlatformWheelEventPhaseChanged
-        || m_momentumPhase == PlatformWheelEventPhaseBegan || m_momentumPhase == PlatformWheelEventPhaseChanged
+#if ENABLE(ASYNC_SCROLLING)
+
+inline bool PlatformWheelEvent::useLatchedEventElement() const
+{
+    return m_phase == PlatformWheelEventPhaseBegan
+        || m_phase == PlatformWheelEventPhaseChanged
+        || m_momentumPhase == PlatformWheelEventPhaseBegan
+        || m_momentumPhase == PlatformWheelEventPhaseChanged
         || (m_phase == PlatformWheelEventPhaseEnded && m_momentumPhase == PlatformWheelEventPhaseNone);
-    }
-    
-    inline bool PlatformWheelEvent::shouldConsiderLatching() const
-    {
-        return m_phase == PlatformWheelEventPhaseBegan || m_phase == PlatformWheelEventPhaseMayBegin;
-    }
-    
-    inline bool PlatformWheelEvent::shouldResetLatching() const
-    {
-        return m_phase == PlatformWheelEventPhaseCancelled || m_phase == PlatformWheelEventPhaseMayBegin || isEndOfMomentumScroll();
-    }
+}
 
-    inline bool PlatformWheelEvent::isEndOfMomentumScroll() const
-    {
-        return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseEnded;
-    }
+inline bool PlatformWheelEvent::shouldConsiderLatching() const
+{
+    return m_phase == PlatformWheelEventPhaseBegan || m_phase == PlatformWheelEventPhaseMayBegin;
+}
 
-    inline bool PlatformWheelEvent::isEndOfNonMomentumScroll() const
-    {
-        return m_phase == PlatformWheelEventPhaseEnded && m_momentumPhase == PlatformWheelEventPhaseNone;
-    }
+inline bool PlatformWheelEvent::shouldResetLatching() const
+{
+    return m_phase == PlatformWheelEventPhaseCancelled || m_phase == PlatformWheelEventPhaseMayBegin || isEndOfMomentumScroll();
+}
 
-    inline bool PlatformWheelEvent::isTransitioningToMomentumScroll() const
-    {
-        return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseBegan;
-    }
-#endif
+inline bool PlatformWheelEvent::isEndOfMomentumScroll() const
+{
+    return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseEnded;
+}
 
-} // namespace WebCore
+inline bool PlatformWheelEvent::isEndOfNonMomentumScroll() const
+{
+    return m_phase == PlatformWheelEventPhaseEnded && m_momentumPhase == PlatformWheelEventPhaseNone;
+}
+
+inline bool PlatformWheelEvent::isTransitioningToMomentumScroll() const
+{
+    return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseBegan;
+}
+
+inline FloatPoint PlatformWheelEvent::swipeVelocity() const
+{
+    // The swiping velocity is stored in the deltas of the event declaring it.
+    return isTransitioningToMomentumScroll() ? FloatPoint(m_wheelTicksX, m_wheelTicksY) : FloatPoint();
+}
 
-#endif // PlatformWheelEvent_h
+#endif // ENABLE(ASYNC_SCROLLING)
+
+} // namespace WebCore