| /* |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef WebInputEvent_h |
| #define WebInputEvent_h |
| |
| #include "WebCommon.h" |
| #include "WebGestureDevice.h" |
| #include "WebPointerProperties.h" |
| #include "WebRect.h" |
| #include "WebTouchPoint.h" |
| |
| #include <string.h> |
| |
| namespace blink { |
| |
| // The classes defined in this file are intended to be used with |
| // WebWidget's handleInputEvent method. These event types are cross- |
| // platform and correspond closely to WebCore's Platform*Event classes. |
| // |
| // WARNING! These classes must remain PODs (plain old data). They are |
| // intended to be "serializable" by copying their raw bytes, so they must |
| // not contain any non-bit-copyable member variables! |
| // |
| // Furthermore, the class members need to be packed so they are aligned |
| // properly and don't have paddings/gaps, otherwise memory check tools |
| // like Valgrind will complain about uninitialized memory usage when |
| // transferring these classes over the wire. |
| |
| #pragma pack(push, 4) |
| |
| // WebInputEvent -------------------------------------------------------------- |
| |
| class WebInputEvent { |
| public: |
| // When we use an input method (or an input method editor), we receive |
| // two events for a keypress. The former event is a keydown, which |
| // provides a keycode, and the latter is a textinput, which provides |
| // a character processed by an input method. (The mapping from a |
| // keycode to a character code is not trivial for non-English |
| // keyboards.) |
| // To support input methods, Safari sends keydown events to WebKit for |
| // filtering. WebKit sends filtered keydown events back to Safari, |
| // which sends them to input methods. |
| // Unfortunately, it is hard to apply this design to Chrome because of |
| // our multiprocess architecture. An input method is running in a |
| // browser process. On the other hand, WebKit is running in a renderer |
| // process. So, this design results in increasing IPC messages. |
| // To support input methods without increasing IPC messages, Chrome |
| // handles keyboard events in a browser process and send asynchronous |
| // input events (to be translated to DOM events) to a renderer |
| // process. |
| // This design is mostly the same as the one of Windows and Mac Carbon. |
| // So, for what it's worth, our Linux and Mac front-ends emulate our |
| // Windows front-end. To emulate our Windows front-end, we can share |
| // our back-end code among Windows, Linux, and Mac. |
| // TODO(hbono): Issue 18064: remove the KeyDown type since it isn't |
| // used in Chrome any longer. |
| |
| // A Java counterpart will be generated for this enum. |
| // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.blink_public.web |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: WebInputEventType |
| enum Type { |
| Undefined = -1, |
| TypeFirst = Undefined, |
| |
| // WebMouseEvent |
| MouseDown, |
| MouseTypeFirst = MouseDown, |
| MouseUp, |
| MouseMove, |
| MouseEnter, |
| MouseLeave, |
| ContextMenu, |
| MouseTypeLast = ContextMenu, |
| |
| // WebMouseWheelEvent |
| MouseWheel, |
| |
| // WebKeyboardEvent |
| RawKeyDown, |
| KeyboardTypeFirst = RawKeyDown, |
| KeyDown, |
| KeyUp, |
| Char, |
| KeyboardTypeLast = Char, |
| |
| // WebGestureEvent |
| GestureScrollBegin, |
| GestureTypeFirst = GestureScrollBegin, |
| GestureScrollEnd, |
| GestureScrollUpdate, |
| GestureFlingStart, |
| GestureFlingCancel, |
| GestureShowPress, |
| GestureTap, |
| GestureTapUnconfirmed, |
| GestureTapDown, |
| GestureTapCancel, |
| GestureDoubleTap, |
| GestureTwoFingerTap, |
| GestureLongPress, |
| GestureLongTap, |
| GesturePinchBegin, |
| GesturePinchEnd, |
| GesturePinchUpdate, |
| GestureTypeLast = GesturePinchUpdate, |
| |
| // WebTouchEvent |
| TouchStart, |
| TouchTypeFirst = TouchStart, |
| TouchMove, |
| TouchEnd, |
| TouchCancel, |
| TouchScrollStarted, |
| TouchTypeLast = TouchScrollStarted, |
| |
| TypeLast = TouchTypeLast |
| }; |
| |
| // The modifier constants cannot change their values since pepper |
| // does a 1-1 mapping of its values; see |
| // content/renderer/pepper/event_conversion.cc |
| // |
| // A Java counterpart will be generated for this enum. |
| // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.blink_public.web |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: WebInputEventModifier |
| enum Modifiers { |
| // modifiers for all events: |
| ShiftKey = 1 << 0, |
| ControlKey = 1 << 1, |
| AltKey = 1 << 2, |
| MetaKey = 1 << 3, |
| |
| // modifiers for keyboard events: |
| IsKeyPad = 1 << 4, |
| IsAutoRepeat = 1 << 5, |
| |
| // modifiers for mouse events: |
| LeftButtonDown = 1 << 6, |
| MiddleButtonDown = 1 << 7, |
| RightButtonDown = 1 << 8, |
| |
| // Toggle modifers for all events. |
| CapsLockOn = 1 << 9, |
| NumLockOn = 1 << 10, |
| |
| IsLeft = 1 << 11, |
| IsRight = 1 << 12, |
| |
| // Indicates that an event was generated on the touch screen while |
| // touch accessibility is enabled, so the event should be handled |
| // by accessibility code first before normal input event processing. |
| IsTouchAccessibility = 1 << 13, |
| |
| IsComposing = 1 << 14, |
| |
| AltGrKey = 1 << 15, |
| FnKey = 1 << 16, |
| SymbolKey = 1 << 17, |
| |
| ScrollLockOn = 1 << 18, |
| }; |
| |
| // Indicates whether the browser needs to block on the ACK result for |
| // this event, and if not why note (for metrics/diagnostics purposes). |
| // These values are direct mappings of the values in PlatformEvent |
| // so the values can be cast between the enumerations. static_asserts |
| // checking this are in web/WebInputEventConversion.cpp. |
| enum DispatchType { |
| // Event can be canceled. |
| Blocking, |
| // Event can not be canceled. |
| EventNonBlocking, |
| // All listeners are passive; not cancelable. |
| ListenersNonBlockingPassive, |
| // This value represents a state which would have normally blocking |
| // but was forced to be non-blocking during fling; not cancelable. |
| ListenersForcedNonBlockingDueToFling, |
| }; |
| |
| // The rail mode for a wheel event specifies the axis on which scrolling is |
| // expected to stick. If this axis is set to Free, then scrolling is not |
| // stuck to any axis. |
| enum RailsMode { |
| RailsModeFree = 0, |
| RailsModeHorizontal = 1, |
| RailsModeVertical = 2, |
| }; |
| |
| static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey; |
| |
| double timeStampSeconds; // Seconds since platform start with microsecond resolution. |
| unsigned size; // The size of this structure, for serialization. |
| Type type; |
| int modifiers; |
| |
| // Returns true if the WebInputEvent |type| is a mouse event. |
| static bool isMouseEventType(int type) |
| { |
| return MouseTypeFirst <= type && type <= MouseTypeLast; |
| } |
| |
| // Returns true if the WebInputEvent |type| is a keyboard event. |
| static bool isKeyboardEventType(int type) |
| { |
| return KeyboardTypeFirst <= type && type <= KeyboardTypeLast; |
| } |
| |
| // Returns true if the WebInputEvent |type| is a touch event. |
| static bool isTouchEventType(int type) |
| { |
| return TouchTypeFirst <= type && type <= TouchTypeLast; |
| } |
| |
| // Returns true if the WebInputEvent is a gesture event. |
| static bool isGestureEventType(int type) |
| { |
| return GestureTypeFirst <= type && type <= GestureTypeLast; |
| } |
| |
| bool isSameEventClass(const WebInputEvent& other) const |
| { |
| if (isMouseEventType(type)) |
| return isMouseEventType(other.type); |
| if (isGestureEventType(type)) |
| return isGestureEventType(other.type); |
| if (isTouchEventType(type)) |
| return isTouchEventType(other.type); |
| if (isKeyboardEventType(type)) |
| return isKeyboardEventType(other.type); |
| return type == other.type; |
| } |
| |
| protected: |
| explicit WebInputEvent(unsigned sizeParam) |
| { |
| memset(this, 0, sizeParam); |
| timeStampSeconds = 0.0; |
| size = sizeParam; |
| type = Undefined; |
| modifiers = 0; |
| } |
| }; |
| |
| // WebKeyboardEvent ----------------------------------------------------------- |
| |
| class WebKeyboardEvent : public WebInputEvent { |
| public: |
| // Caps on string lengths so we can make them static arrays and keep |
| // them PODs. |
| static const size_t textLengthCap = 4; |
| |
| // |windowsKeyCode| is the Windows key code associated with this key |
| // event. Sometimes it's direct from the event (i.e. on Windows), |
| // sometimes it's via a mapping function. If you want a list, see |
| // WebCore/platform/chromium/KeyboardCodes* . Note that this should |
| // ALWAYS store the non-locational version of a keycode as this is |
| // what is returned by the Windows API. For example, it should |
| // store VK_SHIFT instead of VK_RSHIFT. The location information |
| // should be stored in |modifiers|. |
| int windowsKeyCode; |
| |
| // The actual key code genenerated by the platform. The DOM spec runs |
| // on Windows-equivalent codes (thus |windowsKeyCode| above) but it |
| // doesn't hurt to have this one around. |
| int nativeKeyCode; |
| |
| // The DOM code enum of the key pressed as passed by the embedder. DOM |
| // code enum are defined in ui/events/keycodes/dom4/keycode_converter_data.h. |
| int domCode; |
| |
| // The DOM key enum of the key pressed as passed by the embedder. DOM |
| // key enum are defined in ui/events/keycodes/dom3/dom_key_data.h |
| int domKey; |
| |
| // This identifies whether this event was tagged by the system as being |
| // a "system key" event (see |
| // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for |
| // details). Other platforms don't have this concept, but it's just |
| // easier to leave it always false than ifdef. |
| bool isSystemKey; |
| |
| // Whether the event forms part of a browser-handled keyboard shortcut. |
| // This can be used to conditionally suppress Char events after a |
| // shortcut-triggering RawKeyDown goes unhandled. |
| bool isBrowserShortcut; |
| |
| // |text| is the text generated by this keystroke. |unmodifiedText| is |
| // |text|, but unmodified by an concurrently-held modifiers (except |
| // shift). This is useful for working out shortcut keys. Linux and |
| // Windows guarantee one character per event. The Mac does not, but in |
| // reality that's all it ever gives. We're generous, and cap it a bit |
| // longer. |
| WebUChar text[textLengthCap]; |
| WebUChar unmodifiedText[textLengthCap]; |
| |
| WebKeyboardEvent() |
| : WebInputEvent(sizeof(WebKeyboardEvent)) |
| , windowsKeyCode(0) |
| , nativeKeyCode(0) |
| , isSystemKey(false) |
| , isBrowserShortcut(false) |
| { |
| memset(&text, 0, sizeof(text)); |
| memset(&unmodifiedText, 0, sizeof(unmodifiedText)); |
| } |
| }; |
| |
| // WebMouseEvent -------------------------------------------------------------- |
| |
| class WebMouseEvent : public WebInputEvent, public WebPointerProperties { |
| public: |
| // Renderer coordinates. Similar to viewport coordinates but without |
| // DevTools emulation transform or overscroll applied. i.e. the coordinates |
| // in Chromium's RenderView bounds. |
| int x; |
| int y; |
| |
| // DEPRECATED (crbug.com/507787) |
| int windowX; |
| int windowY; |
| |
| // Screen coordinate |
| int globalX; |
| int globalY; |
| |
| int movementX; |
| int movementY; |
| int clickCount; |
| |
| WebMouseEvent() |
| : WebInputEvent(sizeof(WebMouseEvent)) |
| , WebPointerProperties() |
| , x(0) |
| , y(0) |
| , windowX(0) |
| , windowY(0) |
| , globalX(0) |
| , globalY(0) |
| , movementX(0) |
| , movementY(0) |
| , clickCount(0) |
| { |
| } |
| |
| protected: |
| explicit WebMouseEvent(unsigned sizeParam) |
| : WebInputEvent(sizeParam) |
| , WebPointerProperties() |
| , x(0) |
| , y(0) |
| , windowX(0) |
| , windowY(0) |
| , globalX(0) |
| , globalY(0) |
| , movementX(0) |
| , movementY(0) |
| , clickCount(0) |
| { |
| } |
| }; |
| |
| // WebMouseWheelEvent --------------------------------------------------------- |
| |
| class WebMouseWheelEvent : public WebMouseEvent { |
| public: |
| enum Phase { |
| PhaseNone = 0, |
| PhaseBegan = 1 << 0, |
| PhaseStationary = 1 << 1, |
| PhaseChanged = 1 << 2, |
| PhaseEnded = 1 << 3, |
| PhaseCancelled = 1 << 4, |
| PhaseMayBegin = 1 << 5, |
| }; |
| |
| float deltaX; |
| float deltaY; |
| float wheelTicksX; |
| float wheelTicksY; |
| |
| float accelerationRatioX; |
| float accelerationRatioY; |
| |
| // This field exists to allow BrowserPlugin to mark MouseWheel events as |
| // 'resent' to handle the case where an event is not consumed when first |
| // encountered; it should be handled differently by the plugin when it is |
| // sent for thesecond time. No code within Blink touches this, other than to |
| // plumb it through event conversions. |
| int resendingPluginId; |
| |
| Phase phase; |
| Phase momentumPhase; |
| |
| bool scrollByPage; |
| bool hasPreciseScrollingDeltas; |
| |
| RailsMode railsMode; |
| |
| // Whether the event is blocking, non-blocking, all event |
| // listeners were passive or was forced to be non-blocking. |
| DispatchType dispatchType; |
| |
| WebMouseWheelEvent() |
| : WebMouseEvent(sizeof(WebMouseWheelEvent)) |
| , deltaX(0.0f) |
| , deltaY(0.0f) |
| , wheelTicksX(0.0f) |
| , wheelTicksY(0.0f) |
| , accelerationRatioX(1.0f) |
| , accelerationRatioY(1.0f) |
| , resendingPluginId(-1) |
| , phase(PhaseNone) |
| , momentumPhase(PhaseNone) |
| , scrollByPage(false) |
| , hasPreciseScrollingDeltas(false) |
| , railsMode(RailsModeFree) |
| , dispatchType(Blocking) |
| { |
| } |
| }; |
| |
| // WebGestureEvent -------------------------------------------------------------- |
| |
| class WebGestureEvent : public WebInputEvent { |
| public: |
| enum ScrollUnits { |
| PrecisePixels = 0, // generated by high precision devices. |
| Pixels, // large pixel jump duration; should animate to delta. |
| Page // page (visible viewport) based scrolling. |
| }; |
| |
| enum InertialPhaseState { |
| UnknownMomentumPhase = 0, // No phase information. |
| NonMomentumPhase, // Regular scrolling phase. |
| MomentumPhase, // Momentum phase. |
| }; |
| |
| int x; |
| int y; |
| int globalX; |
| int globalY; |
| WebGestureDevice sourceDevice; |
| |
| // If the WebGestureEvent has sourceDevice=WebGestureDeviceTouchscreen, this |
| // field contains the unique identifier for the touch event that released |
| // this event at TouchDispositionGestureFilter. If the WebGestureEvents was |
| // not released through a touch event (e.g. timer-released gesture events or |
| // gesture events with sourceDevice!=WebGestureDeviceTouchscreen), the field |
| // contains 0. See crbug.com/618738. |
| uint32_t uniqueTouchEventId; |
| |
| // This field exists to allow BrowserPlugin to mark GestureScroll events as |
| // 'resent' to handle the case where an event is not consumed when first |
| // encountered; it should be handled differently by the plugin when it is |
| // sent for thesecond time. No code within Blink touches this, other than to |
| // plumb it through event conversions. |
| int resendingPluginId; |
| |
| union { |
| // Tap information must be set for GestureTap, GestureTapUnconfirmed, |
| // and GestureDoubleTap events. |
| struct { |
| int tapCount; |
| float width; |
| float height; |
| } tap; |
| |
| struct { |
| float width; |
| float height; |
| } tapDown; |
| |
| struct { |
| float width; |
| float height; |
| } showPress; |
| |
| struct { |
| float width; |
| float height; |
| } longPress; |
| |
| struct { |
| float firstFingerWidth; |
| float firstFingerHeight; |
| } twoFingerTap; |
| |
| struct { |
| // Initial motion that triggered the scroll. |
| // May be redundant with deltaX/deltaY in the first scrollUpdate. |
| float deltaXHint; |
| float deltaYHint; |
| // Default initialized to ScrollUnits::PrecisePixels. |
| ScrollUnits deltaHintUnits; |
| // If true, this event will skip hit testing to find a scroll |
| // target and instead just scroll the viewport. |
| bool targetViewport; |
| // The state of inertial phase scrolling. OSX has unique phases for normal and |
| // momentum scroll events. Should always be UnknownMomentumPhase for touch based |
| // input as it generates GestureFlingStart instead. |
| InertialPhaseState inertialPhase; |
| // True if this event was synthesized in order to force a hit test; avoiding scroll |
| // latching behavior until crbug.com/526463 is fully implemented. |
| bool synthetic; |
| } scrollBegin; |
| |
| struct { |
| float deltaX; |
| float deltaY; |
| float velocityX; |
| float velocityY; |
| // Whether any previous GestureScrollUpdate in the current scroll |
| // sequence was suppressed (e.g., the causal touchmove was |
| // preventDefault'ed). This bit is particularly useful for |
| // determining whether the observed scroll update sequence captures |
| // the entirety of the generative motion. |
| bool previousUpdateInSequencePrevented; |
| bool preventPropagation; |
| InertialPhaseState inertialPhase; |
| // Default initialized to ScrollUnits::PrecisePixels. |
| ScrollUnits deltaUnits; |
| } scrollUpdate; |
| |
| struct { |
| // The original delta units the scrollBegin and scrollUpdates |
| // were sent as. |
| ScrollUnits deltaUnits; |
| // The state of inertial phase scrolling. OSX has unique phases for normal and |
| // momentum scroll events. Should always be UnknownMomentumPhase for touch based |
| // input as it generates GestureFlingStart instead. |
| InertialPhaseState inertialPhase; |
| // True if this event was synthesized in order to generate the proper |
| // GSB/GSU/GSE matching sequences. This is a temporary so that a future |
| // GSB will generate a hit test so latching behavior is avoided |
| // until crbug.com/526463 is fully implemented. |
| bool synthetic; |
| } scrollEnd; |
| |
| struct { |
| float velocityX; |
| float velocityY; |
| // If true, this event will skip hit testing to find a scroll |
| // target and instead just scroll the viewport. |
| bool targetViewport; |
| } flingStart; |
| |
| struct { |
| // If set to true, don't treat flingCancel |
| // as a part of fling boost events sequence. |
| bool preventBoosting; |
| } flingCancel; |
| |
| struct { |
| bool zoomDisabled; |
| float scale; |
| } pinchUpdate; |
| } data; |
| |
| WebGestureEvent() |
| : WebInputEvent(sizeof(WebGestureEvent)) |
| , x(0) |
| , y(0) |
| , globalX(0) |
| , globalY(0) |
| , sourceDevice(WebGestureDeviceUninitialized) |
| , resendingPluginId(-1) |
| { |
| memset(&data, 0, sizeof(data)); |
| } |
| }; |
| |
| // WebTouchEvent -------------------------------------------------------------- |
| |
| // TODO(e_hakkinen): Replace with WebPointerEvent. crbug.com/508283 |
| class WebTouchEvent : public WebInputEvent { |
| public: |
| // Maximum number of simultaneous touches supported on |
| // Ash/Aura. |
| enum { kTouchesLengthCap = 16 }; |
| |
| unsigned touchesLength; |
| // List of all touches, regardless of state. |
| WebTouchPoint touches[kTouchesLengthCap]; |
| |
| // Whether the event is blocking, non-blocking, all event |
| // listeners were passive or was forced to be non-blocking. |
| DispatchType dispatchType; |
| |
| // For a single touch, this is true after the touch-point has moved beyond |
| // the platform slop region. For a multitouch, this is true after any |
| // touch-point has moved (by whatever amount). |
| bool movedBeyondSlopRegion; |
| |
| // Whether there was an active fling animation when the event was |
| // dispatched. |
| bool dispatchedDuringFling; |
| |
| // Whether this touch event is a touchstart or a first touchmove event per scroll. |
| bool touchStartOrFirstTouchMove; |
| |
| // A unique identifier for the touch event. Valid ids start at one and |
| // increase monotonically. Zero means an unknown id. |
| uint32_t uniqueTouchEventId; |
| |
| WebTouchEvent() |
| : WebInputEvent(sizeof(WebTouchEvent)) |
| , touchesLength(0) |
| , dispatchType(Blocking) |
| , movedBeyondSlopRegion(false) |
| , dispatchedDuringFling(false) |
| , touchStartOrFirstTouchMove(false) |
| , uniqueTouchEventId(0) |
| { |
| } |
| }; |
| |
| #pragma pack(pop) |
| |
| } // namespace blink |
| |
| #endif |