Consolidate/cleanup event cracking code; single out GdkEvents.

ui/base/events.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_BASE_EVENTS_H_
 #define UI_BASE_EVENTS_H_
 #pragma once
 
+#include "ui/base/keycodes/keyboard_codes.h"
+#include "ui/gfx/native_widget_types.h"
+
+namespace gfx {
+class Point;
+}
+
+#if defined(OS_LINUX)

[sadrul, 2011/09/22 20:15:33]

#if defined(TOOLKIT_USES_GTK)

+typedef union _GdkEvent GdkEvent;
+#endif
+#if defined(USE_X11)
+typedef union _XEvent XEvent;
+#endif
+#if defined(USE_WAYLAND)
 namespace ui {
+union WaylandEvent;
+}
+#endif
+
+namespace ui {
+
+// A note about NativeEvent and NativeEvent2.
+// 1. Eventually TOOLKIT_VIEWS will converge on using XEvent as we remove
+//    Gtk/Gdk from the stack.
+// 2. TOUCH_UI needs XEvents now for certain event types.
+// 3. TOUCH_UI also needs GdkEvents for certain event types.
+//
+//    => NativeEvent and NativeEvent2.
+//
+// Once we replace usage of Gtk/Gdk types with Xlib types across the board in
+// views, we can remove NativeEvent2 and typedef XEvent* to NativeEvent. The
+// world will then be beautiful(ish).
+
+#if defined(OS_WIN)
+typedef MSG NativeEvent;
+#elif defined(OS_LINUX)
+
+#if defined(USE_WAYLAND)
+typedef ui::WaylandEvent* NativeEvent;
+#else
+typedef GdkEvent* NativeEvent;
+#endif
+
+#else
+typedef void* NativeEvent;
+#endif
+
+#if defined(USE_X11)
+typedef XEvent* NativeEvent2;
+#else
+typedef void* NativeEvent2;
+#endif

[sadrul, 2011/09/22 20:15:33]

This has to be a bit more complicated at the moment:

#if defined(OS_WIN)
...
#elif defined(USE_WAYLAND)
...
#elif defined(TOOLKIT_USES_GTK)
... the GdkEvent bits
#elif defined(USE_X11)
typedef XEvent* NativeEvent;
#else
typedef void* NativeEvent;
#endif


#if defined(TOOLKIT_USES_GTK)
typedef XEvent* NativeEvent2;
#else
typedef void* NativeEvent2;
#endif

 
 // Event types. (prefixed because of a conflict with windows headers)
 enum EventType {
   ET_UNKNOWN = 0,
   ET_MOUSE_PRESSED,
   ET_MOUSE_DRAGGED,
   ET_MOUSE_RELEASED,
   ET_MOUSE_MOVED,
   ET_MOUSE_ENTERED,
   ET_MOUSE_EXITED,
@@ skipping 15 matching lines @@
 // all platforms.
 enum EventFlags {
   EF_CAPS_LOCK_DOWN     = 1 << 0,
   EF_SHIFT_DOWN         = 1 << 1,
   EF_CONTROL_DOWN       = 1 << 2,
   EF_ALT_DOWN           = 1 << 3,
   EF_LEFT_BUTTON_DOWN   = 1 << 4,
   EF_MIDDLE_BUTTON_DOWN = 1 << 5,
   EF_RIGHT_BUTTON_DOWN  = 1 << 6,
   EF_COMMAND_DOWN       = 1 << 7,  // Only useful on OSX
+  EF_EXTENDED           = 1 << 8,  // Windows extended key (see WM_KEYDOWN doc)
 };
 
 // Flags specific to mouse events
 enum MouseEventFlags {
   EF_IS_DOUBLE_CLICK    = 1 << 16,
   EF_IS_NON_CLIENT      = 1 << 17
 };
 
 enum TouchStatus {
   TOUCH_STATUS_UNKNOWN = 0,  // Unknown touch status. This is used to indicate
                              // that the touch event was not handled.
   TOUCH_STATUS_START,        // The touch event initiated a touch sequence.
   TOUCH_STATUS_CONTINUE,     // The touch event is part of a previously
                              // started touch sequence.
   TOUCH_STATUS_END,          // The touch event ended the touch sequence.
   TOUCH_STATUS_CANCEL,       // The touch event was cancelled, but didn't
                              // terminate the touch sequence.
   TOUCH_STATUS_SYNTH_MOUSE   // The touch event was not processed, but a
                              // synthetic mouse event generated from the
                              // unused touch event was handled.
 };
 
+// Get the EventType from a native event.
+UI_EXPORT EventType EventTypeFromNative(const NativeEvent& native_event);
+UI_EXPORT EventType EventTypeFromNative(const NativeEvent2& native_event);
+
+// Get the EventFlags from a native event.
+UI_EXPORT int EventFlagsFromNative(const NativeEvent& native_event);
+UI_EXPORT int EventFlagsFromNative(const NativeEvent2& native_event);
+
+// Get the location from a native event.
+UI_EXPORT gfx::Point EventLocationFromNative(const NativeEvent& native_event);
+UI_EXPORT gfx::Point EventLocationFromNative(const NativeEvent2& native_event);
+
+// Returns the KeyboardCode from a native event.
+UI_EXPORT KeyboardCode KeyboardCodeFromNative(const NativeEvent& native_event);
+UI_EXPORT KeyboardCode KeyboardCodeFromNative(const NativeEvent2& native_event);
+
+// Returns true if the message is a mouse event.
+UI_EXPORT bool IsMouseEvent(const NativeEvent& native_event);
+UI_EXPORT bool IsMouseEvent(const NativeEvent2& native_event);
+
+// Get the mouse wheel offset from a native event.
+UI_EXPORT int GetMouseWheelOffset(const NativeEvent& native_event);
+UI_EXPORT int GetMouseWheelOffset(const NativeEvent2& native_event);
+
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_H_
-