ui/events/x/events_x.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_constants.h"
   6
   7 #include <cmath>
   8 #include <string.h>
   9 #include <X11/extensions/XInput.h>
  10 #include <X11/extensions/XInput2.h>
  11 #include <X11/Xlib.h>
  12 #include <X11/Xutil.h>
  13 #include <X11/XKBlib.h>
  14
  15 #include "base/logging.h"
  16 #include "base/memory/singleton.h"
  17 #include "ui/events/event.h"
  18 #include "ui/events/event_utils.h"
  19 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
  20 #include "ui/events/x/device_data_manager_x11.h"
  21 #include "ui/events/x/device_list_cache_x.h"
  22 #include "ui/events/x/touch_factory_x11.h"
  23 #include "ui/gfx/display.h"
  24 #include "ui/gfx/point.h"
  25 #include "ui/gfx/rect.h"
  26 #include "ui/gfx/screen.h"
  27 #include "ui/gfx/x/x11_atom_cache.h"
  28 #include "ui/gfx/x/x11_types.h"
  29
  30 namespace {
  31
  32 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
  33 const int kWheelScrollAmount = 53;
  34
  35 const int kMinWheelButton = 4;
  36 const int kMaxWheelButton = 7;
  37
  38 // A class to track current modifier state on master device. Only track ctrl,
  39 // alt, shift and caps lock keys currently. The tracked state can then be used
  40 // by floating device.
  41 class XModifierStateWatcher{
  42  public:
  43   static XModifierStateWatcher* GetInstance() {
  44     return Singleton<XModifierStateWatcher>::get();
  45   }
  46
  47   int StateFromKeyboardCode(ui::KeyboardCode keyboard_code) {
  48     switch (keyboard_code) {
  49       case ui::VKEY_CONTROL:
  50         return ControlMask;
  51       case ui::VKEY_SHIFT:
  52         return ShiftMask;
  53       case ui::VKEY_MENU:
  54         return Mod1Mask;
  55       case ui::VKEY_CAPITAL:
  56         return LockMask;
  57       default:
  58         return 0;
  59     }
  60   }
  61
  62   void UpdateStateFromXEvent(const base::NativeEvent& native_event) {
  63     ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event);
  64     unsigned int mask = StateFromKeyboardCode(keyboard_code);
  65     // Floating device can't access the modifer state from master device.
  66     // We need to track the states of modifier keys in a singleton for
  67     // floating devices such as touch screen. Issue 106426 is one example
  68     // of why we need the modifier states for floating device.
  69     switch (native_event->type) {
  70       case KeyPress:
  71         state_ = native_event->xkey.state | mask;
  72         break;
  73       case KeyRelease:
  74         state_ = native_event->xkey.state & ~mask;
  75         break;
  76       case GenericEvent: {
  77         XIDeviceEvent* xievent =
  78             static_cast<XIDeviceEvent*>(native_event->xcookie.data);
  79         switch (xievent->evtype) {
  80           case XI_KeyPress:
  81             state_ = xievent->mods.effective |= mask;
  82             break;
  83           case XI_KeyRelease:
  84             state_ = xievent->mods.effective &= ~mask;
  85             break;
  86           default:
  87             NOTREACHED();
  88             break;
  89         }
  90         break;
  91       }
  92       default:
  93         NOTREACHED();
  94         break;
  95     }
  96   }
  97
  98   // Returns the current modifer state in master device. It only contains the
  99   // state of ctrl, shift, alt and caps lock keys.
 100   unsigned int state() { return state_; }
 101
 102  private:
 103   friend struct DefaultSingletonTraits<XModifierStateWatcher>;
 104
 105   XModifierStateWatcher() : state_(0) { }
 106
 107   unsigned int state_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(XModifierStateWatcher);
 110 };
 111
 112 #if defined(USE_XI2_MT)
 113 // Detects if a touch event is a driver-generated 'special event'.
 114 // A 'special event' is a touch event with maximum radius and pressure at
 115 // location (0, 0).
 116 // This needs to be done in a cleaner way: http://crbug.com/169256
 117 bool TouchEventIsGeneratedHack(const base::NativeEvent& native_event) {
 118   XIDeviceEvent* event =
 119       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 120   CHECK(event->evtype == XI_TouchBegin ||
 121         event->evtype == XI_TouchUpdate ||
 122         event->evtype == XI_TouchEnd);
 123
 124   // Force is normalized to [0, 1].
 125   if (ui::GetTouchForce(native_event) < 1.0f)
 126     return false;
 127
 128   if (ui::EventLocationFromNative(native_event) != gfx::Point())
 129     return false;
 130
 131   // Radius is in pixels, and the valuator is the diameter in pixels.
 132   double radius = ui::GetTouchRadiusX(native_event), min, max;
 133   unsigned int deviceid =
 134       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
 135   if (!ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
 136       deviceid, ui::DeviceDataManagerX11::DT_TOUCH_MAJOR, &min, &max)) {
 137     return false;
 138   }
 139
 140   return radius * 2 == max;
 141 }
 142 #endif
 143
 144 int GetEventFlagsFromXState(unsigned int state) {
 145   int flags = 0;
 146   if (state & ControlMask)
 147     flags |= ui::EF_CONTROL_DOWN;
 148   if (state & ShiftMask)
 149     flags |= ui::EF_SHIFT_DOWN;
 150   if (state & Mod1Mask)
 151     flags |= ui::EF_ALT_DOWN;
 152   if (state & LockMask)
 153     flags |= ui::EF_CAPS_LOCK_DOWN;
 154   if (state & Mod3Mask)
 155     flags |= ui::EF_MOD3_DOWN;
 156   if (state & Mod4Mask)
 157     flags |= ui::EF_COMMAND_DOWN;
 158   if (state & Mod5Mask)
 159     flags |= ui::EF_ALTGR_DOWN;
 160   if (state & Button1Mask)
 161     flags |= ui::EF_LEFT_MOUSE_BUTTON;
 162   if (state & Button2Mask)
 163     flags |= ui::EF_MIDDLE_MOUSE_BUTTON;
 164   if (state & Button3Mask)
 165     flags |= ui::EF_RIGHT_MOUSE_BUTTON;
 166   return flags;
 167 }
 168
 169 int GetEventFlagsFromXKeyEvent(XEvent* xevent) {
 170   DCHECK(xevent->type == KeyPress || xevent->type == KeyRelease);
 171
 172 #if defined(OS_CHROMEOS)
 173   const int ime_fabricated_flag = 0;
 174 #else
 175   // XIM fabricates key events for the character compositions by XK_Multi_key.
 176   // For example, when a user hits XK_Multi_key, XK_apostrophe, and XK_e in
 177   // order to input "é", then XIM generates a key event with keycode=0 and
 178   // state=0 for the composition, and the sequence of X11 key events will be
 179   // XK_Multi_key, XK_apostrophe, **NoSymbol**, and XK_e.  If the user used
 180   // shift key and/or caps lock key, state can be ShiftMask, LockMask or both.
 181   //
 182   // We have to send these fabricated key events to XIM so it can correctly
 183   // handle the character compositions.
 184   const unsigned int shift_lock_mask = ShiftMask | LockMask;
 185   const bool fabricated_by_xim =
 186       xevent->xkey.keycode == 0 &&
 187       (xevent->xkey.state & ~shift_lock_mask) == 0;
 188   const int ime_fabricated_flag =
 189       fabricated_by_xim ? ui::EF_IME_FABRICATED_KEY : 0;
 190 #endif
 191
 192   return GetEventFlagsFromXState(xevent->xkey.state) |
 193       (xevent->xkey.send_event ? ui::EF_FINAL : 0) |
 194       (IsKeypadKey(XLookupKeysym(&xevent->xkey, 0)) ? ui::EF_NUMPAD_KEY : 0) |
 195       (IsFunctionKey(XLookupKeysym(&xevent->xkey, 0)) ?
 196           ui::EF_FUNCTION_KEY : 0) |
 197       ime_fabricated_flag;
 198 }
 199
 200 int GetEventFlagsFromXGenericEvent(XEvent* xevent) {
 201   DCHECK(xevent->type == GenericEvent);
 202   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
 203   DCHECK((xievent->evtype == XI_KeyPress) ||
 204          (xievent->evtype == XI_KeyRelease));
 205   return GetEventFlagsFromXState(xievent->mods.effective) |
 206          (xevent->xkey.send_event ? ui::EF_FINAL : 0) |
 207          (IsKeypadKey(
 208               XkbKeycodeToKeysym(xievent->display, xievent->detail, 0, 0))
 209               ? ui::EF_NUMPAD_KEY
 210               : 0);
 211 }
 212
 213 // Get the event flag for the button in XButtonEvent. During a ButtonPress
 214 // event, |state| in XButtonEvent does not include the button that has just been
 215 // pressed. Instead |state| contains flags for the buttons (if any) that had
 216 // already been pressed before the current button, and |button| stores the most
 217 // current pressed button. So, if you press down left mouse button, and while
 218 // pressing it down, press down the right mouse button, then for the latter
 219 // event, |state| would have Button1Mask set but not Button3Mask, and |button|
 220 // would be 3.
 221 int GetEventFlagsForButton(int button) {
 222   switch (button) {
 223     case 1:
 224       return ui::EF_LEFT_MOUSE_BUTTON;
 225     case 2:
 226       return ui::EF_MIDDLE_MOUSE_BUTTON;
 227     case 3:
 228       return ui::EF_RIGHT_MOUSE_BUTTON;
 229     default:
 230       return 0;
 231   }
 232 }
 233
 234 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
 235   int buttonflags = 0;
 236   for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) {
 237     if (XIMaskIsSet(xievent->buttons.mask, i)) {
 238       int button = (xievent->sourceid == xievent->deviceid) ?
 239           ui::DeviceDataManagerX11::GetInstance()->GetMappedButton(i) : i;
 240       buttonflags |= GetEventFlagsForButton(button);
 241     }
 242   }
 243   return buttonflags;
 244 }
 245
 246 ui::EventType GetTouchEventType(const base::NativeEvent& native_event) {
 247   XIDeviceEvent* event =
 248       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 249 #if defined(USE_XI2_MT)
 250   switch(event->evtype) {
 251     case XI_TouchBegin:
 252       return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN :
 253                                                        ui::ET_TOUCH_PRESSED;
 254     case XI_TouchUpdate:
 255       return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN :
 256                                                        ui::ET_TOUCH_MOVED;
 257     case XI_TouchEnd:
 258       return TouchEventIsGeneratedHack(native_event) ? ui::ET_TOUCH_CANCELLED :
 259                                                        ui::ET_TOUCH_RELEASED;
 260   }
 261 #endif  // defined(USE_XI2_MT)
 262
 263   DCHECK(ui::TouchFactory::GetInstance()->IsTouchDevice(event->sourceid));
 264   switch (event->evtype) {
 265     case XI_ButtonPress:
 266       return ui::ET_TOUCH_PRESSED;
 267     case XI_ButtonRelease:
 268       return ui::ET_TOUCH_RELEASED;
 269     case XI_Motion:
 270       // Should not convert any emulated Motion event from touch device to
 271       // touch event.
 272       if (!(event->flags & XIPointerEmulated) &&
 273           GetButtonMaskForX2Event(event))
 274         return ui::ET_TOUCH_MOVED;
 275       return ui::ET_UNKNOWN;
 276     default:
 277       NOTREACHED();
 278   }
 279   return ui::ET_UNKNOWN;
 280 }
 281
 282 double GetTouchParamFromXEvent(XEvent* xev,
 283                               ui::DeviceDataManagerX11::DataType val,
 284                               double default_value) {
 285   ui::DeviceDataManagerX11::GetInstance()->GetEventData(
 286       *xev, val, &default_value);
 287   return default_value;
 288 }
 289
 290 void ScaleTouchRadius(XEvent* xev, double* radius) {
 291   DCHECK_EQ(GenericEvent, xev->type);
 292   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
 293   ui::DeviceDataManagerX11::GetInstance()->ApplyTouchRadiusScale(
 294       xiev->sourceid, radius);
 295 }
 296
 297 unsigned int UpdateX11EventFlags(int ui_flags, unsigned int old_x_flags) {
 298   static struct {
 299     int ui;
 300     int x;
 301   } flags[] = {
 302     {ui::EF_CONTROL_DOWN, ControlMask},
 303     {ui::EF_SHIFT_DOWN, ShiftMask},
 304     {ui::EF_ALT_DOWN, Mod1Mask},
 305     {ui::EF_CAPS_LOCK_DOWN, LockMask},
 306     {ui::EF_ALTGR_DOWN, Mod5Mask},
 307     {ui::EF_COMMAND_DOWN, Mod4Mask},
 308     {ui::EF_MOD3_DOWN, Mod3Mask},
 309     {ui::EF_NUMPAD_KEY, Mod2Mask},
 310     {ui::EF_LEFT_MOUSE_BUTTON, Button1Mask},
 311     {ui::EF_MIDDLE_MOUSE_BUTTON, Button2Mask},
 312     {ui::EF_RIGHT_MOUSE_BUTTON, Button3Mask},
 313   };
 314   unsigned int new_x_flags = old_x_flags;
 315   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(flags); ++i) {
 316     if (ui_flags & flags[i].ui)
 317       new_x_flags |= flags[i].x;
 318     else
 319       new_x_flags &= ~flags[i].x;
 320   }
 321   return new_x_flags;
 322 }
 323
 324 unsigned int UpdateX11EventButton(int ui_flag, unsigned int old_x_button) {
 325   switch (ui_flag) {
 326     case ui::EF_LEFT_MOUSE_BUTTON:
 327       return Button1;
 328     case ui::EF_MIDDLE_MOUSE_BUTTON:
 329       return Button2;
 330     case ui::EF_RIGHT_MOUSE_BUTTON:
 331       return Button3;
 332     default:
 333       return old_x_button;
 334   }
 335   NOTREACHED();
 336 }
 337
 338 bool GetGestureTimes(const base::NativeEvent& native_event,
 339                      double* start_time,
 340                      double* end_time) {
 341   if (!ui::DeviceDataManagerX11::GetInstance()->HasGestureTimes(native_event))
 342     return false;
 343
 344   double start_time_, end_time_;
 345   if (!start_time)
 346     start_time = &start_time_;
 347   if (!end_time)
 348     end_time = &end_time_;
 349
 350   ui::DeviceDataManagerX11::GetInstance()->GetGestureTimes(
 351       native_event, start_time, end_time);
 352   return true;
 353 }
 354
 355 }  // namespace
 356
 357 namespace ui {
 358
 359 void UpdateDeviceList() {
 360   XDisplay* display = gfx::GetXDisplay();
 361   DeviceListCacheX::GetInstance()->UpdateDeviceList(display);
 362   TouchFactory::GetInstance()->UpdateDeviceList(display);
 363   DeviceDataManagerX11::GetInstance()->UpdateDeviceList(display);
 364 }
 365
 366 EventType EventTypeFromNative(const base::NativeEvent& native_event) {
 367   // Allow the DeviceDataManager to block the event. If blocked return
 368   // ET_UNKNOWN as the type so this event will not be further processed.
 369   // NOTE: During some events unittests there is no device data manager.
 370   if (DeviceDataManager::HasInstance() &&
 371       static_cast<DeviceDataManagerX11*>(DeviceDataManager::GetInstance())->
 372           IsEventBlocked(native_event)) {
 373     return ET_UNKNOWN;
 374   }
 375
 376   switch (native_event->type) {
 377     case KeyPress:
 378       return ET_KEY_PRESSED;
 379     case KeyRelease:
 380       return ET_KEY_RELEASED;
 381     case ButtonPress:
 382       if (static_cast<int>(native_event->xbutton.button) >= kMinWheelButton &&
 383           static_cast<int>(native_event->xbutton.button) <= kMaxWheelButton)
 384         return ET_MOUSEWHEEL;
 385       return ET_MOUSE_PRESSED;
 386     case ButtonRelease:
 387       // Drop wheel events; we should've already scrolled on the press.
 388       if (static_cast<int>(native_event->xbutton.button) >= kMinWheelButton &&
 389           static_cast<int>(native_event->xbutton.button) <= kMaxWheelButton)
 390         return ET_UNKNOWN;
 391       return ET_MOUSE_RELEASED;
 392     case MotionNotify:
 393       if (native_event->xmotion.state &
 394           (Button1Mask | Button2Mask | Button3Mask))
 395         return ET_MOUSE_DRAGGED;
 396       return ET_MOUSE_MOVED;
 397     case EnterNotify:
 398       // The standard on Windows is to send a MouseMove event when the mouse
 399       // first enters a window instead of sending a special mouse enter event.
 400       // To be consistent we follow the same style.
 401       return ET_MOUSE_MOVED;
 402     case LeaveNotify:
 403       return ET_MOUSE_EXITED;
 404     case GenericEvent: {
 405       TouchFactory* factory = TouchFactory::GetInstance();
 406       if (!factory->ShouldProcessXI2Event(native_event))
 407         return ET_UNKNOWN;
 408
 409       XIDeviceEvent* xievent =
 410           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 411
 412       // This check works only for master and floating slave devices. That is
 413       // why it is necessary to check for the XI_Touch* events in the following
 414       // switch statement to account for attached-slave touchscreens.
 415       if (factory->IsTouchDevice(xievent->sourceid))
 416         return GetTouchEventType(native_event);
 417
 418       switch (xievent->evtype) {
 419         case XI_TouchBegin:
 420           return ui::ET_TOUCH_PRESSED;
 421         case XI_TouchUpdate:
 422           return ui::ET_TOUCH_MOVED;
 423         case XI_TouchEnd:
 424           return ui::ET_TOUCH_RELEASED;
 425         case XI_ButtonPress: {
 426           int button = EventButtonFromNative(native_event);
 427           if (button >= kMinWheelButton && button <= kMaxWheelButton)
 428             return ET_MOUSEWHEEL;
 429           return ET_MOUSE_PRESSED;
 430         }
 431         case XI_ButtonRelease: {
 432           int button = EventButtonFromNative(native_event);
 433           // Drop wheel events; we should've already scrolled on the press.
 434           if (button >= kMinWheelButton && button <= kMaxWheelButton)
 435             return ET_UNKNOWN;
 436           return ET_MOUSE_RELEASED;
 437         }
 438         case XI_Motion: {
 439           bool is_cancel;
 440           DeviceDataManagerX11* devices = DeviceDataManagerX11::GetInstance();
 441           if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel))
 442             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
 443           if (devices->IsScrollEvent(native_event)) {
 444             return devices->IsTouchpadXInputEvent(native_event) ? ET_SCROLL
 445                                                                 : ET_MOUSEWHEEL;
 446           }
 447           if (devices->IsCMTMetricsEvent(native_event))
 448             return ET_UMA_DATA;
 449           if (GetButtonMaskForX2Event(xievent))
 450             return ET_MOUSE_DRAGGED;
 451           return ET_MOUSE_MOVED;
 452         }
 453         case XI_KeyPress:
 454           return ET_KEY_PRESSED;
 455         case XI_KeyRelease:
 456           return ET_KEY_RELEASED;
 457       }
 458     }
 459     default:
 460       break;
 461   }
 462   return ET_UNKNOWN;
 463 }
 464
 465 int EventFlagsFromNative(const base::NativeEvent& native_event) {
 466   switch (native_event->type) {
 467     case KeyPress:
 468     case KeyRelease: {
 469       XModifierStateWatcher::GetInstance()->UpdateStateFromXEvent(native_event);
 470       return GetEventFlagsFromXKeyEvent(native_event);
 471     }
 472     case ButtonPress:
 473     case ButtonRelease: {
 474       int flags = GetEventFlagsFromXState(native_event->xbutton.state);
 475       const EventType type = EventTypeFromNative(native_event);
 476       if (type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED)
 477         flags |= GetEventFlagsForButton(native_event->xbutton.button);
 478       return flags;
 479     }
 480     case EnterNotify:
 481     case LeaveNotify:
 482       return GetEventFlagsFromXState(native_event->xcrossing.state);
 483     case MotionNotify:
 484       return GetEventFlagsFromXState(native_event->xmotion.state);
 485     case GenericEvent: {
 486       XIDeviceEvent* xievent =
 487           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 488
 489       switch (xievent->evtype) {
 490 #if defined(USE_XI2_MT)
 491         case XI_TouchBegin:
 492         case XI_TouchUpdate:
 493         case XI_TouchEnd:
 494           return GetButtonMaskForX2Event(xievent) |
 495                  GetEventFlagsFromXState(xievent->mods.effective) |
 496                  GetEventFlagsFromXState(
 497                      XModifierStateWatcher::GetInstance()->state());
 498           break;
 499 #endif
 500         case XI_ButtonPress:
 501         case XI_ButtonRelease: {
 502           const bool touch =
 503               TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid);
 504           int flags = GetButtonMaskForX2Event(xievent) |
 505                       GetEventFlagsFromXState(xievent->mods.effective);
 506           if (touch) {
 507             flags |= GetEventFlagsFromXState(
 508                 XModifierStateWatcher::GetInstance()->state());
 509           }
 510
 511           const EventType type = EventTypeFromNative(native_event);
 512           int button = EventButtonFromNative(native_event);
 513           if ((type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED) && !touch)
 514             flags |= GetEventFlagsForButton(button);
 515           return flags;
 516         }
 517         case XI_Motion:
 518           return GetButtonMaskForX2Event(xievent) |
 519                  GetEventFlagsFromXState(xievent->mods.effective);
 520         case XI_KeyPress:
 521         case XI_KeyRelease: {
 522           XModifierStateWatcher::GetInstance()->UpdateStateFromXEvent(
 523               native_event);
 524           return GetEventFlagsFromXGenericEvent(native_event);
 525         }
 526       }
 527     }
 528   }
 529   return 0;
 530 }
 531
 532 base::TimeDelta EventTimeFromNative(const base::NativeEvent& native_event) {
 533   switch(native_event->type) {
 534     case KeyPress:
 535     case KeyRelease:
 536       return base::TimeDelta::FromMilliseconds(native_event->xkey.time);
 537     case ButtonPress:
 538     case ButtonRelease:
 539       return base::TimeDelta::FromMilliseconds(native_event->xbutton.time);
 540       break;
 541     case MotionNotify:
 542       return base::TimeDelta::FromMilliseconds(native_event->xmotion.time);
 543       break;
 544     case EnterNotify:
 545     case LeaveNotify:
 546       return base::TimeDelta::FromMilliseconds(native_event->xcrossing.time);
 547       break;
 548     case GenericEvent: {
 549       double start, end;
 550       double touch_timestamp;
 551       if (GetGestureTimes(native_event, &start, &end)) {
 552         // If the driver supports gesture times, use them.
 553         return base::TimeDelta::FromMicroseconds(end * 1000000);
 554       } else if (DeviceDataManagerX11::GetInstance()->GetEventData(
 555           *native_event,
 556           DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP,
 557           &touch_timestamp)) {
 558         return base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000);
 559       } else {
 560         XIDeviceEvent* xide =
 561             static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 562         return base::TimeDelta::FromMilliseconds(xide->time);
 563       }
 564       break;
 565     }
 566   }
 567   NOTREACHED();
 568   return base::TimeDelta();
 569 }
 570
 571 gfx::Point EventLocationFromNative(const base::NativeEvent& native_event) {
 572   switch (native_event->type) {
 573     case EnterNotify:
 574     case LeaveNotify:
 575       return gfx::Point(native_event->xcrossing.x, native_event->xcrossing.y);
 576     case ButtonPress:
 577     case ButtonRelease:
 578       return gfx::Point(native_event->xbutton.x, native_event->xbutton.y);
 579     case MotionNotify:
 580       return gfx::Point(native_event->xmotion.x, native_event->xmotion.y);
 581     case GenericEvent: {
 582       XIDeviceEvent* xievent =
 583           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 584       float x = xievent->event_x;
 585       float y = xievent->event_y;
 586 #if defined(OS_CHROMEOS)
 587       switch (xievent->evtype) {
 588         case XI_TouchBegin:
 589         case XI_TouchUpdate:
 590         case XI_TouchEnd:
 591           ui::DeviceDataManagerX11::GetInstance()->ApplyTouchTransformer(
 592               xievent->deviceid, &x, &y);
 593           break;
 594         default:
 595           break;
 596       }
 597 #endif  // defined(OS_CHROMEOS)
 598       return gfx::Point(static_cast<int>(x), static_cast<int>(y));
 599     }
 600   }
 601   return gfx::Point();
 602 }
 603
 604 gfx::Point EventSystemLocationFromNative(
 605     const base::NativeEvent& native_event) {
 606   switch (native_event->type) {
 607     case EnterNotify:
 608     case LeaveNotify: {
 609       return gfx::Point(native_event->xcrossing.x_root,
 610                         native_event->xcrossing.y_root);
 611     }
 612     case ButtonPress:
 613     case ButtonRelease: {
 614       return gfx::Point(native_event->xbutton.x_root,
 615                         native_event->xbutton.y_root);
 616     }
 617     case MotionNotify: {
 618       return gfx::Point(native_event->xmotion.x_root,
 619                         native_event->xmotion.y_root);
 620     }
 621     case GenericEvent: {
 622       XIDeviceEvent* xievent =
 623           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 624       return gfx::Point(xievent->root_x, xievent->root_y);
 625     }
 626   }
 627
 628   return gfx::Point();
 629 }
 630
 631 int EventButtonFromNative(const base::NativeEvent& native_event) {
 632   CHECK_EQ(GenericEvent, native_event->type);
 633   XIDeviceEvent* xievent =
 634       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 635   int button = xievent->detail;
 636
 637   return (xievent->sourceid == xievent->deviceid) ?
 638          DeviceDataManagerX11::GetInstance()->GetMappedButton(button) : button;
 639 }
 640
 641 KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) {
 642   return KeyboardCodeFromXKeyEvent(native_event);
 643 }
 644
 645 const char* CodeFromNative(const base::NativeEvent& native_event) {
 646   return CodeFromXEvent(native_event);
 647 }
 648
 649 uint32 PlatformKeycodeFromNative(const base::NativeEvent& native_event) {
 650   XKeyEvent* xkey = NULL;
 651   XEvent xkey_from_xi2;
 652   switch (native_event->type) {
 653     case KeyPress:
 654     case KeyRelease:
 655       xkey = &native_event->xkey;
 656       break;
 657     case GenericEvent: {
 658       XIDeviceEvent* xievent =
 659           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 660       switch (xievent->evtype) {
 661         case XI_KeyPress:
 662         case XI_KeyRelease:
 663           // Build an XKeyEvent corresponding to the XI2 event,
 664           // so that we can call XLookupString on it.
 665           InitXKeyEventFromXIDeviceEvent(*native_event, &xkey_from_xi2);
 666           xkey = &xkey_from_xi2.xkey;
 667           break;
 668         default:
 669           NOTREACHED();
 670           break;
 671       }
 672       break;
 673     }
 674     default:
 675       NOTREACHED();
 676       break;
 677   }
 678   KeySym keysym = XK_VoidSymbol;
 679   if (xkey)
 680     XLookupString(xkey, NULL, 0, &keysym, NULL);
 681   return keysym;
 682 }
 683
 684 bool IsCharFromNative(const base::NativeEvent& native_event) {
 685   return false;
 686 }
 687
 688 uint32 WindowsKeycodeFromNative(const base::NativeEvent& native_event) {
 689   int windows_key_code = ui::KeyboardCodeFromXKeyEvent(native_event);
 690   if (windows_key_code == ui::VKEY_SHIFT ||
 691       windows_key_code == ui::VKEY_CONTROL ||
 692       windows_key_code == ui::VKEY_MENU) {
 693     // To support DOM3 'location' attribute, we need to lookup an X KeySym and
 694     // set ui::VKEY_[LR]XXX instead of ui::VKEY_XXX.
 695     KeySym keysym = XK_VoidSymbol;
 696     XLookupString(&native_event->xkey, NULL, 0, &keysym, NULL);
 697     switch (keysym) {
 698       case XK_Shift_L:
 699         return ui::VKEY_LSHIFT;
 700       case XK_Shift_R:
 701         return ui::VKEY_RSHIFT;
 702       case XK_Control_L:
 703         return ui::VKEY_LCONTROL;
 704       case XK_Control_R:
 705         return ui::VKEY_RCONTROL;
 706       case XK_Meta_L:
 707       case XK_Alt_L:
 708         return ui::VKEY_LMENU;
 709       case XK_Meta_R:
 710       case XK_Alt_R:
 711         return ui::VKEY_RMENU;
 712     }
 713   }
 714   return windows_key_code;
 715 }
 716
 717 uint16 TextFromNative(const base::NativeEvent& native_event) {
 718   int flags = EventFlagsFromNative(native_event);
 719   if ((flags & ui::EF_CONTROL_DOWN) != 0) {
 720     int windows_key_code = WindowsKeycodeFromNative(native_event);
 721     return ui::GetControlCharacterForKeycode(windows_key_code,
 722                                              flags & ui::EF_SHIFT_DOWN);
 723   }
 724
 725   return UnmodifiedTextFromNative(native_event);
 726 }
 727
 728 uint16 UnmodifiedTextFromNative(const base::NativeEvent& native_event) {
 729   uint32 keycode = WindowsKeycodeFromNative(native_event);
 730   if (keycode == ui::VKEY_RETURN)
 731     return '\r';
 732   else
 733     return ui::GetCharacterFromXEvent(native_event);
 734 }
 735
 736 int GetChangedMouseButtonFlagsFromNative(
 737     const base::NativeEvent& native_event) {
 738   switch (native_event->type) {
 739     case ButtonPress:
 740     case ButtonRelease:
 741       return GetEventFlagsFromXState(native_event->xbutton.state);
 742     case GenericEvent: {
 743       XIDeviceEvent* xievent =
 744           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 745       switch (xievent->evtype) {
 746         case XI_ButtonPress:
 747         case XI_ButtonRelease:
 748           return GetEventFlagsForButton(EventButtonFromNative(native_event));
 749         default:
 750           break;
 751       }
 752     }
 753     default:
 754       break;
 755   }
 756   return 0;
 757 }
 758
 759 gfx::Vector2d GetMouseWheelOffset(const base::NativeEvent& native_event) {
 760   float x_offset, y_offset;
 761   if (GetScrollOffsets(
 762       native_event, &x_offset, &y_offset, NULL, NULL, NULL)) {
 763     return gfx::Vector2d(static_cast<int>(x_offset),
 764                          static_cast<int>(y_offset));
 765   }
 766
 767   int button = native_event->type == GenericEvent ?
 768       EventButtonFromNative(native_event) : native_event->xbutton.button;
 769
 770   switch (button) {
 771     case 4:
 772       return gfx::Vector2d(0, kWheelScrollAmount);
 773     case 5:
 774       return gfx::Vector2d(0, -kWheelScrollAmount);
 775     case 6:
 776       return gfx::Vector2d(kWheelScrollAmount, 0);
 777     case 7:
 778       return gfx::Vector2d(-kWheelScrollAmount, 0);
 779     default:
 780       return gfx::Vector2d();
 781   }
 782 }
 783
 784 base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) {
 785   if (!event || event->type == GenericEvent)
 786     return NULL;
 787   XEvent* copy = new XEvent;
 788   *copy = *event;
 789   return copy;
 790 }
 791
 792 void ReleaseCopiedNativeEvent(const base::NativeEvent& event) {
 793   delete event;
 794 }
 795
 796 void IncrementTouchIdRefCount(const base::NativeEvent& xev) {
 797   ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
 798   double tracking_id;
 799   if (!manager->GetEventData(
 800           *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
 801     return;
 802   }
 803
 804   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
 805   factory->AcquireSlotForTrackingID(tracking_id);
 806 }
 807
 808 void ClearTouchIdIfReleased(const base::NativeEvent& xev) {
 809   ui::EventType type = ui::EventTypeFromNative(xev);
 810   if (type == ui::ET_TOUCH_CANCELLED ||
 811       type == ui::ET_TOUCH_RELEASED) {
 812     ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
 813     ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
 814     double tracking_id;
 815     if (manager->GetEventData(
 816         *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
 817       factory->ReleaseSlotForTrackingID(tracking_id);
 818     }
 819   }
 820 }
 821
 822 int GetTouchId(const base::NativeEvent& xev) {
 823   double slot = 0;
 824   ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
 825   double tracking_id;
 826   if (!manager->GetEventData(
 827       *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
 828     LOG(ERROR) << "Could not get the tracking ID for the event. Using 0.";
 829   } else {
 830     ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
 831     slot = factory->GetSlotForTrackingID(tracking_id);
 832   }
 833   return slot;
 834 }
 835
 836 float GetTouchRadiusX(const base::NativeEvent& native_event) {
 837   double radius = GetTouchParamFromXEvent(native_event,
 838       ui::DeviceDataManagerX11::DT_TOUCH_MAJOR, 0.0) / 2.0;
 839   ScaleTouchRadius(native_event, &radius);
 840   return radius;
 841 }
 842
 843 float GetTouchRadiusY(const base::NativeEvent& native_event) {
 844   double radius = GetTouchParamFromXEvent(native_event,
 845       ui::DeviceDataManagerX11::DT_TOUCH_MINOR, 0.0) / 2.0;
 846   ScaleTouchRadius(native_event, &radius);
 847   return radius;
 848 }
 849
 850 float GetTouchAngle(const base::NativeEvent& native_event) {
 851   return GetTouchParamFromXEvent(native_event,
 852       ui::DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.0) / 2.0;
 853 }
 854
 855 float GetTouchForce(const base::NativeEvent& native_event) {
 856   double force = 0.0;
 857   force = GetTouchParamFromXEvent(native_event,
 858       ui::DeviceDataManagerX11::DT_TOUCH_PRESSURE, 0.0);
 859   unsigned int deviceid =
 860       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
 861   // Force is normalized to fall into [0, 1]
 862   if (!ui::DeviceDataManagerX11::GetInstance()->NormalizeData(
 863       deviceid, ui::DeviceDataManagerX11::DT_TOUCH_PRESSURE, &force))
 864     force = 0.0;
 865   return force;
 866 }
 867
 868 bool GetScrollOffsets(const base::NativeEvent& native_event,
 869                       float* x_offset,
 870                       float* y_offset,
 871                       float* x_offset_ordinal,
 872                       float* y_offset_ordinal,
 873                       int* finger_count) {
 874   if (!DeviceDataManagerX11::GetInstance()->IsScrollEvent(native_event))
 875     return false;
 876
 877   // Temp values to prevent passing NULLs to DeviceDataManager.
 878   float x_offset_, y_offset_;
 879   float x_offset_ordinal_, y_offset_ordinal_;
 880   int finger_count_;
 881   if (!x_offset)
 882     x_offset = &x_offset_;
 883   if (!y_offset)
 884     y_offset = &y_offset_;
 885   if (!x_offset_ordinal)
 886     x_offset_ordinal = &x_offset_ordinal_;
 887   if (!y_offset_ordinal)
 888     y_offset_ordinal = &y_offset_ordinal_;
 889   if (!finger_count)
 890     finger_count = &finger_count_;
 891
 892   DeviceDataManagerX11::GetInstance()->GetScrollOffsets(
 893       native_event,
 894       x_offset, y_offset,
 895       x_offset_ordinal, y_offset_ordinal,
 896       finger_count);
 897   return true;
 898 }
 899
 900 bool GetFlingData(const base::NativeEvent& native_event,
 901                   float* vx,
 902                   float* vy,
 903                   float* vx_ordinal,
 904                   float* vy_ordinal,
 905                   bool* is_cancel) {
 906   if (!DeviceDataManagerX11::GetInstance()->IsFlingEvent(native_event))
 907     return false;
 908
 909   float vx_, vy_;
 910   float vx_ordinal_, vy_ordinal_;
 911   bool is_cancel_;
 912   if (!vx)
 913     vx = &vx_;
 914   if (!vy)
 915     vy = &vy_;
 916   if (!vx_ordinal)
 917     vx_ordinal = &vx_ordinal_;
 918   if (!vy_ordinal)
 919     vy_ordinal = &vy_ordinal_;
 920   if (!is_cancel)
 921     is_cancel = &is_cancel_;
 922
 923   DeviceDataManagerX11::GetInstance()->GetFlingData(
 924       native_event, vx, vy, vx_ordinal, vy_ordinal, is_cancel);
 925   return true;
 926 }
 927
 928 void UpdateX11EventForFlags(Event* event) {
 929   XEvent* xev = event->native_event();
 930   if (!xev)
 931     return;
 932   switch (xev->type) {
 933     case KeyPress:
 934     case KeyRelease:
 935       xev->xkey.state = UpdateX11EventFlags(event->flags(), xev->xkey.state);
 936       break;
 937     case ButtonPress:
 938     case ButtonRelease:
 939       xev->xbutton.state =
 940           UpdateX11EventFlags(event->flags(), xev->xbutton.state);
 941       break;
 942     case GenericEvent: {
 943       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
 944       DCHECK(xievent);
 945       xievent->mods.effective =
 946           UpdateX11EventFlags(event->flags(), xievent->mods.effective);
 947       break;
 948     }
 949     default:
 950       break;
 951   }
 952 }
 953
 954 void UpdateX11EventForChangedButtonFlags(MouseEvent* event) {
 955   XEvent* xev = event->native_event();
 956   if (!xev)
 957     return;
 958   switch (xev->type) {
 959     case ButtonPress:
 960     case ButtonRelease:
 961       xev->xbutton.button = UpdateX11EventButton(event->changed_button_flags(),
 962                                                  xev->xbutton.button);
 963       break;
 964     case GenericEvent: {
 965       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
 966       CHECK(xievent && (xievent->evtype == XI_ButtonPress ||
 967                         xievent->evtype == XI_ButtonRelease));
 968       xievent->detail =
 969           UpdateX11EventButton(event->changed_button_flags(), xievent->detail);
 970       break;
 971     }
 972     default:
 973       break;
 974   }
 975 }
 976
 977 }  // namespace ui