FCL/sf/mw/qtwebkit: comparison WebKit/chromium/public/WebInputEvent.h

equal deleted inserted replaced

--1:000000000000
+:4f2f89ce4247
+/*
+* 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,
+// 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,
+};
+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;
+}
+// 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;
+}
+};
+// 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