x11: Listen for and process XInput2 events.

ui/platform_window/x11/x11_window.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/platform_window/x11/x11_window.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
+#include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/platform_window/platform_window_delegate.h"
 
 namespace ui {
 
 namespace {
 
 const char* kAtomsToCache[] = {
@@ skipping 13 matching lines @@
 }  // namespace
 
 X11Window::X11Window(PlatformWindowDelegate* delegate)
     : delegate_(delegate),
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(None),
       xroot_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false) {
   CHECK(delegate_);
+  TouchFactory::SetTouchDeviceListFromCommandLine();
 }
 
 X11Window::~X11Window() {
   Destroy();
 }
 
 void X11Window::Destroy() {
   if (xwindow_ == None)
     return;
 
   // Stop processing events.
   PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   XDestroyWindow(xdisplay_, xwindow_);
   xwindow_ = None;
 }
 
+void X11Window::ProcessXInput2Event(XEvent* xev) {
+  if (!TouchFactory::GetInstance()->ShouldProcessXI2Event(xev))
+    return;
+  EventType event_type = EventTypeFromNative(xev);
+  switch (event_type) {
+    case ET_KEY_PRESSED:
+    case ET_KEY_RELEASED: {
+      KeyEvent key_event(xev, false);
+      delegate_->DispatchEvent(&key_event);
+      break;
+    }
+    case ET_MOUSE_PRESSED:
+    case ET_MOUSE_MOVED:
+    case ET_MOUSE_DRAGGED:
+    case ET_MOUSE_RELEASED: {
+      MouseEvent mouse_event(xev);
+      delegate_->DispatchEvent(&mouse_event);
+      break;
+    }
+    case ET_MOUSEWHEEL: {
+      MouseWheelEvent wheel_event(xev);
+      delegate_->DispatchEvent(&wheel_event);
+      break;
+    }
+    case ET_SCROLL_FLING_START:
+    case ET_SCROLL_FLING_CANCEL:
+    case ET_SCROLL: {
+      ScrollEvent scroll_event(xev);
+      delegate_->DispatchEvent(&scroll_event);
+      break;
+    }
+    case ET_TOUCH_MOVED:
+    case ET_TOUCH_PRESSED:
+    case ET_TOUCH_CANCELLED:
+    case ET_TOUCH_RELEASED: {
+      TouchEvent touch_event(xev);
+      delegate_->DispatchEvent(&touch_event);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
 void X11Window::Show() {
   if (window_mapped_)
     return;
 
   CHECK(PlatformEventSource::GetInstance());
   PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
@@ skipping 17 matching lines @@
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
 
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   memset(mask, 0, sizeof(mask));
 
   XISetMask(mask, XI_TouchBegin);
   XISetMask(mask, XI_TouchUpdate);
   XISetMask(mask, XI_TouchEnd);
+  XISetMask(mask, XI_ButtonPress);
+  XISetMask(mask, XI_ButtonRelease);
+  XISetMask(mask, XI_Motion);
+  XISetMask(mask, XI_KeyPress);
+  XISetMask(mask, XI_KeyRelease);
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(xdisplay_, xwindow_, &evmask, 1);
   XFlush(xdisplay_);
 
   ::Atom protocols[2];
   protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
@@ skipping 172 matching lines @@
 
         XSendEvent(xdisplay_,
                    reply_event.xclient.window,
                    False,
                    SubstructureRedirectMask | SubstructureNotifyMask,
                    &reply_event);
         XFlush(xdisplay_);
       }
       break;
     }
+
+    case GenericEvent: {
+      ProcessXInput2Event(xev);
+      break;
+    }
   }
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 
 }  // namespace ui