touch: Always expect XInput2 availability.

views/events/event_x.cc

 // Copyright (c) 2011 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 "views/events/event.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
-#if defined(HAVE_XINPUT2)
 #include <X11/extensions/XInput2.h>
-#endif
 #include <X11/Xlib.h>
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
+#include "views/touchui/touch_factory.h"
 #include "views/widget/root_view.h"
 
-#if defined(HAVE_XINPUT2)
-#include "views/touchui/touch_factory.h"
-#endif
-
 namespace views {
 
 namespace {
 
 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
 static int kWheelScrollAmount = 53;
 
 int GetEventFlagsFromXState(unsigned int state) {
   int flags = 0;
   if (state & ControlMask)
@@ skipping 29 matching lines @@
     case 2:
       return ui::EF_MIDDLE_BUTTON_DOWN;
     case 3:
       return ui::EF_RIGHT_BUTTON_DOWN;
   }
 
   DLOG(WARNING) << "Unexpected button (" << button << ") received.";
   return 0;
 }
 
-#if defined(HAVE_XINPUT2)
 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
   int buttonflags = 0;
 
   for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) {
     if (XIMaskIsSet(xievent->buttons.mask, i)) {
       buttonflags |= GetEventFlagsForButton(i);
     }
   }
 
   return buttonflags;
@@ skipping 31 matching lines @@
 }
 
 int GetTouchIDFromXEvent(XEvent* xev) {
   float slot = 0;
   if (!TouchFactory::GetInstance()->ExtractTouchParam(
         *xev, TouchFactory::TP_SLOT_ID, &slot))
     LOG(ERROR) << "Could not get the slot ID for the event. Using 0.";
   return slot;
 }
 
-#endif  // HAVE_XINPUT2
-
 ui::EventType EventTypeFromNative(NativeEvent2 native_event) {
   switch (native_event->type) {
     case KeyPress:
       return ui::ET_KEY_PRESSED;
     case KeyRelease:
       return ui::ET_KEY_RELEASED;
     case ButtonPress:
       if (native_event->xbutton.button == 4 ||
           native_event->xbutton.button == 5)
         return ui::ET_MOUSEWHEEL;
       return ui::ET_MOUSE_PRESSED;
     case ButtonRelease:
       if (native_event->xbutton.button == 4 ||
           native_event->xbutton.button == 5)
         return ui::ET_MOUSEWHEEL;
       return ui::ET_MOUSE_RELEASED;
     case MotionNotify:
       if (native_event->xmotion.state &
           (Button1Mask | Button2Mask | Button3Mask))
         return ui::ET_MOUSE_DRAGGED;
       return ui::ET_MOUSE_MOVED;
-#if defined(HAVE_XINPUT2)
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       if (TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid))
         return GetTouchEventType(native_event);
       switch (xievent->evtype) {
         case XI_ButtonPress:
           return (xievent->detail == 4 || xievent->detail == 5) ?
               ui::ET_MOUSEWHEEL : ui::ET_MOUSE_PRESSED;
         case XI_ButtonRelease:
           return (xievent->detail == 4 || xievent->detail == 5) ?
               ui::ET_MOUSEWHEEL : ui::ET_MOUSE_RELEASED;
         case XI_Motion:
           return GetButtonMaskForX2Event(xievent) ? ui::ET_MOUSE_DRAGGED :
               ui::ET_MOUSE_MOVED;
       }
     }
