Pileus Git - ~andy/gtk/blob - gdk/x11/gdkdevicemanager-xi2.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gdkx11devicemanager-xi2.h"
  21 #include "gdkx11device-xi2.h"
  22
  23 #include "gdkdevicemanagerprivate-core.h"
  24 #include "gdkdeviceprivate.h"
  25 #include "gdkdisplayprivate.h"
  26 #include "gdkeventtranslator.h"
  27 #include "gdkprivate-x11.h"
  28 #include "gdkintl.h"
  29 #include "gdkkeysyms.h"
  30 #include "gdkinternals.h"
  31
  32 #include <X11/Xlib.h>
  33 #include <X11/Xutil.h>
  34 #include <X11/extensions/XInput2.h>
  35
  36 #include <string.h>
  37
  38 struct _GdkX11DeviceManagerXI2
  39 {
  40   GdkX11DeviceManagerCore parent_object;
  41
  42   GHashTable *id_table;
  43
  44   GList *devices;
  45
  46   gint opcode;
  47   gint major;
  48   gint minor;
  49 };
  50
  51 struct _GdkX11DeviceManagerXI2Class
  52 {
  53   GdkDeviceManagerClass parent_class;
  54 };
  55
  56 static void     gdk_x11_device_manager_xi2_event_translator_init (GdkEventTranslatorIface *iface);
  57
  58 G_DEFINE_TYPE_WITH_CODE (GdkX11DeviceManagerXI2, gdk_x11_device_manager_xi2, GDK_TYPE_X11_DEVICE_MANAGER_CORE,
  59                          G_IMPLEMENT_INTERFACE (GDK_TYPE_EVENT_TRANSLATOR,
  60                                                 gdk_x11_device_manager_xi2_event_translator_init))
  61
  62
  63 #define HAS_FOCUS(toplevel) ((toplevel)->has_focus || (toplevel)->has_pointer_focus)
  64
  65
  66 static void    gdk_x11_device_manager_xi2_constructed  (GObject      *object);
  67 static void    gdk_x11_device_manager_xi2_dispose      (GObject      *object);
  68 static void    gdk_x11_device_manager_xi2_set_property (GObject      *object,
  69                                                         guint         prop_id,
  70                                                         const GValue *value,
  71                                                         GParamSpec   *pspec);
  72 static void    gdk_x11_device_manager_xi2_get_property (GObject      *object,
  73                                                         guint         prop_id,
  74                                                         GValue       *value,
  75                                                         GParamSpec   *pspec);
  76
  77 static GList * gdk_x11_device_manager_xi2_list_devices (GdkDeviceManager *device_manager,
  78                                                         GdkDeviceType     type);
  79 static GdkDevice * gdk_x11_device_manager_xi2_get_client_pointer (GdkDeviceManager *device_manager);
  80
  81 static gboolean gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
  82                                                             GdkDisplay         *display,
  83                                                             GdkEvent           *event,
  84                                                             XEvent             *xevent);
  85 static GdkEventMask gdk_x11_device_manager_xi2_get_handled_events   (GdkEventTranslator *translator);
  86 static void         gdk_x11_device_manager_xi2_select_window_events (GdkEventTranslator *translator,
  87                                                                      Window              window,
  88                                                                      GdkEventMask        event_mask);
  89 static GdkWindow *  gdk_x11_device_manager_xi2_get_window           (GdkEventTranslator *translator,
  90                                                                      XEvent             *xevent);
  91
  92 enum {
  93   PROP_0,
  94   PROP_OPCODE,
  95   PROP_MAJOR,
  96   PROP_MINOR
  97 };
  98
  99 static void
 100 gdk_x11_device_manager_xi2_class_init (GdkX11DeviceManagerXI2Class *klass)
 101 {
 102   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
 103   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 104
 105   object_class->constructed = gdk_x11_device_manager_xi2_constructed;
 106   object_class->dispose = gdk_x11_device_manager_xi2_dispose;
 107   object_class->set_property = gdk_x11_device_manager_xi2_set_property;
 108   object_class->get_property = gdk_x11_device_manager_xi2_get_property;
 109
 110   device_manager_class->list_devices = gdk_x11_device_manager_xi2_list_devices;
 111   device_manager_class->get_client_pointer = gdk_x11_device_manager_xi2_get_client_pointer;
 112
 113   g_object_class_install_property (object_class,
 114                                    PROP_OPCODE,
 115                                    g_param_spec_int ("opcode",
 116                                                      P_("Opcode"),
 117                                                      P_("Opcode for XInput2 requests"),
 118                                                      0, G_MAXINT, 0,
 119                                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 120   g_object_class_install_property (object_class,
 121                                    PROP_MAJOR,
 122                                    g_param_spec_int ("major",
 123                                                      P_("Major"),
 124                                                      P_("Major version number"),
 125                                                      0, G_MAXINT, 0,
 126                                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 127   g_object_class_install_property (object_class,
 128                                    PROP_MINOR,
 129                                    g_param_spec_int ("minor",
 130                                                      P_("Minor"),
 131                                                      P_("Minor version number"),
 132                                                      0, G_MAXINT, 0,
 133                                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 134 }
 135
 136 static void
 137 gdk_x11_device_manager_xi2_init (GdkX11DeviceManagerXI2 *device_manager)
 138 {
 139   device_manager->id_table = g_hash_table_new_full (g_direct_hash,
 140                                                     g_direct_equal,
 141                                                     NULL,
 142                                                     (GDestroyNotify) g_object_unref);
 143 }
 144
 145 static void
 146 _gdk_x11_device_manager_xi2_select_events (GdkDeviceManager *device_manager,
 147                                            Window            xwindow,
 148                                            XIEventMask      *event_mask)
 149 {
 150   GdkDisplay *display;
 151   Display *xdisplay;
 152
 153   display = gdk_device_manager_get_display (device_manager);
 154   xdisplay = GDK_DISPLAY_XDISPLAY (display);
 155
 156   XISelectEvents (xdisplay, xwindow, event_mask, 1);
 157 }
 158
 159 static void
 160 translate_valuator_class (GdkDisplay          *display,
 161                           GdkDevice           *device,
 162                           Atom                 valuator_label,
 163                           gdouble              min,
 164                           gdouble              max,
 165                           gdouble              resolution)
 166 {
 167   static gboolean initialized = FALSE;
 168   static Atom label_atoms [GDK_AXIS_LAST] = { 0 };
 169   GdkAxisUse use = GDK_AXIS_IGNORE;
 170   GdkAtom label;
 171   gint i;
 172
 173   if (!initialized)
 174     {
 175       label_atoms [GDK_AXIS_X] = gdk_x11_get_xatom_by_name_for_display (display, "Abs X");
 176       label_atoms [GDK_AXIS_Y] = gdk_x11_get_xatom_by_name_for_display (display, "Abs Y");
 177       label_atoms [GDK_AXIS_PRESSURE] = gdk_x11_get_xatom_by_name_for_display (display, "Abs Pressure");
 178       label_atoms [GDK_AXIS_XTILT] = gdk_x11_get_xatom_by_name_for_display (display, "Abs Tilt X");
 179       label_atoms [GDK_AXIS_YTILT] = gdk_x11_get_xatom_by_name_for_display (display, "Abs Tilt Y");
 180       label_atoms [GDK_AXIS_WHEEL] = gdk_x11_get_xatom_by_name_for_display (display, "Abs Wheel");
 181       initialized = TRUE;
 182     }
 183
 184   for (i = GDK_AXIS_IGNORE; i < GDK_AXIS_LAST; i++)
 185     {
 186       if (label_atoms[i] == valuator_label)
 187         {
 188           use = i;
 189           break;
 190         }
 191     }
 192
 193   if (valuator_label != None)
 194     label = gdk_x11_xatom_to_atom_for_display (display, valuator_label);
 195   else
 196     label = GDK_NONE;
 197
 198   _gdk_device_add_axis (device, label, use, min, max, resolution);
 199 }
 200
 201 static void
 202 translate_device_classes (GdkDisplay      *display,
 203                           GdkDevice       *device,
 204                           XIAnyClassInfo **classes,
 205                           guint            n_classes)
 206 {
 207   gint i;
 208
 209   g_object_freeze_notify (G_OBJECT (device));
 210
 211   for (i = 0; i < n_classes; i++)
 212     {
 213       XIAnyClassInfo *class_info = classes[i];
 214
 215       switch (class_info->type)
 216         {
 217         case XIKeyClass:
 218           {
 219             XIKeyClassInfo *key_info = (XIKeyClassInfo *) class_info;
 220             gint i;
 221
 222             _gdk_device_set_keys (device, key_info->num_keycodes);
 223
 224             for (i = 0; i < key_info->num_keycodes; i++)
 225               gdk_device_set_key (device, i, key_info->keycodes[i], 0);
 226           }
 227           break;
 228         case XIValuatorClass:
 229           {
 230             XIValuatorClassInfo *valuator_info = (XIValuatorClassInfo *) class_info;
 231             translate_valuator_class (display, device,
 232                                       valuator_info->label,
 233                                       valuator_info->min,
 234                                       valuator_info->max,
 235                                       valuator_info->resolution);
 236           }
 237           break;
 238 #ifdef XINPUT_2_2
 239         case XIScrollClass:
 240           {
 241             XIScrollClassInfo *scroll_info = (XIScrollClassInfo *) class_info;
 242             GdkScrollDirection direction;
 243
 244             if (scroll_info->scroll_type == XIScrollTypeVertical)
 245               direction = GDK_SCROLL_DOWN;
 246             else
 247               direction = GDK_SCROLL_RIGHT;
 248
 249             GDK_NOTE (INPUT,
 250                       g_message ("\n\tscroll valuator %d: %s, increment %f",
 251                                  scroll_info->number,
 252                                  scroll_info->scroll_type == XIScrollTypeVertical
 253                                                 ? "vertical"
 254                                                 : "horizontal",
 255                                  scroll_info->increment));
 256
 257             _gdk_x11_device_xi2_add_scroll_valuator (GDK_X11_DEVICE_XI2 (device),
 258                                                      scroll_info->number,
 259                                                      direction,
 260                                                      scroll_info->increment);
 261           }
 262 #endif /* XINPUT_2_2 */
 263         default:
 264           /* Ignore */
 265           break;
 266         }
 267     }
 268
 269   g_object_thaw_notify (G_OBJECT (device));
 270 }
 271
 272 static gboolean
 273 is_touch_device (XIAnyClassInfo **classes,
 274                  guint            n_classes,
 275                  GdkInputSource  *device_type,
 276                  gint            *num_touches)
 277 {
 278 #ifdef XINPUT_2_2
 279   guint i;
 280
 281   for (i = 0; i < n_classes; i++)
 282     {
 283       XITouchClassInfo *class = (XITouchClassInfo *) classes[i];
 284
 285       if (class->type != XITouchClass)
 286         continue;
 287
 288       if (class->num_touches > 0)
 289         {
 290           if (class->mode == XIDirectTouch)
 291             *device_type = GDK_SOURCE_TOUCHSCREEN;
 292           else if (class->mode == XIDependentTouch)
 293             *device_type = GDK_SOURCE_TOUCHPAD;
 294           else
 295             continue;
 296
 297           *num_touches = class->num_touches;
 298
 299           return TRUE;
 300         }
 301     }
 302 #endif
 303
 304   return FALSE;
 305 }
 306
 307 static GdkDevice *
 308 create_device (GdkDeviceManager *device_manager,
 309                GdkDisplay       *display,
 310                XIDeviceInfo     *dev)
 311 {
 312   GdkInputSource input_source;
 313   GdkInputSource touch_source;
 314   GdkDeviceType type;
 315   GdkDevice *device;
 316   GdkInputMode mode;
 317   gint num_touches = 0;
 318
 319   if (dev->use == XIMasterKeyboard || dev->use == XISlaveKeyboard)
 320     input_source = GDK_SOURCE_KEYBOARD;
 321   else if (dev->use == XISlavePointer &&
 322            is_touch_device (dev->classes, dev->num_classes, &touch_source, &num_touches))
 323     input_source = touch_source;
 324   else
 325     {
 326       gchar *tmp_name;
 327
 328       tmp_name = g_ascii_strdown (dev->name, -1);
 329
 330       if (strstr (tmp_name, "eraser"))
 331         input_source = GDK_SOURCE_ERASER;
 332       else if (strstr (tmp_name, "cursor"))
 333         input_source = GDK_SOURCE_CURSOR;
 334       else if (strstr (tmp_name, "wacom") ||
 335                strstr (tmp_name, "pen"))
 336         input_source = GDK_SOURCE_PEN;
 337       else
 338         input_source = GDK_SOURCE_MOUSE;
 339
 340       g_free (tmp_name);
 341     }
 342
 343   switch (dev->use)
 344     {
 345     case XIMasterKeyboard:
 346     case XIMasterPointer:
 347       type = GDK_DEVICE_TYPE_MASTER;
 348       mode = GDK_MODE_SCREEN;
 349       break;
 350     case XISlaveKeyboard:
 351     case XISlavePointer:
 352       type = GDK_DEVICE_TYPE_SLAVE;
 353       mode = GDK_MODE_DISABLED;
 354       break;
 355     case XIFloatingSlave:
 356     default:
 357       type = GDK_DEVICE_TYPE_FLOATING;
 358       mode = GDK_MODE_DISABLED;
 359       break;
 360     }
 361
 362   GDK_NOTE (INPUT,
 363             ({
 364               const gchar *type_names[] = { "master", "slave", "floating" };
 365               const gchar *source_names[] = { "mouse", "pen", "eraser", "cursor", "keyboard", "direct touch", "indirect touch" };
 366               const gchar *mode_names[] = { "disabled", "screen", "window" };
 367               g_message ("input device:\n\tname: %s\n\ttype: %s\n\tsource: %s\n\tmode: %s\n\thas cursor: %d\n\ttouches: %d",
 368                          dev->name,
 369                          type_names[type],
 370                          source_names[input_source],
 371                          mode_names[mode],
 372                          dev->use == XIMasterPointer,
 373                          num_touches);
 374             }));
 375
 376   device = g_object_new (GDK_TYPE_X11_DEVICE_XI2,
 377                          "name", dev->name,
 378                          "type", type,
 379                          "input-source", input_source,
 380                          "input-mode", mode,
 381                          "has-cursor", (dev->use == XIMasterPointer),
 382                          "display", display,
 383                          "device-manager", device_manager,
 384                          "device-id", dev->deviceid,
 385                          NULL);
 386
 387   translate_device_classes (display, device, dev->classes, dev->num_classes);
 388
 389   return device;
 390 }
 391
 392 static GdkDevice *
 393 add_device (GdkX11DeviceManagerXI2 *device_manager,
 394             XIDeviceInfo           *dev,
 395             gboolean                emit_signal)
 396 {
 397   GdkDisplay *display;
 398   GdkDevice *device;
 399
 400   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (device_manager));
 401   device = create_device (GDK_DEVICE_MANAGER (device_manager), display, dev);
 402
 403   g_hash_table_replace (device_manager->id_table,
 404                         GINT_TO_POINTER (dev->deviceid),
 405                         g_object_ref (device));
 406
 407   device_manager->devices = g_list_append (device_manager->devices, device);
 408
 409   if (emit_signal)
 410     {
 411       if (dev->use == XISlavePointer || dev->use == XISlaveKeyboard)
 412         {
 413           GdkDevice *master;
 414
 415           /* The device manager is already constructed, then
 416            * keep the hierarchy coherent for the added device.
 417            */
 418           master = g_hash_table_lookup (device_manager->id_table,
 419                                         GINT_TO_POINTER (dev->attachment));
 420
 421           _gdk_device_set_associated_device (device, master);
 422           _gdk_device_add_slave (master, device);
 423         }
 424
 425       g_signal_emit_by_name (device_manager, "device-added", device);
 426     }
 427
 428   return device;
 429 }
 430
 431 static void
 432 remove_device (GdkX11DeviceManagerXI2 *device_manager,
 433                gint                    device_id)
 434 {
 435   GdkDevice *device;
 436
 437   device = g_hash_table_lookup (device_manager->id_table,
 438                                 GINT_TO_POINTER (device_id));
 439
 440   if (device)
 441     {
 442       device_manager->devices = g_list_remove (device_manager->devices, device);
 443
 444       g_signal_emit_by_name (device_manager, "device-removed", device);
 445
 446       g_object_run_dispose (G_OBJECT (device));
 447
 448       g_hash_table_remove (device_manager->id_table,
 449                            GINT_TO_POINTER (device_id));
 450     }
 451 }
 452
 453 static void
 454 relate_masters (gpointer key,
 455                 gpointer value,
 456                 gpointer user_data)
 457 {
 458   GdkX11DeviceManagerXI2 *device_manager;
 459   GdkDevice *device, *relative;
 460
 461   device_manager = user_data;
 462   device = g_hash_table_lookup (device_manager->id_table, key);
 463   relative = g_hash_table_lookup (device_manager->id_table, value);
 464
 465   _gdk_device_set_associated_device (device, relative);
 466   _gdk_device_set_associated_device (relative, device);
 467 }
 468
 469 static void
 470 relate_slaves (gpointer key,
 471                gpointer value,
 472                gpointer user_data)
 473 {
 474   GdkX11DeviceManagerXI2 *device_manager;
 475   GdkDevice *slave, *master;
 476
 477   device_manager = user_data;
 478   slave = g_hash_table_lookup (device_manager->id_table, key);
 479   master = g_hash_table_lookup (device_manager->id_table, value);
 480
 481   _gdk_device_set_associated_device (slave, master);
 482   _gdk_device_add_slave (master, slave);
 483 }
 484
 485 static void
 486 gdk_x11_device_manager_xi2_constructed (GObject *object)
 487 {
 488   GdkX11DeviceManagerXI2 *device_manager;
 489   GdkDisplay *display;
 490   GdkScreen *screen;
 491   GHashTable *masters, *slaves;
 492   Display *xdisplay;
 493   XIDeviceInfo *info, *dev;
 494   int ndevices, i;
 495   XIEventMask event_mask;
 496   unsigned char mask[2] = { 0 };
 497
 498   device_manager = GDK_X11_DEVICE_MANAGER_XI2 (object);
 499   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (object));
 500   xdisplay = GDK_DISPLAY_XDISPLAY (display);
 501
 502   g_assert (device_manager->major == 2);
 503
 504   masters = g_hash_table_new (NULL, NULL);
 505   slaves = g_hash_table_new (NULL, NULL);
 506
 507   info = XIQueryDevice (xdisplay, XIAllDevices, &ndevices);
 508
 509   /* Initialize devices list */
 510   for (i = 0; i < ndevices; i++)
 511     {
 512       dev = &info[i];
 513
 514       if (!dev->enabled)
 515               continue;
 516
 517       add_device (device_manager, dev, FALSE);
 518
 519       if (dev->use == XIMasterPointer ||
 520           dev->use == XIMasterKeyboard)
 521         {
 522           g_hash_table_insert (masters,
 523                                GINT_TO_POINTER (dev->deviceid),
 524                                GINT_TO_POINTER (dev->attachment));
 525         }
 526       else if (dev->use == XISlavePointer ||
 527                dev->use == XISlaveKeyboard)
 528         {
 529           g_hash_table_insert (slaves,
 530                                GINT_TO_POINTER (dev->deviceid),
 531                                GINT_TO_POINTER (dev->attachment));
 532         }
 533     }
 534
 535   XIFreeDeviceInfo (info);
 536
 537   /* Stablish relationships between devices */
 538   g_hash_table_foreach (masters, relate_masters, object);
 539   g_hash_table_destroy (masters);
 540
 541   g_hash_table_foreach (slaves, relate_slaves, object);
 542   g_hash_table_destroy (slaves);
 543
 544   /* Connect to hierarchy change events */
 545   screen = gdk_display_get_default_screen (display);
 546   XISetMask (mask, XI_HierarchyChanged);
 547   XISetMask (mask, XI_DeviceChanged);
 548
 549   event_mask.deviceid = XIAllDevices;
 550   event_mask.mask_len = sizeof (mask);
 551   event_mask.mask = mask;
 552
 553   _gdk_x11_device_manager_xi2_select_events (GDK_DEVICE_MANAGER (object),
 554                                              GDK_WINDOW_XID (gdk_screen_get_root_window (screen)),
 555                                              &event_mask);
 556 }
 557
 558 static void
 559 gdk_x11_device_manager_xi2_dispose (GObject *object)
 560 {
 561   GdkX11DeviceManagerXI2 *device_manager;
 562
 563   device_manager = GDK_X11_DEVICE_MANAGER_XI2 (object);
 564
 565   g_list_free_full (device_manager->devices, g_object_unref);
 566   device_manager->devices = NULL;
 567
 568   if (device_manager->id_table)
 569     {
 570       g_hash_table_destroy (device_manager->id_table);
 571       device_manager->id_table = NULL;
 572     }
 573
 574   G_OBJECT_CLASS (gdk_x11_device_manager_xi2_parent_class)->dispose (object);
 575 }
 576
 577 static GList *
 578 gdk_x11_device_manager_xi2_list_devices (GdkDeviceManager *device_manager,
 579                                          GdkDeviceType     type)
 580 {
 581   GdkX11DeviceManagerXI2 *device_manager_xi2;
 582   GList *cur, *list = NULL;
 583
 584   device_manager_xi2 = GDK_X11_DEVICE_MANAGER_XI2 (device_manager);
 585
 586   for (cur = device_manager_xi2->devices; cur; cur = cur->next)
 587     {
 588       GdkDevice *dev = cur->data;
 589
 590       if (type == gdk_device_get_device_type (dev))
 591         list = g_list_prepend (list, dev);
 592     }
 593
 594   return list;
 595 }
 596
 597 static GdkDevice *
 598 gdk_x11_device_manager_xi2_get_client_pointer (GdkDeviceManager *device_manager)
 599 {
 600   GdkX11DeviceManagerXI2 *device_manager_xi2;
 601   GdkDisplay *display;
 602   int device_id;
 603
 604   device_manager_xi2 = (GdkX11DeviceManagerXI2 *) device_manager;
 605   display = gdk_device_manager_get_display (device_manager);
 606
 607   XIGetClientPointer (GDK_DISPLAY_XDISPLAY (display),
 608                       None, &device_id);
 609
 610   return g_hash_table_lookup (device_manager_xi2->id_table,
 611                               GINT_TO_POINTER (device_id));
 612 }
 613
 614 static void
 615 gdk_x11_device_manager_xi2_set_property (GObject      *object,
 616                                          guint         prop_id,
 617                                          const GValue *value,
 618                                          GParamSpec   *pspec)
 619 {
 620   GdkX11DeviceManagerXI2 *device_manager;
 621
 622   device_manager = GDK_X11_DEVICE_MANAGER_XI2 (object);
 623
 624   switch (prop_id)
 625     {
 626     case PROP_OPCODE:
 627       device_manager->opcode = g_value_get_int (value);
 628       break;
 629     case PROP_MAJOR:
 630       device_manager->major = g_value_get_int (value);
 631       break;
 632     case PROP_MINOR:
 633       device_manager->minor = g_value_get_int (value);
 634       break;
 635     default:
 636       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 637       break;
 638     }
 639 }
 640
 641 static void
 642 gdk_x11_device_manager_xi2_get_property (GObject    *object,
 643                                          guint       prop_id,
 644                                          GValue     *value,
 645                                          GParamSpec *pspec)
 646 {
 647   GdkX11DeviceManagerXI2 *device_manager;
 648
 649   device_manager = GDK_X11_DEVICE_MANAGER_XI2 (object);
 650
 651   switch (prop_id)
 652     {
 653     case PROP_OPCODE:
 654       g_value_set_int (value, device_manager->opcode);
 655       break;
 656     case PROP_MAJOR:
 657       g_value_set_int (value, device_manager->major);
 658       break;
 659     case PROP_MINOR:
 660       g_value_set_int (value, device_manager->minor);
 661       break;
 662     default:
 663       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 664       break;
 665     }
 666 }
 667
 668 static void
 669 gdk_x11_device_manager_xi2_event_translator_init (GdkEventTranslatorIface *iface)
 670 {
 671   iface->translate_event = gdk_x11_device_manager_xi2_translate_event;
 672   iface->get_handled_events = gdk_x11_device_manager_xi2_get_handled_events;
 673   iface->select_window_events = gdk_x11_device_manager_xi2_select_window_events;
 674   iface->get_window = gdk_x11_device_manager_xi2_get_window;
 675 }
 676
 677 static void
 678 handle_hierarchy_changed (GdkX11DeviceManagerXI2 *device_manager,
 679                           XIHierarchyEvent       *ev)
 680 {
 681   GdkDisplay *display;
 682   Display *xdisplay;
 683   XIDeviceInfo *info;
 684   int ndevices;
 685   gint i;
 686
 687   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (device_manager));
 688   xdisplay = GDK_DISPLAY_XDISPLAY (display);
 689
 690   for (i = 0; i < ev->num_info; i++)
 691     {
 692       if (ev->info[i].flags & XIDeviceEnabled)
 693         {
 694           gdk_x11_display_error_trap_push (display);
 695           info = XIQueryDevice (xdisplay, ev->info[i].deviceid, &ndevices);
 696           gdk_x11_display_error_trap_pop_ignored (display);
 697           if (info)
 698             {
 699               add_device (device_manager, &info[0], TRUE);
 700               XIFreeDeviceInfo (info);
 701             }
 702         }
 703       else if (ev->info[i].flags & XIDeviceDisabled)
 704         remove_device (device_manager, ev->info[i].deviceid);
 705       else if (ev->info[i].flags & XISlaveAttached ||
 706                ev->info[i].flags & XISlaveDetached)
 707         {
 708           GdkDevice *master, *slave;
 709
 710           slave = g_hash_table_lookup (device_manager->id_table,
 711                                        GINT_TO_POINTER (ev->info[i].deviceid));
 712
 713           if (!slave)
 714             continue;
 715
 716           /* Remove old master info */
 717           master = gdk_device_get_associated_device (slave);
 718
 719           if (master)
 720             {
 721               _gdk_device_remove_slave (master, slave);
 722               _gdk_device_set_associated_device (slave, NULL);
 723
 724               g_signal_emit_by_name (device_manager, "device-changed", master);
 725             }
 726
 727           /* Add new master if it's an attachment event */
 728           if (ev->info[i].flags & XISlaveAttached)
 729             {
 730               gdk_x11_display_error_trap_push (display);
 731               info = XIQueryDevice (xdisplay, ev->info[i].deviceid, &ndevices);
 732               gdk_x11_display_error_trap_pop_ignored (display);
 733               if (info)
 734                 {
 735                   master = g_hash_table_lookup (device_manager->id_table,
 736                                                 GINT_TO_POINTER (info->attachment));
 737                   XIFreeDeviceInfo (info);
 738                 }
 739
 740               if (master)
 741                 {
 742                   _gdk_device_set_associated_device (slave, master);
 743                   _gdk_device_add_slave (master, slave);
 744
 745                   g_signal_emit_by_name (device_manager, "device-changed", master);
 746                 }
 747             }
 748
 749           g_signal_emit_by_name (device_manager, "device-changed", slave);
 750         }
 751     }
 752 }
 753
 754 static void
 755 handle_device_changed (GdkX11DeviceManagerXI2 *device_manager,
 756                        XIDeviceChangedEvent   *ev)
 757 {
 758   GdkDisplay *display;
 759   GdkDevice *device, *source_device;
 760
 761   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (device_manager));
 762   device = g_hash_table_lookup (device_manager->id_table,
 763                                 GUINT_TO_POINTER (ev->deviceid));
 764   source_device = g_hash_table_lookup (device_manager->id_table,
 765                                        GUINT_TO_POINTER (ev->sourceid));
 766
 767   if (device)
 768     {
 769       _gdk_device_reset_axes (device);
 770       translate_device_classes (display, device, ev->classes, ev->num_classes);
 771
 772       g_signal_emit_by_name (G_OBJECT (device), "changed");
 773     }
 774
 775   if (source_device)
 776     _gdk_device_xi2_reset_scroll_valuators (GDK_X11_DEVICE_XI2 (source_device));
 777 }
 778
 779 static GdkCrossingMode
 780 translate_crossing_mode (gint mode)
 781 {
 782   switch (mode)
 783     {
 784     case NotifyNormal:
 785       return GDK_CROSSING_NORMAL;
 786     case NotifyGrab:
 787       return GDK_CROSSING_GRAB;
 788     case NotifyUngrab:
 789       return GDK_CROSSING_UNGRAB;
 790     default:
 791       g_assert_not_reached ();
 792     }
 793 }
 794
 795 static GdkNotifyType
 796 translate_notify_type (gint detail)
 797 {
 798   switch (detail)
 799     {
 800     case NotifyInferior:
 801       return GDK_NOTIFY_INFERIOR;
 802     case NotifyAncestor:
 803       return GDK_NOTIFY_ANCESTOR;
 804     case NotifyVirtual:
 805       return GDK_NOTIFY_VIRTUAL;
 806     case NotifyNonlinear:
 807       return GDK_NOTIFY_NONLINEAR;
 808     case NotifyNonlinearVirtual:
 809       return GDK_NOTIFY_NONLINEAR_VIRTUAL;
 810     default:
 811       g_assert_not_reached ();
 812     }
 813 }
 814
 815 static gboolean
 816 set_screen_from_root (GdkDisplay *display,
 817                       GdkEvent   *event,
 818                       Window      xrootwin)
 819 {
 820   GdkScreen *screen;
 821
 822   screen = _gdk_x11_display_screen_for_xrootwin (display, xrootwin);
 823
 824   if (screen)
 825     {
 826       gdk_event_set_screen (event, screen);
 827
 828       return TRUE;
 829     }
 830
 831   return FALSE;
 832 }
 833
 834 static void
 835 set_user_time (GdkEvent *event)
 836 {
 837   GdkWindow *window;
 838   guint32 time;
 839
 840   window = gdk_window_get_toplevel (event->any.window);
 841   g_return_if_fail (GDK_IS_WINDOW (window));
 842
 843   time = gdk_event_get_time (event);
 844
 845   /* If an event doesn't have a valid timestamp, we shouldn't use it
 846    * to update the latest user interaction time.
 847    */
 848   if (time != GDK_CURRENT_TIME)
 849     gdk_x11_window_set_user_time (window, time);
 850 }
 851
 852 static gdouble *
 853 translate_axes (GdkDevice       *device,
 854                 gdouble          x,
 855                 gdouble          y,
 856                 GdkWindow       *window,
 857                 XIValuatorState *valuators)
 858 {
 859   guint n_axes, i;
 860   gdouble *axes;
 861   gdouble *vals;
 862
 863   g_object_get (device, "n-axes", &n_axes, NULL);
 864
 865   axes = g_new0 (gdouble, n_axes);
 866   vals = valuators->values;
 867
 868   for (i = 0; i < valuators->mask_len * 8; i++)
 869     {
 870       GdkAxisUse use;
 871       gdouble val;
 872
 873       if (!XIMaskIsSet (valuators->mask, i))
 874         continue;
 875
 876       use = gdk_device_get_axis_use (device, i);
 877       val = *vals++;
 878
 879       switch (use)
 880         {
 881         case GDK_AXIS_X:
 882         case GDK_AXIS_Y:
 883           if (gdk_device_get_mode (device) == GDK_MODE_WINDOW)
 884             _gdk_device_translate_window_coord (device, window, i, val, &axes[i]);
 885           else
 886             {
 887               if (use == GDK_AXIS_X)
 888                 axes[i] = x;
 889               else
 890                 axes[i] = y;
 891             }
 892           break;
 893         default:
 894           _gdk_device_translate_axis (device, i, val, &axes[i]);
 895           break;
 896         }
 897     }
 898
 899   return axes;
 900 }
 901
 902 static gboolean
 903 is_parent_of (GdkWindow *parent,
 904               GdkWindow *child)
 905 {
 906   GdkWindow *w;
 907
 908   w = child;
 909   while (w != NULL)
 910     {
 911       if (w == parent)
 912         return TRUE;
 913
 914       w = gdk_window_get_parent (w);
 915     }
 916
 917   return FALSE;
 918 }
 919
 920 static GdkWindow *
 921 get_event_window (GdkEventTranslator *translator,
 922                   XIEvent            *ev)
 923 {
 924   GdkDisplay *display;
 925   GdkWindow *window = NULL;
 926
 927   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (translator));
 928
 929   switch (ev->evtype)
 930     {
 931     case XI_KeyPress:
 932     case XI_KeyRelease:
 933     case XI_ButtonPress:
 934     case XI_ButtonRelease:
 935     case XI_Motion:
 936 #ifdef XINPUT_2_2
 937     case XI_TouchUpdate:
 938     case XI_TouchBegin:
 939     case XI_TouchEnd:
 940 #endif /* XINPUT_2_2 */
 941       {
 942         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
 943
 944         window = gdk_x11_window_lookup_for_display (display, xev->event);
 945
 946         /* Apply keyboard grabs to non-native windows */
 947         if (ev->evtype == XI_KeyPress || ev->evtype == XI_KeyRelease)
 948           {
 949             GdkDeviceGrabInfo *info;
 950             GdkDevice *device;
 951             gulong serial;
 952
 953             device = g_hash_table_lookup (GDK_X11_DEVICE_MANAGER_XI2 (translator)->id_table,
 954                                           GUINT_TO_POINTER (((XIDeviceEvent *) ev)->deviceid));
 955
 956             serial = _gdk_display_get_next_serial (display);
 957             info = _gdk_display_has_device_grab (display, device, serial);
 958
 959             if (info &&
 960                 (!is_parent_of (info->window, window) ||
 961                  !info->owner_events))
 962               {
 963                 /* Report key event against grab window */
 964                 window = info->window;
 965               }
 966           }
 967       }
 968       break;
 969     case XI_Enter:
 970     case XI_Leave:
 971     case XI_FocusIn:
 972     case XI_FocusOut:
 973       {
 974         XIEnterEvent *xev = (XIEnterEvent *) ev;
 975
 976         window = gdk_x11_window_lookup_for_display (display, xev->event);
 977       }
 978       break;
 979     }
 980
 981   return window;
 982 }
 983
 984 static gboolean
 985 gdk_x11_device_manager_xi2_translate_core_event (GdkEventTranslator *translator,
 986                                                  GdkDisplay         *display,
 987                                                  GdkEvent           *event,
 988                                                  XEvent             *xevent)
 989 {
 990   GdkEventTranslatorIface *parent_iface;
 991   gboolean keyboard = FALSE;
 992   GdkDevice *device;
 993
 994   if ((xevent->type == KeyPress || xevent->type == KeyRelease) &&
 995       (xevent->xkey.keycode == 0 || xevent->xkey.serial == 0))
 996     {
 997       /* The X input methods (when triggered via XFilterEvent)
 998        * generate a core key press event with keycode 0 to signal the
 999        * end of a key sequence. We use the core translate_event
1000        * implementation to translate this event.
1001        *
1002        * Other less educated IM modules like to filter every keypress,
1003        * only to have these replaced by their own homegrown events,
1004        * these events oddly have serial=0, so we try to catch these.
1005        *
1006        * This is just a bandaid fix to keep xim working with a single
1007        * keyboard until XFilterEvent learns about XI2.
1008        */
1009       keyboard = TRUE;
1010     }
1011   else if (xevent->xany.send_event)
1012     {
1013       /* If another process sends us core events, process them; we
1014        * assume that it won't send us redundant core and XI2 events.
1015        * (At the moment, it's not possible to send XI2 events anyway.
1016        * In the future, an app that was trying to decide whether to
1017        * send core or XI2 events could look at the event mask on the
1018        * window to see which kind we are listening to.)
1019        */
1020       switch (xevent->type)
1021         {
1022         case KeyPress:
1023         case KeyRelease:
1024         case FocusIn:
1025         case FocusOut:
1026           keyboard = TRUE;
1027           break;
1028
1029         case ButtonPress:
1030         case ButtonRelease:
1031         case MotionNotify:
1032         case EnterNotify:
1033         case LeaveNotify:
1034           break;
1035
1036         default:
1037           return FALSE;
1038         }
1039     }
1040   else
1041     return FALSE;
1042
1043   parent_iface = g_type_interface_peek_parent (GDK_EVENT_TRANSLATOR_GET_IFACE (translator));
1044   if (!parent_iface->translate_event (translator, display, event, xevent))
1045     return FALSE;
1046
1047   /* The core device manager sets a core device on the event.
1048    * We need to override that with an XI2 device, since we are
1049    * using XI2.
1050    */
1051   device = gdk_x11_device_manager_xi2_get_client_pointer ((GdkDeviceManager *)translator);
1052   if (keyboard)
1053     device = gdk_device_get_associated_device (device);
1054   gdk_event_set_device (event, device);
1055
1056   return TRUE;
1057 }
1058
1059 static gboolean
1060 scroll_valuators_changed (GdkX11DeviceXI2 *device,
1061                           XIValuatorState *valuators,
1062                           gdouble         *dx,
1063                           gdouble         *dy)
1064 {
1065   gboolean has_scroll_valuators = FALSE;
1066   GdkScrollDirection direction;
1067   guint n_axes, i, n_val;
1068   gdouble *vals;
1069
1070   n_axes = gdk_device_get_n_axes (GDK_DEVICE (device));
1071   vals = valuators->values;
1072   *dx = *dy = 0;
1073   n_val = 0;
1074
1075   for (i = 0; i < MIN (valuators->mask_len * 8, n_axes); i++)
1076     {
1077       gdouble delta;
1078
1079       if (!XIMaskIsSet (valuators->mask, i))
1080         continue;
1081
1082       if (_gdk_x11_device_xi2_get_scroll_delta (device, i, vals[n_val],
1083                                                 &direction, &delta))
1084         {
1085           has_scroll_valuators = TRUE;
1086
1087           if (direction == GDK_SCROLL_UP ||
1088               direction == GDK_SCROLL_DOWN)
1089             *dy = delta;
1090           else
1091             *dx = delta;
1092         }
1093
1094       n_val++;
1095     }
1096
1097   return has_scroll_valuators;
1098 }
1099
1100 static gboolean
1101 gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
1102                                             GdkDisplay         *display,
1103                                             GdkEvent           *event,
1104                                             XEvent             *xevent)
1105 {
1106   GdkX11DeviceManagerXI2 *device_manager;
1107   XGenericEventCookie *cookie;
1108   gboolean return_val = TRUE;
1109   GdkWindow *window;
1110   XIEvent *ev;
1111
1112   device_manager = (GdkX11DeviceManagerXI2 *) translator;
1113   cookie = &xevent->xcookie;
1114
1115   if (xevent->type != GenericEvent)
1116     return gdk_x11_device_manager_xi2_translate_core_event (translator, display, event, xevent);
1117   else if (cookie->extension != device_manager->opcode)
1118     return FALSE;
1119
1120   ev = (XIEvent *) cookie->data;
1121
1122   if (!ev)
1123     return FALSE;
1124
1125   window = get_event_window (translator, ev);
1126
1127   if (window && GDK_WINDOW_DESTROYED (window))
1128     return FALSE;
1129
1130   if (ev->evtype == XI_Motion ||
1131       ev->evtype == XI_ButtonRelease)
1132     {
1133       if (_gdk_x11_moveresize_handle_event (xevent))
1134         return FALSE;
1135     }
1136
1137   switch (ev->evtype)
1138     {
1139     case XI_HierarchyChanged:
1140       handle_hierarchy_changed (device_manager,
1141                                 (XIHierarchyEvent *) ev);
1142       return_val = FALSE;
1143       break;
1144     case XI_DeviceChanged:
1145       handle_device_changed (device_manager,
1146                              (XIDeviceChangedEvent *) ev);
1147       return_val = FALSE;
1148       break;
1149     case XI_KeyPress:
1150     case XI_KeyRelease:
1151       {
1152         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
1153         GdkKeymap *keymap = gdk_keymap_get_for_display (display);
1154         GdkModifierType consumed, state;
1155         GdkDevice *device, *source_device;
1156
1157         event->key.type = xev->evtype == XI_KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
1158
1159         event->key.window = window;
1160
1161         event->key.time = xev->time;
1162         event->key.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1163         event->key.group = xev->group.effective;
1164
1165         event->key.hardware_keycode = xev->detail;
1166         event->key.is_modifier = gdk_x11_keymap_key_is_modifier (keymap, event->key.hardware_keycode);
1167
1168         device = g_hash_table_lookup (device_manager->id_table,
1169                                       GUINT_TO_POINTER (xev->deviceid));
1170         gdk_event_set_device (event, device);
1171
1172         source_device = g_hash_table_lookup (device_manager->id_table,
1173                                              GUINT_TO_POINTER (xev->sourceid));
1174         gdk_event_set_source_device (event, source_device);
1175
1176         event->key.keyval = GDK_KEY_VoidSymbol;
1177
1178         gdk_keymap_translate_keyboard_state (keymap,
1179                                              event->key.hardware_keycode,
1180                                              event->key.state,
1181                                              event->key.group,
1182                                              &event->key.keyval,
1183                                              NULL, NULL, &consumed);
1184
1185         state = event->key.state & ~consumed;
1186         _gdk_x11_keymap_add_virt_mods (keymap, &state);
1187         event->key.state |= state;
1188
1189         _gdk_x11_event_translate_keyboard_string (&event->key);
1190
1191         if (ev->evtype == XI_KeyPress)
1192           set_user_time (event);
1193
1194         /* FIXME: emulate autorepeat on key
1195          * release? XI2 seems attached to Xkb.
1196          */
1197       }
1198
1199       break;
1200     case XI_ButtonPress:
1201     case XI_ButtonRelease:
1202       {
1203         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
1204         GdkDevice *source_device;
1205
1206         if (ev->evtype == XI_ButtonRelease &&
1207             (xev->detail >= 4 && xev->detail <= 7))
1208           return FALSE;
1209         else if (ev->evtype == XI_ButtonPress &&
1210                  (xev->detail >= 4 && xev->detail <= 7))
1211           {
1212             /* Button presses of button 4-7 are scroll events */
1213             event->scroll.type = GDK_SCROLL;
1214
1215             if (xev->detail == 4)
1216               event->scroll.direction = GDK_SCROLL_UP;
1217             else if (xev->detail == 5)
1218               event->scroll.direction = GDK_SCROLL_DOWN;
1219             else if (xev->detail == 6)
1220               event->scroll.direction = GDK_SCROLL_LEFT;
1221             else
1222               event->scroll.direction = GDK_SCROLL_RIGHT;
1223
1224             event->scroll.window = window;
1225             event->scroll.time = xev->time;
1226             event->scroll.x = (gdouble) xev->event_x;
1227             event->scroll.y = (gdouble) xev->event_y;
1228             event->scroll.x_root = (gdouble) xev->root_x;
1229             event->scroll.y_root = (gdouble) xev->root_y;
1230             event->scroll.delta_x = 0;
1231             event->scroll.delta_y = 0;
1232
1233             event->scroll.device = g_hash_table_lookup (device_manager->id_table,
1234                                                         GUINT_TO_POINTER (xev->deviceid));
1235
1236             source_device = g_hash_table_lookup (device_manager->id_table,
1237                                                  GUINT_TO_POINTER (xev->sourceid));
1238             gdk_event_set_source_device (event, source_device);
1239
1240             event->scroll.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1241
1242 #ifdef XINPUT_2_2
1243             if (xev->flags & XIPointerEmulated)
1244               _gdk_event_set_pointer_emulated (event, TRUE);
1245 #endif
1246           }
1247         else
1248           {
1249             event->button.type = (ev->evtype == XI_ButtonPress) ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE;
1250
1251             event->button.window = window;
1252             event->button.time = xev->time;
1253             event->button.x = (gdouble) xev->event_x;
1254             event->button.y = (gdouble) xev->event_y;
1255             event->button.x_root = (gdouble) xev->root_x;
1256             event->button.y_root = (gdouble) xev->root_y;
1257
1258             event->button.device = g_hash_table_lookup (device_manager->id_table,
1259                                                         GUINT_TO_POINTER (xev->deviceid));
1260
1261             source_device = g_hash_table_lookup (device_manager->id_table,
1262                                                  GUINT_TO_POINTER (xev->sourceid));
1263             gdk_event_set_source_device (event, source_device);
1264
1265             event->button.axes = translate_axes (event->button.device,
1266                                                  event->button.x,
1267                                                  event->button.y,
1268                                                  event->button.window,
1269                                                  &xev->valuators);
1270
1271             if (gdk_device_get_mode (event->button.device) == GDK_MODE_WINDOW)
1272               {
1273                 GdkDevice *device = event->button.device;
1274
1275                 /* Update event coordinates from axes */
1276                 gdk_device_get_axis (device, event->button.axes, GDK_AXIS_X, &event->button.x);
1277                 gdk_device_get_axis (device, event->button.axes, GDK_AXIS_Y, &event->button.y);
1278               }
1279
1280             event->button.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1281
1282             event->button.button = xev->detail;
1283           }
1284
1285 #ifdef XINPUT_2_2
1286         if (xev->flags & XIPointerEmulated)
1287           _gdk_event_set_pointer_emulated (event, TRUE);
1288 #endif
1289
1290         if (return_val == FALSE)
1291           break;
1292
1293         if (!set_screen_from_root (display, event, xev->root))
1294           {
1295             return_val = FALSE;
1296             break;
1297           }
1298
1299         if (ev->evtype == XI_ButtonPress)
1300           set_user_time (event);
1301
1302         break;
1303       }
1304
1305     case XI_Motion:
1306       {
1307         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
1308         GdkDevice *source_device, *device;
1309         gdouble delta_x, delta_y;
1310
1311         source_device = g_hash_table_lookup (device_manager->id_table,
1312                                              GUINT_TO_POINTER (xev->sourceid));
1313         device = g_hash_table_lookup (device_manager->id_table,
1314                                       GUINT_TO_POINTER (xev->deviceid));
1315
1316         /* When scrolling, X might send events twice here; once with both the
1317          * device and the source device set to the physical device, and once
1318          * with the device set to the master device.
1319          * Since we are only interested in the latter, and
1320          * scroll_valuators_changed() updates the valuator cache for the
1321          * source device, we need to explicitly ignore the first event in
1322          * order to get the correct delta for the second.
1323          */
1324         if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_SLAVE &&
1325             scroll_valuators_changed (GDK_X11_DEVICE_XI2 (source_device),
1326                                       &xev->valuators, &delta_x, &delta_y))
1327           {
1328             event->scroll.type = GDK_SCROLL;
1329             event->scroll.direction = GDK_SCROLL_SMOOTH;
1330
1331             GDK_NOTE(EVENTS,
1332                      g_message ("smooth scroll: %s\n\tdevice: %u\n\tsource device: %u\n\twindow %ld\n\tdeltas: %f %f",
1333 #ifdef XINPUT_2_2
1334                                 (xev->flags & XIPointerEmulated) ? "emulated" : "",
1335 #else
1336                                  "",
1337 #endif
1338                                 xev->deviceid, xev->sourceid,
1339                                 xev->event, delta_x, delta_y));
1340
1341
1342             event->scroll.window = window;
1343             event->scroll.time = xev->time;
1344             event->scroll.x = (gdouble) xev->event_x;
1345             event->scroll.y = (gdouble) xev->event_y;
1346             event->scroll.x_root = (gdouble) xev->root_x;
1347             event->scroll.y_root = (gdouble) xev->root_y;
1348             event->scroll.delta_x = delta_x;
1349             event->scroll.delta_y = delta_y;
1350
1351             event->scroll.device = device;
1352             gdk_event_set_source_device (event, source_device);
1353
1354             event->scroll.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1355             break;
1356           }
1357
1358         event->motion.type = GDK_MOTION_NOTIFY;
1359         event->motion.window = window;
1360         event->motion.time = xev->time;
1361         event->motion.x = (gdouble) xev->event_x;
1362         event->motion.y = (gdouble) xev->event_y;
1363         event->motion.x_root = (gdouble) xev->root_x;
1364         event->motion.y_root = (gdouble) xev->root_y;
1365
1366         event->motion.device = device;
1367         gdk_event_set_source_device (event, source_device);
1368
1369         event->motion.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1370
1371 #ifdef XINPUT_2_2
1372         if (xev->flags & XIPointerEmulated)
1373           _gdk_event_set_pointer_emulated (event, TRUE);
1374 #endif
1375
1376         /* There doesn't seem to be motion hints in XI */
1377         event->motion.is_hint = FALSE;
1378
1379         event->motion.axes = translate_axes (event->motion.device,
1380                                              event->motion.x,
1381                                              event->motion.y,
1382                                              event->motion.window,
1383                                              &xev->valuators);
1384
1385         if (gdk_device_get_mode (event->motion.device) == GDK_MODE_WINDOW)
1386           {
1387             GdkDevice *device = event->motion.device;
1388
1389             /* Update event coordinates from axes */
1390             gdk_device_get_axis (device, event->motion.axes, GDK_AXIS_X, &event->motion.x);
1391             gdk_device_get_axis (device, event->motion.axes, GDK_AXIS_Y, &event->motion.y);
1392           }
1393       }
1394       break;
1395
1396 #ifdef XINPUT_2_2
1397     case XI_TouchBegin:
1398     case XI_TouchEnd:
1399       {
1400         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
1401         GdkDevice *source_device;
1402
1403         GDK_NOTE(EVENTS,
1404                  g_message ("touch %s:\twindow %ld\n\ttouch id: %u\n\tpointer emulating: %d",
1405                             ev->evtype == XI_TouchBegin ? "begin" : "end",
1406                             xev->event,
1407                             xev->detail,
1408                             xev->flags & XITouchEmulatingPointer));
1409
1410         if (ev->evtype == XI_TouchBegin)
1411           event->touch.type = GDK_TOUCH_BEGIN;
1412         else if (ev->evtype == XI_TouchEnd)
1413           event->touch.type = GDK_TOUCH_END;
1414
1415         event->touch.window = window;
1416         event->touch.time = xev->time;
1417         event->touch.x = (gdouble) xev->event_x;
1418         event->touch.y = (gdouble) xev->event_y;
1419         event->touch.x_root = (gdouble) xev->root_x;
1420         event->touch.y_root = (gdouble) xev->root_y;
1421
1422         event->touch.device = g_hash_table_lookup (device_manager->id_table,
1423                                                    GUINT_TO_POINTER (xev->deviceid));
1424
1425         source_device = g_hash_table_lookup (device_manager->id_table,
1426                                              GUINT_TO_POINTER (xev->sourceid));
1427         gdk_event_set_source_device (event, source_device);
1428
1429         event->touch.axes = translate_axes (event->touch.device,
1430                                             event->touch.x,
1431                                             event->touch.y,
1432                                             event->touch.window,
1433                                             &xev->valuators);
1434
1435         if (gdk_device_get_mode (event->touch.device) == GDK_MODE_WINDOW)
1436           {
1437             GdkDevice *device = event->touch.device;
1438
1439             /* Update event coordinates from axes */
1440             gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_X, &event->touch.x);
1441             gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_Y, &event->touch.y);
1442           }
1443
1444         event->touch.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1445
1446         if (ev->evtype == XI_TouchBegin)
1447           event->touch.state |= GDK_BUTTON1_MASK;
1448
1449         event->touch.sequence = GUINT_TO_POINTER (xev->detail);
1450
1451         if (xev->flags & XITouchEmulatingPointer)
1452           {
1453             event->touch.emulating_pointer = TRUE;
1454             _gdk_event_set_pointer_emulated (event, TRUE);
1455           }
1456
1457         if (return_val == FALSE)
1458           break;
1459
1460         if (!set_screen_from_root (display, event, xev->root))
1461           {
1462             return_val = FALSE;
1463             break;
1464           }
1465
1466         if (ev->evtype == XI_TouchBegin)
1467           set_user_time (event);
1468       }
1469       break;
1470
1471     case XI_TouchUpdate:
1472       {
1473         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
1474         GdkDevice *source_device;
1475
1476         GDK_NOTE(EVENTS,
1477                  g_message ("touch update:\twindow %ld\n\ttouch id: %u\n\tpointer emulating: %d",
1478                             xev->event,
1479                             xev->detail,
1480                             xev->flags & XITouchEmulatingPointer));
1481
1482         event->touch.window = window;
1483         event->touch.sequence = GUINT_TO_POINTER (xev->detail);
1484         event->touch.type = GDK_TOUCH_UPDATE;
1485         event->touch.time = xev->time;
1486         event->touch.x = (gdouble) xev->event_x;
1487         event->touch.y = (gdouble) xev->event_y;
1488         event->touch.x_root = (gdouble) xev->root_x;
1489         event->touch.y_root = (gdouble) xev->root_y;
1490
1491         event->touch.device = g_hash_table_lookup (device_manager->id_table,
1492                                                    GINT_TO_POINTER (xev->deviceid));
1493
1494         source_device = g_hash_table_lookup (device_manager->id_table,
1495                                              GUINT_TO_POINTER (xev->sourceid));
1496         gdk_event_set_source_device (event, source_device);
1497
1498         event->touch.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1499
1500         event->touch.state |= GDK_BUTTON1_MASK;
1501
1502         if (xev->flags & XITouchEmulatingPointer)
1503           {
1504             event->touch.emulating_pointer = TRUE;
1505             _gdk_event_set_pointer_emulated (event, TRUE);
1506           }
1507
1508         event->touch.axes = translate_axes (event->touch.device,
1509                                             event->touch.x,
1510                                             event->touch.y,
1511                                             event->touch.window,
1512                                             &xev->valuators);
1513
1514         if (gdk_device_get_mode (event->touch.device) == GDK_MODE_WINDOW)
1515           {
1516             GdkDevice *device = event->touch.device;
1517
1518             /* Update event coordinates from axes */
1519             gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_X, &event->touch.x);
1520             gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_Y, &event->touch.y);
1521           }
1522       }
1523       break;
1524 #endif  /* XINPUT_2_2 */
1525
1526     case XI_Enter:
1527     case XI_Leave:
1528       {
1529         XIEnterEvent *xev = (XIEnterEvent *) ev;
1530         GdkDevice *device, *source_device;
1531
1532         event->crossing.type = (ev->evtype == XI_Enter) ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
1533
1534         event->crossing.x = (gdouble) xev->event_x;
1535         event->crossing.y = (gdouble) xev->event_y;
1536         event->crossing.x_root = (gdouble) xev->root_x;
1537         event->crossing.y_root = (gdouble) xev->root_y;
1538         event->crossing.time = xev->time;
1539         event->crossing.focus = xev->focus;
1540
1541         event->crossing.window = window;
1542         event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xev->child);
1543
1544         device = g_hash_table_lookup (device_manager->id_table,
1545                                       GINT_TO_POINTER (xev->deviceid));
1546         gdk_event_set_device (event, device);
1547
1548         source_device = g_hash_table_lookup (device_manager->id_table,
1549                                              GUINT_TO_POINTER (xev->sourceid));
1550         gdk_event_set_source_device (event, source_device);
1551         _gdk_device_xi2_reset_scroll_valuators (GDK_X11_DEVICE_XI2 (source_device));
1552
1553         event->crossing.mode = translate_crossing_mode (xev->mode);
1554         event->crossing.detail = translate_notify_type (xev->detail);
1555         event->crossing.state = _gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
1556       }
1557       break;
1558     case XI_FocusIn:
1559     case XI_FocusOut:
1560       {
1561         XIEnterEvent *xev = (XIEnterEvent *) ev;
1562         GdkDevice *device, *source_device;
1563
1564         device = g_hash_table_lookup (device_manager->id_table,
1565                                       GINT_TO_POINTER (xev->deviceid));
1566
1567         source_device = g_hash_table_lookup (device_manager->id_table,
1568                                              GUINT_TO_POINTER (xev->sourceid));
1569
1570         _gdk_device_manager_core_handle_focus (window,
1571                                                xev->event,
1572                                                device,
1573                                                source_device,
1574                                                (ev->evtype == XI_FocusIn) ? TRUE : FALSE,
1575                                                xev->detail,
1576                                                xev->mode);
1577
1578         return_val = FALSE;
1579       }
1580       break;
1581     default:
1582       return_val = FALSE;
1583       break;
1584     }
1585
1586   event->any.send_event = cookie->send_event;
1587
1588   if (return_val)
1589     {
1590       if (event->any.window)
1591         g_object_ref (event->any.window);
1592
1593       if (((event->any.type == GDK_ENTER_NOTIFY) ||
1594            (event->any.type == GDK_LEAVE_NOTIFY)) &&
1595           (event->crossing.subwindow != NULL))
1596         g_object_ref (event->crossing.subwindow);
1597     }
1598   else
1599     {
1600       /* Mark this event as having no resources to be freed */
1601       event->any.window = NULL;
1602       event->any.type = GDK_NOTHING;
1603     }
1604
1605   return return_val;
1606 }
1607
1608 static GdkEventMask
1609 gdk_x11_device_manager_xi2_get_handled_events (GdkEventTranslator *translator)
1610 {
1611   return (GDK_KEY_PRESS_MASK |
1612           GDK_KEY_RELEASE_MASK |
1613           GDK_BUTTON_PRESS_MASK |
1614           GDK_BUTTON_RELEASE_MASK |
1615           GDK_SCROLL_MASK |
1616           GDK_ENTER_NOTIFY_MASK |
1617           GDK_LEAVE_NOTIFY_MASK |
1618           GDK_POINTER_MOTION_MASK |
1619           GDK_POINTER_MOTION_HINT_MASK |
1620           GDK_BUTTON1_MOTION_MASK |
1621           GDK_BUTTON2_MOTION_MASK |
1622           GDK_BUTTON3_MOTION_MASK |
1623           GDK_BUTTON_MOTION_MASK |
1624           GDK_FOCUS_CHANGE_MASK |
1625           GDK_TOUCH_MASK);
1626 }
1627
1628 static void
1629 gdk_x11_device_manager_xi2_select_window_events (GdkEventTranslator *translator,
1630                                                  Window              window,
1631                                                  GdkEventMask        evmask)
1632 {
1633   GdkDeviceManager *device_manager;
1634   XIEventMask event_mask;
1635
1636   device_manager = GDK_DEVICE_MANAGER (translator);
1637
1638   event_mask.deviceid = XIAllMasterDevices;
1639   event_mask.mask = _gdk_x11_device_xi2_translate_event_mask (GDK_X11_DEVICE_MANAGER_XI2 (device_manager),
1640                                                               evmask,
1641                                                               &event_mask.mask_len);
1642
1643   _gdk_x11_device_manager_xi2_select_events (device_manager, window, &event_mask);
1644   g_free (event_mask.mask);
1645 }
1646
1647 static GdkWindow *
1648 gdk_x11_device_manager_xi2_get_window (GdkEventTranslator *translator,
1649                                        XEvent             *xevent)
1650 {
1651   GdkX11DeviceManagerXI2 *device_manager;
1652   XIEvent *ev;
1653
1654   device_manager = (GdkX11DeviceManagerXI2 *) translator;
1655
1656   if (xevent->type != GenericEvent ||
1657       xevent->xcookie.extension != device_manager->opcode)
1658     return NULL;
1659
1660   ev = (XIEvent *) xevent->xcookie.data;
1661
1662   return get_event_window (translator, ev);
1663 }
1664
1665 GdkDevice *
1666 _gdk_x11_device_manager_xi2_lookup (GdkX11DeviceManagerXI2 *device_manager_xi2,
1667                                     gint                    device_id)
1668 {
1669   return g_hash_table_lookup (device_manager_xi2->id_table,
1670                               GINT_TO_POINTER (device_id));
1671 }