aura-x11: Add support for xmodmap'ed pointer buttons.

ui/base/x/events_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 "ui/base/events.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/XInput2.h>
 #include <string.h>
 
 #include "base/logging.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/touch/touch_factory.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/gfx/point.h"
 
 #if !defined(TOOLKIT_USES_GTK)
 #include "base/message_pump_x.h"
 #endif
 
 namespace {
 
 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
 static const int kWheelScrollAmount = 53;
@@ skipping 47 matching lines @@
       return ui::EF_RIGHT_BUTTON_DOWN;
     default:
       return 0;
   }
 }
 
 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);
+      int button = (xievent->sourceid == xievent->deviceid) ?
+                   ui::GetMappedButton(i) : i;
+      buttonflags |= GetEventFlagsForButton(button);
     }
   }
   return buttonflags;
 }
 
 ui::EventType GetTouchEventType(const base::NativeEvent& native_event) {
   XIDeviceEvent* event =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 #if defined(USE_XI2_MT)
   switch(event->evtype) {
@@ skipping 90 matching lines @@
       return ET_MOUSE_MOVED;
     case EnterNotify:
       return ET_MOUSE_ENTERED;
     case LeaveNotify:
       return ET_MOUSE_EXITED;
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       if (TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid))
         return GetTouchEventType(native_event);
+      int button = EventButtonFromNative(native_event);
       switch (xievent->evtype) {
         case XI_ButtonPress:
-          if (xievent->detail >= kMinWheelButton &&
-              xievent->detail <= kMaxWheelButton)
+          if (button >= kMinWheelButton &&
+              button <= kMaxWheelButton)
             return ET_MOUSEWHEEL;
           return ET_MOUSE_PRESSED;
         case XI_ButtonRelease:
-          if (xievent->detail >= kMinWheelButton &&
-              xievent->detail <= kMaxWheelButton)
+          if (button >= kMinWheelButton &&
+              button <= kMaxWheelButton)
             return ET_MOUSEWHEEL;
           return ET_MOUSE_RELEASED;
         case XI_Motion:
           return GetButtonMaskForX2Event(xievent) ?
               ET_MOUSE_DRAGGED : ET_MOUSE_MOVED;
       }
     }
     default:
       break;
   }
@@ skipping 19 matching lines @@
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       const bool touch =
           TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid);
       switch (xievent->evtype) {
         case XI_ButtonPress:
         case XI_ButtonRelease: {
           int flags = GetButtonMaskForX2Event(xievent) |
               GetEventFlagsFromXState(xievent->mods.effective);
           const EventType type = EventTypeFromNative(native_event);
+          int button = EventButtonFromNative(native_event);
           if ((type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED) && !touch)
-            flags |= GetEventFlagsForButton(xievent->detail);
+            flags |= GetEventFlagsForButton(button);
           return flags;
         }
         case XI_Motion:
            return GetButtonMaskForX2Event(xievent) |
                   GetEventFlagsFromXState(xievent->mods.effective);
       }
     }
   }
   return 0;
 }
@@ skipping 26 matching lines @@
       double y = xievent->event_y;
       if (XIMaskIsSet(xievent->valuators.mask, 1))
         y = *valuators++ - (xievent->root_y - xievent->event_y);
 
       return gfx::Point(static_cast<int>(x), static_cast<int>(y));
     }
   }
   return gfx::Point();
 }
 
+int EventButtonFromNative(const base::NativeEvent& native_event) {
+  CHECK_EQ(GenericEvent, native_event->type);
+  XIDeviceEvent* xievent =
+      static_cast<XIDeviceEvent*>(native_event->xcookie.data);
+  int button = xievent->detail;
+
+  return (xievent->sourceid == xievent->deviceid) ?
+         ui::GetMappedButton(button) : button;
+}
+
 KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) {
   return KeyboardCodeFromXKeyEvent(native_event);
 }
 
 bool IsMouseEvent(const base::NativeEvent& native_event) {
   if (native_event->type == ButtonPress ||
       native_event->type == ButtonRelease ||
       native_event->type == MotionNotify)
     return true;
   if (native_event->type == GenericEvent) {
     XIDeviceEvent* xievent =
         static_cast<XIDeviceEvent*>(native_event->xcookie.data);
     return xievent->evtype == XI_ButtonPress ||
            xievent->evtype == XI_ButtonRelease ||
            xievent->evtype == XI_Motion;
   }
   return false;
 }
 
 int GetMouseWheelOffset(const base::NativeEvent& native_event) {
   int button;
-  if (native_event->type == GenericEvent) {
-    XIDeviceEvent* xiev =
-        static_cast<XIDeviceEvent*>(native_event->xcookie.data);
-    button = xiev->detail;
-  } else {
+  if (native_event->type == GenericEvent)
+    button = EventButtonFromNative(native_event);
+  else
     button = native_event->xbutton.button;
-  }
   switch (button) {
     case 4:
 #if defined(OS_CHROMEOS)
       return kTouchpadScrollAmount;
     case 8:
 #endif
       return kWheelScrollAmount;
 
     case 5:
 #if defined(OS_CHROMEOS)
@@ skipping 78 matching lines @@
   // Make sure we use atom from current xdisplay, which may
   // change during the test.
   noop->xclient.message_type = XInternAtom(
       base::MessagePumpX::GetDefaultXDisplay(),
       "noop", False);
 #endif
   return noop;
 }
 
 }  // namespace ui