ui/events/event.cc

   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.
   4
   5 #include "ui/events/event.h"
   6
   7 #if defined(USE_X11)
   8 #include <X11/extensions/XInput2.h>
   9 #include <X11/keysym.h>
  10 #include <X11/Xlib.h>
  11 #endif
  12
  13 #include <cmath>
  14 #include <cstring>
  15
  16 #include "base/metrics/histogram.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "ui/events/event_utils.h"
  19 #include "ui/events/keycodes/dom3/dom_code.h"
  20 #include "ui/events/keycodes/dom3/dom_key.h"
  21 #include "ui/events/keycodes/dom4/keycode_converter.h"
  22 #include "ui/events/keycodes/keyboard_code_conversion.h"
  23 #include "ui/gfx/geometry/point3_f.h"
  24 #include "ui/gfx/geometry/point_conversions.h"
  25 #include "ui/gfx/geometry/safe_integer_conversions.h"
  26 #include "ui/gfx/transform.h"
  27 #include "ui/gfx/transform_util.h"
  28
  29 #if defined(USE_X11)
  30 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
  31 #elif defined(USE_OZONE)
  32 #include "ui/events/ozone/layout/keyboard_layout_engine.h"
  33 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
  34 #endif
  35
  36 namespace {
  37
  38 std::string EventTypeName(ui::EventType type) {
  39 #define RETURN_IF_TYPE(t) if (type == ui::t)  return #t
  40 #define CASE_TYPE(t) case ui::t:  return #t
  41   switch (type) {
  42     CASE_TYPE(ET_UNKNOWN);
  43     CASE_TYPE(ET_MOUSE_PRESSED);
  44     CASE_TYPE(ET_MOUSE_DRAGGED);
  45     CASE_TYPE(ET_MOUSE_RELEASED);
  46     CASE_TYPE(ET_MOUSE_MOVED);
  47     CASE_TYPE(ET_MOUSE_ENTERED);
  48     CASE_TYPE(ET_MOUSE_EXITED);
  49     CASE_TYPE(ET_KEY_PRESSED);
  50     CASE_TYPE(ET_KEY_RELEASED);
  51     CASE_TYPE(ET_MOUSEWHEEL);
  52     CASE_TYPE(ET_MOUSE_CAPTURE_CHANGED);
  53     CASE_TYPE(ET_TOUCH_RELEASED);
  54     CASE_TYPE(ET_TOUCH_PRESSED);
  55     CASE_TYPE(ET_TOUCH_MOVED);
  56     CASE_TYPE(ET_TOUCH_CANCELLED);
  57     CASE_TYPE(ET_DROP_TARGET_EVENT);
  58     CASE_TYPE(ET_TRANSLATED_KEY_PRESS);
  59     CASE_TYPE(ET_TRANSLATED_KEY_RELEASE);
  60     CASE_TYPE(ET_GESTURE_SCROLL_BEGIN);
  61     CASE_TYPE(ET_GESTURE_SCROLL_END);
  62     CASE_TYPE(ET_GESTURE_SCROLL_UPDATE);
  63     CASE_TYPE(ET_GESTURE_SHOW_PRESS);
  64     CASE_TYPE(ET_GESTURE_WIN8_EDGE_SWIPE);
  65     CASE_TYPE(ET_GESTURE_TAP);
  66     CASE_TYPE(ET_GESTURE_TAP_DOWN);
  67     CASE_TYPE(ET_GESTURE_TAP_CANCEL);
  68     CASE_TYPE(ET_GESTURE_BEGIN);
  69     CASE_TYPE(ET_GESTURE_END);
  70     CASE_TYPE(ET_GESTURE_TWO_FINGER_TAP);
  71     CASE_TYPE(ET_GESTURE_PINCH_BEGIN);
  72     CASE_TYPE(ET_GESTURE_PINCH_END);
  73     CASE_TYPE(ET_GESTURE_PINCH_UPDATE);
  74     CASE_TYPE(ET_GESTURE_LONG_PRESS);
  75     CASE_TYPE(ET_GESTURE_LONG_TAP);
  76     CASE_TYPE(ET_GESTURE_SWIPE);
  77     CASE_TYPE(ET_GESTURE_TAP_UNCONFIRMED);
  78     CASE_TYPE(ET_GESTURE_DOUBLE_TAP);
  79     CASE_TYPE(ET_SCROLL);
  80     CASE_TYPE(ET_SCROLL_FLING_START);
  81     CASE_TYPE(ET_SCROLL_FLING_CANCEL);
  82     CASE_TYPE(ET_CANCEL_MODE);
  83     CASE_TYPE(ET_UMA_DATA);
  84     case ui::ET_LAST: NOTREACHED(); return std::string();
  85     // Don't include default, so that we get an error when new type is added.
  86   }
  87 #undef CASE_TYPE
  88
  89   NOTREACHED();
  90   return std::string();
  91 }
  92
  93 bool IsX11SendEventTrue(const base::NativeEvent& event) {
  94 #if defined(USE_X11)
  95   return event && event->xany.send_event;
  96 #else
  97   return false;
  98 #endif
  99 }
 100
 101 bool X11EventHasNonStandardState(const base::NativeEvent& event) {
 102 #if defined(USE_X11)
 103   const unsigned int kAllStateMask =
 104       Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask |
 105       Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask |
 106       LockMask | ControlMask | AnyModifier;
 107   return event && (event->xkey.state & ~kAllStateMask) != 0;
 108 #else
 109   return false;
 110 #endif
 111 }
 112
 113 unsigned long long get_next_touch_event_id() {
 114   static unsigned long long id = 0;
 115   return id++;
 116 }
 117
 118 }  // namespace
 119
 120 namespace ui {
 121
 122 ////////////////////////////////////////////////////////////////////////////////
 123 // Event
 124
 125 // static
 126 scoped_ptr<Event> Event::Clone(const Event& event) {
 127   if (event.IsKeyEvent()) {
 128     return make_scoped_ptr(new KeyEvent(static_cast<const KeyEvent&>(event)));
 129   }
 130
 131   if (event.IsMouseEvent()) {
 132     if (event.IsMouseWheelEvent()) {
 133       return make_scoped_ptr(
 134           new MouseWheelEvent(static_cast<const MouseWheelEvent&>(event)));
 135     }
 136
 137     return make_scoped_ptr(
 138         new MouseEvent(static_cast<const MouseEvent&>(event)));
 139   }
 140
 141   if (event.IsTouchEvent()) {
 142     return make_scoped_ptr(
 143         new TouchEvent(static_cast<const TouchEvent&>(event)));
 144   }
 145
 146   if (event.IsGestureEvent()) {
 147     return make_scoped_ptr(
 148         new GestureEvent(static_cast<const GestureEvent&>(event)));
 149   }
 150
 151   if (event.IsScrollEvent()) {
 152     return make_scoped_ptr(
 153         new ScrollEvent(static_cast<const ScrollEvent&>(event)));
 154   }
 155
 156   return make_scoped_ptr(new Event(event));
 157 }
 158
 159 Event::~Event() {
 160   if (delete_native_event_)
 161     ReleaseCopiedNativeEvent(native_event_);
 162 }
 163
 164 GestureEvent* Event::AsGestureEvent() {
 165   CHECK(IsGestureEvent());
 166   return static_cast<GestureEvent*>(this);
 167 }
 168
 169 const GestureEvent* Event::AsGestureEvent() const {
 170   CHECK(IsGestureEvent());
 171   return static_cast<const GestureEvent*>(this);
 172 }
 173
 174 bool Event::HasNativeEvent() const {
 175   base::NativeEvent null_event;
 176   std::memset(&null_event, 0, sizeof(null_event));
 177   return !!std::memcmp(&native_event_, &null_event, sizeof(null_event));
 178 }
 179
 180 void Event::StopPropagation() {
 181   // TODO(sad): Re-enable these checks once View uses dispatcher to dispatch
 182   // events.
 183   // CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
 184   CHECK(cancelable_);
 185   result_ = static_cast<EventResult>(result_ | ER_CONSUMED);
 186 }
 187
 188 void Event::SetHandled() {
 189   // TODO(sad): Re-enable these checks once View uses dispatcher to dispatch
 190   // events.
 191   // CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
 192   CHECK(cancelable_);
 193   result_ = static_cast<EventResult>(result_ | ER_HANDLED);
 194 }
 195
 196 Event::Event(EventType type, base::TimeDelta time_stamp, int flags)
 197     : type_(type),
 198       time_stamp_(time_stamp),
 199       flags_(flags),
 200       native_event_(base::NativeEvent()),
 201       delete_native_event_(false),
 202       cancelable_(true),
 203       target_(NULL),
 204       phase_(EP_PREDISPATCH),
 205       result_(ER_UNHANDLED),
 206       source_device_id_(ED_UNKNOWN_DEVICE) {
 207   if (type_ < ET_LAST)
 208     name_ = EventTypeName(type_);
 209 }
 210
 211 Event::Event(const base::NativeEvent& native_event,
 212              EventType type,
 213              int flags)
 214     : type_(type),
 215       time_stamp_(EventTimeFromNative(native_event)),
 216       flags_(flags),
 217       native_event_(native_event),
 218       delete_native_event_(false),
 219       cancelable_(true),
 220       target_(NULL),
 221       phase_(EP_PREDISPATCH),
 222       result_(ER_UNHANDLED),
 223       source_device_id_(ED_UNKNOWN_DEVICE) {
 224   base::TimeDelta delta = EventTimeForNow() - time_stamp_;
 225   if (type_ < ET_LAST)
 226     name_ = EventTypeName(type_);
 227   base::HistogramBase::Sample delta_sample =
 228       static_cast<base::HistogramBase::Sample>(delta.InMicroseconds());
 229   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Browser", delta_sample, 1, 1000000,
 230                               100);
 231   std::string name_for_event =
 232       base::StringPrintf("Event.Latency.Browser.%s", name_.c_str());
 233   base::HistogramBase* counter_for_type =
 234       base::Histogram::FactoryGet(
 235           name_for_event,
 236           1,
 237           1000000,
 238           100,
 239           base::HistogramBase::kUmaTargetedHistogramFlag);
 240   counter_for_type->Add(delta_sample);
 241
 242 #if defined(USE_X11)
 243   if (native_event->type == GenericEvent) {
 244     XIDeviceEvent* xiev =
 245         static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 246     source_device_id_ = xiev->sourceid;
 247   }
 248 #endif
 249 }
 250
 251 Event::Event(const Event& copy)
 252     : type_(copy.type_),
 253       time_stamp_(copy.time_stamp_),
 254       latency_(copy.latency_),
 255       flags_(copy.flags_),
 256       native_event_(CopyNativeEvent(copy.native_event_)),
 257       delete_native_event_(true),
 258       cancelable_(true),
 259       target_(NULL),
 260       phase_(EP_PREDISPATCH),
 261       result_(ER_UNHANDLED),
 262       source_device_id_(copy.source_device_id_) {
 263   if (type_ < ET_LAST)
 264     name_ = EventTypeName(type_);
 265 }
 266
 267 void Event::SetType(EventType type) {
 268   if (type_ < ET_LAST)
 269     name_ = std::string();
 270   type_ = type;
 271   if (type_ < ET_LAST)
 272     name_ = EventTypeName(type_);
 273 }
 274
 275 ////////////////////////////////////////////////////////////////////////////////
 276 // CancelModeEvent
 277
 278 CancelModeEvent::CancelModeEvent()
 279     : Event(ET_CANCEL_MODE, base::TimeDelta(), 0) {
 280   set_cancelable(false);
 281 }
 282
 283 CancelModeEvent::~CancelModeEvent() {
 284 }
 285
 286 ////////////////////////////////////////////////////////////////////////////////
 287 // LocatedEvent
 288
 289 LocatedEvent::~LocatedEvent() {
 290 }
 291
 292 LocatedEvent::LocatedEvent(const base::NativeEvent& native_event)
 293     : Event(native_event,
 294             EventTypeFromNative(native_event),
 295             EventFlagsFromNative(native_event)),
 296       location_(EventLocationFromNative(native_event)),
 297       root_location_(location_) {
 298 }
 299
 300 LocatedEvent::LocatedEvent(EventType type,
 301                            const gfx::PointF& location,
 302                            const gfx::PointF& root_location,
 303                            base::TimeDelta time_stamp,
 304                            int flags)
 305     : Event(type, time_stamp, flags),
 306       location_(location),
 307       root_location_(root_location) {
 308 }
 309
 310 void LocatedEvent::UpdateForRootTransform(
 311     const gfx::Transform& reversed_root_transform) {
 312   // Transform has to be done at root level.
 313   gfx::Point3F p(location_);
 314   reversed_root_transform.TransformPoint(&p);
 315   location_ = p.AsPointF();
 316   root_location_ = location_;
 317 }
 318
 319 ////////////////////////////////////////////////////////////////////////////////
 320 // MouseEvent
 321
 322 MouseEvent::MouseEvent(const base::NativeEvent& native_event)
 323     : LocatedEvent(native_event),
 324       changed_button_flags_(
 325           GetChangedMouseButtonFlagsFromNative(native_event)) {
 326   if (type() == ET_MOUSE_PRESSED || type() == ET_MOUSE_RELEASED)
 327     SetClickCount(GetRepeatCount(*this));
 328 }
 329
 330 MouseEvent::MouseEvent(EventType type,
 331                        const gfx::PointF& location,
 332                        const gfx::PointF& root_location,
 333                        base::TimeDelta time_stamp,
 334                        int flags,
 335                        int changed_button_flags)
 336     : LocatedEvent(type, location, root_location, time_stamp, flags),
 337       changed_button_flags_(changed_button_flags) {
 338   if (this->type() == ET_MOUSE_MOVED && IsAnyButton())
 339     SetType(ET_MOUSE_DRAGGED);
 340 }
 341
 342 // static
 343 bool MouseEvent::IsRepeatedClickEvent(
 344     const MouseEvent& event1,
 345     const MouseEvent& event2) {
 346   // These values match the Windows defaults.
 347   static const int kDoubleClickTimeMS = 500;
 348   static const int kDoubleClickWidth = 4;
 349   static const int kDoubleClickHeight = 4;
 350
 351   if (event1.type() != ET_MOUSE_PRESSED ||
 352       event2.type() != ET_MOUSE_PRESSED)
 353     return false;
 354
 355   // Compare flags, but ignore EF_IS_DOUBLE_CLICK to allow triple clicks.
 356   if ((event1.flags() & ~EF_IS_DOUBLE_CLICK) !=
 357       (event2.flags() & ~EF_IS_DOUBLE_CLICK))
 358     return false;
 359
 360   base::TimeDelta time_difference = event2.time_stamp() - event1.time_stamp();
 361
 362   if (time_difference.InMilliseconds() > kDoubleClickTimeMS)
 363     return false;
 364
 365   if (std::abs(event2.x() - event1.x()) > kDoubleClickWidth / 2)
 366     return false;
 367
 368   if (std::abs(event2.y() - event1.y()) > kDoubleClickHeight / 2)
 369     return false;
 370
 371   return true;
 372 }
 373
 374 // static
 375 int MouseEvent::GetRepeatCount(const MouseEvent& event) {
 376   int click_count = 1;
 377   if (last_click_event_) {
 378     if (event.type() == ui::ET_MOUSE_RELEASED) {
 379       if (event.changed_button_flags() ==
 380               last_click_event_->changed_button_flags()) {
 381         last_click_complete_ = true;
 382         return last_click_event_->GetClickCount();
 383       } else {
 384         // If last_click_event_ has changed since this button was pressed
 385         // return a click count of 1.
 386         return click_count;
 387       }
 388     }
 389     if (event.time_stamp() != last_click_event_->time_stamp())
 390       last_click_complete_ = true;
 391     if (!last_click_complete_ ||
 392         IsX11SendEventTrue(event.native_event())) {
 393       click_count = last_click_event_->GetClickCount();
 394     } else if (IsRepeatedClickEvent(*last_click_event_, event)) {
 395       click_count = last_click_event_->GetClickCount() + 1;
 396     }
 397     delete last_click_event_;
 398   }
 399   last_click_event_ = new MouseEvent(event);
 400   last_click_complete_ = false;
 401   if (click_count > 3)
 402     click_count = 3;
 403   last_click_event_->SetClickCount(click_count);
 404   return click_count;
 405 }
 406
 407 void MouseEvent::ResetLastClickForTest() {
 408   if (last_click_event_) {
 409     delete last_click_event_;
 410     last_click_event_ = NULL;
 411     last_click_complete_ = false;
 412   }
 413 }
 414
 415 // static
 416 MouseEvent* MouseEvent::last_click_event_ = NULL;
 417 bool MouseEvent::last_click_complete_ = false;
 418
 419 int MouseEvent::GetClickCount() const {
 420   if (type() != ET_MOUSE_PRESSED && type() != ET_MOUSE_RELEASED)
 421     return 0;
 422
 423   if (flags() & EF_IS_TRIPLE_CLICK)
 424     return 3;
 425   else if (flags() & EF_IS_DOUBLE_CLICK)
 426     return 2;
 427   else
 428     return 1;
 429 }
 430
 431 void MouseEvent::SetClickCount(int click_count) {
 432   if (type() != ET_MOUSE_PRESSED && type() != ET_MOUSE_RELEASED)
 433     return;
 434
 435   DCHECK(click_count > 0);
 436   DCHECK(click_count <= 3);
 437
 438   int f = flags();
 439   switch (click_count) {
 440     case 1:
 441       f &= ~EF_IS_DOUBLE_CLICK;
 442       f &= ~EF_IS_TRIPLE_CLICK;
 443       break;
 444     case 2:
 445       f |= EF_IS_DOUBLE_CLICK;
 446       f &= ~EF_IS_TRIPLE_CLICK;
 447       break;
 448     case 3:
 449       f &= ~EF_IS_DOUBLE_CLICK;
 450       f |= EF_IS_TRIPLE_CLICK;
 451       break;
 452   }
 453   set_flags(f);
 454 }
 455
 456 ////////////////////////////////////////////////////////////////////////////////
 457 // MouseWheelEvent
 458
 459 MouseWheelEvent::MouseWheelEvent(const base::NativeEvent& native_event)
 460     : MouseEvent(native_event),
 461       offset_(GetMouseWheelOffset(native_event)) {
 462 }
 463
 464 MouseWheelEvent::MouseWheelEvent(const ScrollEvent& scroll_event)
 465     : MouseEvent(scroll_event),
 466       offset_(gfx::ToRoundedInt(scroll_event.x_offset()),
 467               gfx::ToRoundedInt(scroll_event.y_offset())) {
 468   SetType(ET_MOUSEWHEEL);
 469 }
 470
 471 MouseWheelEvent::MouseWheelEvent(const MouseEvent& mouse_event,
 472                                  int x_offset,
 473                                  int y_offset)
 474     : MouseEvent(mouse_event), offset_(x_offset, y_offset) {
 475   DCHECK(type() == ET_MOUSEWHEEL);
 476 }
 477
 478 MouseWheelEvent::MouseWheelEvent(const MouseWheelEvent& mouse_wheel_event)
 479     : MouseEvent(mouse_wheel_event),
 480       offset_(mouse_wheel_event.offset()) {
 481   DCHECK(type() == ET_MOUSEWHEEL);
 482 }
 483
 484 MouseWheelEvent::MouseWheelEvent(const gfx::Vector2d& offset,
 485                                  const gfx::PointF& location,
 486                                  const gfx::PointF& root_location,
 487                                  base::TimeDelta time_stamp,
 488                                  int flags,
 489                                  int changed_button_flags)
 490     : MouseEvent(ui::ET_MOUSEWHEEL,
 491                  location,
 492                  root_location,
 493                  time_stamp,
 494                  flags,
 495                  changed_button_flags),
 496       offset_(offset) {
 497 }
 498
 499 #if defined(OS_WIN)
 500 // This value matches windows WHEEL_DELTA.
 501 // static
 502 const int MouseWheelEvent::kWheelDelta = 120;
 503 #else
 504 // This value matches GTK+ wheel scroll amount.
 505 const int MouseWheelEvent::kWheelDelta = 53;
 506 #endif
 507
 508 ////////////////////////////////////////////////////////////////////////////////
 509 // TouchEvent
 510
 511 TouchEvent::TouchEvent(const base::NativeEvent& native_event)
 512     : LocatedEvent(native_event),
 513       touch_id_(GetTouchId(native_event)),
 514       unique_event_id_(get_next_touch_event_id()),
 515       radius_x_(GetTouchRadiusX(native_event)),
 516       radius_y_(GetTouchRadiusY(native_event)),
 517       rotation_angle_(GetTouchAngle(native_event)),
 518       force_(GetTouchForce(native_event)),
 519       may_cause_scrolling_(false),
 520       should_remove_native_touch_id_mapping_(false) {
 521   latency()->AddLatencyNumberWithTimestamp(
 522       INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, 0,
 523       base::TimeTicks::FromInternalValue(time_stamp().ToInternalValue()), 1);
 524   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 525
 526   FixRotationAngle();
 527   if (type() == ET_TOUCH_RELEASED || type() == ET_TOUCH_CANCELLED)
 528     should_remove_native_touch_id_mapping_ = true;
 529 }
 530
 531 TouchEvent::TouchEvent(EventType type,
 532                        const gfx::PointF& location,
 533                        int touch_id,
 534                        base::TimeDelta time_stamp)
 535     : LocatedEvent(type, location, location, time_stamp, 0),
 536       touch_id_(touch_id),
 537       unique_event_id_(get_next_touch_event_id()),
 538       radius_x_(0.0f),
 539       radius_y_(0.0f),
 540       rotation_angle_(0.0f),
 541       force_(0.0f),
 542       may_cause_scrolling_(false),
 543       should_remove_native_touch_id_mapping_(false) {
 544   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 545 }
 546
 547 TouchEvent::TouchEvent(EventType type,
 548                        const gfx::PointF& location,
 549                        int flags,
 550                        int touch_id,
 551                        base::TimeDelta time_stamp,
 552                        float radius_x,
 553                        float radius_y,
 554                        float angle,
 555                        float force)
 556     : LocatedEvent(type, location, location, time_stamp, flags),
 557       touch_id_(touch_id),
 558       unique_event_id_(get_next_touch_event_id()),
 559       radius_x_(radius_x),
 560       radius_y_(radius_y),
 561       rotation_angle_(angle),
 562       force_(force),
 563       may_cause_scrolling_(false),
 564       should_remove_native_touch_id_mapping_(false) {
 565   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 566   FixRotationAngle();
 567 }
 568
 569 TouchEvent::TouchEvent(const TouchEvent& copy)
 570     : LocatedEvent(copy),
 571       touch_id_(copy.touch_id_),
 572       unique_event_id_(copy.unique_event_id_),
 573       radius_x_(copy.radius_x_),
 574       radius_y_(copy.radius_y_),
 575       rotation_angle_(copy.rotation_angle_),
 576       force_(copy.force_),
 577       may_cause_scrolling_(copy.may_cause_scrolling_),
 578       should_remove_native_touch_id_mapping_(false) {
 579   // Copied events should not remove touch id mapping, as this either causes the
 580   // mapping to be lost before the initial event has finished dispatching, or
 581   // the copy to attempt to remove the mapping from a null |native_event_|.
 582 }
 583
 584 TouchEvent::~TouchEvent() {
 585   // In ctor TouchEvent(native_event) we call GetTouchId() which in X11
 586   // platform setups the tracking_id to slot mapping. So in dtor here,
 587   // if this touch event is a release event, we clear the mapping accordingly.
 588   if (should_remove_native_touch_id_mapping_) {
 589     DCHECK(type() == ET_TOUCH_RELEASED || type() == ET_TOUCH_CANCELLED);
 590     if (type() == ET_TOUCH_RELEASED || type() == ET_TOUCH_CANCELLED)
 591       ClearTouchIdIfReleased(native_event());
 592   }
 593 }
 594
 595 void TouchEvent::UpdateForRootTransform(
 596     const gfx::Transform& inverted_root_transform) {
 597   LocatedEvent::UpdateForRootTransform(inverted_root_transform);
 598   gfx::DecomposedTransform decomp;
 599   bool success = gfx::DecomposeTransform(&decomp, inverted_root_transform);
 600   DCHECK(success);
 601   if (decomp.scale[0])
 602     radius_x_ *= decomp.scale[0];
 603   if (decomp.scale[1])
 604     radius_y_ *= decomp.scale[1];
 605 }
 606
 607 void TouchEvent::DisableSynchronousHandling() {
 608   DispatcherApi dispatcher_api(this);
 609   dispatcher_api.set_result(
 610       static_cast<EventResult>(result() | ER_DISABLE_SYNC_HANDLING));
 611 }
 612
 613 void TouchEvent::FixRotationAngle() {
 614   while (rotation_angle_ < 0)
 615     rotation_angle_ += 180;
 616   while (rotation_angle_ >= 180)
 617     rotation_angle_ -= 180;
 618 }
 619
 620 ////////////////////////////////////////////////////////////////////////////////
 621 // KeyEvent
 622
 623 // static
 624 KeyEvent* KeyEvent::last_key_event_ = NULL;
 625
 626 // static
 627 bool KeyEvent::IsRepeated(const KeyEvent& event) {
 628   // A safe guard in case if there were continous key pressed events that are
 629   // not auto repeat.
 630   const int kMaxAutoRepeatTimeMs = 2000;
 631   // Ignore key events that have non standard state masks as it may be
 632   // reposted by an IME. IBUS-GTK uses this field to detect the
 633   // re-posted event for example. crbug.com/385873.
 634   if (X11EventHasNonStandardState(event.native_event()))
 635     return false;
 636   if (event.is_char())
 637     return false;
 638   if (event.type() == ui::ET_KEY_RELEASED) {
 639     delete last_key_event_;
 640     last_key_event_ = NULL;
 641     return false;
 642   }
 643   CHECK_EQ(ui::ET_KEY_PRESSED, event.type());
 644   if (!last_key_event_) {
 645     last_key_event_ = new KeyEvent(event);
 646     return false;
 647   } else if (event.time_stamp() == last_key_event_->time_stamp()) {
 648     // The KeyEvent is created from the same native event.
 649     return (last_key_event_->flags() & ui::EF_IS_REPEAT) != 0;
 650   }
 651   if (event.key_code() == last_key_event_->key_code() &&
 652       event.flags() == (last_key_event_->flags() & ~ui::EF_IS_REPEAT) &&
 653       (event.time_stamp() - last_key_event_->time_stamp()).InMilliseconds() <
 654           kMaxAutoRepeatTimeMs) {
 655     last_key_event_->set_time_stamp(event.time_stamp());
 656     last_key_event_->set_flags(last_key_event_->flags() | ui::EF_IS_REPEAT);
 657     return true;
 658   }
 659   delete last_key_event_;
 660   last_key_event_ = new KeyEvent(event);
 661   return false;
 662 }
 663
 664 KeyEvent::KeyEvent(const base::NativeEvent& native_event)
 665     : Event(native_event,
 666             EventTypeFromNative(native_event),
 667             EventFlagsFromNative(native_event)),
 668       key_code_(KeyboardCodeFromNative(native_event)),
 669       code_(CodeFromNative(native_event)),
 670       is_char_(IsCharFromNative(native_event)),
 671       platform_keycode_(PlatformKeycodeFromNative(native_event)),
 672       key_(DomKey::NONE),
 673       character_(0) {
 674   if (IsRepeated(*this))
 675     set_flags(flags() | ui::EF_IS_REPEAT);
 676
 677 #if defined(USE_X11)
 678   NormalizeFlags();
 679 #endif
 680 #if defined(OS_WIN)
 681   // Only Windows has native character events.
 682   if (is_char_)
 683     character_ = native_event.wParam;
 684 #endif
 685 }
 686
 687 KeyEvent::KeyEvent(EventType type,
 688                    KeyboardCode key_code,
 689                    int flags)
 690     : Event(type, EventTimeForNow(), flags),
 691       key_code_(key_code),
 692       code_(DomCode::NONE),
 693       is_char_(false),
 694       platform_keycode_(0),
 695       key_(DomKey::NONE),
 696       character_() {
 697 }
 698
 699 KeyEvent::KeyEvent(EventType type,
 700                    KeyboardCode key_code,
 701                    DomCode code,
 702                    int flags)
 703     : Event(type, EventTimeForNow(), flags),
 704       key_code_(key_code),
 705       code_(code),
 706       is_char_(false),
 707       platform_keycode_(0),
 708       key_(DomKey::NONE),
 709       character_(0) {
 710 }
 711
 712 KeyEvent::KeyEvent(EventType type,
 713                    KeyboardCode key_code,
 714                    DomCode code,
 715                    int flags,
 716                    DomKey key,
 717                    base::char16 character,
 718                    base::TimeDelta time_stamp)
 719     : Event(type, time_stamp, flags),
 720       key_code_(key_code),
 721       code_(code),
 722       is_char_(false),
 723       platform_keycode_(0),
 724       key_(key),
 725       character_(character) {
 726 }
 727
 728 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
 729     : Event(ET_KEY_PRESSED, EventTimeForNow(), flags),
 730       key_code_(key_code),
 731       code_(DomCode::NONE),
 732       is_char_(true),
 733       platform_keycode_(0),
 734       key_(DomKey::CHARACTER),
 735       character_(character) {
 736 }
 737
 738 KeyEvent::KeyEvent(const KeyEvent& rhs)
 739     : Event(rhs),
 740       key_code_(rhs.key_code_),
 741       code_(rhs.code_),
 742       is_char_(rhs.is_char_),
 743       platform_keycode_(rhs.platform_keycode_),
 744       key_(rhs.key_),
 745       character_(rhs.character_) {
 746   if (rhs.extended_key_event_data_)
 747     extended_key_event_data_.reset(rhs.extended_key_event_data_->Clone());
 748 }
 749
 750 KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) {
 751   if (this != &rhs) {
 752     Event::operator=(rhs);
 753     key_code_ = rhs.key_code_;
 754     code_ = rhs.code_;
 755     key_ = rhs.key_;
 756     is_char_ = rhs.is_char_;
 757     platform_keycode_ = rhs.platform_keycode_;
 758     character_ = rhs.character_;
 759
 760     if (rhs.extended_key_event_data_)
 761       extended_key_event_data_.reset(rhs.extended_key_event_data_->Clone());
 762   }
 763   return *this;
 764 }
 765
 766 KeyEvent::~KeyEvent() {}
 767
 768 void KeyEvent::SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data) {
 769   extended_key_event_data_ = data.Pass();
 770 }
 771
 772 void KeyEvent::ApplyLayout() const {
 773   // If the client has set the character (e.g. faked key events from virtual
 774   // keyboard), it's client's responsibility to set the dom key correctly.
 775   // Otherwise, set the dom key as unidentified.
 776   // Please refer to crbug.com/443889.
 777   if (character_ != 0) {
 778     key_ = DomKey::UNIDENTIFIED;
 779     return;
 780   }
 781 #if defined(OS_WIN)
 782   // Native Windows character events always have is_char_ == true,
 783   // so this is a synthetic or native keystroke event.
 784   // Therefore, perform only the fallback action.
 785   GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 786 #elif defined(USE_X11)
 787   // When a control key is held, prefer ASCII characters to non ASCII
 788   // characters in order to use it for shortcut keys.  GetCharacterFromKeyCode
 789   // returns 'a' for VKEY_A even if the key is actually bound to 'à' in X11.
 790   // GetCharacterFromXEvent returns 'à' in that case.
 791   character_ = (IsControlDown() || !native_event()) ?
 792       GetCharacterFromKeyCode(key_code_, flags()) :
 793       GetCharacterFromXEvent(native_event());
 794   // TODO(kpschoedel): set key_ field for X11.
 795 #elif defined(USE_OZONE)
 796   KeyboardCode key_code;
 797   if (!KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()->Lookup(
 798       code_, flags(), &key_, &character_, &key_code, &platform_keycode_)) {
 799     GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 800   }
 801 #else
 802   if (native_event()) {
 803     DCHECK(EventTypeFromNative(native_event()) == ET_KEY_PRESSED ||
 804            EventTypeFromNative(native_event()) == ET_KEY_RELEASED);
 805   }
 806   // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
 807   GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 808 #endif
 809 }
 810
 811 DomKey KeyEvent::GetDomKey() const {
 812   // Determination of character_ and key_ may be done lazily.
 813   if (key_ == DomKey::NONE)
 814     ApplyLayout();
 815   return key_;
 816 }
 817
 818 base::char16 KeyEvent::GetCharacter() const {
 819   // Determination of character_ and key_ may be done lazily.
 820   if (key_ == DomKey::NONE)
 821     ApplyLayout();
 822   return character_;
 823 }
 824
 825 base::char16 KeyEvent::GetText() const {
 826   if ((flags() & EF_CONTROL_DOWN) != 0) {
 827     // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
 828     return GetControlCharacterForKeycode(key_code_,
 829                                          (flags() & EF_SHIFT_DOWN) != 0);
 830   }
 831   return GetUnmodifiedText();
 832 }
 833
 834 base::char16 KeyEvent::GetUnmodifiedText() const {
 835   if (!is_char_ && (key_code_ == VKEY_RETURN))
 836     return '\r';
 837   return GetCharacter();
 838 }
 839
 840 bool KeyEvent::IsUnicodeKeyCode() const {
 841 #if defined(OS_WIN)
 842   if (!IsAltDown())
 843     return false;
 844   const int key = key_code();
 845   if (key >= VKEY_NUMPAD0 && key <= VKEY_NUMPAD9)
 846     return true;
 847   // Check whether the user is using the numeric keypad with num-lock off.
 848   // In that case, EF_EXTENDED will not be set; if it is set, the key event
 849   // originated from the relevant non-numpad dedicated key, e.g. [Insert].
 850   return (!(flags() & EF_EXTENDED) &&
 851           (key == VKEY_INSERT || key == VKEY_END  || key == VKEY_DOWN ||
 852            key == VKEY_NEXT   || key == VKEY_LEFT || key == VKEY_CLEAR ||
 853            key == VKEY_RIGHT  || key == VKEY_HOME || key == VKEY_UP ||
 854            key == VKEY_PRIOR));
 855 #else
 856   return false;
 857 #endif
 858 }
 859
 860 void KeyEvent::NormalizeFlags() {
 861   int mask = 0;
 862   switch (key_code()) {
 863     case VKEY_CONTROL:
 864       mask = EF_CONTROL_DOWN;
 865       break;
 866     case VKEY_SHIFT:
 867       mask = EF_SHIFT_DOWN;
 868       break;
 869     case VKEY_MENU:
 870       mask = EF_ALT_DOWN;
 871       break;
 872     case VKEY_CAPITAL:
 873       mask = EF_CAPS_LOCK_DOWN;
 874       break;
 875     default:
 876       return;
 877   }
 878   if (type() == ET_KEY_PRESSED)
 879     set_flags(flags() | mask);
 880   else
 881     set_flags(flags() & ~mask);
 882 }
 883
 884 bool KeyEvent::IsTranslated() const {
 885   switch (type()) {
 886     case ET_KEY_PRESSED:
 887     case ET_KEY_RELEASED:
 888       return false;
 889     case ET_TRANSLATED_KEY_PRESS:
 890     case ET_TRANSLATED_KEY_RELEASE:
 891       return true;
 892     default:
 893       NOTREACHED();
 894       return false;
 895   }
 896 }
 897
 898 void KeyEvent::SetTranslated(bool translated) {
 899   switch (type()) {
 900     case ET_KEY_PRESSED:
 901     case ET_TRANSLATED_KEY_PRESS:
 902       SetType(translated ? ET_TRANSLATED_KEY_PRESS : ET_KEY_PRESSED);
 903       break;
 904     case ET_KEY_RELEASED:
 905     case ET_TRANSLATED_KEY_RELEASE:
 906       SetType(translated ? ET_TRANSLATED_KEY_RELEASE : ET_KEY_RELEASED);
 907       break;
 908     default:
 909       NOTREACHED();
 910   }
 911 }
 912
 913 KeyboardCode KeyEvent::GetLocatedWindowsKeyboardCode() const {
 914   return NonLocatedToLocatedKeyboardCode(key_code_, code_);
 915 }
 916
 917 uint16 KeyEvent::GetConflatedWindowsKeyCode() const {
 918   if (is_char_)
 919     return character_;
 920   return key_code_;
 921 }
 922
 923 std::string KeyEvent::GetCodeString() const {
 924   return KeycodeConverter::DomCodeToCodeString(code_);
 925 }
 926
 927 ////////////////////////////////////////////////////////////////////////////////
 928 // ScrollEvent
 929
 930 ScrollEvent::ScrollEvent(const base::NativeEvent& native_event)
 931     : MouseEvent(native_event) {
 932   if (type() == ET_SCROLL) {
 933     GetScrollOffsets(native_event,
 934                      &x_offset_, &y_offset_,
 935                      &x_offset_ordinal_, &y_offset_ordinal_,
 936                      &finger_count_);
 937   } else if (type() == ET_SCROLL_FLING_START ||
 938              type() == ET_SCROLL_FLING_CANCEL) {
 939     GetFlingData(native_event,
 940                  &x_offset_, &y_offset_,
 941                  &x_offset_ordinal_, &y_offset_ordinal_,
 942                  NULL);
 943   } else {
 944     NOTREACHED() << "Unexpected event type " << type()
 945         << " when constructing a ScrollEvent.";
 946   }
 947 }
 948
 949 ScrollEvent::ScrollEvent(EventType type,
 950                          const gfx::PointF& location,
 951                          base::TimeDelta time_stamp,
 952                          int flags,
 953                          float x_offset,
 954                          float y_offset,
 955                          float x_offset_ordinal,
 956                          float y_offset_ordinal,
 957                          int finger_count)
 958     : MouseEvent(type, location, location, time_stamp, flags, 0),
 959       x_offset_(x_offset),
 960       y_offset_(y_offset),
 961       x_offset_ordinal_(x_offset_ordinal),
 962       y_offset_ordinal_(y_offset_ordinal),
 963       finger_count_(finger_count) {
 964   CHECK(IsScrollEvent());
 965 }
 966
 967 void ScrollEvent::Scale(const float factor) {
 968   x_offset_ *= factor;
 969   y_offset_ *= factor;
 970   x_offset_ordinal_ *= factor;
 971   y_offset_ordinal_ *= factor;
 972 }
 973
 974 ////////////////////////////////////////////////////////////////////////////////
 975 // GestureEvent
 976
 977 GestureEvent::GestureEvent(float x,
 978                            float y,
 979                            int flags,
 980                            base::TimeDelta time_stamp,
 981                            const GestureEventDetails& details)
 982     : LocatedEvent(details.type(),
 983                    gfx::PointF(x, y),
 984                    gfx::PointF(x, y),
 985                    time_stamp,
 986                    flags | EF_FROM_TOUCH),
 987       details_(details) {
 988 }
 989
 990 GestureEvent::~GestureEvent() {
 991 }
 992
 993 }  // namespace ui