Home | History | Annotate | Download | only in x 
      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/x/touch_factory_x11.h"
      6 
      7 #include <X11/cursorfont.h>
      8 #include <X11/extensions/XInput.h>
      9 #include <X11/extensions/XInput2.h>
     10 #include <X11/extensions/XIproto.h>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/command_line.h"
     14 #include "base/compiler_specific.h"
     15 #include "base/logging.h"
     16 #include "base/memory/singleton.h"
     17 #include "base/message_loop/message_loop.h"
     18 #include "base/strings/string_number_conversions.h"
     19 #include "base/strings/string_split.h"
     20 #include "ui/events/event_switches.h"
     21 #include "ui/events/x/device_data_manager.h"
     22 #include "ui/events/x/device_list_cache_x.h"
     23 #include "ui/gfx/x/x11_types.h"
     24 
     25 namespace ui {
     26 
     27 TouchFactory::TouchFactory()
     28     : pointer_device_lookup_(),
     29       touch_device_available_(false),
     30       touch_events_disabled_(false),
     31       touch_device_list_(),
     32       max_touch_points_(-1),
     33       id_generator_(0) {
     34   if (!DeviceDataManager::GetInstance()->IsXInput2Available())
     35     return;
     36 
     37   XDisplay* display = gfx::GetXDisplay();
     38   UpdateDeviceList(display);
     39 
     40   CommandLine* cmdline = CommandLine::ForCurrentProcess();
     41   touch_events_disabled_ = cmdline->HasSwitch(switches::kTouchEvents) &&
     42       cmdline->GetSwitchValueASCII(switches::kTouchEvents) ==
     43           switches::kTouchEventsDisabled;
     44 }
     45 
     46 TouchFactory::~TouchFactory() {
     47 }
     48 
     49 // static
     50 TouchFactory* TouchFactory::GetInstance() {
     51   return Singleton<TouchFactory>::get();
     52 }
     53 
     54 // static
     55 void TouchFactory::SetTouchDeviceListFromCommandLine() {
     56   // Get a list of pointer-devices that should be treated as touch-devices.
     57   // This is primarily used for testing/debugging touch-event processing when a
     58   // touch-device isn't available.
     59   std::string touch_devices =
     60       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
     61           switches::kTouchDevices);
     62 
     63   if (!touch_devices.empty()) {
     64     std::vector<std::string> devs;
     65     std::vector<unsigned int> device_ids;
     66     unsigned int devid;
     67     base::SplitString(touch_devices, ',', &devs);
     68     for (std::vector<std::string>::iterator iter = devs.begin();
     69         iter != devs.end(); ++iter) {
     70       if (base::StringToInt(*iter, reinterpret_cast<int*>(&devid)))
     71         device_ids.push_back(devid);
     72       else
     73         DLOG(WARNING) << "Invalid touch-device id: " << *iter;
     74     }
     75     ui::TouchFactory::GetInstance()->SetTouchDeviceList(device_ids);
     76   }
     77 }
     78 
     79 void TouchFactory::UpdateDeviceList(Display* display) {
     80   // Detect touch devices.
     81   touch_device_available_ = false;
     82   touch_device_lookup_.reset();
     83   touch_device_list_.clear();
     84   max_touch_points_ = -1;
     85 
     86 #if !defined(USE_XI2_MT)
     87   // NOTE: The new API for retrieving the list of devices (XIQueryDevice) does
     88   // not provide enough information to detect a touch device. As a result, the
     89   // old version of query function (XListInputDevices) is used instead.
     90   // If XInput2 is not supported, this will return null (with count of -1) so
     91   // we assume there cannot be any touch devices.
     92   // With XI2.1 or older, we allow only single touch devices.
     93   XDeviceList dev_list =
     94       DeviceListCacheX::GetInstance()->GetXDeviceList(display);
     95   Atom xi_touchscreen = XInternAtom(display, XI_TOUCHSCREEN, false);
     96   for (int i = 0; i < dev_list.count; i++) {
     97     if (dev_list[i].type == xi_touchscreen) {
     98       touch_device_lookup_[dev_list[i].id] = true;
     99       touch_device_list_[dev_list[i].id] = false;
    100       touch_device_available_ = true;
    101     }
    102   }
    103 #endif
    104 
    105   if (!DeviceDataManager::GetInstance()->IsXInput2Available())
    106     return;
    107 
    108   // Instead of asking X for the list of devices all the time, let's maintain a
    109   // list of pointer devices we care about.
    110   // It should not be necessary to select for slave devices. XInput2 provides
    111   // enough information to the event callback to decide which slave device
    112   // triggered the event, thus decide whether the 'pointer event' is a
    113   // 'mouse event' or a 'touch event'.
    114   // However, on some desktops, some events from a master pointer are
    115   // not delivered to the client. So we select for slave devices instead.
    116   // If the touch device has 'GrabDevice' set and 'SendCoreEvents' unset (which
    117   // is possible), then the device is detected as a floating device, and a
    118   // floating device is not connected to a master device. So it is necessary to
    119   // also select on the floating devices.
    120   pointer_device_lookup_.reset();
    121   XIDeviceList xi_dev_list =
    122       DeviceListCacheX::GetInstance()->GetXI2DeviceList(display);
    123   for (int i = 0; i < xi_dev_list.count; i++) {
    124     XIDeviceInfo* devinfo = xi_dev_list.devices + i;
    125     if (devinfo->use == XIFloatingSlave || devinfo->use == XIMasterPointer) {
    126 #if defined(USE_XI2_MT)
    127       for (int k = 0; k < devinfo->num_classes; ++k) {
    128         XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
    129         if (xiclassinfo->type == XITouchClass) {
    130           XITouchClassInfo* tci =
    131               reinterpret_cast<XITouchClassInfo *>(xiclassinfo);
    132           // Only care direct touch device (such as touch screen) right now
    133           if (tci->mode == XIDirectTouch) {
    134             touch_device_lookup_[devinfo->deviceid] = true;
    135             touch_device_list_[devinfo->deviceid] = true;
    136             touch_device_available_ = true;
    137             if (tci->num_touches > 0 && tci->num_touches > max_touch_points_)
    138               max_touch_points_ = tci->num_touches;
    139           }
    140         }
    141       }
    142 #endif
    143       pointer_device_lookup_[devinfo->deviceid] = true;
    144     }
    145   }
    146 }
    147 
    148 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
    149   DCHECK_EQ(GenericEvent, xev->type);
    150   XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data);
    151   XIDeviceEvent* xiev = reinterpret_cast<XIDeviceEvent*>(event);
    152 
    153 #if defined(USE_XI2_MT)
    154   if (event->evtype == XI_TouchBegin ||
    155       event->evtype == XI_TouchUpdate ||
    156       event->evtype == XI_TouchEnd) {
    157     return !touch_events_disabled_ && IsTouchDevice(xiev->deviceid);
    158   }
    159 #endif
    160   if (event->evtype != XI_ButtonPress &&
    161       event->evtype != XI_ButtonRelease &&
    162       event->evtype != XI_Motion)
    163     return true;
    164 
    165   if (!pointer_device_lookup_[xiev->deviceid])
    166     return false;
    167 
    168   return IsTouchDevice(xiev->deviceid) ? !touch_events_disabled_ : true;
    169 }
    170 
    171 void TouchFactory::SetupXI2ForXWindow(Window window) {
    172   // Setup mask for mouse events. It is possible that a device is loaded/plugged
    173   // in after we have setup XInput2 on a window. In such cases, we need to
    174   // either resetup XInput2 for the window, so that we get events from the new
    175   // device, or we need to listen to events from all devices, and then filter
    176   // the events from uninteresting devices. We do the latter because that's
    177   // simpler.
    178 
    179   XDisplay* display = gfx::GetXDisplay();
    180 
    181   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
    182   memset(mask, 0, sizeof(mask));
    183 
    184 #if defined(USE_XI2_MT)
    185   XISetMask(mask, XI_TouchBegin);
    186   XISetMask(mask, XI_TouchUpdate);
    187   XISetMask(mask, XI_TouchEnd);
    188 #endif
    189   XISetMask(mask, XI_ButtonPress);
    190   XISetMask(mask, XI_ButtonRelease);
    191   XISetMask(mask, XI_Motion);
    192 
    193   XIEventMask evmask;
    194   evmask.deviceid = XIAllDevices;
    195   evmask.mask_len = sizeof(mask);
    196   evmask.mask = mask;
    197   XISelectEvents(display, window, &evmask, 1);
    198   XFlush(display);
    199 }
    200 
    201 void TouchFactory::SetTouchDeviceList(
    202     const std::vector<unsigned int>& devices) {
    203   touch_device_lookup_.reset();
    204   touch_device_list_.clear();
    205   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
    206        iter != devices.end(); ++iter) {
    207     DCHECK(*iter < touch_device_lookup_.size());
    208     touch_device_lookup_[*iter] = true;
    209     touch_device_list_[*iter] = false;
    210   }
    211 }
    212 
    213 bool TouchFactory::IsTouchDevice(unsigned deviceid) const {
    214   return deviceid < touch_device_lookup_.size() ?
    215       touch_device_lookup_[deviceid] : false;
    216 }
    217 
    218 bool TouchFactory::IsMultiTouchDevice(unsigned int deviceid) const {
    219   return (deviceid < touch_device_lookup_.size() &&
    220           touch_device_lookup_[deviceid]) ?
    221           touch_device_list_.find(deviceid)->second :
    222           false;
    223 }
    224 
    225 bool TouchFactory::QuerySlotForTrackingID(uint32 tracking_id, int* slot) {
    226   if (!id_generator_.HasGeneratedIDFor(tracking_id))
    227     return false;
    228   *slot = static_cast<int>(id_generator_.GetGeneratedID(tracking_id));
    229   return true;
    230 }
    231 
    232 int TouchFactory::GetSlotForTrackingID(uint32 tracking_id) {
    233   return id_generator_.GetGeneratedID(tracking_id);
    234 }
    235 
    236 void TouchFactory::ReleaseSlotForTrackingID(uint32 tracking_id) {
    237   id_generator_.ReleaseNumber(tracking_id);
    238 }
    239 
    240 bool TouchFactory::IsTouchDevicePresent() {
    241   return !touch_events_disabled_ && touch_device_available_;
    242 }
    243 
    244 int TouchFactory::GetMaxTouchPoints() const {
    245   return max_touch_points_;
    246 }
    247 
    248 void TouchFactory::SetTouchDeviceForTest(
    249     const std::vector<unsigned int>& devices) {
    250   touch_device_lookup_.reset();
    251   touch_device_list_.clear();
    252   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
    253        iter != devices.end(); ++iter) {
    254     DCHECK(*iter < touch_device_lookup_.size());
    255     touch_device_lookup_[*iter] = true;
    256     touch_device_list_[*iter] = true;
    257   }
    258   touch_device_available_ = true;
    259   touch_events_disabled_ = false;
    260 }
    261 
    262 void TouchFactory::SetPointerDeviceForTest(
    263     const std::vector<unsigned int>& devices) {
    264   pointer_device_lookup_.reset();
    265   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
    266        iter != devices.end(); ++iter) {
    267     pointer_device_lookup_[*iter] = true;
    268   }
    269 }
    270 
    271 }  // namespace ui
    272