-#endif
     default:
       NOTREACHED();
       break;
   }
   return ui::ET_UNKNOWN;
 }
 
 int GetMouseWheelOffset(XEvent* xev) {
-#if defined(HAVE_XINPUT2)
   if (xev->type == GenericEvent) {
     XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
     return xiev->detail == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
   }
-#endif
   return xev->xbutton.button == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
 }
 
 gfx::Point GetEventLocation(XEvent* xev) {
   switch (xev->type) {
     case ButtonPress:
     case ButtonRelease:
       return gfx::Point(xev->xbutton.x, xev->xbutton.y);
 
     case MotionNotify:
       return gfx::Point(xev->xmotion.x, xev->xmotion.y);
 
-#if defined(HAVE_XINPUT2)
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(xev->xcookie.data);
       return gfx::Point(static_cast<int>(xievent->event_x),
                         static_cast<int>(xievent->event_y));
     }
-#endif
   }
 
   return gfx::Point();
 }
 
 int GetLocatedEventFlags(XEvent* xev) {
   switch (xev->type) {
     case ButtonPress:
     case ButtonRelease:
       return GetEventFlagsFromXState(xev->xbutton.state) |
              GetEventFlagsForButton(xev->xbutton.button);
 
     case MotionNotify:
       return GetEventFlagsFromXState(xev->xmotion.state);
 
-#if defined(HAVE_XINPUT2)
     case GenericEvent: {
       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
       bool touch =
           TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid);
       switch (xievent->evtype) {
         case XI_ButtonPress:
         case XI_ButtonRelease:
           return GetButtonMaskForX2Event(xievent) |
                  GetEventFlagsFromXState(xievent->mods.effective) |
                  (touch ? 0 : GetEventFlagsForButton(xievent->detail));
 
         case XI_Motion:
            return GetButtonMaskForX2Event(xievent) |
                   GetEventFlagsFromXState(xievent->mods.effective);
       }
     }
-#endif
   }
 
   return 0;
 }
 
 uint16 GetCharacterFromXKeyEvent(XKeyEvent* key) {
   char buf[6];
   int bytes_written = XLookupString(key, buf, 6, NULL, NULL);
   DCHECK_LE(bytes_written, 6);
 
   string16 result;
   return (bytes_written > 0 && UTF8ToUTF16(buf, bytes_written, &result) &&
           result.length() == 1) ? result[0] : 0;
 }
 
-#if defined(HAVE_XINPUT2)
 float GetTouchParamFromXEvent(XEvent* xev,
                               TouchFactory::TouchParam tp,
                               float default_value) {
   TouchFactory::GetInstance()->ExtractTouchParam(*xev, tp, &default_value);
   return default_value;
 }
-#endif
 
 float GetTouchForceFromXEvent(XEvent* xev) {
   float force = 0.0;
-#if defined(HAVE_XINPUT2)
   force = GetTouchParamFromXEvent(xev, TouchFactory::TP_PRESSURE, 0.0);
   unsigned int deviceid =
       static_cast<XIDeviceEvent*>(xev->xcookie.data)->sourceid;
   // Force is normalized to fall into [0, 1]
   if (!TouchFactory::GetInstance()->NormalizeTouchParam(
       deviceid, TouchFactory::TP_PRESSURE, &force))
     force = 0.0;
-#endif
   return force;
 }
 
 // The following two functions are copied from event_gtk.cc. These will be
 // removed when GTK dependency is removed.
 uint16 GetCharacterFromGdkKeyval(guint keyval) {
   guint32 ch = gdk_keyval_to_unicode(keyval);
 
   // We only support BMP characters.
   return ch < 0xFFFE ? static_cast<uint16>(ch) : 0;
@@ skipping 116 matching lines @@
 
 MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2,
                                  FromNativeEvent2 from_native)
     : MouseEvent(native_event_2, from_native),
       offset_(GetMouseWheelOffset(native_event_2)) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent, public:
 
-#if defined(HAVE_XINPUT2)
 TouchEvent::TouchEvent(NativeEvent2 native_event_2,
                        FromNativeEvent2 from_native)
     : LocatedEvent(native_event_2, from_native),
       touch_id_(GetTouchIDFromXEvent(native_event_2)),
       radius_x_(GetTouchParamFromXEvent(native_event_2,
                                         TouchFactory::TP_TOUCH_MAJOR,
                                         2.0) / 2.0),
       radius_y_(GetTouchParamFromXEvent(native_event_2,
                                         TouchFactory::TP_TOUCH_MINOR,
                                         2.0) / 2.0),
       rotation_angle_(GetTouchParamFromXEvent(native_event_2,
                                               TouchFactory::TP_ORIENTATION,
                                               0.0)),
       force_(GetTouchForceFromXEvent(native_event_2)) {
   if (type() == ui::ET_TOUCH_PRESSED || type() == ui::ET_TOUCH_RELEASED) {
     TouchFactory* factory = TouchFactory::GetInstance();
     float slot;
     if (factory->ExtractTouchParam(*native_event_2,
                                    TouchFactory::TP_SLOT_ID, &slot)) {
       factory->SetSlotUsed(slot, type() == ui::ET_TOUCH_PRESSED);
     }
   }
 }
-#endif
 
 }  // namespace views