--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/chromium/public/WebInputEvent.h Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,302 @@
+/*
+ * 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