Source/WebCore/platform/PlatformWheelEvent.h

   1 /*
   2  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef PlatformWheelEvent_h
  27 #define PlatformWheelEvent_h
  28
  29 #include "IntPoint.h"
  30 #include "PlatformEvent.h"
  31 #include <wtf/WindowsExtras.h>
  32
  33 #if PLATFORM(GTK)
  34 typedef struct _GdkEventScroll GdkEventScroll;
  35 #endif
  36
  37 #if PLATFORM(EFL)
  38 typedef struct _Evas_Event_Mouse_Wheel Evas_Event_Mouse_Wheel;
  39 #endif
  40
  41 namespace WebCore {
  42
  43     class FloatPoint;
  44     class FloatSize;
  45
  46     // Wheel events come in two flavors:
  47     // 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,
  48     // and synthesized in other cases where platforms generate line-by-line scrolling events.
  49     // 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
  50     // up and down (you get the same behavior as if the user was clicking in a scrollbar track to page up or page down).
  51     enum PlatformWheelEventGranularity : uint8_t {
  52         ScrollByPageWheelEvent,
  53         ScrollByPixelWheelEvent,
  54     };
  55
  56 #if PLATFORM(COCOA)
  57     enum PlatformWheelEventPhase : uint8_t {
  58         PlatformWheelEventPhaseNone        = 0,
  59         PlatformWheelEventPhaseBegan       = 1 << 0,
  60         PlatformWheelEventPhaseStationary  = 1 << 1,
  61         PlatformWheelEventPhaseChanged     = 1 << 2,
  62         PlatformWheelEventPhaseEnded       = 1 << 3,
  63         PlatformWheelEventPhaseCancelled   = 1 << 4,
  64         PlatformWheelEventPhaseMayBegin    = 1 << 5,
  65     };
  66 #endif
  67
  68     class PlatformWheelEvent : public PlatformEvent {
  69     public:
  70         PlatformWheelEvent()
  71             : PlatformEvent(PlatformEvent::Wheel)
  72             , m_deltaX(0)
  73             , m_deltaY(0)
  74             , m_wheelTicksX(0)
  75             , m_wheelTicksY(0)
  76             , m_granularity(ScrollByPixelWheelEvent)
  77             , m_directionInvertedFromDevice(false)
  78 #if PLATFORM(COCOA)
  79             , m_hasPreciseScrollingDeltas(false)
  80             , m_phase(PlatformWheelEventPhaseNone)
  81             , m_momentumPhase(PlatformWheelEventPhaseNone)
  82             , m_scrollCount(0)
  83             , m_unacceleratedScrollingDeltaX(0)
  84             , m_unacceleratedScrollingDeltaY(0)
  85 #endif
  86         {
  87         }
  88
  89         PlatformWheelEvent(IntPoint position, IntPoint globalPosition, float deltaX, float deltaY, float wheelTicksX, float wheelTicksY, PlatformWheelEventGranularity granularity, bool shiftKey, bool ctrlKey, bool altKey, bool metaKey)
  90             : PlatformEvent(PlatformEvent::Wheel, shiftKey, ctrlKey, altKey, metaKey, 0)
  91             , m_position(position)
  92             , m_globalPosition(globalPosition)
  93             , m_deltaX(deltaX)
  94             , m_deltaY(deltaY)
  95             , m_wheelTicksX(wheelTicksX)
  96             , m_wheelTicksY(wheelTicksY)
  97             , m_granularity(granularity)
  98             , m_directionInvertedFromDevice(false)
  99 #if PLATFORM(COCOA)
 100             , m_hasPreciseScrollingDeltas(false)
 101             , m_phase(PlatformWheelEventPhaseNone)
 102             , m_momentumPhase(PlatformWheelEventPhaseNone)
 103             , m_scrollCount(0)
 104             , m_unacceleratedScrollingDeltaX(0)
 105             , m_unacceleratedScrollingDeltaY(0)
 106 #endif
 107         {
 108         }
 109
 110         PlatformWheelEvent copyTurningVerticalTicksIntoHorizontalTicks() const
 111         {
 112             PlatformWheelEvent copy = *this;
 113
 114             copy.m_deltaX = copy.m_deltaY;
 115             copy.m_deltaY = 0;
 116             copy.m_wheelTicksX = copy.m_wheelTicksY;
 117             copy.m_wheelTicksY = 0;
 118
 119             return copy;
 120         }
 121
 122         PlatformWheelEvent copyWithDeltas(float deltaX, float deltaY) const
 123         {
 124             PlatformWheelEvent copy = *this;
 125             copy.m_deltaX = deltaX;
 126             copy.m_deltaY = deltaY;
 127             return copy;
 128         }
 129
 130         const IntPoint& position() const { return m_position; } // PlatformWindow coordinates.
 131         const IntPoint& globalPosition() const { return m_globalPosition; } // Screen coordinates.
 132
 133         float deltaX() const { return m_deltaX; }
 134         float deltaY() const { return m_deltaY; }
 135
 136         float wheelTicksX() const { return m_wheelTicksX; }
 137         float wheelTicksY() const { return m_wheelTicksY; }
 138
 139         PlatformWheelEventGranularity granularity() const { return m_granularity; }
 140
 141         bool directionInvertedFromDevice() const { return m_directionInvertedFromDevice; }
 142
 143 #if PLATFORM(GTK)
 144         explicit PlatformWheelEvent(GdkEventScroll*);
 145 #endif
 146
 147 #if PLATFORM(EFL)
 148         explicit PlatformWheelEvent(const Evas_Event_Mouse_Wheel*);
 149 #endif
 150
 151 #if PLATFORM(COCOA)
 152         bool hasPreciseScrollingDeltas() const { return m_hasPreciseScrollingDeltas; }
 153         void setHasPreciseScrollingDeltas(bool b) { m_hasPreciseScrollingDeltas = b; }
 154         PlatformWheelEventPhase phase() const { return m_phase; }
 155         PlatformWheelEventPhase momentumPhase() const { return m_momentumPhase; }
 156         unsigned scrollCount() const { return m_scrollCount; }
 157         float unacceleratedScrollingDeltaX() const { return m_unacceleratedScrollingDeltaX; }
 158         float unacceleratedScrollingDeltaY() const { return m_unacceleratedScrollingDeltaY; }
 159         bool useLatchedEventElement() const;
 160         bool shouldConsiderLatching() const;
 161         bool shouldResetLatching() const;
 162         bool isEndOfMomentumScroll() const;
 163         bool isEndOfNonMomentumScroll() const;
 164         bool isTransitioningToMomentumScroll() const;
 165 #else
 166         bool useLatchedEventElement() const { return false; }
 167 #endif
 168
 169 #if PLATFORM(WIN)
 170         PlatformWheelEvent(HWND, WPARAM, LPARAM, bool isMouseHWheel);
 171         PlatformWheelEvent(HWND, const FloatSize& delta, const FloatPoint& location);
 172 #endif
 173
 174     protected:
 175         IntPoint m_position;
 176         IntPoint m_globalPosition;
 177         float m_deltaX;
 178         float m_deltaY;
 179         float m_wheelTicksX;
 180         float m_wheelTicksY;
 181         PlatformWheelEventGranularity m_granularity;
 182         bool m_directionInvertedFromDevice;
 183 #if PLATFORM(COCOA)
 184         bool m_hasPreciseScrollingDeltas;
 185         PlatformWheelEventPhase m_phase;
 186         PlatformWheelEventPhase m_momentumPhase;
 187         unsigned m_scrollCount;
 188         float m_unacceleratedScrollingDeltaX;
 189         float m_unacceleratedScrollingDeltaY;
 190 #endif
 191     };
 192
 193 #if PLATFORM(COCOA)
 194     inline bool PlatformWheelEvent::useLatchedEventElement() const
 195     {
 196         return m_phase == PlatformWheelEventPhaseBegan || m_phase == PlatformWheelEventPhaseChanged
 197         || m_momentumPhase == PlatformWheelEventPhaseBegan || m_momentumPhase == PlatformWheelEventPhaseChanged
 198         || (m_phase == PlatformWheelEventPhaseEnded && m_momentumPhase == PlatformWheelEventPhaseNone);
 199     }
 200
 201     inline bool PlatformWheelEvent::shouldConsiderLatching() const
 202     {
 203         return m_phase == PlatformWheelEventPhaseBegan || m_phase == PlatformWheelEventPhaseMayBegin;
 204     }
 205
 206     inline bool PlatformWheelEvent::shouldResetLatching() const
 207     {
 208         return m_phase == PlatformWheelEventPhaseCancelled || m_phase == PlatformWheelEventPhaseMayBegin || isEndOfMomentumScroll();
 209     }
 210
 211     inline bool PlatformWheelEvent::isEndOfMomentumScroll() const
 212     {
 213         return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseEnded;
 214     }
 215
 216     inline bool PlatformWheelEvent::isEndOfNonMomentumScroll() const
 217     {
 218         return m_phase == PlatformWheelEventPhaseEnded && m_momentumPhase == PlatformWheelEventPhaseNone;
 219     }
 220
 221     inline bool PlatformWheelEvent::isTransitioningToMomentumScroll() const
 222     {
 223         return m_phase == PlatformWheelEventPhaseNone && m_momentumPhase == PlatformWheelEventPhaseBegan;
 224     }
 225 #endif
 226
 227 } // namespace WebCore
 228
 229 #endif // PlatformWheelEvent_h