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 14 #include "base/logging.h" 15 #include "base/memory/singleton.h" 16 #include "ui/events/event_utils.h" 17 #include "ui/events/keycodes/keyboard_code_conversion_x.h" 18 #include "ui/events/x/device_data_manager.h" 19 #include "ui/events/x/device_list_cache_x.h" 20 #include "ui/events/x/touch_factory_x11.h" 21 #include "ui/gfx/display.h" 22 #include "ui/gfx/point.h" 23 #include "ui/gfx/rect.h" 24 #include "ui/gfx/screen.h" 25 #include "ui/gfx/x/x11_atom_cache.h" 26 #include "ui/gfx/x/x11_types.h" 27 28 namespace { 29 30 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+. 31 const int kWheelScrollAmount = 53; 32 33 const int kMinWheelButton = 4; 34 const int kMaxWheelButton = 7; 35 36 // A class to track current modifier state on master device. Only track ctrl, 37 // alt, shift and caps lock keys currently. The tracked state can then be used 38 // by floating device. 39 class XModifierStateWatcher{ 40 public: 41 static XModifierStateWatcher* GetInstance() { 42 return Singleton<XModifierStateWatcher>::get(); 43 } 44 45 void UpdateStateFromEvent(const base::NativeEvent& native_event) { 46 // Floating device can't access the modifer state from master device. 47 // We need to track the states of modifier keys in a singleton for 48 // floating devices such as touch screen. Issue 106426 is one example 49 // of why we need the modifier states for floating device. 50 state_ = native_event->xkey.state; 51 // master_state is the state before key press. We need to track the 52 // state after key press for floating device. Currently only ctrl, 53 // shift, alt and caps lock keys are tracked. 54 ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event); 55 unsigned int mask = 0; 56 57 switch (keyboard_code) { 58 case ui::VKEY_CONTROL: { 59 mask = ControlMask; 60 break; 61 } 62 case ui::VKEY_SHIFT: { 63 mask = ShiftMask; 64 break; 65 } 66 case ui::VKEY_MENU: { 67 mask = Mod1Mask; 68 break; 69 } 70 case ui::VKEY_CAPITAL: { 71 mask = LockMask; 72 break; 73 } 74 default: 75 break; 76 } 77 78 if (native_event->type == KeyPress) 79 state_ |= mask; 80 else 81 state_ &= ~mask; 82 } 83 84 // Returns the current modifer state in master device. It only contains the 85 // state of ctrl, shift, alt and caps lock keys. 86 unsigned int state() { return state_; } 87 88 private: 89 friend struct DefaultSingletonTraits<XModifierStateWatcher>; 90 91 XModifierStateWatcher() : state_(0) { } 92 93 unsigned int state_; 94 95 DISALLOW_COPY_AND_ASSIGN(XModifierStateWatcher); 96 }; 97 98 #if defined(USE_XI2_MT) 99 // Detects if a touch event is a driver-generated 'special event'. 100 // A 'special event' is a touch event with maximum radius and pressure at 101 // location (0, 0). 102 // This needs to be done in a cleaner way: http://crbug.com/169256 103 bool TouchEventIsGeneratedHack(const base::NativeEvent& native_event) { 104 XIDeviceEvent* event = 105 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 106 CHECK(event->evtype == XI_TouchBegin || 107 event->evtype == XI_TouchUpdate || 108 event->evtype == XI_TouchEnd); 109 110 // Force is normalized to [0, 1]. 111 if (ui::GetTouchForce(native_event) < 1.0f) 112 return false; 113 114 if (ui::EventLocationFromNative(native_event) != gfx::Point()) 115 return false; 116 117 // Radius is in pixels, and the valuator is the diameter in pixels. 118 double radius = ui::GetTouchRadiusX(native_event), min, max; 119 unsigned int deviceid = 120 static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid; 121 if (!ui::DeviceDataManager::GetInstance()->GetDataRange( 122 deviceid, ui::DeviceDataManager::DT_TOUCH_MAJOR, &min, &max)) { 123 return false; 124 } 125 126 return radius * 2 == max; 127 } 128 #endif 129 130 int GetEventFlagsFromXState(unsigned int state) { 131 int flags = 0; 132 if (state & ControlMask) 133 flags |= ui::EF_CONTROL_DOWN; 134 if (state & ShiftMask) 135 flags |= ui::EF_SHIFT_DOWN; 136 if (state & Mod1Mask) 137 flags |= ui::EF_ALT_DOWN; 138 if (state & LockMask) 139 flags |= ui::EF_CAPS_LOCK_DOWN; 140 if (state & Mod3Mask) 141 flags |= ui::EF_MOD3_DOWN; 142 if (state & Mod4Mask) 143 flags |= ui::EF_COMMAND_DOWN; 144 if (state & Mod5Mask) 145 flags |= ui::EF_ALTGR_DOWN; 146 if (state & Button1Mask) 147 flags |= ui::EF_LEFT_MOUSE_BUTTON; 148 if (state & Button2Mask) 149 flags |= ui::EF_MIDDLE_MOUSE_BUTTON; 150 if (state & Button3Mask) 151 flags |= ui::EF_RIGHT_MOUSE_BUTTON; 152 return flags; 153 } 154 155 int GetEventFlagsFromXKeyEvent(XEvent* xevent) { 156 DCHECK(xevent->type == KeyPress || xevent->type == KeyRelease); 157 158 #if defined(OS_CHROMEOS) 159 const int ime_fabricated_flag = 0; 160 #else 161 // XIM fabricates key events for the character compositions by XK_Multi_key. 162 // For example, when a user hits XK_Multi_key, XK_apostrophe, and XK_e in 163 // order to input "", then XIM generates a key event with keycode=0 and 164 // state=0 for the composition, and the sequence of X11 key events will be 165 // XK_Multi_key, XK_apostrophe, **NoSymbol**, and XK_e. If the user used 166 // shift key and/or caps lock key, state can be ShiftMask, LockMask or both. 167 // 168 // We have to send these fabricated key events to XIM so it can correctly 169 // handle the character compositions. 170 const unsigned int shift_lock_mask = ShiftMask | LockMask; 171 const bool fabricated_by_xim = 172 xevent->xkey.keycode == 0 && 173 (xevent->xkey.state & ~shift_lock_mask) == 0; 174 const int ime_fabricated_flag = 175 fabricated_by_xim ? ui::EF_IME_FABRICATED_KEY : 0; 176 #endif 177 178 return GetEventFlagsFromXState(xevent->xkey.state) | 179 (IsKeypadKey(XLookupKeysym(&xevent->xkey, 0)) ? ui::EF_NUMPAD_KEY : 0) | 180 (IsFunctionKey(XLookupKeysym(&xevent->xkey, 0)) ? 181 ui::EF_FUNCTION_KEY : 0) | 182 ime_fabricated_flag; 183 } 184 185 // Get the event flag for the button in XButtonEvent. During a ButtonPress 186 // event, |state| in XButtonEvent does not include the button that has just been 187 // pressed. Instead |state| contains flags for the buttons (if any) that had 188 // already been pressed before the current button, and |button| stores the most 189 // current pressed button. So, if you press down left mouse button, and while 190 // pressing it down, press down the right mouse button, then for the latter 191 // event, |state| would have Button1Mask set but not Button3Mask, and |button| 192 // would be 3. 193 int GetEventFlagsForButton(int button) { 194 switch (button) { 195 case 1: 196 return ui::EF_LEFT_MOUSE_BUTTON; 197 case 2: 198 return ui::EF_MIDDLE_MOUSE_BUTTON; 199 case 3: 200 return ui::EF_RIGHT_MOUSE_BUTTON; 201 default: 202 return 0; 203 } 204 } 205 206 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) { 207 int buttonflags = 0; 208 for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) { 209 if (XIMaskIsSet(xievent->buttons.mask, i)) { 210 int button = (xievent->sourceid == xievent->deviceid) ? 211 ui::DeviceDataManager::GetInstance()->GetMappedButton(i) : i; 212 buttonflags |= GetEventFlagsForButton(button); 213 } 214 } 215 return buttonflags; 216 } 217 218 ui::EventType GetTouchEventType(const base::NativeEvent& native_event) { 219 XIDeviceEvent* event = 220 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 221 #if defined(USE_XI2_MT) 222 switch(event->evtype) { 223 case XI_TouchBegin: 224 return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN : 225 ui::ET_TOUCH_PRESSED; 226 case XI_TouchUpdate: 227 return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN : 228 ui::ET_TOUCH_MOVED; 229 case XI_TouchEnd: 230 return TouchEventIsGeneratedHack(native_event) ? ui::ET_TOUCH_CANCELLED : 231 ui::ET_TOUCH_RELEASED; 232 } 233 #endif // defined(USE_XI2_MT) 234 235 DCHECK(ui::TouchFactory::GetInstance()->IsTouchDevice(event->sourceid)); 236 switch (event->evtype) { 237 case XI_ButtonPress: 238 return ui::ET_TOUCH_PRESSED; 239 case XI_ButtonRelease: 240 return ui::ET_TOUCH_RELEASED; 241 case XI_Motion: 242 // Should not convert any emulated Motion event from touch device to 243 // touch event. 244 if (!(event->flags & XIPointerEmulated) && 245 GetButtonMaskForX2Event(event)) 246 return ui::ET_TOUCH_MOVED; 247 return ui::ET_UNKNOWN; 248 default: 249 NOTREACHED(); 250 } 251 return ui::ET_UNKNOWN; 252 } 253 254 double GetTouchParamFromXEvent(XEvent* xev, 255 ui::DeviceDataManager::DataType val, 256 double default_value) { 257 ui::DeviceDataManager::GetInstance()->GetEventData( 258 *xev, val, &default_value); 259 return default_value; 260 } 261 262 } // namespace 263 264 namespace ui { 265 266 void UpdateDeviceList() { 267 XDisplay* display = gfx::GetXDisplay(); 268 DeviceListCacheX::GetInstance()->UpdateDeviceList(display); 269 TouchFactory::GetInstance()->UpdateDeviceList(display); 270 DeviceDataManager::GetInstance()->UpdateDeviceList(display); 271 } 272 273 EventType EventTypeFromNative(const base::NativeEvent& native_event) { 274 switch (native_event->type) { 275 case KeyPress: 276 return ET_KEY_PRESSED; 277 case KeyRelease: 278 return ET_KEY_RELEASED; 279 case ButtonPress: 280 if (static_cast<int>(native_event->xbutton.button) >= kMinWheelButton && 281 static_cast<int>(native_event->xbutton.button) <= kMaxWheelButton) 282 return ET_MOUSEWHEEL; 283 return ET_MOUSE_PRESSED; 284 case ButtonRelease: 285 // Drop wheel events; we should've already scrolled on the press. 286 if (static_cast<int>(native_event->xbutton.button) >= kMinWheelButton && 287 static_cast<int>(native_event->xbutton.button) <= kMaxWheelButton) 288 return ET_UNKNOWN; 289 return ET_MOUSE_RELEASED; 290 case MotionNotify: 291 if (native_event->xmotion.state & 292 (Button1Mask | Button2Mask | Button3Mask)) 293 return ET_MOUSE_DRAGGED; 294 return ET_MOUSE_MOVED; 295 case EnterNotify: 296 // The standard on Windows is to send a MouseMove event when the mouse 297 // first enters a window instead of sending a special mouse enter event. 298 // To be consistent we follow the same style. 299 return ET_MOUSE_MOVED; 300 case LeaveNotify: 301 return ET_MOUSE_EXITED; 302 case GenericEvent: { 303 TouchFactory* factory = TouchFactory::GetInstance(); 304 if (!factory->ShouldProcessXI2Event(native_event)) 305 return ET_UNKNOWN; 306 307 XIDeviceEvent* xievent = 308 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 309 310 // This check works only for master and floating slave devices. That is 311 // why it is necessary to check for the XI_Touch* events in the following 312 // switch statement to account for attached-slave touchscreens. 313 if (factory->IsTouchDevice(xievent->sourceid)) 314 return GetTouchEventType(native_event); 315 316 switch (xievent->evtype) { 317 case XI_TouchBegin: 318 return ui::ET_TOUCH_PRESSED; 319 case XI_TouchUpdate: 320 return ui::ET_TOUCH_MOVED; 321 case XI_TouchEnd: 322 return ui::ET_TOUCH_RELEASED; 323 case XI_ButtonPress: { 324 int button = EventButtonFromNative(native_event); 325 if (button >= kMinWheelButton && button <= kMaxWheelButton) 326 return ET_MOUSEWHEEL; 327 return ET_MOUSE_PRESSED; 328 } 329 case XI_ButtonRelease: { 330 int button = EventButtonFromNative(native_event); 331 // Drop wheel events; we should've already scrolled on the press. 332 if (button >= kMinWheelButton && button <= kMaxWheelButton) 333 return ET_UNKNOWN; 334 return ET_MOUSE_RELEASED; 335 } 336 case XI_Motion: { 337 bool is_cancel; 338 if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel)) { 339 return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START; 340 } else if (DeviceDataManager::GetInstance()->IsScrollEvent( 341 native_event)) { 342 return IsTouchpadEvent(native_event) ? ET_SCROLL : ET_MOUSEWHEEL; 343 } else if (DeviceDataManager::GetInstance()->IsCMTMetricsEvent( 344 native_event)) { 345 return ET_UMA_DATA; 346 } else if (GetButtonMaskForX2Event(xievent)) { 347 return ET_MOUSE_DRAGGED; 348 } else { 349 return ET_MOUSE_MOVED; 350 } 351 } 352 } 353 } 354 default: 355 break; 356 } 357 return ET_UNKNOWN; 358 } 359 360 int EventFlagsFromNative(const base::NativeEvent& native_event) { 361 switch (native_event->type) { 362 case KeyPress: 363 case KeyRelease: { 364 XModifierStateWatcher::GetInstance()->UpdateStateFromEvent(native_event); 365 return GetEventFlagsFromXKeyEvent(native_event); 366 } 367 case ButtonPress: 368 case ButtonRelease: { 369 int flags = GetEventFlagsFromXState(native_event->xbutton.state); 370 const EventType type = EventTypeFromNative(native_event); 371 if (type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED) 372 flags |= GetEventFlagsForButton(native_event->xbutton.button); 373 return flags; 374 } 375 case EnterNotify: 376 case LeaveNotify: 377 return GetEventFlagsFromXState(native_event->xcrossing.state); 378 case MotionNotify: 379 return GetEventFlagsFromXState(native_event->xmotion.state); 380 case GenericEvent: { 381 XIDeviceEvent* xievent = 382 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 383 384 switch (xievent->evtype) { 385 #if defined(USE_XI2_MT) 386 case XI_TouchBegin: 387 case XI_TouchUpdate: 388 case XI_TouchEnd: 389 return GetButtonMaskForX2Event(xievent) | 390 GetEventFlagsFromXState(xievent->mods.effective) | 391 GetEventFlagsFromXState( 392 XModifierStateWatcher::GetInstance()->state()); 393 break; 394 #endif 395 case XI_ButtonPress: 396 case XI_ButtonRelease: { 397 const bool touch = 398 TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid); 399 int flags = GetButtonMaskForX2Event(xievent) | 400 GetEventFlagsFromXState(xievent->mods.effective); 401 if (touch) { 402 flags |= GetEventFlagsFromXState( 403 XModifierStateWatcher::GetInstance()->state()); 404 } 405 406 const EventType type = EventTypeFromNative(native_event); 407 int button = EventButtonFromNative(native_event); 408 if ((type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED) && !touch) 409 flags |= GetEventFlagsForButton(button); 410 return flags; 411 } 412 case XI_Motion: 413 return GetButtonMaskForX2Event(xievent) | 414 GetEventFlagsFromXState(xievent->mods.effective); 415 } 416 } 417 } 418 return 0; 419 } 420 421 base::TimeDelta EventTimeFromNative(const base::NativeEvent& native_event) { 422 switch(native_event->type) { 423 case KeyPress: 424 case KeyRelease: 425 return base::TimeDelta::FromMilliseconds(native_event->xkey.time); 426 case ButtonPress: 427 case ButtonRelease: 428 return base::TimeDelta::FromMilliseconds(native_event->xbutton.time); 429 break; 430 case MotionNotify: 431 return base::TimeDelta::FromMilliseconds(native_event->xmotion.time); 432 break; 433 case EnterNotify: 434 case LeaveNotify: 435 return base::TimeDelta::FromMilliseconds(native_event->xcrossing.time); 436 break; 437 case GenericEvent: { 438 double start, end; 439 double touch_timestamp; 440 if (GetGestureTimes(native_event, &start, &end)) { 441 // If the driver supports gesture times, use them. 442 return base::TimeDelta::FromMicroseconds(end * 1000000); 443 } else if (DeviceDataManager::GetInstance()->GetEventData(*native_event, 444 DeviceDataManager::DT_TOUCH_RAW_TIMESTAMP, &touch_timestamp)) { 445 return base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000); 446 } else { 447 XIDeviceEvent* xide = 448 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 449 return base::TimeDelta::FromMilliseconds(xide->time); 450 } 451 break; 452 } 453 } 454 NOTREACHED(); 455 return base::TimeDelta(); 456 } 457 458 gfx::Point EventLocationFromNative(const base::NativeEvent& native_event) { 459 switch (native_event->type) { 460 case EnterNotify: 461 case LeaveNotify: 462 return gfx::Point(native_event->xcrossing.x, native_event->xcrossing.y); 463 case ButtonPress: 464 case ButtonRelease: 465 return gfx::Point(native_event->xbutton.x, native_event->xbutton.y); 466 case MotionNotify: 467 return gfx::Point(native_event->xmotion.x, native_event->xmotion.y); 468 case GenericEvent: { 469 XIDeviceEvent* xievent = 470 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 471 float x = xievent->event_x; 472 float y = xievent->event_y; 473 #if defined(OS_CHROMEOS) 474 switch (xievent->evtype) { 475 case XI_TouchBegin: 476 case XI_TouchUpdate: 477 case XI_TouchEnd: 478 ui::DeviceDataManager::GetInstance()->ApplyTouchTransformer( 479 xievent->deviceid, &x, &y); 480 break; 481 default: 482 break; 483 } 484 #endif // defined(OS_CHROMEOS) 485 return gfx::Point(static_cast<int>(x), static_cast<int>(y)); 486 } 487 } 488 return gfx::Point(); 489 } 490 491 gfx::Point EventSystemLocationFromNative( 492 const base::NativeEvent& native_event) { 493 switch (native_event->type) { 494 case EnterNotify: 495 case LeaveNotify: { 496 return gfx::Point(native_event->xcrossing.x_root, 497 native_event->xcrossing.y_root); 498 } 499 case ButtonPress: 500 case ButtonRelease: { 501 return gfx::Point(native_event->xbutton.x_root, 502 native_event->xbutton.y_root); 503 } 504 case MotionNotify: { 505 return gfx::Point(native_event->xmotion.x_root, 506 native_event->xmotion.y_root); 507 } 508 case GenericEvent: { 509 XIDeviceEvent* xievent = 510 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 511 return gfx::Point(xievent->root_x, xievent->root_y); 512 } 513 } 514 515 return gfx::Point(); 516 } 517 518 int EventButtonFromNative(const base::NativeEvent& native_event) { 519 CHECK_EQ(GenericEvent, native_event->type); 520 XIDeviceEvent* xievent = 521 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 522 int button = xievent->detail; 523 524 return (xievent->sourceid == xievent->deviceid) ? 525 DeviceDataManager::GetInstance()->GetMappedButton(button) : button; 526 } 527 528 KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) { 529 return KeyboardCodeFromXKeyEvent(native_event); 530 } 531 532 const char* CodeFromNative(const base::NativeEvent& native_event) { 533 return CodeFromXEvent(native_event); 534 } 535 536 uint32 PlatformKeycodeFromNative(const base::NativeEvent& native_event) { 537 KeySym keysym; 538 XLookupString(&native_event->xkey, NULL, 0, &keysym, NULL); 539 return keysym; 540 } 541 542 int GetChangedMouseButtonFlagsFromNative( 543 const base::NativeEvent& native_event) { 544 switch (native_event->type) { 545 case ButtonPress: 546 case ButtonRelease: 547 return GetEventFlagsFromXState(native_event->xbutton.state); 548 case GenericEvent: { 549 XIDeviceEvent* xievent = 550 static_cast<XIDeviceEvent*>(native_event->xcookie.data); 551 switch (xievent->evtype) { 552 case XI_ButtonPress: 553 case XI_ButtonRelease: 554 return GetEventFlagsForButton(EventButtonFromNative(native_event)); 555 default: 556 break; 557 } 558 } 559 default: 560 break; 561 } 562 return 0; 563 } 564 565 gfx::Vector2d GetMouseWheelOffset(const base::NativeEvent& native_event) { 566 float x_offset, y_offset; 567 if (GetScrollOffsets( 568 native_event, &x_offset, &y_offset, NULL, NULL, NULL)) { 569 return gfx::Vector2d(static_cast<int>(x_offset), 570 static_cast<int>(y_offset)); 571 } 572 573 int button = native_event->type == GenericEvent ? 574 EventButtonFromNative(native_event) : native_event->xbutton.button; 575 576 switch (button) { 577 case 4: 578 return gfx::Vector2d(0, kWheelScrollAmount); 579 case 5: 580 return gfx::Vector2d(0, -kWheelScrollAmount); 581 case 6: 582 return gfx::Vector2d(kWheelScrollAmount, 0); 583 case 7: 584 return gfx::Vector2d(-kWheelScrollAmount, 0); 585 default: 586 return gfx::Vector2d(); 587 } 588 } 589 590 base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) { 591 if (!event || event->type == GenericEvent) 592 return NULL; 593 XEvent* copy = new XEvent; 594 *copy = *event; 595 return copy; 596 } 597 598 void ReleaseCopiedNativeEvent(const base::NativeEvent& event) { 599 delete event; 600 } 601 602 void ClearTouchIdIfReleased(const base::NativeEvent& xev) { 603 ui::EventType type = ui::EventTypeFromNative(xev); 604 if (type == ui::ET_TOUCH_CANCELLED || 605 type == ui::ET_TOUCH_RELEASED) { 606 ui::TouchFactory* factory = ui::TouchFactory::GetInstance(); 607 ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance(); 608 double tracking_id; 609 if (manager->GetEventData( 610 *xev, ui::DeviceDataManager::DT_TOUCH_TRACKING_ID, &tracking_id)) { 611 factory->ReleaseSlotForTrackingID(tracking_id); 612 } 613 } 614 } 615 616 int GetTouchId(const base::NativeEvent& xev) { 617 double slot = 0; 618 ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance(); 619 double tracking_id; 620 if (!manager->GetEventData( 621 *xev, ui::DeviceDataManager::DT_TOUCH_TRACKING_ID, &tracking_id)) { 622 LOG(ERROR) << "Could not get the tracking ID for the event. Using 0."; 623 } else { 624 ui::TouchFactory* factory = ui::TouchFactory::GetInstance(); 625 slot = factory->GetSlotForTrackingID(tracking_id); 626 } 627 return slot; 628 } 629 630 float GetTouchRadiusX(const base::NativeEvent& native_event) { 631 return GetTouchParamFromXEvent(native_event, 632 ui::DeviceDataManager::DT_TOUCH_MAJOR, 0.0) / 2.0; 633 } 634 635 float GetTouchRadiusY(const base::NativeEvent& native_event) { 636 return GetTouchParamFromXEvent(native_event, 637 ui::DeviceDataManager::DT_TOUCH_MINOR, 0.0) / 2.0; 638 } 639 640 float GetTouchAngle(const base::NativeEvent& native_event) { 641 return GetTouchParamFromXEvent(native_event, 642 ui::DeviceDataManager::DT_TOUCH_ORIENTATION, 0.0) / 2.0; 643 } 644 645 float GetTouchForce(const base::NativeEvent& native_event) { 646 double force = 0.0; 647 force = GetTouchParamFromXEvent(native_event, 648 ui::DeviceDataManager::DT_TOUCH_PRESSURE, 0.0); 649 unsigned int deviceid = 650 static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid; 651 // Force is normalized to fall into [0, 1] 652 if (!ui::DeviceDataManager::GetInstance()->NormalizeData( 653 deviceid, ui::DeviceDataManager::DT_TOUCH_PRESSURE, &force)) 654 force = 0.0; 655 return force; 656 } 657 658 bool GetScrollOffsets(const base::NativeEvent& native_event, 659 float* x_offset, 660 float* y_offset, 661 float* x_offset_ordinal, 662 float* y_offset_ordinal, 663 int* finger_count) { 664 if (!DeviceDataManager::GetInstance()->IsScrollEvent(native_event)) 665 return false; 666 667 // Temp values to prevent passing NULLs to DeviceDataManager. 668 float x_offset_, y_offset_; 669 float x_offset_ordinal_, y_offset_ordinal_; 670 int finger_count_; 671 if (!x_offset) 672 x_offset = &x_offset_; 673 if (!y_offset) 674 y_offset = &y_offset_; 675 if (!x_offset_ordinal) 676 x_offset_ordinal = &x_offset_ordinal_; 677 if (!y_offset_ordinal) 678 y_offset_ordinal = &y_offset_ordinal_; 679 if (!finger_count) 680 finger_count = &finger_count_; 681 682 DeviceDataManager::GetInstance()->GetScrollOffsets( 683 native_event, 684 x_offset, y_offset, 685 x_offset_ordinal, y_offset_ordinal, 686 finger_count); 687 return true; 688 } 689 690 bool GetFlingData(const base::NativeEvent& native_event, 691 float* vx, 692 float* vy, 693 float* vx_ordinal, 694 float* vy_ordinal, 695 bool* is_cancel) { 696 if (!DeviceDataManager::GetInstance()->IsFlingEvent(native_event)) 697 return false; 698 699 float vx_, vy_; 700 float vx_ordinal_, vy_ordinal_; 701 bool is_cancel_; 702 if (!vx) 703 vx = &vx_; 704 if (!vy) 705 vy = &vy_; 706 if (!vx_ordinal) 707 vx_ordinal = &vx_ordinal_; 708 if (!vy_ordinal) 709 vy_ordinal = &vy_ordinal_; 710 if (!is_cancel) 711 is_cancel = &is_cancel_; 712 713 DeviceDataManager::GetInstance()->GetFlingData( 714 native_event, vx, vy, vx_ordinal, vy_ordinal, is_cancel); 715 return true; 716 } 717 718 bool GetGestureTimes(const base::NativeEvent& native_event, 719 double* start_time, 720 double* end_time) { 721 if (!DeviceDataManager::GetInstance()->HasGestureTimes(native_event)) 722 return false; 723 724 double start_time_, end_time_; 725 if (!start_time) 726 start_time = &start_time_; 727 if (!end_time) 728 end_time = &end_time_; 729 730 DeviceDataManager::GetInstance()->GetGestureTimes( 731 native_event, start_time, end_time); 732 return true; 733 } 734 735 bool IsTouchpadEvent(const base::NativeEvent& event) { 736 return DeviceDataManager::GetInstance()->IsTouchpadXInputEvent(event); 737 } 738 739 } // namespace ui 740
