1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef UI_EVENTS_EVENT_H_
6 #define UI_EVENTS_EVENT_H_
8 #include "base/basictypes.h"
9 #include "base/compiler_specific.h"
10 #include "base/event_types.h"
11 #include "base/gtest_prod_util.h"
12 #include "base/logging.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/time/time.h"
15 #include "ui/events/event_constants.h"
16 #include "ui/events/gesture_event_details.h"
17 #include "ui/events/gestures/gesture_types.h"
18 #include "ui/events/keycodes/dom/dom_key.h"
19 #include "ui/events/keycodes/keyboard_codes.h"
20 #include "ui/events/latency_info.h"
21 #include "ui/gfx/geometry/point.h"
22 #include "ui/gfx/geometry/point_conversions.h"
32 class EVENTS_EXPORT Event
{
34 static scoped_ptr
<Event
> Clone(const Event
& event
);
40 explicit DispatcherApi(Event
* event
) : event_(event
) {}
42 void set_target(EventTarget
* target
) {
43 event_
->target_
= target
;
46 void set_phase(EventPhase phase
) { event_
->phase_
= phase
; }
47 void set_result(int result
) {
48 event_
->result_
= static_cast<EventResult
>(result
);
55 DISALLOW_COPY_AND_ASSIGN(DispatcherApi
);
58 const base::NativeEvent
& native_event() const { return native_event_
; }
59 EventType
type() const { return type_
; }
60 const std::string
& name() const { return name_
; }
61 // time_stamp represents time since machine was booted.
62 const base::TimeDelta
& time_stamp() const { return time_stamp_
; }
63 int flags() const { return flags_
; }
65 // This is only intended to be used externally by classes that are modifying
66 // events in an EventRewriter.
67 void set_flags(int flags
) { flags_
= flags
; }
69 EventTarget
* target() const { return target_
; }
70 EventPhase
phase() const { return phase_
; }
71 EventResult
result() const { return result_
; }
73 LatencyInfo
* latency() { return &latency_
; }
74 const LatencyInfo
* latency() const { return &latency_
; }
75 void set_latency(const LatencyInfo
& latency
) { latency_
= latency
; }
77 int source_device_id() const { return source_device_id_
; }
78 void set_source_device_id(int id
) { source_device_id_
= id
; }
80 // By default, events are "cancelable", this means any default processing that
81 // the containing abstraction layer may perform can be prevented by calling
82 // SetHandled(). SetHandled() or StopPropagation() must not be called for
83 // events that are not cancelable.
84 bool cancelable() const { return cancelable_
; }
86 // The following methods return true if the respective keys were pressed at
87 // the time the event was created.
88 bool IsShiftDown() const { return (flags_
& EF_SHIFT_DOWN
) != 0; }
89 bool IsControlDown() const { return (flags_
& EF_CONTROL_DOWN
) != 0; }
90 bool IsCapsLockDown() const { return (flags_
& EF_CAPS_LOCK_DOWN
) != 0; }
91 bool IsAltDown() const { return (flags_
& EF_ALT_DOWN
) != 0; }
92 bool IsAltGrDown() const { return (flags_
& EF_ALTGR_DOWN
) != 0; }
93 bool IsCommandDown() const { return (flags_
& EF_COMMAND_DOWN
) != 0; }
94 bool IsRepeat() const { return (flags_
& EF_IS_REPEAT
) != 0; }
96 bool IsKeyEvent() const {
97 return type_
== ET_KEY_PRESSED
|| type_
== ET_KEY_RELEASED
;
100 bool IsMouseEvent() const {
101 return type_
== ET_MOUSE_PRESSED
||
102 type_
== ET_MOUSE_DRAGGED
||
103 type_
== ET_MOUSE_RELEASED
||
104 type_
== ET_MOUSE_MOVED
||
105 type_
== ET_MOUSE_ENTERED
||
106 type_
== ET_MOUSE_EXITED
||
107 type_
== ET_MOUSEWHEEL
||
108 type_
== ET_MOUSE_CAPTURE_CHANGED
;
111 bool IsTouchEvent() const {
112 return type_
== ET_TOUCH_RELEASED
||
113 type_
== ET_TOUCH_PRESSED
||
114 type_
== ET_TOUCH_MOVED
||
115 type_
== ET_TOUCH_CANCELLED
;
118 bool IsGestureEvent() const {
120 case ET_GESTURE_SCROLL_BEGIN
:
121 case ET_GESTURE_SCROLL_END
:
122 case ET_GESTURE_SCROLL_UPDATE
:
124 case ET_GESTURE_TAP_CANCEL
:
125 case ET_GESTURE_TAP_DOWN
:
126 case ET_GESTURE_BEGIN
:
128 case ET_GESTURE_TWO_FINGER_TAP
:
129 case ET_GESTURE_PINCH_BEGIN
:
130 case ET_GESTURE_PINCH_END
:
131 case ET_GESTURE_PINCH_UPDATE
:
132 case ET_GESTURE_LONG_PRESS
:
133 case ET_GESTURE_LONG_TAP
:
134 case ET_GESTURE_SWIPE
:
135 case ET_GESTURE_SHOW_PRESS
:
136 case ET_GESTURE_WIN8_EDGE_SWIPE
:
137 // When adding a gesture event which is paired with an event which
138 // occurs earlier, add the event to |IsEndingEvent|.
141 case ET_SCROLL_FLING_CANCEL
:
142 case ET_SCROLL_FLING_START
:
143 // These can be ScrollEvents too. EF_FROM_TOUCH determines if they're
144 // Gesture or Scroll events.
145 return (flags_
& EF_FROM_TOUCH
) == EF_FROM_TOUCH
;
153 // An ending event is paired with the event which started it. Setting capture
154 // should not prevent ending events from getting to their initial target.
155 bool IsEndingEvent() const {
157 case ui::ET_TOUCH_CANCELLED
:
158 case ui::ET_GESTURE_TAP_CANCEL
:
159 case ui::ET_GESTURE_END
:
160 case ui::ET_GESTURE_SCROLL_END
:
161 case ui::ET_GESTURE_PINCH_END
:
168 bool IsScrollEvent() const {
169 // Flings can be GestureEvents too. EF_FROM_TOUCH determins if they're
170 // Gesture or Scroll events.
171 return type_
== ET_SCROLL
||
172 ((type_
== ET_SCROLL_FLING_START
||
173 type_
== ET_SCROLL_FLING_CANCEL
) &&
174 !(flags() & EF_FROM_TOUCH
));
177 bool IsScrollGestureEvent() const {
178 return type_
== ET_GESTURE_SCROLL_BEGIN
||
179 type_
== ET_GESTURE_SCROLL_UPDATE
||
180 type_
== ET_GESTURE_SCROLL_END
;
183 bool IsFlingScrollEvent() const {
184 return type_
== ET_SCROLL_FLING_CANCEL
||
185 type_
== ET_SCROLL_FLING_START
;
188 bool IsMouseWheelEvent() const {
189 return type_
== ET_MOUSEWHEEL
;
192 bool IsLocatedEvent() const {
193 return IsMouseEvent() || IsScrollEvent() || IsTouchEvent() ||
197 // Convenience methods to cast |this| to a GestureEvent. IsGestureEvent()
198 // must be true as a precondition to calling these methods.
199 GestureEvent
* AsGestureEvent();
200 const GestureEvent
* AsGestureEvent() const;
202 // Returns true if the event has a valid |native_event_|.
203 bool HasNativeEvent() const;
205 // Immediately stops the propagation of the event. This must be called only
206 // from an EventHandler during an event-dispatch. Any event handler that may
207 // be in the list will not receive the event after this is called.
208 // Note that StopPropagation() can be called only for cancelable events.
209 void StopPropagation();
210 bool stopped_propagation() const { return !!(result_
& ER_CONSUMED
); }
212 // Marks the event as having been handled. A handled event does not reach the
213 // next event phase. For example, if an event is handled during the pre-target
214 // phase, then the event is dispatched to all pre-target handlers, but not to
215 // the target or post-target handlers.
216 // Note that SetHandled() can be called only for cancelable events.
218 bool handled() const { return result_
!= ER_UNHANDLED
; }
221 Event(EventType type
, base::TimeDelta time_stamp
, int flags
);
222 Event(const base::NativeEvent
& native_event
, EventType type
, int flags
);
223 Event(const Event
& copy
);
224 void SetType(EventType type
);
225 void set_cancelable(bool cancelable
) { cancelable_
= cancelable
; }
227 void set_time_stamp(const base::TimeDelta
& time_stamp
) {
228 time_stamp_
= time_stamp
;
231 void set_name(const std::string
& name
) { name_
= name
; }
234 friend class EventTestApi
;
238 base::TimeDelta time_stamp_
;
239 LatencyInfo latency_
;
241 base::NativeEvent native_event_
;
242 bool delete_native_event_
;
244 EventTarget
* target_
;
248 // The device id the event came from, or ED_UNKNOWN_DEVICE if the information
250 int source_device_id_
;
253 class EVENTS_EXPORT CancelModeEvent
: public Event
{
256 ~CancelModeEvent() override
;
259 class EVENTS_EXPORT LocatedEvent
: public Event
{
261 ~LocatedEvent() override
;
263 float x() const { return location_
.x(); }
264 float y() const { return location_
.y(); }
265 void set_location(const gfx::PointF
& location
) { location_
= location
; }
266 // TODO(tdresser): Always return floating point location. See
268 gfx::Point
location() const { return gfx::ToFlooredPoint(location_
); }
269 const gfx::PointF
& location_f() const { return location_
; }
270 void set_root_location(const gfx::PointF
& root_location
) {
271 root_location_
= root_location
;
273 gfx::Point
root_location() const {
274 return gfx::ToFlooredPoint(root_location_
);
276 const gfx::PointF
& root_location_f() const {
277 return root_location_
;
280 // Transform the locations using |inverted_root_transform|.
281 // This is applied to both |location_| and |root_location_|.
282 virtual void UpdateForRootTransform(
283 const gfx::Transform
& inverted_root_transform
);
285 template <class T
> void ConvertLocationToTarget(T
* source
, T
* target
) {
286 if (!target
|| target
== source
)
288 // TODO(tdresser): Rewrite ConvertPointToTarget to use PointF. See
290 gfx::Point offset
= gfx::ToFlooredPoint(location_
);
291 T::ConvertPointToTarget(source
, target
, &offset
);
292 gfx::Vector2d diff
= gfx::ToFlooredPoint(location_
) - offset
;
293 location_
= location_
- diff
;
297 friend class LocatedEventTestApi
;
298 explicit LocatedEvent(const base::NativeEvent
& native_event
);
300 // Create a new LocatedEvent which is identical to the provided model.
301 // If source / target windows are provided, the model location will be
302 // converted from |source| coordinate system to |target| coordinate system.
304 LocatedEvent(const LocatedEvent
& model
, T
* source
, T
* target
)
306 location_(model
.location_
),
307 root_location_(model
.root_location_
) {
308 ConvertLocationToTarget(source
, target
);
311 // Used for synthetic events in testing.
312 LocatedEvent(EventType type
,
313 const gfx::PointF
& location
,
314 const gfx::PointF
& root_location
,
315 base::TimeDelta time_stamp
,
318 gfx::PointF location_
;
320 // |location_| multiplied by an optional transformation matrix for
321 // rotations, animations and skews.
322 gfx::PointF root_location_
;
325 // Structure for handling common fields between touch and mouse to support
326 // PointerEvents API.
327 class EVENTS_EXPORT PointerDetails
{
330 explicit PointerDetails(EventPointerType pointer_type
)
331 : pointer_type_(pointer_type
) {}
332 PointerDetails(EventPointerType pointer_type
,
338 : pointer_type_(pointer_type
),
345 EventPointerType
pointer_type() const { return pointer_type_
; };
347 // If we aren't provided with a radius on one axis, use the
348 // information from the other axis.
349 float radius_x() const { return radius_x_
> 0 ? radius_x_
: radius_y_
; }
350 float radius_y() const { return radius_y_
> 0 ? radius_y_
: radius_x_
; }
351 float force() const { return force_
; }
352 float tilt_x() const { return tilt_x_
; }
353 float tilt_y() const { return tilt_y_
; }
356 // For the mutators of the members on this class.
357 friend class TouchEvent
;
358 friend class MouseEvent
;
360 // The type of pointer device.
361 EventPointerType pointer_type_
= EventPointerType::POINTER_TYPE_UNKNOWN
;
363 // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
364 float radius_x_
= 0.0;
366 // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
367 float radius_y_
= 0.0;
369 // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
372 // Angle of tilt of the X (major) axis. 0.0 if unknown.
375 // Angle of tilt of the Y (minor) axis. 0.0 if unknown.
379 class EVENTS_EXPORT MouseEvent
: public LocatedEvent
{
381 explicit MouseEvent(const base::NativeEvent
& native_event
);
383 // Create a new MouseEvent based on the provided model.
384 // Uses the provided |type| and |flags| for the new event.
385 // If source / target windows are provided, the model location will be
386 // converted from |source| coordinate system to |target| coordinate system.
388 MouseEvent(const MouseEvent
& model
, T
* source
, T
* target
)
389 : LocatedEvent(model
, source
, target
),
390 changed_button_flags_(model
.changed_button_flags_
),
391 pointer_details_(model
.pointer_details_
) {}
394 MouseEvent(const MouseEvent
& model
,
399 : LocatedEvent(model
, source
, target
),
400 changed_button_flags_(model
.changed_button_flags_
),
401 pointer_details_(model
.pointer_details_
) {
406 // Used for synthetic events in testing, gesture recognizer and Ozone
407 MouseEvent(EventType type
,
408 const gfx::PointF
& location
,
409 const gfx::PointF
& root_location
,
410 base::TimeDelta time_stamp
,
412 int changed_button_flags
);
414 // Conveniences to quickly test what button is down
415 bool IsOnlyLeftMouseButton() const {
416 return button_flags() == EF_LEFT_MOUSE_BUTTON
;
419 bool IsLeftMouseButton() const {
420 return (flags() & EF_LEFT_MOUSE_BUTTON
) != 0;
423 bool IsOnlyMiddleMouseButton() const {
424 return button_flags() == EF_MIDDLE_MOUSE_BUTTON
;
427 bool IsMiddleMouseButton() const {
428 return (flags() & EF_MIDDLE_MOUSE_BUTTON
) != 0;
431 bool IsOnlyRightMouseButton() const {
432 return button_flags() == EF_RIGHT_MOUSE_BUTTON
;
435 bool IsRightMouseButton() const {
436 return (flags() & EF_RIGHT_MOUSE_BUTTON
) != 0;
439 bool IsAnyButton() const {
440 return button_flags() != 0;
443 // Compares two mouse down events and returns true if the second one should
444 // be considered a repeat of the first.
445 static bool IsRepeatedClickEvent(
446 const MouseEvent
& event1
,
447 const MouseEvent
& event2
);
449 // Get the click count. Can be 1, 2 or 3 for mousedown messages, 0 otherwise.
450 int GetClickCount() const;
452 // Set the click count for a mousedown message. Can be 1, 2 or 3.
453 void SetClickCount(int click_count
);
455 // Identifies the button that changed. During a press this corresponds to the
456 // button that was pressed and during a release this corresponds to the button
457 // that was released.
458 // NOTE: during a press and release flags() contains the complete set of
459 // flags. Use this to determine the button that was pressed or released.
460 int changed_button_flags() const { return changed_button_flags_
; }
462 // Updates the button that changed.
463 void set_changed_button_flags(int flags
) { changed_button_flags_
= flags
; }
465 // Event details common to MouseEvent and TouchEvent.
466 const PointerDetails
& pointer_details() const { return pointer_details_
; }
467 void set_pointer_details(const PointerDetails
& details
) {
468 pointer_details_
= details
;
472 FRIEND_TEST_ALL_PREFIXES(EventTest
, DoubleClickRequiresRelease
);
473 FRIEND_TEST_ALL_PREFIXES(EventTest
, SingleClickRightLeft
);
475 // Returns the flags for the mouse buttons.
476 int button_flags() const {
477 return flags() & (EF_LEFT_MOUSE_BUTTON
| EF_MIDDLE_MOUSE_BUTTON
|
478 EF_RIGHT_MOUSE_BUTTON
| EF_BACK_MOUSE_BUTTON
|
479 EF_FORWARD_MOUSE_BUTTON
);
482 // Returns the repeat count based on the previous mouse click, if it is
483 // recent enough and within a small enough distance.
484 static int GetRepeatCount(const MouseEvent
& click_event
);
486 // Resets the last_click_event_ for unit tests.
487 static void ResetLastClickForTest();
489 // See description above getter for details.
490 int changed_button_flags_
;
492 static MouseEvent
* last_click_event_
;
494 // We can create a MouseEvent for a native event more than once. We set this
495 // to true when the next event either has a different timestamp or we see a
496 // release signalling that the press (click) event was completed.
497 static bool last_click_complete_
;
499 // Structure for holding pointer details for implementing PointerEvents API.
500 PointerDetails pointer_details_
;
505 class EVENTS_EXPORT MouseWheelEvent
: public MouseEvent
{
507 // See |offset| for details.
508 static const int kWheelDelta
;
510 explicit MouseWheelEvent(const base::NativeEvent
& native_event
);
511 explicit MouseWheelEvent(const ScrollEvent
& scroll_event
);
512 MouseWheelEvent(const MouseEvent
& mouse_event
, int x_offset
, int y_offset
);
513 MouseWheelEvent(const MouseWheelEvent
& mouse_wheel_event
);
516 MouseWheelEvent(const MouseWheelEvent
& model
,
519 : MouseEvent(model
, source
, target
, model
.type(), model
.flags()),
520 offset_(model
.x_offset(), model
.y_offset()) {
523 // Used for synthetic events in testing and by the gesture recognizer.
524 MouseWheelEvent(const gfx::Vector2d
& offset
,
525 const gfx::PointF
& location
,
526 const gfx::PointF
& root_location
,
527 base::TimeDelta time_stamp
,
529 int changed_button_flags
);
531 // The amount to scroll. This is in multiples of kWheelDelta.
532 // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
533 int x_offset() const { return offset_
.x(); }
534 int y_offset() const { return offset_
.y(); }
535 const gfx::Vector2d
& offset() const { return offset_
; }
538 gfx::Vector2d offset_
;
541 class EVENTS_EXPORT TouchEvent
: public LocatedEvent
{
543 explicit TouchEvent(const base::NativeEvent
& native_event
);
545 // Create a new TouchEvent which is identical to the provided model.
546 // If source / target windows are provided, the model location will be
547 // converted from |source| coordinate system to |target| coordinate system.
549 TouchEvent(const TouchEvent
& model
, T
* source
, T
* target
)
550 : LocatedEvent(model
, source
, target
),
551 touch_id_(model
.touch_id_
),
552 unique_event_id_(model
.unique_event_id_
),
553 rotation_angle_(model
.rotation_angle_
),
554 may_cause_scrolling_(model
.may_cause_scrolling_
),
555 should_remove_native_touch_id_mapping_(false),
556 pointer_details_(model
.pointer_details_
) {}
558 TouchEvent(EventType type
,
559 const gfx::PointF
& location
,
561 base::TimeDelta time_stamp
);
563 TouchEvent(EventType type
,
564 const gfx::PointF
& location
,
567 base::TimeDelta timestamp
,
573 TouchEvent(const TouchEvent
& copy
);
575 ~TouchEvent() override
;
577 // The id of the pointer this event modifies.
578 int touch_id() const { return touch_id_
; }
579 // A unique identifier for this event.
580 uint32
unique_event_id() const { return unique_event_id_
; }
582 float rotation_angle() const { return rotation_angle_
; }
584 void set_may_cause_scrolling(bool causes
) { may_cause_scrolling_
= causes
; }
585 bool may_cause_scrolling() const { return may_cause_scrolling_
; }
587 // TODO(robert.bradford): ozone_platform_egltest.cc could use
588 // UpdateForRootTransform() instead: crbug.com/519337
589 void set_radius_x(const float r
) { pointer_details_
.radius_x_
= r
; }
590 void set_radius_y(const float r
) { pointer_details_
.radius_y_
= r
; }
592 void set_should_remove_native_touch_id_mapping(
593 bool should_remove_native_touch_id_mapping
) {
594 should_remove_native_touch_id_mapping_
=
595 should_remove_native_touch_id_mapping
;
598 // Overridden from LocatedEvent.
599 void UpdateForRootTransform(
600 const gfx::Transform
& inverted_root_transform
) override
;
602 // Marks the event as not participating in synchronous gesture recognition.
603 void DisableSynchronousHandling();
604 bool synchronous_handling_disabled() const {
605 return !!(result() & ER_DISABLE_SYNC_HANDLING
);
608 // Event details common to MouseEvent and TouchEvent.
609 const PointerDetails
& pointer_details() const { return pointer_details_
; }
612 // Adjusts rotation_angle_ to within the acceptable range.
613 void FixRotationAngle();
615 // The identity (typically finger) of the touch starting at 0 and incrementing
616 // for each separable additional touch that the hardware can detect.
619 // A unique identifier for the touch event.
620 const uint32 unique_event_id_
;
622 // Clockwise angle (in degrees) of the major axis from the X axis. Must be
623 // less than 180 and non-negative.
624 float rotation_angle_
;
626 // Whether the (unhandled) touch event will produce a scroll event (e.g., a
627 // touchmove that exceeds the platform slop region, or a touchend that
628 // causes a fling). Defaults to false.
629 bool may_cause_scrolling_
;
631 // True if this event should remove the mapping between the native
632 // event id and the touch_id_. This should only be the case for
633 // release and cancel events where the associated touch press event
634 // created a mapping between the native id and the touch_id_.
635 bool should_remove_native_touch_id_mapping_
;
637 // Structure for holding pointer details for implementing PointerEvents API.
638 PointerDetails pointer_details_
;
641 // An interface that individual platforms can use to store additional data on
644 // Currently only used in mojo.
645 class EVENTS_EXPORT ExtendedKeyEventData
{
647 virtual ~ExtendedKeyEventData() {}
649 virtual ExtendedKeyEventData
* Clone() const = 0;
652 // A KeyEvent is really two distinct classes, melded together due to the
653 // DOM legacy of Windows key events: a keystroke event (is_char_ == false),
654 // or a character event (is_char_ == true).
656 // For a keystroke event,
657 // -- |bool is_char_| is false.
658 // -- |EventType Event::type()| can be ET_KEY_PRESSED or ET_KEY_RELEASED.
659 // -- |DomCode code_| and |int Event::flags()| represent the physical key event.
660 // - code_ is a platform-independent representation of the physical key,
661 // based on DOM UI Events KeyboardEvent |code| values. It does not
662 // vary depending on key layout.
663 // http://www.w3.org/TR/DOM-Level-3-Events-code/
664 // - Event::flags() provides the active modifiers for the physical key
665 // press. Its value reflects the state after the event; that is, for
666 // a modifier key, a press includes the corresponding flag and a release
668 // -- |DomKey key_| provides the meaning (character or action) of the key
669 // event, in the context of the active layout and modifiers. It corresponds
670 // to DOM UI Events KeyboardEvent |key| values.
671 // http://www.w3.org/TR/DOM-Level-3-Events-key/
672 // -- |KeyboardCode key_code_| supports the legacy web event |keyCode| field,
673 // and its VKEY_ values are chosen to match Windows/IE for compatibility.
674 // For printable characters, this may or may not be a layout-mapped value,
675 // imitating MS Windows: if the mapped key generates a character that has
676 // an associated VKEY_ code, then key_code_ is that code; if not, then
677 // key_code_ is the unmapped VKEY_ code. For example, US, Greek, Cyrillic,
678 // Japanese, etc. all use VKEY_Q for the key beside Tab, while French uses
679 // VKEY_A. The stored key_code_ is non-located (e.g. VKEY_SHIFT rather than
680 // VKEY_LSHIFT, VKEY_1 rather than VKEY_NUMPAD1).
682 // For a character event,
683 // -- |bool is_char_| is true.
684 // -- |EventType Event::type()| is ET_KEY_PRESSED.
685 // -- |DomCode code_| is DomCode::NONE.
686 // -- |DomKey key_| is a UTF-16 code point.
687 // -- |KeyboardCode key_code_| is conflated with the character-valued key_
688 // by some code, because both arrive in the wParam field of a Windows event.
690 class EVENTS_EXPORT KeyEvent
: public Event
{
692 // Create a KeyEvent from a NativeEvent. For Windows this native event can
693 // be either a keystroke message (WM_KEYUP/WM_KEYDOWN) or a character message
694 // (WM_CHAR). Other systems have only keystroke events.
695 explicit KeyEvent(const base::NativeEvent
& native_event
);
697 // Create a keystroke event from a legacy KeyboardCode.
698 // This should not be used in new code.
699 KeyEvent(EventType type
, KeyboardCode key_code
, int flags
);
701 // Create a fully defined keystroke event.
702 KeyEvent(EventType type
,
703 KeyboardCode key_code
,
707 base::TimeDelta time_stamp
);
709 // Create a character event.
710 KeyEvent(base::char16 character
, KeyboardCode key_code
, int flags
);
712 // Used for synthetic events with code of DOM KeyboardEvent (e.g. 'KeyA')
713 // See also: ui/events/keycodes/dom/dom_values.txt
714 KeyEvent(EventType type
,
715 KeyboardCode key_code
,
719 KeyEvent(const KeyEvent
& rhs
);
721 KeyEvent
& operator=(const KeyEvent
& rhs
);
723 ~KeyEvent() override
;
725 // TODO(erg): While we transition to mojo, we have to hack around a mismatch
726 // in our event types. Our ui::Events don't really have all the data we need
727 // to process key events, and we instead do per-platform conversions with
728 // native HWNDs or XEvents. And we can't reliably send those native data
729 // types across mojo types in a cross-platform way. So instead, we set the
730 // resulting data when read across IPC boundaries.
731 void SetExtendedKeyEventData(scoped_ptr
<ExtendedKeyEventData
> data
);
732 const ExtendedKeyEventData
* extended_key_event_data() const {
733 return extended_key_event_data_
.get();
736 // This bypasses the normal mapping from keystroke events to characters,
737 // which allows an I18N virtual keyboard to fabricate a keyboard event that
738 // does not have a corresponding KeyboardCode (example: U+00E1 Latin small
739 // letter A with acute, U+0410 Cyrillic capital letter A).
740 void set_character(base::char16 character
) {
741 key_
= DomKey::FromCharacter(character
);
744 // Gets the character generated by this key event. It only supports Unicode
746 base::char16
GetCharacter() const;
748 // If this is a keystroke event with key_code_ VKEY_RETURN, returns '\r';
749 // otherwise returns the same as GetCharacter().
750 base::char16
GetUnmodifiedText() const;
752 // If the Control key is down in the event, returns a layout-independent
753 // character (corresponding to US layout); otherwise returns the same
754 // as GetUnmodifiedText().
755 base::char16
GetText() const;
757 // Gets the platform key code. For XKB, this is the xksym value.
758 // This should not be used in new code.
759 void set_platform_keycode(uint32 keycode
) { platform_keycode_
= keycode
; }
760 uint32
platform_keycode() const { return platform_keycode_
; }
762 // Gets the associated (Windows-based) KeyboardCode for this key event.
763 // Historically, this has also been used to obtain the character associated
764 // with a character event, because both use the Window message 'wParam' field.
765 // This should be avoided; if necessary for backwards compatibility, use
766 // GetConflatedWindowsKeyCode().
767 KeyboardCode
key_code() const { return key_code_
; }
769 // True if this is a character event, false if this is a keystroke event.
770 bool is_char() const { return is_char_
; }
772 // This is only intended to be used externally by classes that are modifying
773 // events in an EventRewriter.
774 void set_key_code(KeyboardCode key_code
) { key_code_
= key_code
; }
776 // Returns the same value as key_code(), except that located codes are
777 // returned in place of non-located ones (e.g. VKEY_LSHIFT or VKEY_RSHIFT
778 // instead of VKEY_SHIFT). This is a hybrid of semantic and physical
779 // for legacy DOM reasons.
780 KeyboardCode
GetLocatedWindowsKeyboardCode() const;
782 // For a keystroke event, returns the same value as key_code().
783 // For a character event, returns the same value as GetCharacter().
784 // This exists for backwards compatibility with Windows key events.
785 uint16
GetConflatedWindowsKeyCode() const;
787 // Returns true for [Alt]+<num-pad digit> Unicode alt key codes used by Win.
788 // TODO(msw): Additional work may be needed for analogues on other platforms.
789 bool IsUnicodeKeyCode() const;
791 // Returns the DOM .code (physical key identifier) for a keystroke event.
792 DomCode
code() const { return code_
; };
793 std::string
GetCodeString() const;
795 // Returns the DOM .key (layout meaning) for a keystroke event.
796 DomKey
GetDomKey() const;
798 // Normalizes flags_ so that it describes the state after the event.
799 // (Native X11 event flags describe the state before the event.)
800 void NormalizeFlags();
803 friend class KeyEventTestApi
;
805 // This allows a subclass TranslatedKeyEvent to be a non character event.
806 void set_is_char(bool is_char
) { is_char_
= is_char
; }
809 // Determine key_ on a keystroke event from code_ and flags().
810 void ApplyLayout() const;
812 KeyboardCode key_code_
;
814 // DOM KeyboardEvent |code| (e.g. DomCode::KEY_A, DomCode::SPACE).
815 // http://www.w3.org/TR/DOM-Level-3-Events-code/
817 // This value represents the physical position in the keyboard and can be
818 // converted from / to keyboard scan code like XKB.
821 // True if this is a character event, false if this is a keystroke event.
822 bool is_char_
= false;
824 // The platform related keycode value. For XKB, it's keysym value.
825 // For now, this is used for CharacterComposer in ChromeOS.
826 mutable uint32 platform_keycode_
= 0;
828 // TODO(kpschoedel): refactor so that key_ is not mutable.
829 // This requires defining the KeyEvent completely at construction rather
830 // than lazily under GetCharacter(), which likely also means removing
831 // the two 'incomplete' constructors. crbug.com/444045
833 // DOM KeyboardEvent |key|
834 // http://www.w3.org/TR/DOM-Level-3-Events-key/
836 // This value represents the meaning of a key, which is either a Unicode
837 // character, or a named DomKey:: value.
838 // This is not necessarily initialized when the event is constructed;
839 // it may be set only if and when GetCharacter() or GetDomKey() is called.
840 mutable DomKey key_
= DomKey::NONE
;
842 // Parts of our event handling require raw native events (see both the
843 // windows and linux implementations of web_input_event in content/). Because
844 // mojo instead serializes and deserializes events in potentially different
845 // processes, we need to have a mechanism to keep track of this data.
846 scoped_ptr
<ExtendedKeyEventData
> extended_key_event_data_
;
848 static bool IsRepeated(const KeyEvent
& event
);
850 static KeyEvent
* last_key_event_
;
853 class EVENTS_EXPORT ScrollEvent
: public MouseEvent
{
855 explicit ScrollEvent(const base::NativeEvent
& native_event
);
857 ScrollEvent(const ScrollEvent
& model
,
860 : MouseEvent(model
, source
, target
),
861 x_offset_(model
.x_offset_
),
862 y_offset_(model
.y_offset_
),
863 x_offset_ordinal_(model
.x_offset_ordinal_
),
864 y_offset_ordinal_(model
.y_offset_ordinal_
),
865 finger_count_(model
.finger_count_
){
869 ScrollEvent(EventType type
,
870 const gfx::PointF
& location
,
871 base::TimeDelta time_stamp
,
875 float x_offset_ordinal
,
876 float y_offset_ordinal
,
879 // Scale the scroll event's offset value.
880 // This is useful in the multi-monitor setup where it needs to be scaled
881 // to provide a consistent user experience.
882 void Scale(const float factor
);
884 float x_offset() const { return x_offset_
; }
885 float y_offset() const { return y_offset_
; }
886 float x_offset_ordinal() const { return x_offset_ordinal_
; }
887 float y_offset_ordinal() const { return y_offset_ordinal_
; }
888 int finger_count() const { return finger_count_
; }
891 // Potential accelerated offsets.
894 // Unaccelerated offsets.
895 float x_offset_ordinal_
;
896 float y_offset_ordinal_
;
897 // Number of fingers on the pad.
901 class EVENTS_EXPORT GestureEvent
: public LocatedEvent
{
903 GestureEvent(float x
,
906 base::TimeDelta time_stamp
,
907 const GestureEventDetails
& details
);
909 // Create a new GestureEvent which is identical to the provided model.
910 // If source / target windows are provided, the model location will be
911 // converted from |source| coordinate system to |target| coordinate system.
912 template <typename T
>
913 GestureEvent(const GestureEvent
& model
, T
* source
, T
* target
)
914 : LocatedEvent(model
, source
, target
),
915 details_(model
.details_
) {
918 ~GestureEvent() override
;
920 const GestureEventDetails
& details() const { return details_
; }
923 GestureEventDetails details_
;
928 #endif // UI_EVENTS_EVENT_H_