diff options
Diffstat (limited to 'views/events')
| -rw-r--r-- | views/events/event.cc | 70 | ||||
| -rw-r--r-- | views/events/event.h | 99 | ||||
| -rw-r--r-- | views/events/event_aura.cc | 91 | ||||
| -rw-r--r-- | views/events/event_gtk.cc | 214 | ||||
| -rw-r--r-- | views/events/event_utils_win.cc | 31 | ||||
| -rw-r--r-- | views/events/event_utils_win.h | 34 | ||||
| -rw-r--r-- | views/events/event_wayland.cc | 193 | ||||
| -rw-r--r-- | views/events/event_win.cc | 288 | ||||
| -rw-r--r-- | views/events/event_x.cc | 387 |
9 files changed, 281 insertions, 1126 deletions
diff --git a/views/events/event.cc b/views/events/event.cc index a8db132..c9cfecc 100644 --- a/views/events/event.cc +++ b/views/events/event.cc @@ -17,36 +17,45 @@ Event::Event(ui::EventType type, int flags) : type_(type), time_stamp_(base::Time::NowFromSystemTime()), flags_(flags) { - Init(); + // Safely initialize the pointer/struct to null/empty. + memset(&native_event_, 0, sizeof(native_event_)); +#if defined(TOOLKIT_USES_GTK) + gdk_event_ = NULL; +#endif } -Event::Event(NativeEvent native_event, ui::EventType type, int flags) - : type_(type), - time_stamp_(base::Time::NowFromSystemTime()), - flags_(flags) { - InitWithNativeEvent(native_event); -} - -Event::Event(NativeEvent2 native_event_2, ui::EventType type, int flags, - FromNativeEvent2 from_native) - : native_event_2_(native_event_2), +Event::Event(const NativeEvent& native_event, ui::EventType type, int flags) + : native_event_(native_event), type_(type), time_stamp_(base::Time::NowFromSystemTime()), flags_(flags) { - InitWithNativeEvent2(native_event_2, from_native); +#if defined(TOOLKIT_USES_GTK) + gdk_event_ = NULL; +#endif } //////////////////////////////////////////////////////////////////////////////// // LocatedEvent, protected: +#if !defined(USE_AURA) +LocatedEvent::LocatedEvent(const NativeEvent& native_event) + : Event(native_event, + ui::EventTypeFromNative(native_event), + ui::EventFlagsFromNative(native_event)), + location_(ui::EventLocationFromNative(native_event)) { +} +#endif + // TODO(msw): Kill this legacy constructor when we update uses. -LocatedEvent::LocatedEvent(ui::EventType type, const gfx::Point& location, +LocatedEvent::LocatedEvent(ui::EventType type, + const gfx::Point& location, int flags) : Event(type, flags), location_(location) { } -LocatedEvent::LocatedEvent(const LocatedEvent& model, View* source, +LocatedEvent::LocatedEvent(const LocatedEvent& model, + View* source, View* target) : Event(model), location_(model.location_) { @@ -63,7 +72,19 @@ LocatedEvent::LocatedEvent(const LocatedEvent& model, View* root) //////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: -KeyEvent::KeyEvent(ui::EventType type, ui::KeyboardCode key_code, +#if !defined(USE_AURA) +KeyEvent::KeyEvent(const NativeEvent& native_event) + : Event(native_event, + ui::EventTypeFromNative(native_event), + ui::EventFlagsFromNative(native_event)), + key_code_(ui::KeyboardCodeFromNative(native_event)), + character_(0), + unmodified_character_(0) { +} +#endif + +KeyEvent::KeyEvent(ui::EventType type, + ui::KeyboardCode key_code, int event_flags) : Event(type, event_flags), key_code_(key_code), @@ -175,13 +196,16 @@ uint16 KeyEvent::GetCharacterFromKeyCode(ui::KeyboardCode key_code, int flags) { //////////////////////////////////////////////////////////////////////////////// // MouseEvent, public: +MouseEvent::MouseEvent(const NativeEvent& native_event) + : LocatedEvent(native_event) { +} + MouseEvent::MouseEvent(const MouseEvent& model, View* source, View* target) : LocatedEvent(model, source, target) { } -MouseEvent::MouseEvent(const TouchEvent& touch, - FromNativeEvent2 from_native) - : LocatedEvent(touch.native_event_2(), from_native) { +MouseEvent::MouseEvent(const TouchEvent& touch) + : LocatedEvent(touch.native_event()) { // The location of the event is correctly extracted from the native event. But // it is necessary to update the event type. ui::EventType mtype = ui::ET_UNKNOWN; @@ -216,6 +240,16 @@ MouseEvent::MouseEvent(const TouchEvent& touch, } //////////////////////////////////////////////////////////////////////////////// +// MouseWheelEvent, public: + +#if !defined(USE_AURA) +MouseWheelEvent::MouseWheelEvent(const ui::NativeEvent& native_event) + : MouseEvent(native_event), + offset_(ui::GetMouseWheelOffset(native_event)) { +} +#endif + +//////////////////////////////////////////////////////////////////////////////// // TouchEvent, public: TouchEvent::TouchEvent(ui::EventType type, diff --git a/views/events/event.h b/views/events/event.h index 4231598..cd9e648 100644 --- a/views/events/event.h +++ b/views/events/event.h @@ -11,20 +11,31 @@ #include "ui/base/events.h" #include "ui/base/keycodes/keyboard_codes.h" #include "ui/gfx/point.h" -#include "views/native_types.h" #include "views/views_export.h" -#if defined(USE_X11) -typedef union _XEvent XEvent; -#endif - namespace ui { class OSExchangeData; } -using ui::OSExchangeData; + +#if defined(USE_AURA) +namespace aura { +class Event; +} +#endif + +// TODO(msw): Remove GTK support from views event code when possible. +#if defined(TOOLKIT_USES_GTK) +typedef union _GdkEvent GdkEvent; +#endif namespace views { +#if defined(USE_AURA) +typedef aura::Event* NativeEvent; +#else +typedef ui::NativeEvent NativeEvent; +#endif + class View; namespace internal { @@ -32,11 +43,6 @@ class NativeWidgetView; class RootView; } -#if defined(OS_WIN) || defined(USE_AURA) -VIEWS_EXPORT bool IsClientMouseEvent(const views::NativeEvent& native_event); -VIEWS_EXPORT bool IsNonClientMouseEvent(const views::NativeEvent& native_event); -#endif - //////////////////////////////////////////////////////////////////////////////// // // Event class @@ -51,13 +57,10 @@ VIEWS_EXPORT bool IsNonClientMouseEvent(const views::NativeEvent& native_event); //////////////////////////////////////////////////////////////////////////////// class VIEWS_EXPORT Event { public: - // This type exists to distinguish between the NativeEvent and NativeEvent2 - // constructors. - // TODO(beng): remove once we rid views of Gtk/Gdk. - struct FromNativeEvent2 {}; - const NativeEvent& native_event() const { return native_event_; } - const NativeEvent2& native_event_2() const { return native_event_2_; } +#if defined(TOOLKIT_USES_GTK) + GdkEvent* gdk_event() const { return gdk_event_; } +#endif ui::EventType type() const { return type_; } const base::Time& time_stamp() const { return time_stamp_; } int flags() const { return flags_; } @@ -88,26 +91,15 @@ class VIEWS_EXPORT Event { type_ == ui::ET_TOUCH_CANCELLED; } -#if defined(OS_WIN) && !defined(USE_AURA) - // Returns the EventFlags in terms of windows flags. - int GetWindowsFlags() const; -#elif defined(OS_LINUX) - // Get the views::Event flags from a native GdkEvent. - static int GetFlagsFromGdkEvent(NativeEvent native_event); -#endif - protected: Event(ui::EventType type, int flags); - Event(NativeEvent native_event, ui::EventType type, int flags); - // Because the world is complicated, sometimes we have two different kinds of - // NativeEvent in play in the same executable. See native_types.h for the tale - // of woe. - Event(NativeEvent2 native_event, ui::EventType type, int flags, - FromNativeEvent2); + Event(const NativeEvent& native_event, ui::EventType type, int flags); +#if defined(TOOLKIT_USES_GTK) + Event(GdkEvent* gdk_event, ui::EventType type, int flags); +#endif Event(const Event& model) : native_event_(model.native_event()), - native_event_2_(model.native_event_2()), type_(model.type()), time_stamp_(model.time_stamp()), flags_(model.flags()) { @@ -118,13 +110,10 @@ class VIEWS_EXPORT Event { private: void operator=(const Event&); - // Safely initializes the native event members of this class. - void Init(); - void InitWithNativeEvent(NativeEvent native_event); - void InitWithNativeEvent2(NativeEvent2 native_event_2, FromNativeEvent2); - NativeEvent native_event_; - NativeEvent2 native_event_2_; +#if defined(TOOLKIT_USES_GTK) + GdkEvent* gdk_event_; +#endif ui::EventType type_; base::Time time_stamp_; int flags_; @@ -145,8 +134,10 @@ class VIEWS_EXPORT LocatedEvent : public Event { const gfx::Point& location() const { return location_; } protected: - explicit LocatedEvent(NativeEvent native_event); - LocatedEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native); + explicit LocatedEvent(const NativeEvent& native_event); +#if defined(TOOLKIT_USES_GTK) + explicit LocatedEvent(GdkEvent* gdk_event); +#endif // TODO(msw): Kill this legacy constructor when we update uses. // Simple initialization from cracked metadata. @@ -175,8 +166,10 @@ class TouchEvent; //////////////////////////////////////////////////////////////////////////////// class VIEWS_EXPORT MouseEvent : public LocatedEvent { public: - explicit MouseEvent(NativeEvent native_event); - MouseEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native); + explicit MouseEvent(const NativeEvent& native_event); +#if defined(TOOLKIT_USES_GTK) + explicit MouseEvent(GdkEvent* gdk_event); +#endif // Create a new MouseEvent which is identical to the provided model. // If source / target views are provided, the model location will be converted @@ -188,7 +181,7 @@ class VIEWS_EXPORT MouseEvent : public LocatedEvent { // mapped from the TouchEvent to appropriate MouseEvent attributes. // GestureManager uses this to convert TouchEvents that are not handled by any // view. - MouseEvent(const TouchEvent& touch, FromNativeEvent2 from_native); + explicit MouseEvent(const TouchEvent& touch); // TODO(msw): Kill this legacy constructor when we update uses. // Create a new mouse event @@ -247,7 +240,7 @@ class VIEWS_EXPORT MouseEvent : public LocatedEvent { //////////////////////////////////////////////////////////////////////////////// class VIEWS_EXPORT TouchEvent : public LocatedEvent { public: - TouchEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native); + explicit TouchEvent(const NativeEvent& native_event); // Create a new touch event. TouchEvent(ui::EventType type, @@ -305,8 +298,10 @@ class VIEWS_EXPORT TouchEvent : public LocatedEvent { //////////////////////////////////////////////////////////////////////////////// class VIEWS_EXPORT KeyEvent : public Event { public: - explicit KeyEvent(NativeEvent native_event); - KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native); + explicit KeyEvent(const NativeEvent& native_event); +#if defined(TOOLKIT_USES_GTK) + explicit KeyEvent(GdkEvent* gdk_event); +#endif // Creates a new KeyEvent synthetically (i.e. not in response to an input // event from the host environment). This is typically only used in testing as @@ -381,8 +376,10 @@ class VIEWS_EXPORT MouseWheelEvent : public MouseEvent { // See |offset| for details. static const int kWheelDelta; - explicit MouseWheelEvent(NativeEvent native_event); - MouseWheelEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native); + explicit MouseWheelEvent(const NativeEvent& native_event); +#if defined(TOOLKIT_USES_GTK) + explicit MouseWheelEvent(GdkEvent* gdk_event); +#endif // The amount to scroll. This is in multiples of kWheelDelta. int offset() const { return offset_; } @@ -411,7 +408,7 @@ class VIEWS_EXPORT MouseWheelEvent : public MouseEvent { //////////////////////////////////////////////////////////////////////////////// class VIEWS_EXPORT DropTargetEvent : public LocatedEvent { public: - DropTargetEvent(const OSExchangeData& data, + DropTargetEvent(const ui::OSExchangeData& data, int x, int y, int source_operations) @@ -421,12 +418,12 @@ class VIEWS_EXPORT DropTargetEvent : public LocatedEvent { // TODO(msw): Hook up key state flags for CTRL + drag and drop, etc. } - const OSExchangeData& data() const { return data_; } + const ui::OSExchangeData& data() const { return data_; } int source_operations() const { return source_operations_; } private: // Data associated with the drag/drop session. - const OSExchangeData& data_; + const ui::OSExchangeData& data_; // Bitmask of supported ui::DragDropTypes::DragOperation by the source. int source_operations_; diff --git a/views/events/event_aura.cc b/views/events/event_aura.cc index 57c9d97..f5bda06 100644 --- a/views/events/event_aura.cc +++ b/views/events/event_aura.cc @@ -9,84 +9,24 @@ namespace views { -namespace { - -int GetKeyStateFlags() { - NOTIMPLEMENTED(); - return 0; -} - -ui::EventType EventTypeFromNative(NativeEvent native_event) { - return native_event->type(); -} - -int EventFlagsFromNative(NativeEvent native_event) { - return native_event->flags(); -} - -} - -bool IsClientMouseEvent(const views::NativeEvent& native_event) { - return true; -} - -bool IsNonClientMouseEvent(const views::NativeEvent& native_event) { - return false; -} - -//////////////////////////////////////////////////////////////////////////////// -// Event, private: - -void Event::Init() { -} - -void Event::InitWithNativeEvent(NativeEvent native_event) { - native_event_ = native_event; - // TODO(beng): remove once we rid views of Gtk/Gdk. - native_event_2_ = NULL; -} - -void Event::InitWithNativeEvent2(NativeEvent2 native_event_2, - FromNativeEvent2) { - // No one should ever call this on Aura. - // TODO(beng): remove once we rid views of Gtk/Gdk. - NOTREACHED(); - native_event_2_ = NULL; -} - //////////////////////////////////////////////////////////////////////////////// // LocatedEvent, protected: -LocatedEvent::LocatedEvent(NativeEvent native_event) +LocatedEvent::LocatedEvent(const NativeEvent& native_event) : Event(native_event, native_event->type(), native_event->flags()), location_(static_cast<aura::LocatedEvent*>(native_event)->location()) { } -LocatedEvent::LocatedEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - //////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: -KeyEvent::KeyEvent(NativeEvent native_event) - : Event(native_event, native_event->type(), GetKeyStateFlags()), +KeyEvent::KeyEvent(const NativeEvent& native_event) + : Event(native_event, native_event->type(), native_event->flags()), key_code_(static_cast<aura::KeyEvent*>(native_event)->key_code()), character_(0), unmodified_character_(0) { } -KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // No one should ever call this on Windows. - // TODO(beng): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - uint16 KeyEvent::GetCharacter() const { NOTIMPLEMENTED(); return key_code_; @@ -98,34 +38,11 @@ uint16 KeyEvent::GetUnmodifiedCharacter() const { } //////////////////////////////////////////////////////////////////////////////// -// MouseEvent, public: - -MouseEvent::MouseEvent(NativeEvent native_event) - : LocatedEvent(native_event) { -} - -MouseEvent::MouseEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : LocatedEvent(native_event_2, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - -//////////////////////////////////////////////////////////////////////////////// // MouseWheelEvent, public: -MouseWheelEvent::MouseWheelEvent(NativeEvent native_event) +MouseWheelEvent::MouseWheelEvent(const NativeEvent& native_event) : MouseEvent(native_event), offset_(0 /* TODO(beng): obtain */) { } -MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : MouseEvent(native_event_2, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - } // namespace views diff --git a/views/events/event_gtk.cc b/views/events/event_gtk.cc index 13c8a8d..9221d69 100644 --- a/views/events/event_gtk.cc +++ b/views/events/event_gtk.cc @@ -8,85 +8,27 @@ #include "base/logging.h" #include "ui/base/keycodes/keyboard_code_conversion_gtk.h" - -namespace views { +#include "ui/gfx/point.h" namespace { -ui::EventType EventTypeFromNative(NativeEvent native_event) { - // Add new event types as necessary. - switch (native_event->type) { - case GDK_2BUTTON_PRESS: - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_PRESS: - return ui::ET_MOUSE_PRESSED; - case GDK_BUTTON_RELEASE: - return ui::ET_MOUSE_RELEASED; - case GDK_DRAG_MOTION: - return ui::ET_MOUSE_DRAGGED; - case GDK_ENTER_NOTIFY: - return ui::ET_MOUSE_ENTERED; +unsigned int GetGdkStateFromNative(GdkEvent* gdk_event) { + switch (gdk_event->type) { case GDK_KEY_PRESS: - return ui::ET_KEY_PRESSED; case GDK_KEY_RELEASE: - return ui::ET_KEY_RELEASED; - case GDK_LEAVE_NOTIFY: - return ui::ET_MOUSE_EXITED; - case GDK_MOTION_NOTIFY: - if (native_event->motion.state & GDK_BUTTON1_MASK || - native_event->motion.state & GDK_BUTTON2_MASK || - native_event->motion.state & GDK_BUTTON3_MASK || - native_event->motion.state & GDK_BUTTON4_MASK || - native_event->motion.state & GDK_BUTTON5_MASK) { - return ui::ET_MOUSE_DRAGGED; - } - return ui::ET_MOUSE_MOVED; - case GDK_SCROLL: - return ui::ET_MOUSEWHEEL; - default: - NOTREACHED(); - break; - } - return ui::ET_UNKNOWN; -} - -GdkEventKey* GetGdkEventKeyFromNative(NativeEvent native_event) { - DCHECK(native_event->type == GDK_KEY_PRESS || - native_event->type == GDK_KEY_RELEASE); - return &native_event->key; -} - -gfx::Point GetMouseEventLocation(NativeEvent native_event) { - double x = 0, y = 0; - if (gdk_event_get_coords(native_event, &x, &y)) - return gfx::Point(static_cast<int>(x), static_cast<int>(y)); - return gfx::Point(); -} - -int GetMouseWheelOffset(NativeEvent native_event) { - DCHECK(native_event->type == GDK_SCROLL); - int offset = (native_event->scroll.direction == GDK_SCROLL_UP || - native_event->scroll.direction == GDK_SCROLL_LEFT) ? 1 : -1; - return MouseWheelEvent::kWheelDelta * offset; -} - -unsigned int GetGdkStateFromNative(NativeEvent native_event) { - switch (native_event->type) { - case GDK_KEY_PRESS: - case GDK_KEY_RELEASE: - return native_event->key.state; + return gdk_event->key.state; case GDK_BUTTON_PRESS: case GDK_2BUTTON_PRESS: case GDK_3BUTTON_PRESS: case GDK_BUTTON_RELEASE: - return native_event->button.state; + return gdk_event->button.state; case GDK_SCROLL: - return native_event->scroll.state; + return gdk_event->scroll.state; case GDK_MOTION_NOTIFY: - return native_event->motion.state; + return gdk_event->motion.state; case GDK_ENTER_NOTIFY: case GDK_LEAVE_NOTIFY: - return native_event->crossing.state; + return gdk_event->crossing.state; default: NOTREACHED(); break; @@ -106,21 +48,55 @@ int GetFlagsFromGdkState(unsigned int state) { return flags; } -} // namespace - //////////////////////////////////////////////////////////////////////////////// -// Event, public: +// These functions mirror ui/base/events.h, but GTK is in the midst of removal. -// static -int Event::GetFlagsFromGdkEvent(NativeEvent native_event) { - int flags = GetFlagsFromGdkState(GetGdkStateFromNative(native_event)); - if (native_event->type == GDK_2BUTTON_PRESS) +ui::EventType EventTypeFromNative(GdkEvent* gdk_event) { + // Add new event types as necessary. + switch (gdk_event->type) { + case GDK_2BUTTON_PRESS: + case GDK_3BUTTON_PRESS: + case GDK_BUTTON_PRESS: + return ui::ET_MOUSE_PRESSED; + case GDK_BUTTON_RELEASE: + return ui::ET_MOUSE_RELEASED; + case GDK_DRAG_MOTION: + return ui::ET_MOUSE_DRAGGED; + case GDK_ENTER_NOTIFY: + return ui::ET_MOUSE_ENTERED; + case GDK_KEY_PRESS: + return ui::ET_KEY_PRESSED; + case GDK_KEY_RELEASE: + return ui::ET_KEY_RELEASED; + case GDK_LEAVE_NOTIFY: + return ui::ET_MOUSE_EXITED; + case GDK_MOTION_NOTIFY: + if (gdk_event->motion.state & GDK_BUTTON1_MASK || + gdk_event->motion.state & GDK_BUTTON2_MASK || + gdk_event->motion.state & GDK_BUTTON3_MASK || + gdk_event->motion.state & GDK_BUTTON4_MASK || + gdk_event->motion.state & GDK_BUTTON5_MASK) { + return ui::ET_MOUSE_DRAGGED; + } + return ui::ET_MOUSE_MOVED; + case GDK_SCROLL: + return ui::ET_MOUSEWHEEL; + default: + NOTREACHED(); + break; + } + return ui::ET_UNKNOWN; +} + +int EventFlagsFromNative(GdkEvent* gdk_event) { + int flags = GetFlagsFromGdkState(GetGdkStateFromNative(gdk_event)); + if (gdk_event->type == GDK_2BUTTON_PRESS) flags |= ui::EF_IS_DOUBLE_CLICK; - if (native_event->type == GDK_BUTTON_PRESS || - native_event->type == GDK_2BUTTON_PRESS || - native_event->type == GDK_3BUTTON_PRESS || - native_event->type == GDK_BUTTON_RELEASE) { - switch (native_event->button.button) { + if (gdk_event->type == GDK_BUTTON_PRESS || + gdk_event->type == GDK_2BUTTON_PRESS || + gdk_event->type == GDK_3BUTTON_PRESS || + gdk_event->type == GDK_BUTTON_RELEASE) { + switch (gdk_event->button.button) { case 1: return flags | ui::EF_LEFT_BUTTON_DOWN; case 2: @@ -132,54 +108,84 @@ int Event::GetFlagsFromGdkEvent(NativeEvent native_event) { return flags; } -//////////////////////////////////////////////////////////////////////////////// -// Event, private: +gfx::Point EventLocationFromNative(GdkEvent* gdk_event) { + double x = 0, y = 0; + if (gdk_event_get_coords(gdk_event, &x, &y)) + return gfx::Point(static_cast<int>(x), static_cast<int>(y)); + return gfx::Point(); +} -void Event::Init() { - native_event_ = NULL; - native_event_2_ = NULL; +ui::KeyboardCode KeyboardCodeFromNative(GdkEvent* gdk_event) { + DCHECK(gdk_event->type == GDK_KEY_PRESS || + gdk_event->type == GDK_KEY_RELEASE); + return ui::KeyboardCodeFromGdkEventKey(&gdk_event->key); } -void Event::InitWithNativeEvent(NativeEvent native_event) { - native_event_ = native_event; - // TODO(beng): remove once we rid views of Gtk/Gdk. - native_event_2_ = NULL; +bool IsMouseEvent(GdkEvent* gdk_event) { + return gdk_event->type == GDK_MOTION_NOTIFY || + gdk_event->type == GDK_BUTTON_PRESS || + gdk_event->type == GDK_2BUTTON_PRESS || + gdk_event->type == GDK_3BUTTON_PRESS || + gdk_event->type == GDK_BUTTON_RELEASE; } -//////////////////////////////////////////////////////////////////////////////// -// LocatedEvent, protected: +int GetMouseWheelOffset(GdkEvent* gdk_event) { + DCHECK(gdk_event->type == GDK_SCROLL); + int offset = (gdk_event->scroll.direction == GDK_SCROLL_UP || + gdk_event->scroll.direction == GDK_SCROLL_LEFT) ? 1 : -1; + return offset; +} -LocatedEvent::LocatedEvent(NativeEvent native_event) - : Event(native_event, EventTypeFromNative(native_event), - GetFlagsFromGdkEvent(native_event)), - location_(GetMouseEventLocation(native_event)) { +} // namespace + +namespace views { + +//////////////////////////////////////////////////////////////////////////////// +// Event, protected: + +Event::Event(GdkEvent* gdk_event, ui::EventType type, int flags) + : native_event_(NULL), + gdk_event_(gdk_event), + type_(type), + time_stamp_(base::Time::NowFromSystemTime()), + flags_(flags) { } //////////////////////////////////////////////////////////////////////////////// -// MouseEvent, public: +// LocatedEvent, protected: -MouseEvent::MouseEvent(NativeEvent native_event) - : LocatedEvent(native_event) { +LocatedEvent::LocatedEvent(GdkEvent* gdk_event) + : Event(gdk_event, + EventTypeFromNative(gdk_event), + EventFlagsFromNative(gdk_event)), + location_(EventLocationFromNative(gdk_event)) { } //////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: -KeyEvent::KeyEvent(NativeEvent native_event) - : Event(native_event, EventTypeFromNative(native_event), - GetFlagsFromGdkEvent(native_event)), - key_code_(ui::KeyboardCodeFromGdkEventKey( - GetGdkEventKeyFromNative(native_event))), +KeyEvent::KeyEvent(GdkEvent* gdk_event) + : Event(gdk_event, + EventTypeFromNative(gdk_event), + EventFlagsFromNative(gdk_event)), + key_code_(KeyboardCodeFromNative(gdk_event)), character_(0), unmodified_character_(0) { } //////////////////////////////////////////////////////////////////////////////// +// MouseEvent, public: + +MouseEvent::MouseEvent(GdkEvent* gdk_event) + : LocatedEvent(gdk_event) { +} + +//////////////////////////////////////////////////////////////////////////////// // MouseWheelEvent, public: -MouseWheelEvent::MouseWheelEvent(NativeEvent native_event) - : MouseEvent(native_event), - offset_(GetMouseWheelOffset(native_event)) { +MouseWheelEvent::MouseWheelEvent(GdkEvent* gdk_event) + : MouseEvent(gdk_event), + offset_(kWheelDelta * GetMouseWheelOffset(gdk_event)) { } } // namespace views diff --git a/views/events/event_utils_win.cc b/views/events/event_utils_win.cc deleted file mode 100644 index 7d29271..0000000 --- a/views/events/event_utils_win.cc +++ /dev/null @@ -1,31 +0,0 @@ -// 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. - -#include "views/events/event_utils_win.h" - -#include "ui/base/events.h" -#include "views/events/event.h" - -namespace views { - -int GetRepeatCount(const KeyEvent& event) { - return LOWORD(event.native_event().lParam); -} - -bool IsExtendedKey(const KeyEvent& event) { - return (HIWORD(event.native_event().lParam) & KF_EXTENDED) == KF_EXTENDED; -} - -int GetWindowsFlags(const Event& event) { - // TODO(beng): need support for x1/x2. - int result = 0; - result |= (event.flags() & ui::EF_SHIFT_DOWN) ? MK_SHIFT : 0; - result |= (event.flags() & ui::EF_CONTROL_DOWN) ? MK_CONTROL : 0; - result |= (event.flags() & ui::EF_LEFT_BUTTON_DOWN) ? MK_LBUTTON : 0; - result |= (event.flags() & ui::EF_MIDDLE_BUTTON_DOWN) ? MK_MBUTTON : 0; - result |= (event.flags() & ui::EF_RIGHT_BUTTON_DOWN) ? MK_RBUTTON : 0; - return result; -} - -} // namespace views diff --git a/views/events/event_utils_win.h b/views/events/event_utils_win.h deleted file mode 100644 index b11b45c..0000000 --- a/views/events/event_utils_win.h +++ /dev/null @@ -1,34 +0,0 @@ -// 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 VIEWS_EVENTS_EVENT_UTILS_WIN_H_ -#define VIEWS_EVENTS_EVENT_UTILS_WIN_H_ -#pragma once - -#include "ui/gfx/native_widget_types.h" -#include "views/views_export.h" - -// Windows-specific Event utilities. Add functionality here rather than adding -// #ifdefs to event.h - -namespace views { - -class Event; -class KeyEvent; - -// Returns the repeat count of the specified KeyEvent. Valid only for -// KeyEvents constructed from a MSG. -int GetRepeatCount(const KeyEvent& event); - -// Returns true if the affected key is a Windows extended key. See documentation -// for WM_KEYDOWN for explanation. -// Valid only for KeyEvents constructed from a MSG. -VIEWS_EXPORT bool IsExtendedKey(const KeyEvent& event); - -// Return a mask of windows key/button state flags for the event object. -int GetWindowsFlags(const Event& event); - -} // namespace views - -#endif // VIEWS_EVENTS_EVENT_UTILS_WIN_H_ diff --git a/views/events/event_wayland.cc b/views/events/event_wayland.cc index 92b5482..95d564f 100644 --- a/views/events/event_wayland.cc +++ b/views/events/event_wayland.cc @@ -4,191 +4,13 @@ #include "views/events/event.h" -#include <X11/Xlib.h> - #include "base/logging.h" -#include "ui/base/keycodes/keyboard_code_conversion_x.h" -#include "ui/wayland/events/wayland_event.h" namespace views { -namespace { - -static int kWheelScrollAmount = 53; - -ui::EventType EventTypeFromNative(NativeEvent native_event) { - switch (native_event->type) { - case ui::WAYLAND_BUTTON: - switch (native_event->button.button) { - case ui::LEFT_BUTTON: - case ui::RIGHT_BUTTON: - case ui::MIDDLE_BUTTON: - return native_event->button.state ? ui::ET_MOUSE_PRESSED - : ui::ET_MOUSE_RELEASED; - case ui::SCROLL_UP: - case ui::SCROLL_DOWN: - return ui::ET_MOUSEWHEEL; - default: - break; - } - break; - case ui::WAYLAND_KEY: - return native_event->key.state ? ui::ET_KEY_PRESSED - : ui::ET_KEY_RELEASED; - case ui::WAYLAND_MOTION: - return ui::ET_MOUSE_MOVED; - case ui::WAYLAND_POINTER_FOCUS: - return native_event->pointer_focus.state ? ui::ET_MOUSE_ENTERED - : ui::ET_MOUSE_EXITED; - case ui::WAYLAND_KEYBOARD_FOCUS: - return ui::ET_UNKNOWN; - default: - break; - } - return ui::ET_UNKNOWN; -} - -gfx::Point GetMouseEventLocation(NativeEvent native_event) { - switch (native_event->type) { - case ui::WAYLAND_BUTTON: - return gfx::Point(native_event->button.x, native_event->button.y); - case ui::WAYLAND_MOTION: - return gfx::Point(native_event->motion.x, native_event->motion.y); - case ui::WAYLAND_POINTER_FOCUS: - return gfx::Point(native_event->pointer_focus.x, - native_event->pointer_focus.y); - default: - return gfx::Point(0, 0); - } -} - -int GetEventFlagsFromState(unsigned int state) { - int flags = 0; - if (state & ControlMask) - flags |= ui::EF_CONTROL_DOWN; - if (state & ShiftMask) - flags |= ui::EF_SHIFT_DOWN; - if (state & Mod1Mask) - flags |= ui::EF_ALT_DOWN; - if (state & LockMask) - flags |= ui::EF_CAPS_LOCK_DOWN; - if (state & Button1Mask) - flags |= ui::EF_LEFT_BUTTON_DOWN; - if (state & Button2Mask) - flags |= ui::EF_MIDDLE_BUTTON_DOWN; - if (state & Button3Mask) - flags |= ui::EF_RIGHT_BUTTON_DOWN; - - return flags; -} - -int GetButtonEventFlagsFromNativeEvent(NativeEvent native_event) { - // TODO(dnicoara): Need to add double click. - int flags = 0; - switch (native_event->button.button) { - case ui::LEFT_BUTTON: - return flags | ui::EF_LEFT_BUTTON_DOWN; - case ui::MIDDLE_BUTTON: - return flags | ui::EF_MIDDLE_BUTTON_DOWN; - case ui::RIGHT_BUTTON: - return flags | ui::EF_RIGHT_BUTTON_DOWN; - } - return flags; -} - -int GetEventFlagsFromNativeEvent(NativeEvent native_event) { - switch (native_event->type) { - case ui::WAYLAND_BUTTON: - return GetButtonEventFlagsFromNativeEvent(native_event) | - GetEventFlagsFromState(native_event->button.modifiers); - case ui::WAYLAND_KEY: - return GetEventFlagsFromState(native_event->key.modifiers); - case ui::WAYLAND_MOTION: - return GetEventFlagsFromState(native_event->motion.modifiers); - case ui::WAYLAND_KEYBOARD_FOCUS: - return GetEventFlagsFromState(native_event->keyboard_focus.modifiers); - default: - return 0; - } -} - -int GetMouseWheelOffset(NativeEvent native_event) { - if (native_event->button.button == ui::SCROLL_UP) { - return kWheelScrollAmount; - } else { - return -kWheelScrollAmount; - } -} - -} // namespace - -//////////////////////////////////////////////////////////////////////////////// -// Event, private: - -void Event::Init() { - native_event_ = NULL; - native_event_2_ = NULL; -} - -void Event::InitWithNativeEvent(NativeEvent native_event) { - native_event_ = native_event; - // TODO(dnicoara): Remove once we rid views of Gtk/Gdk. - native_event_2_ = NULL; -} - -void Event::InitWithNativeEvent2(NativeEvent2 native_event_2, - FromNativeEvent2) { - native_event_2_ = NULL; - // TODO(dnicoara): Remove once we rid views of Gtk/Gdk. - native_event_2_ = native_event_2; -} - -//////////////////////////////////////////////////////////////////////////////// -// MouseEvent, public: - -MouseEvent::MouseEvent(NativeEvent native_event) - : LocatedEvent(native_event) { -} - -MouseEvent::MouseEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : LocatedEvent(native_event_2, from_native) { - // TODO(dnicoara): Remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - -//////////////////////////////////////////////////////////////////////////////// -// LocatedEvent, protected: - -LocatedEvent::LocatedEvent(NativeEvent native_event) - : Event(native_event, EventTypeFromNative(native_event), - GetEventFlagsFromNativeEvent(native_event)), - location_(GetMouseEventLocation(native_event)) { -} - -LocatedEvent::LocatedEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // TODO(dnicoara) Remove once we rid views of Gtk. - NOTREACHED(); -} - ////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: - -KeyEvent::KeyEvent(NativeEvent native_event) - : Event(native_event, EventTypeFromNative(native_event), - GetEventFlagsFromNativeEvent(native_event)), - key_code_(ui::KeyboardCodeFromXKeysym(native_event->key.sym)) { -} - -KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // TODO(dnicoara) Remove once we rid views of Gtk. - NOTREACHED(); -} - uint16 KeyEvent::GetCharacter() const { return GetCharacterFromKeyCode(key_code_, flags()); } @@ -197,19 +19,4 @@ uint16 KeyEvent::GetUnmodifiedCharacter() const { return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN); } -////////////////////////////////////////////////////////////////////////////// -// MouseWheelEvent, public: - -MouseWheelEvent::MouseWheelEvent(NativeEvent native_event) - : MouseEvent(native_event), - offset_(GetMouseWheelOffset(native_event)) { -} - -MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : MouseEvent(native_event_2, from_native) { - // TODO(dnicoara) Remove once we rid views of Gtk. - NOTREACHED(); -} - } // namespace views diff --git a/views/events/event_win.cc b/views/events/event_win.cc index 6f0eab0..b066c2d 100644 --- a/views/events/event_win.cc +++ b/views/events/event_win.cc @@ -4,263 +4,13 @@ #include "views/events/event.h" -#include <windows.h> - #include "base/logging.h" -#include "ui/base/keycodes/keyboard_code_conversion_win.h" namespace views { -namespace { - -// Returns a mask corresponding to the set of modifier keys that are currently -// pressed. Windows key messages don't come with control key state as parameters -// as with mouse messages, so we need to explicitly ask for these states. -int GetKeyStateFlags() { - int flags = 0; - flags |= (GetKeyState(VK_MENU) & 0x80)? ui::EF_ALT_DOWN : 0; - flags |= (GetKeyState(VK_SHIFT) & 0x80)? ui::EF_SHIFT_DOWN : 0; - flags |= (GetKeyState(VK_CONTROL) & 0x80)? ui::EF_CONTROL_DOWN : 0; - return flags; -} - -bool IsButtonDown(NativeEvent native_event) { - return (native_event.wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON | - MK_XBUTTON1 | MK_XBUTTON2)) != 0; -} - -// Convert windows message identifiers to Event types. -ui::EventType EventTypeFromNative(NativeEvent native_event) { - switch (native_event.message) { - case WM_KEYDOWN: - case WM_SYSKEYDOWN: - case WM_CHAR: - return ui::ET_KEY_PRESSED; - case WM_KEYUP: - case WM_SYSKEYUP: - return ui::ET_KEY_RELEASED; - case WM_LBUTTONDBLCLK: - case WM_LBUTTONDOWN: - case WM_MBUTTONDBLCLK: - case WM_MBUTTONDOWN: - case WM_NCLBUTTONDBLCLK: - case WM_NCLBUTTONDOWN: - case WM_NCMBUTTONDBLCLK: - case WM_NCMBUTTONDOWN: - case WM_NCRBUTTONDBLCLK: - case WM_NCRBUTTONDOWN: - case WM_NCXBUTTONDBLCLK: - case WM_NCXBUTTONDOWN: - case WM_RBUTTONDBLCLK: - case WM_RBUTTONDOWN: - case WM_XBUTTONDBLCLK: - case WM_XBUTTONDOWN: - return ui::ET_MOUSE_PRESSED; - case WM_LBUTTONUP: - case WM_MBUTTONUP: - case WM_NCLBUTTONUP: - case WM_NCMBUTTONUP: - case WM_NCRBUTTONUP: - case WM_NCXBUTTONUP: - case WM_RBUTTONUP: - case WM_XBUTTONUP: - return ui::ET_MOUSE_RELEASED; - case WM_MOUSEMOVE: - return IsButtonDown(native_event) ? ui::ET_MOUSE_DRAGGED : - ui::ET_MOUSE_MOVED; - case WM_NCMOUSEMOVE: - return ui::ET_MOUSE_MOVED; - case WM_MOUSEWHEEL: - return ui::ET_MOUSEWHEEL; - case WM_MOUSELEAVE: - case WM_NCMOUSELEAVE: - return ui::ET_MOUSE_EXITED; - default: - NOTREACHED(); - } - return ui::ET_UNKNOWN; -} - -// Get views::Event flags from a native Windows message -int EventFlagsFromNative(NativeEvent native_event) { - int flags = 0; - - // TODO(msw): ORing the pressed/released button into the flags is _wrong_. - // It makes it impossible to tell which button was modified when multiple - // buttons are/were held down. We need to instead put the modified button into - // a separate member on the MouseEvent, then audit all consumers of - // MouseEvents to fix them to use the resulting values correctly. - switch (native_event.message) { - case WM_LBUTTONDBLCLK: - case WM_LBUTTONDOWN: - case WM_LBUTTONUP: - case WM_NCLBUTTONDBLCLK: - case WM_NCLBUTTONDOWN: - case WM_NCLBUTTONUP: - native_event.wParam |= MK_LBUTTON; - break; - case WM_MBUTTONDBLCLK: - case WM_MBUTTONDOWN: - case WM_MBUTTONUP: - case WM_NCMBUTTONDBLCLK: - case WM_NCMBUTTONDOWN: - case WM_NCMBUTTONUP: - native_event.wParam |= MK_MBUTTON; - break; - case WM_RBUTTONDBLCLK: - case WM_RBUTTONDOWN: - case WM_RBUTTONUP: - case WM_NCRBUTTONDBLCLK: - case WM_NCRBUTTONDOWN: - case WM_NCRBUTTONUP: - native_event.wParam |= MK_RBUTTON; - break; - case WM_NCXBUTTONDBLCLK: - case WM_NCXBUTTONDOWN: - case WM_NCXBUTTONUP: - case WM_XBUTTONDBLCLK: - case WM_XBUTTONDOWN: - case WM_XBUTTONUP: - native_event.wParam |= MK_XBUTTON1; - break; - } - - // Check if the event occurred in the non-client area. - if (IsNonClientMouseEvent(native_event)) - flags |= ui::EF_IS_NON_CLIENT; - - // Check for double click events. - switch (native_event.message) { - case WM_NCLBUTTONDBLCLK: - case WM_NCMBUTTONDBLCLK: - case WM_NCRBUTTONDBLCLK: - case WM_NCXBUTTONDBLCLK: - case WM_LBUTTONDBLCLK: - case WM_MBUTTONDBLCLK: - case WM_RBUTTONDBLCLK: - case WM_XBUTTONDBLCLK: - flags |= ui::EF_IS_DOUBLE_CLICK; - break; - } - - // For non-client mouse message, the WPARAM value represents the hit test - // result, instead of the key state. - switch (native_event.message) { - case WM_NCLBUTTONDOWN: - case WM_NCLBUTTONUP: - flags |= ui::EF_LEFT_BUTTON_DOWN; - break; - case WM_NCMBUTTONDOWN: - case WM_NCMBUTTONUP: - flags |= ui::EF_MIDDLE_BUTTON_DOWN; - break; - case WM_NCRBUTTONDOWN: - case WM_NCRBUTTONUP: - flags |= ui::EF_RIGHT_BUTTON_DOWN; - break; - default: { - UINT win_flags = GET_KEYSTATE_WPARAM(native_event.wParam); - flags |= (win_flags & MK_CONTROL) ? ui::EF_CONTROL_DOWN : 0; - flags |= (win_flags & MK_SHIFT) ? ui::EF_SHIFT_DOWN : 0; - flags |= (GetKeyState(VK_MENU) < 0) ? ui::EF_ALT_DOWN : 0; - flags |= (win_flags & MK_LBUTTON) ? ui::EF_LEFT_BUTTON_DOWN : 0; - flags |= (win_flags & MK_MBUTTON) ? ui::EF_MIDDLE_BUTTON_DOWN : 0; - flags |= (win_flags & MK_RBUTTON) ? ui::EF_RIGHT_BUTTON_DOWN : 0; - break; - } - } - - return flags; -} - -} // namespace - -bool IsClientMouseEvent(const views::NativeEvent& native_event) { - return native_event.message == WM_MOUSELEAVE || - native_event.message == WM_MOUSEHOVER || - (native_event.message >= WM_MOUSEFIRST && - native_event.message <= WM_MOUSELAST); -} - -bool IsNonClientMouseEvent(const views::NativeEvent& native_event) { - return native_event.message == WM_NCMOUSELEAVE || - native_event.message == WM_NCMOUSEHOVER || - (native_event.message >= WM_NCMOUSEMOVE && - native_event.message <= WM_NCXBUTTONDBLCLK); -} - -//////////////////////////////////////////////////////////////////////////////// -// Event, public: - -int Event::GetWindowsFlags() const { - // TODO: need support for x1/x2. - int result = 0; - result |= (flags_ & ui::EF_SHIFT_DOWN) ? MK_SHIFT : 0; - result |= (flags_ & ui::EF_CONTROL_DOWN) ? MK_CONTROL : 0; - result |= (flags_ & ui::EF_LEFT_BUTTON_DOWN) ? MK_LBUTTON : 0; - result |= (flags_ & ui::EF_MIDDLE_BUTTON_DOWN) ? MK_MBUTTON : 0; - result |= (flags_ & ui::EF_RIGHT_BUTTON_DOWN) ? MK_RBUTTON : 0; - return result; -} - -//////////////////////////////////////////////////////////////////////////////// -// Event, private: - -void Event::Init() { - ZeroMemory(&native_event_, sizeof(native_event_)); - native_event_2_ = NULL; -} - -void Event::InitWithNativeEvent(NativeEvent native_event) { - native_event_ = native_event; - // TODO(beng): remove once we rid views of Gtk/Gdk. - native_event_2_ = NULL; -} - -void Event::InitWithNativeEvent2(NativeEvent2 native_event_2, - FromNativeEvent2) { - // No one should ever call this on Windows. - // TODO(beng): remove once we rid views of Gtk/Gdk. - NOTREACHED(); - native_event_2_ = NULL; -} - -//////////////////////////////////////////////////////////////////////////////// -// LocatedEvent, protected: - -LocatedEvent::LocatedEvent(NativeEvent native_event) - : Event(native_event, EventTypeFromNative(native_event), - EventFlagsFromNative(native_event)), - location_(native_event.pt.x, native_event.pt.y) { -} - -LocatedEvent::LocatedEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - //////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: -KeyEvent::KeyEvent(NativeEvent native_event) - : Event(native_event, - EventTypeFromNative(native_event), - GetKeyStateFlags()), - key_code_(ui::KeyboardCodeForWindowsKeyCode(native_event.wParam)), - character_(0), - unmodified_character_(0) { -} - -KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native) - : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) { - // No one should ever call this on Windows. - // TODO(beng): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - uint16 KeyEvent::GetCharacter() const { if (character_) return character_; @@ -276,42 +26,4 @@ uint16 KeyEvent::GetUnmodifiedCharacter() const { GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN); } -//////////////////////////////////////////////////////////////////////////////// -// MouseEvent, public: - -MouseEvent::MouseEvent(NativeEvent native_event) - : LocatedEvent(native_event) { - if (IsNonClientMouseEvent(native_event)) { - // Non-client message. The position is contained in a POINTS structure in - // LPARAM, and is in screen coordinates so we have to convert to client. - POINT native_point = location_.ToPOINT(); - ScreenToClient(native_event.hwnd, &native_point); - location_ = gfx::Point(native_point); - } -} - -MouseEvent::MouseEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : LocatedEvent(native_event_2, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - -//////////////////////////////////////////////////////////////////////////////// -// MouseWheelEvent, public: - -MouseWheelEvent::MouseWheelEvent(NativeEvent native_event) - : MouseEvent(native_event), - offset_(GET_WHEEL_DELTA_WPARAM(native_event.wParam)) { -} - -MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : MouseEvent(native_event_2, from_native) { - // No one should ever call this on Windows. - // TODO(msw): remove once we rid views of Gtk/Gdk. - NOTREACHED(); -} - } // namespace views diff --git a/views/events/event_x.cc b/views/events/event_x.cc index fda4aff..9957d5f0 100644 --- a/views/events/event_x.cc +++ b/views/events/event_x.cc @@ -12,234 +12,27 @@ #include "base/logging.h" #include "base/utf_string_conversions.h" #include "ui/base/keycodes/keyboard_code_conversion_x.h" -#include "views/touchui/touch_factory.h" +#include "ui/base/touch/touch_factory.h" #include "views/widget/root_view.h" namespace views { namespace { -// Scroll amount for each wheelscroll event. 53 is also the value used for GTK+. -static int kWheelScrollAmount = 53; - -int GetEventFlagsFromXState(unsigned int state) { - int flags = 0; - if (state & ControlMask) - flags |= ui::EF_CONTROL_DOWN; - if (state & ShiftMask) - flags |= ui::EF_SHIFT_DOWN; - if (state & Mod1Mask) - flags |= ui::EF_ALT_DOWN; - if (state & LockMask) - flags |= ui::EF_CAPS_LOCK_DOWN; - if (state & Button1Mask) - flags |= ui::EF_LEFT_BUTTON_DOWN; - if (state & Button2Mask) - flags |= ui::EF_MIDDLE_BUTTON_DOWN; - if (state & Button3Mask) - flags |= ui::EF_RIGHT_BUTTON_DOWN; - - return flags; -} - -// Get the event flag for the button in XButtonEvent. During a ButtonPress -// event, |state| in XButtonEvent does not include the button that has just been -// pressed. Instead |state| contains flags for the buttons (if any) that had -// already been pressed before the current button, and |button| stores the most -// current pressed button. So, if you press down left mouse button, and while -// pressing it down, press down the right mouse button, then for the latter -// event, |state| would have Button1Mask set but not Button3Mask, and |button| -// would be 3. -int GetEventFlagsForButton(int button) { - switch (button) { - case 1: - return ui::EF_LEFT_BUTTON_DOWN; - case 2: - return ui::EF_MIDDLE_BUTTON_DOWN; - case 3: - return ui::EF_RIGHT_BUTTON_DOWN; - } - - DLOG(WARNING) << "Unexpected button (" << button << ") received."; - return 0; -} - -int GetButtonMaskForX2Event(XIDeviceEvent* xievent) { - int buttonflags = 0; - - for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) { - if (XIMaskIsSet(xievent->buttons.mask, i)) { - buttonflags |= GetEventFlagsForButton(i); - } - } - - return buttonflags; -} - -ui::EventType GetTouchEventType(XEvent* xev) { -#if defined(USE_XI2_MT) - XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data); - switch(event->evtype) { - case XI_TouchBegin: - return ui::ET_TOUCH_PRESSED; - case XI_TouchUpdate: - return ui::ET_TOUCH_MOVED; - case XI_TouchEnd: - return ui::ET_TOUCH_RELEASED; - } - - return ui::ET_UNKNOWN; -#else - XGenericEventCookie* cookie = &xev->xcookie; - DCHECK_EQ(cookie->evtype, XI_Motion); - - // Note: We will not generate a _STATIONARY event here. It will be created, - // when necessary, by a RWHVV. - // TODO(sad): When should _CANCELLED be generated? - - TouchFactory* factory = TouchFactory::GetInstance(); - float slot; - if (!factory->ExtractTouchParam(*xev, TouchFactory::TP_SLOT_ID, &slot)) - return ui::ET_UNKNOWN; - - if (!factory->IsSlotUsed(slot)) { - // This is a new touch point. - return ui::ET_TOUCH_PRESSED; - } - - float tracking; - if (!factory->ExtractTouchParam(*xev, TouchFactory::TP_TRACKING_ID, - &tracking)) - return ui::ET_UNKNOWN; - - if (tracking == 0l) { - // The touch point has been released. - return ui::ET_TOUCH_RELEASED; - } - - return ui::ET_TOUCH_MOVED; -#endif // defined(USE_XI2_MT) -} - int GetTouchIDFromXEvent(XEvent* xev) { float id = 0; #if defined(USE_XI2_MT) // TODO(ningxin.hu@gmail.com): Make the id always start from 0 for a new // touch-sequence when TRACKING_ID is used to extract the touch id. - TouchFactory::TouchParam tp = TouchFactory::TP_TRACKING_ID; + ui::TouchFactory::TouchParam tp = ui::TouchFactory::TP_TRACKING_ID; #else - TouchFactory::TouchParam tp = TouchFactory::TP_SLOT_ID; + ui::TouchFactory::TouchParam tp = ui::TouchFactory::TP_SLOT_ID; #endif - if (!TouchFactory::GetInstance()->ExtractTouchParam( - *xev, tp, &id)) + if (!ui::TouchFactory::GetInstance()->ExtractTouchParam(*xev, tp, &id)) LOG(ERROR) << "Could not get the touch ID for the event. Using 0."; return id; } -ui::EventType EventTypeFromNative(NativeEvent2 native_event) { - switch (native_event->type) { - case KeyPress: - return ui::ET_KEY_PRESSED; - case KeyRelease: - return ui::ET_KEY_RELEASED; - case ButtonPress: - if (native_event->xbutton.button == 4 || - native_event->xbutton.button == 5) - return ui::ET_MOUSEWHEEL; - return ui::ET_MOUSE_PRESSED; - case ButtonRelease: - if (native_event->xbutton.button == 4 || - native_event->xbutton.button == 5) - return ui::ET_MOUSEWHEEL; - return ui::ET_MOUSE_RELEASED; - case MotionNotify: - if (native_event->xmotion.state & - (Button1Mask | Button2Mask | Button3Mask)) - return ui::ET_MOUSE_DRAGGED; - return ui::ET_MOUSE_MOVED; - case GenericEvent: { - XIDeviceEvent* xievent = - static_cast<XIDeviceEvent*>(native_event->xcookie.data); - if (TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid)) - return GetTouchEventType(native_event); - switch (xievent->evtype) { - case XI_ButtonPress: - return (xievent->detail == 4 || xievent->detail == 5) ? - ui::ET_MOUSEWHEEL : ui::ET_MOUSE_PRESSED; - case XI_ButtonRelease: - return (xievent->detail == 4 || xievent->detail == 5) ? - ui::ET_MOUSEWHEEL : ui::ET_MOUSE_RELEASED; - case XI_Motion: - return GetButtonMaskForX2Event(xievent) ? ui::ET_MOUSE_DRAGGED : - ui::ET_MOUSE_MOVED; - } - } - default: - NOTREACHED(); - break; - } - return ui::ET_UNKNOWN; -} - -int GetMouseWheelOffset(XEvent* xev) { - if (xev->type == GenericEvent) { - XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data); - return xiev->detail == 4 ? kWheelScrollAmount : -kWheelScrollAmount; - } - return xev->xbutton.button == 4 ? kWheelScrollAmount : -kWheelScrollAmount; -} - -gfx::Point GetEventLocation(XEvent* xev) { - switch (xev->type) { - case ButtonPress: - case ButtonRelease: - return gfx::Point(xev->xbutton.x, xev->xbutton.y); - - case MotionNotify: - return gfx::Point(xev->xmotion.x, xev->xmotion.y); - - case GenericEvent: { - XIDeviceEvent* xievent = - static_cast<XIDeviceEvent*>(xev->xcookie.data); - return gfx::Point(static_cast<int>(xievent->event_x), - static_cast<int>(xievent->event_y)); - } - } - - return gfx::Point(); -} - -int GetLocatedEventFlags(XEvent* xev) { - switch (xev->type) { - case ButtonPress: - case ButtonRelease: - return GetEventFlagsFromXState(xev->xbutton.state) | - GetEventFlagsForButton(xev->xbutton.button); - - case MotionNotify: - return GetEventFlagsFromXState(xev->xmotion.state); - - case GenericEvent: { - XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data); - bool touch = - TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid); - switch (xievent->evtype) { - case XI_ButtonPress: - case XI_ButtonRelease: - return GetButtonMaskForX2Event(xievent) | - GetEventFlagsFromXState(xievent->mods.effective) | - (touch ? 0 : GetEventFlagsForButton(xievent->detail)); - - case XI_Motion: - return GetButtonMaskForX2Event(xievent) | - GetEventFlagsFromXState(xievent->mods.effective); - } - } - } - - return 0; -} - uint16 GetCharacterFromXKeyEvent(XKeyEvent* key) { char buf[6]; int bytes_written = XLookupString(key, buf, 6, NULL, NULL); @@ -251,26 +44,27 @@ uint16 GetCharacterFromXKeyEvent(XKeyEvent* key) { } float GetTouchParamFromXEvent(XEvent* xev, - TouchFactory::TouchParam tp, + ui::TouchFactory::TouchParam tp, float default_value) { - TouchFactory::GetInstance()->ExtractTouchParam(*xev, tp, &default_value); + ui::TouchFactory::GetInstance()->ExtractTouchParam(*xev, tp, &default_value); return default_value; } float GetTouchForceFromXEvent(XEvent* xev) { float force = 0.0; - force = GetTouchParamFromXEvent(xev, TouchFactory::TP_PRESSURE, 0.0); + force = GetTouchParamFromXEvent(xev, ui::TouchFactory::TP_PRESSURE, 0.0); unsigned int deviceid = static_cast<XIDeviceEvent*>(xev->xcookie.data)->sourceid; // Force is normalized to fall into [0, 1] - if (!TouchFactory::GetInstance()->NormalizeTouchParam( - deviceid, TouchFactory::TP_PRESSURE, &force)) + if (!ui::TouchFactory::GetInstance()->NormalizeTouchParam( + deviceid, ui::TouchFactory::TP_PRESSURE, &force)) force = 0.0; return force; } // The following two functions are copied from event_gtk.cc. These will be // removed when GTK dependency is removed. +#if defined(TOOLKIT_USES_GTK) uint16 GetCharacterFromGdkKeyval(guint keyval) { guint32 ch = gdk_keyval_to_unicode(keyval); @@ -278,67 +72,39 @@ uint16 GetCharacterFromGdkKeyval(guint keyval) { return ch < 0xFFFE ? static_cast<uint16>(ch) : 0; } -GdkEventKey* GetGdkEventKeyFromNative(NativeEvent native_event) { - DCHECK(native_event->type == GDK_KEY_PRESS || - native_event->type == GDK_KEY_RELEASE); - return &native_event->key; +GdkEventKey* GetGdkEventKeyFromNative(GdkEvent* gdk_event) { + DCHECK(gdk_event->type == GDK_KEY_PRESS || + gdk_event->type == GDK_KEY_RELEASE); + return &gdk_event->key; } +#endif } // namespace //////////////////////////////////////////////////////////////////////////////// -// Event, private: - -void Event::InitWithNativeEvent2(NativeEvent2 native_event_2, - FromNativeEvent2) { - native_event_ = NULL; - // TODO(beng): remove once we rid views of Gtk/Gdk. - native_event_2_ = native_event_2; -} - -//////////////////////////////////////////////////////////////////////////////// -// LocatedEvent, protected: - -LocatedEvent::LocatedEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : Event(native_event_2, - EventTypeFromNative(native_event_2), - GetLocatedEventFlags(native_event_2), - from_native), - location_(GetEventLocation(native_event_2)) { -} - -//////////////////////////////////////////////////////////////////////////////// // KeyEvent, public: -KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native) - : Event(native_event_2, - EventTypeFromNative(native_event_2), - GetEventFlagsFromXState(native_event_2->xkey.state), - from_native), - key_code_(ui::KeyboardCodeFromXKeyEvent(native_event_2)), - character_(0), - unmodified_character_(0) { -} - uint16 KeyEvent::GetCharacter() const { if (character_) return character_; - if (!native_event_2()) { + if (!native_event()) { +#if defined(TOOLKIT_USES_GTK) // This event may have been created from a Gdk event. - if (IsControlDown() || !native_event()) - return GetCharacterFromKeyCode(key_code_, flags()); - - uint16 ch = GetCharacterFromGdkKeyval( - GetGdkEventKeyFromNative(native_event())->keyval); - return ch ? ch : GetCharacterFromKeyCode(key_code_, flags()); + if (!IsControlDown() && gdk_event()) { + uint16 ch = GetCharacterFromGdkKeyval( + GetGdkEventKeyFromNative(gdk_event())->keyval); + if (ch) + return ch; + } +#endif + return GetCharacterFromKeyCode(key_code_, flags()); } - DCHECK(native_event_2()->type == KeyPress || - native_event_2()->type == KeyRelease); + DCHECK(native_event()->type == KeyPress || + native_event()->type == KeyRelease); - uint16 ch = GetCharacterFromXKeyEvent(&native_event_2()->xkey); + uint16 ch = GetCharacterFromXKeyEvent(&native_event()->xkey); return ch ? ch : GetCharacterFromKeyCode(key_code_, flags()); } @@ -346,38 +112,37 @@ uint16 KeyEvent::GetUnmodifiedCharacter() const { if (unmodified_character_) return unmodified_character_; - if (!native_event_2()) { + if (!native_event()) { +#if defined(TOOLKIT_USES_GTK) // This event may have been created from a Gdk event. - if (!native_event()) - return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN); - - GdkEventKey* key = GetGdkEventKeyFromNative(native_event()); - - static const guint kIgnoredModifiers = - GDK_CONTROL_MASK | GDK_LOCK_MASK | GDK_MOD1_MASK | GDK_MOD2_MASK | - GDK_MOD3_MASK | GDK_MOD4_MASK | GDK_MOD5_MASK | GDK_SUPER_MASK | - GDK_HYPER_MASK | GDK_META_MASK; - - // We can't use things like (key->state & GDK_SHIFT_MASK), as it may mask - // out bits used by X11 or Gtk internally. - GdkModifierType modifiers = - static_cast<GdkModifierType>(key->state & ~kIgnoredModifiers); - guint keyval = 0; - uint16 ch = 0; - if (gdk_keymap_translate_keyboard_state(NULL, key->hardware_keycode, - modifiers, key->group, &keyval, - NULL, NULL, NULL)) { - ch = GetCharacterFromGdkKeyval(keyval); + if (gdk_event()) { + GdkEventKey* key = GetGdkEventKeyFromNative(gdk_event()); + + static const guint kIgnoredModifiers = + GDK_CONTROL_MASK | GDK_LOCK_MASK | GDK_MOD1_MASK | GDK_MOD2_MASK | + GDK_MOD3_MASK | GDK_MOD4_MASK | GDK_MOD5_MASK | GDK_SUPER_MASK | + GDK_HYPER_MASK | GDK_META_MASK; + + // We can't use things like (key->state & GDK_SHIFT_MASK), as it may mask + // out bits used by X11 or Gtk internally. + GdkModifierType modifiers = + static_cast<GdkModifierType>(key->state & ~kIgnoredModifiers); + guint keyval = 0; + if (gdk_keymap_translate_keyboard_state(NULL, key->hardware_keycode, + modifiers, key->group, &keyval, NULL, NULL, NULL)) { + uint16 ch = GetCharacterFromGdkKeyval(keyval); + if (ch) + return ch; + } } - - return ch ? ch : - GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN); +#endif + return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN); } - DCHECK(native_event_2()->type == KeyPress || - native_event_2()->type == KeyRelease); + DCHECK(native_event()->type == KeyPress || + native_event()->type == KeyRelease); - XKeyEvent key = native_event_2()->xkey; + XKeyEvent key = native_event()->xkey; static const unsigned int kIgnoredModifiers = ControlMask | LockMask | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask; @@ -391,45 +156,27 @@ uint16 KeyEvent::GetUnmodifiedCharacter() const { } //////////////////////////////////////////////////////////////////////////////// -// MouseEvent, public: - -MouseEvent::MouseEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : LocatedEvent(native_event_2, from_native) { -} - -//////////////////////////////////////////////////////////////////////////////// -// MouseWheelEvent, public: - -MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : MouseEvent(native_event_2, from_native), - offset_(GetMouseWheelOffset(native_event_2)) { -} - -//////////////////////////////////////////////////////////////////////////////// // TouchEvent, public: -TouchEvent::TouchEvent(NativeEvent2 native_event_2, - FromNativeEvent2 from_native) - : LocatedEvent(native_event_2, from_native), - touch_id_(GetTouchIDFromXEvent(native_event_2)), - radius_x_(GetTouchParamFromXEvent(native_event_2, - TouchFactory::TP_TOUCH_MAJOR, +TouchEvent::TouchEvent(const ui::NativeEvent& native_event) + : LocatedEvent(native_event), + touch_id_(GetTouchIDFromXEvent(native_event)), + radius_x_(GetTouchParamFromXEvent(native_event, + ui::TouchFactory::TP_TOUCH_MAJOR, 2.0) / 2.0), - radius_y_(GetTouchParamFromXEvent(native_event_2, - TouchFactory::TP_TOUCH_MINOR, + radius_y_(GetTouchParamFromXEvent(native_event, + ui::TouchFactory::TP_TOUCH_MINOR, 2.0) / 2.0), - rotation_angle_(GetTouchParamFromXEvent(native_event_2, - TouchFactory::TP_ORIENTATION, + rotation_angle_(GetTouchParamFromXEvent(native_event, + ui::TouchFactory::TP_ORIENTATION, 0.0)), - force_(GetTouchForceFromXEvent(native_event_2)) { + force_(GetTouchForceFromXEvent(native_event)) { #if !defined(USE_XI2_MT) if (type() == ui::ET_TOUCH_PRESSED || type() == ui::ET_TOUCH_RELEASED) { - TouchFactory* factory = TouchFactory::GetInstance(); + ui::TouchFactory* factory = ui::TouchFactory::GetInstance(); float slot; - if (factory->ExtractTouchParam(*native_event_2, - TouchFactory::TP_SLOT_ID, &slot)) { + if (factory->ExtractTouchParam(*native_event, + ui::TouchFactory::TP_SLOT_ID, &slot)) { factory->SetSlotUsed(slot, type() == ui::ET_TOUCH_PRESSED); } } |