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 scoped_ptr<Event>(new KeyEvent(static_cast<const KeyEvent&>(event)));
 129   }
 130
 131   if (event.IsMouseEvent()) {
 132     if (event.IsMouseWheelEvent()) {
 133       return scoped_ptr<Event>(
 134           new MouseWheelEvent(static_cast<const MouseWheelEvent&>(event)));
 135     }
 136
 137     return scoped_ptr<Event>(
 138         new MouseEvent(static_cast<const MouseEvent&>(event)));
 139   }
 140
 141   if (event.IsTouchEvent()) {
 142     return scoped_ptr<Event>(
 143         new TouchEvent(static_cast<const TouchEvent&>(event)));
 144   }
 145
 146   if (event.IsGestureEvent()) {
 147     return scoped_ptr<Event>(
 148         new GestureEvent(static_cast<const GestureEvent&>(event)));
 149   }
 150
 151   if (event.IsScrollEvent()) {
 152     return scoped_ptr<Event>(
 153         new ScrollEvent(static_cast<const ScrollEvent&>(event)));
 154   }
 155
 156   return scoped_ptr<Event>(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                                  int flags,
 488                                  int changed_button_flags)
 489     : MouseEvent(ui::ET_MOUSEWHEEL,
 490                  location,
 491                  root_location,
 492                  EventTimeForNow(),
 493                  flags,
 494                  changed_button_flags),
 495       offset_(offset) {
 496 }
 497
 498 #if defined(OS_WIN)
 499 // This value matches windows WHEEL_DELTA.
 500 // static
 501 const int MouseWheelEvent::kWheelDelta = 120;
 502 #else
 503 // This value matches GTK+ wheel scroll amount.
 504 const int MouseWheelEvent::kWheelDelta = 53;
 505 #endif
 506
 507 void MouseWheelEvent::UpdateForRootTransform(
 508     const gfx::Transform& inverted_root_transform) {
 509   LocatedEvent::UpdateForRootTransform(inverted_root_transform);
 510   gfx::DecomposedTransform decomp;
 511   bool success = gfx::DecomposeTransform(&decomp, inverted_root_transform);
 512   DCHECK(success);
 513   if (decomp.scale[0]) {
 514     offset_.set_x(
 515         gfx::ToRoundedInt(SkMScalarToFloat(offset_.x() * decomp.scale[0])));
 516   }
 517   if (decomp.scale[1]) {
 518     offset_.set_y(
 519         gfx::ToRoundedInt(SkMScalarToFloat(offset_.y() * decomp.scale[1])));
 520   }
 521 }
 522
 523 ////////////////////////////////////////////////////////////////////////////////
 524 // TouchEvent
 525
 526 TouchEvent::TouchEvent(const base::NativeEvent& native_event)
 527     : LocatedEvent(native_event),
 528       touch_id_(GetTouchId(native_event)),
 529       unique_event_id_(get_next_touch_event_id()),
 530       radius_x_(GetTouchRadiusX(native_event)),
 531       radius_y_(GetTouchRadiusY(native_event)),
 532       rotation_angle_(GetTouchAngle(native_event)),
 533       force_(GetTouchForce(native_event)),
 534       may_cause_scrolling_(false),
 535       should_remove_native_touch_id_mapping_(false) {
 536   latency()->AddLatencyNumberWithTimestamp(
 537       INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, 0,
 538       base::TimeTicks::FromInternalValue(time_stamp().ToInternalValue()), 1);
 539   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 540
 541   FixRotationAngle();
 542   if (type() == ET_TOUCH_RELEASED || type() == ET_TOUCH_CANCELLED)
 543     should_remove_native_touch_id_mapping_ = true;
 544 }
 545
 546 TouchEvent::TouchEvent(EventType type,
 547                        const gfx::PointF& location,
 548                        int touch_id,
 549                        base::TimeDelta time_stamp)
 550     : LocatedEvent(type, location, location, time_stamp, 0),
 551       touch_id_(touch_id),
 552       unique_event_id_(get_next_touch_event_id()),
 553       radius_x_(0.0f),
 554       radius_y_(0.0f),
 555       rotation_angle_(0.0f),
 556       force_(0.0f),
 557       may_cause_scrolling_(false),
 558       should_remove_native_touch_id_mapping_(false) {
 559   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 560 }
 561
 562 TouchEvent::TouchEvent(EventType type,
 563                        const gfx::PointF& location,
 564                        int flags,
 565                        int touch_id,
 566                        base::TimeDelta time_stamp,
 567                        float radius_x,
 568                        float radius_y,
 569                        float angle,
 570                        float force)
 571     : LocatedEvent(type, location, location, time_stamp, flags),
 572       touch_id_(touch_id),
 573       unique_event_id_(get_next_touch_event_id()),
 574       radius_x_(radius_x),
 575       radius_y_(radius_y),
 576       rotation_angle_(angle),
 577       force_(force),
 578       may_cause_scrolling_(false),
 579       should_remove_native_touch_id_mapping_(false) {
 580   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 581   FixRotationAngle();
 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   }
 648   if (event.key_code() == last_key_event_->key_code() &&
 649       event.flags() == last_key_event_->flags() &&
 650       (event.time_stamp() - last_key_event_->time_stamp()).InMilliseconds() <
 651       kMaxAutoRepeatTimeMs) {
 652     last_key_event_->set_time_stamp(event.time_stamp());
 653     return true;
 654   }
 655   delete last_key_event_;
 656   last_key_event_ = new KeyEvent(event);
 657   return false;
 658 }
 659
 660 KeyEvent::KeyEvent(const base::NativeEvent& native_event)
 661     : Event(native_event,
 662             EventTypeFromNative(native_event),
 663             EventFlagsFromNative(native_event)),
 664       key_code_(KeyboardCodeFromNative(native_event)),
 665       code_(CodeFromNative(native_event)),
 666       is_char_(IsCharFromNative(native_event)),
 667       platform_keycode_(PlatformKeycodeFromNative(native_event)),
 668       key_(DomKey::NONE),
 669       character_(0) {
 670   if (IsRepeated(*this))
 671     set_flags(flags() | ui::EF_IS_REPEAT);
 672
 673 #if defined(USE_X11)
 674   NormalizeFlags();
 675 #endif
 676 #if defined(OS_WIN)
 677   // Only Windows has native character events.
 678   if (is_char_)
 679     character_ = native_event.wParam;
 680 #endif
 681 }
 682
 683 KeyEvent::KeyEvent(EventType type,
 684                    KeyboardCode key_code,
 685                    int flags)
 686     : Event(type, EventTimeForNow(), flags),
 687       key_code_(key_code),
 688       code_(DomCode::NONE),
 689       is_char_(false),
 690       platform_keycode_(0),
 691       key_(DomKey::NONE),
 692       character_() {
 693 }
 694
 695 KeyEvent::KeyEvent(EventType type,
 696                    KeyboardCode key_code,
 697                    DomCode code,
 698                    int flags)
 699     : Event(type, EventTimeForNow(), flags),
 700       key_code_(key_code),
 701       code_(code),
 702       is_char_(false),
 703       platform_keycode_(0),
 704       key_(DomKey::NONE),
 705       character_(0) {
 706 }
 707
 708 KeyEvent::KeyEvent(EventType type,
 709                    KeyboardCode key_code,
 710                    DomCode code,
 711                    int flags,
 712                    DomKey key,
 713                    base::char16 character,
 714                    base::TimeDelta time_stamp)
 715     : Event(type, time_stamp, flags),
 716       key_code_(key_code),
 717       code_(code),
 718       is_char_(false),
 719       platform_keycode_(0),
 720       key_(key),
 721       character_(character) {
 722 }
 723
 724 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
 725     : Event(ET_KEY_PRESSED, EventTimeForNow(), flags),
 726       key_code_(key_code),
 727       code_(DomCode::NONE),
 728       is_char_(true),
 729       platform_keycode_(0),
 730       key_(DomKey::CHARACTER),
 731       character_(character) {
 732 }
 733
 734 KeyEvent::KeyEvent(const KeyEvent& rhs)
 735     : Event(rhs),
 736       key_code_(rhs.key_code_),
 737       code_(rhs.code_),
 738       is_char_(rhs.is_char_),
 739       platform_keycode_(rhs.platform_keycode_),
 740       key_(rhs.key_),
 741       character_(rhs.character_) {
 742   if (rhs.extended_key_event_data_)
 743     extended_key_event_data_.reset(rhs.extended_key_event_data_->Clone());
 744 }
 745
 746 KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) {
 747   if (this != &rhs) {
 748     Event::operator=(rhs);
 749     key_code_ = rhs.key_code_;
 750     code_ = rhs.code_;
 751     key_ = rhs.key_;
 752     is_char_ = rhs.is_char_;
 753     platform_keycode_ = rhs.platform_keycode_;
 754     character_ = rhs.character_;
 755
 756     if (rhs.extended_key_event_data_)
 757       extended_key_event_data_.reset(rhs.extended_key_event_data_->Clone());
 758   }
 759   return *this;
 760 }
 761
 762 KeyEvent::~KeyEvent() {}
 763
 764 void KeyEvent::SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data) {
 765   extended_key_event_data_ = data.Pass();
 766 }
 767
 768 void KeyEvent::ApplyLayout() const {
 769   // If the client has set the character (e.g. faked key events from virtual
 770   // keyboard), it's client's responsibility to set the dom key correctly.
 771   // Otherwise, set the dom key as unidentified.
 772   // Please refer to crbug.com/443889.
 773   if (character_ != 0) {
 774     key_ = DomKey::UNIDENTIFIED;
 775     return;
 776   }
 777 #if defined(OS_WIN)
 778   // Native Windows character events always have is_char_ == true,
 779   // so this is a synthetic or native keystroke event.
 780   // Therefore, perform only the fallback action.
 781   GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 782 #elif defined(USE_X11)
 783   // When a control key is held, prefer ASCII characters to non ASCII
 784   // characters in order to use it for shortcut keys.  GetCharacterFromKeyCode
 785   // returns 'a' for VKEY_A even if the key is actually bound to 'à' in X11.
 786   // GetCharacterFromXEvent returns 'à' in that case.
 787   character_ = (IsControlDown() || !native_event()) ?
 788       GetCharacterFromKeyCode(key_code_, flags()) :
 789       GetCharacterFromXEvent(native_event());
 790   // TODO(kpschoedel): set key_ field for X11.
 791 #elif defined(USE_OZONE)
 792   KeyboardCode key_code;
 793   if (!KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()->Lookup(
 794       code_, flags(), &key_, &character_, &key_code, &platform_keycode_)) {
 795     GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 796   }
 797 #else
 798   if (native_event()) {
 799     DCHECK(EventTypeFromNative(native_event()) == ET_KEY_PRESSED ||
 800            EventTypeFromNative(native_event()) == ET_KEY_RELEASED);
 801   }
 802   // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
 803   GetMeaningFromKeyCode(key_code_, flags(), &key_, &character_);
 804 #endif
 805 }
 806
 807 DomKey KeyEvent::GetDomKey() const {
 808   // Determination of character_ and key_ may be done lazily.
 809   if (key_ == DomKey::NONE)
 810     ApplyLayout();
 811   return key_;
 812 }
 813
 814 base::char16 KeyEvent::GetCharacter() const {
 815   // Determination of character_ and key_ may be done lazily.
 816   if (key_ == DomKey::NONE)
 817     ApplyLayout();
 818   return character_;
 819 }
 820
 821 base::char16 KeyEvent::GetText() const {
 822   if ((flags() & EF_CONTROL_DOWN) != 0) {
 823     // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
 824     return GetControlCharacterForKeycode(key_code_,
 825                                          (flags() & EF_SHIFT_DOWN) != 0);
 826   }
 827   return GetUnmodifiedText();
 828 }
 829
 830 base::char16 KeyEvent::GetUnmodifiedText() const {
 831   if (!is_char_ && (key_code_ == VKEY_RETURN))
 832     return '\r';
 833   return GetCharacter();
 834 }
 835
 836 bool KeyEvent::IsUnicodeKeyCode() const {
 837 #if defined(OS_WIN)
 838   if (!IsAltDown())
 839     return false;
 840   const int key = key_code();
 841   if (key >= VKEY_NUMPAD0 && key <= VKEY_NUMPAD9)
 842     return true;
 843   // Check whether the user is using the numeric keypad with num-lock off.
 844   // In that case, EF_EXTENDED will not be set; if it is set, the key event
 845   // originated from the relevant non-numpad dedicated key, e.g. [Insert].
 846   return (!(flags() & EF_EXTENDED) &&
 847           (key == VKEY_INSERT || key == VKEY_END  || key == VKEY_DOWN ||
 848            key == VKEY_NEXT   || key == VKEY_LEFT || key == VKEY_CLEAR ||
 849            key == VKEY_RIGHT  || key == VKEY_HOME || key == VKEY_UP ||
 850            key == VKEY_PRIOR));
 851 #else
 852   return false;
 853 #endif
 854 }
 855
 856 void KeyEvent::NormalizeFlags() {
 857   int mask = 0;
 858   switch (key_code()) {
 859     case VKEY_CONTROL:
 860       mask = EF_CONTROL_DOWN;
 861       break;
 862     case VKEY_SHIFT:
 863       mask = EF_SHIFT_DOWN;
 864       break;
 865     case VKEY_MENU:
 866       mask = EF_ALT_DOWN;
 867       break;
 868     case VKEY_CAPITAL:
 869       mask = EF_CAPS_LOCK_DOWN;
 870       break;
 871     default:
 872       return;
 873   }
 874   if (type() == ET_KEY_PRESSED)
 875     set_flags(flags() | mask);
 876   else
 877     set_flags(flags() & ~mask);
 878 }
 879
 880 bool KeyEvent::IsTranslated() const {
 881   switch (type()) {
 882     case ET_KEY_PRESSED:
 883     case ET_KEY_RELEASED:
 884       return false;
 885     case ET_TRANSLATED_KEY_PRESS:
 886     case ET_TRANSLATED_KEY_RELEASE:
 887       return true;
 888     default:
 889       NOTREACHED();
 890       return false;
 891   }
 892 }
 893
 894 void KeyEvent::SetTranslated(bool translated) {
 895   switch (type()) {
 896     case ET_KEY_PRESSED:
 897     case ET_TRANSLATED_KEY_PRESS:
 898       SetType(translated ? ET_TRANSLATED_KEY_PRESS : ET_KEY_PRESSED);
 899       break;
 900     case ET_KEY_RELEASED:
 901     case ET_TRANSLATED_KEY_RELEASE:
 902       SetType(translated ? ET_TRANSLATED_KEY_RELEASE : ET_KEY_RELEASED);
 903       break;
 904     default:
 905       NOTREACHED();
 906   }
 907 }
 908
 909 KeyboardCode KeyEvent::GetLocatedWindowsKeyboardCode() const {
 910   return NonLocatedToLocatedKeyboardCode(key_code_, code_);
 911 }
 912
 913 uint16 KeyEvent::GetConflatedWindowsKeyCode() const {
 914   if (is_char_)
 915     return character_;
 916   return key_code_;
 917 }
 918
 919 std::string KeyEvent::GetCodeString() const {
 920   return KeycodeConverter::DomCodeToCodeString(code_);
 921 }
 922
 923 ////////////////////////////////////////////////////////////////////////////////
 924 // ScrollEvent
 925
 926 ScrollEvent::ScrollEvent(const base::NativeEvent& native_event)
 927     : MouseEvent(native_event) {
 928   if (type() == ET_SCROLL) {
 929     GetScrollOffsets(native_event,
 930                      &x_offset_, &y_offset_,
 931                      &x_offset_ordinal_, &y_offset_ordinal_,
 932                      &finger_count_);
 933   } else if (type() == ET_SCROLL_FLING_START ||
 934              type() == ET_SCROLL_FLING_CANCEL) {
 935     GetFlingData(native_event,
 936                  &x_offset_, &y_offset_,
 937                  &x_offset_ordinal_, &y_offset_ordinal_,
 938                  NULL);
 939   } else {
 940     NOTREACHED() << "Unexpected event type " << type()
 941         << " when constructing a ScrollEvent.";
 942   }
 943 }
 944
 945 ScrollEvent::ScrollEvent(EventType type,
 946                          const gfx::PointF& location,
 947                          base::TimeDelta time_stamp,
 948                          int flags,
 949                          float x_offset,
 950                          float y_offset,
 951                          float x_offset_ordinal,
 952                          float y_offset_ordinal,
 953                          int finger_count)
 954     : MouseEvent(type, location, location, time_stamp, flags, 0),
 955       x_offset_(x_offset),
 956       y_offset_(y_offset),
 957       x_offset_ordinal_(x_offset_ordinal),
 958       y_offset_ordinal_(y_offset_ordinal),
 959       finger_count_(finger_count) {
 960   CHECK(IsScrollEvent());
 961 }
 962
 963 void ScrollEvent::Scale(const float factor) {
 964   x_offset_ *= factor;
 965   y_offset_ *= factor;
 966   x_offset_ordinal_ *= factor;
 967   y_offset_ordinal_ *= factor;
 968 }
 969
 970 ////////////////////////////////////////////////////////////////////////////////
 971 // GestureEvent
 972
 973 GestureEvent::GestureEvent(float x,
 974                            float y,
 975                            int flags,
 976                            base::TimeDelta time_stamp,
 977                            const GestureEventDetails& details)
 978     : LocatedEvent(details.type(),
 979                    gfx::PointF(x, y),
 980                    gfx::PointF(x, y),
 981                    time_stamp,
 982                    flags | EF_FROM_TOUCH),
 983       details_(details) {
 984 }
 985
 986 GestureEvent::~GestureEvent() {
 987 }
 988
 989 }  // namespace ui