blob: d329604febf849cee79a043dd7c680a7a231d5fc [file] [log] [blame]
/*
* 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 "WebTouchPoint.h"
#include <string.h>
namespace WebKit {
// 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!
// WebInputEvent --------------------------------------------------------------
class WebInputEvent {
public:
WebInputEvent(unsigned sizeParam = sizeof(WebInputEvent))
: size(sizeParam)
, type(Undefined)
, modifiers(0)
, timeStampSeconds(0.0) { }
// 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.
enum Type {
Undefined = -1,
// WebMouseEvent
MouseDown,
MouseUp,
MouseMove,
MouseEnter,
MouseLeave,
ContextMenu,
// WebMouseWheelEvent
MouseWheel,
// WebKeyboardEvent
RawKeyDown,
KeyDown,
KeyUp,
Char,
// WebTouchEvent
TouchStart,
TouchMove,
TouchEnd,
TouchCancel,
};
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 modifiers for all events. Danger: these are not reflected
// into WebCore, so round-tripping from WebInputEvent to a WebCore
// event and back will not preserve these flags.
CapsLockOn = 1 << 9,
NumLockOn = 1 << 10,
};
static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
unsigned size; // The size of this structure, for serialization.
Type type;
int modifiers;
double timeStampSeconds; // Seconds since epoch.
// Returns true if the WebInputEvent |type| is a mouse event.
static bool isMouseEventType(int type)
{
return type == MouseDown
|| type == MouseUp
|| type == MouseMove
|| type == MouseEnter
|| type == MouseLeave
|| type == ContextMenu;
}
// Returns true if the WebInputEvent |type| is a keyboard event.
static bool isKeyboardEventType(int type)
{
return type == RawKeyDown
|| type == KeyDown
|| type == KeyUp
|| type == Char;
}
// Returns true if the WebInputEvent |type| is a touch event.
static bool isTouchEventType(int type)
{
return type == TouchStart
|| type == TouchMove
|| type == TouchEnd
|| type == TouchCancel;
}
// Returns true if the WebInputEvent |type| should be handled as user gesture.
static bool isUserGestureEventType(int type)
{
return isKeyboardEventType(type)
|| type == MouseDown
|| type == MouseUp
|| type == TouchStart
|| type == TouchEnd;
}
};
// 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;
// http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the
// identifiers. The longest is 18 characters, so we round up to the
// next multiple of 4.
static const size_t keyIdentifierLengthCap = 20;
// |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* .
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;
// |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];
// This is a string identifying the key pressed.
char keyIdentifier[keyIdentifierLengthCap];
// 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.
// int is used instead of bool to ensure the size of this structure is
// strictly aligned to a factor of 4 bytes, otherwise memory check tools
// like valgrind may complain about uninitialized memory usage when
// transfering it over the wire.
int isSystemKey;
WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent))
: WebInputEvent(sizeParam)
, windowsKeyCode(0)
, nativeKeyCode(0)
, isSystemKey(false)
{
memset(&text, 0, sizeof(text));
memset(&unmodifiedText, 0, sizeof(unmodifiedText));
memset(&keyIdentifier, 0, sizeof(keyIdentifier));
}
// Sets keyIdentifier based on the value of windowsKeyCode. This is
// handy for generating synthetic keyboard events.
WEBKIT_API void setKeyIdentifierFromWindowsKeyCode();
};
// WebMouseEvent --------------------------------------------------------------
class WebMouseEvent : public WebInputEvent {
public:
// These values defined for WebCore::MouseButton
enum Button {
ButtonNone = -1,
ButtonLeft,
ButtonMiddle,
ButtonRight
};
Button button;
int x;
int y;
int windowX;
int windowY;
int globalX;
int globalY;
int clickCount;
WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent))
: WebInputEvent(sizeParam)
, button(ButtonNone)
, x(0)
, y(0)
, windowX(0)
, windowY(0)
, globalX(0)
, globalY(0)
, clickCount(0)
{
}
};
// WebMouseWheelEvent ---------------------------------------------------------
class WebMouseWheelEvent : public WebMouseEvent {
public:
float deltaX;
float deltaY;
float wheelTicksX;
float wheelTicksY;
// int is used instead of bool to ensure the size of this structure is
// strictly aligned to a factor of 4 bytes, otherwise memory check tools
// like valgrind may complain about uninitialized memory usage when
// transfering it over the wire.
int scrollByPage;
WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent))
: WebMouseEvent(sizeParam)
, deltaX(0.0f)
, deltaY(0.0f)
, wheelTicksX(0.0f)
, wheelTicksY(0.0f)
, scrollByPage(false)
{
}
};
// WebTouchEvent --------------------------------------------------------------
class WebTouchEvent : public WebInputEvent {
public:
static const int touchPointsLengthCap = 4;
int touchPointsLength;
WebTouchPoint touchPoints[touchPointsLengthCap];
WebTouchEvent(unsigned sizeParam = sizeof(WebTouchEvent))
: WebInputEvent(sizeParam)
, touchPointsLength(0)
{
}
};
} // namespace WebKit
#endif