Pileus Git - ~andy/gtk/blob - gdk/wayland/gdkdevice-wayland.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 #define _GNU_SOURCE
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <errno.h>
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26 #include <gdk/gdkwindow.h>
  27 #include <gdk/gdktypes.h>
  28 #include "gdkprivate-wayland.h"
  29 #include "gdkwayland.h"
  30 #include "gdkkeysyms.h"
  31 #include "gdkdeviceprivate.h"
  32 #include "gdkdevicemanagerprivate.h"
  33 #include "gdkprivate-wayland.h"
  34
  35 #include <xkbcommon/xkbcommon.h>
  36 #include <X11/keysym.h>
  37
  38 #include <sys/time.h>
  39
  40 #define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
  41 #define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
  42 #define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  43 #define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
  44 #define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
  45 #define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  46
  47 typedef struct _GdkDeviceCore GdkDeviceCore;
  48 typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
  49 typedef struct _GdkWaylandDevice GdkWaylandDevice;
  50
  51 typedef struct _DataOffer DataOffer;
  52
  53 typedef struct _GdkWaylandSelectionOffer GdkWaylandSelectionOffer;
  54
  55 struct _GdkWaylandDevice
  56 {
  57   struct wl_seat *wl_seat;
  58   struct wl_pointer *wl_pointer;
  59   struct wl_keyboard *wl_keyboard;
  60
  61   GdkDisplay *display;
  62   GdkDeviceManager *device_manager;
  63
  64   GdkDevice *pointer;
  65   GdkDevice *keyboard;
  66
  67   GdkModifierType modifiers;
  68   GdkWindow *pointer_focus;
  69   GdkWindow *keyboard_focus;
  70   struct wl_data_device *data_device;
  71   double surface_x, surface_y;
  72   uint32_t time;
  73   GdkWindow *pointer_grab_window;
  74   uint32_t pointer_grab_time;
  75   guint32 repeat_timer;
  76   guint32 repeat_key;
  77   guint32 repeat_count;
  78
  79   DataOffer *drag_offer;
  80   DataOffer *selection_offer;
  81
  82   GdkWaylandSelectionOffer *selection_offer_out;
  83
  84   struct wl_surface *pointer_surface;
  85 };
  86
  87 struct _GdkDeviceCore
  88 {
  89   GdkDevice parent_instance;
  90   GdkWaylandDevice *device;
  91 };
  92
  93 struct _GdkDeviceCoreClass
  94 {
  95   GdkDeviceClass parent_class;
  96 };
  97
  98 G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
  99
 100 #define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
 101 #define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
 102 #define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
 103 #define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
 104 #define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
 105 #define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
 106
 107 typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
 108 typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
 109
 110 struct _GdkDeviceManagerCore
 111 {
 112   GdkDeviceManager parent_object;
 113   GdkDevice *core_pointer;
 114   GdkDevice *core_keyboard;
 115   GList *devices;
 116 };
 117
 118 struct _GdkDeviceManagerCoreClass
 119 {
 120   GdkDeviceManagerClass parent_class;
 121 };
 122
 123 G_DEFINE_TYPE (GdkDeviceManagerCore,
 124                gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
 125
 126 static gboolean
 127 gdk_device_core_get_history (GdkDevice      *device,
 128                              GdkWindow      *window,
 129                              guint32         start,
 130                              guint32         stop,
 131                              GdkTimeCoord ***events,
 132                              gint           *n_events)
 133 {
 134   return FALSE;
 135 }
 136
 137 static void
 138 gdk_device_core_get_state (GdkDevice       *device,
 139                            GdkWindow       *window,
 140                            gdouble         *axes,
 141                            GdkModifierType *mask)
 142 {
 143   gint x_int, y_int;
 144
 145   gdk_window_get_device_position (window, device, &x_int, &y_int, mask);
 146
 147   if (axes)
 148     {
 149       axes[0] = x_int;
 150       axes[1] = y_int;
 151     }
 152 }
 153
 154 static void
 155 gdk_device_core_set_window_cursor (GdkDevice *device,
 156                                    GdkWindow *window,
 157                                    GdkCursor *cursor)
 158 {
 159   GdkWaylandDevice *wd = GDK_DEVICE_CORE(device)->device;
 160   struct wl_buffer *buffer;
 161   int x, y, w, h;
 162
 163   if (cursor)
 164     g_object_ref (cursor);
 165
 166   /* Setting the cursor to NULL means that we should use the default cursor */
 167   if (!cursor)
 168     {
 169       /* FIXME: Is this the best sensible default ? */
 170       cursor = _gdk_wayland_display_get_cursor_for_type (device->display,
 171                                                          GDK_LEFT_PTR);
 172     }
 173
 174   buffer = _gdk_wayland_cursor_get_buffer (cursor, &x, &y, &w, &h);
 175   wl_pointer_set_cursor (wd->wl_pointer, wd->time, wd->pointer_surface, x, y);
 176   wl_surface_attach (wd->pointer_surface, buffer, 0, 0);
 177   wl_surface_damage (wd->pointer_surface,  0, 0, w, h);
 178
 179   g_object_unref (cursor);
 180 }
 181
 182 static void
 183 gdk_device_core_warp (GdkDevice *device,
 184                       GdkScreen *screen,
 185                       gint       x,
 186                       gint       y)
 187 {
 188 }
 189
 190 static void
 191 gdk_device_core_query_state (GdkDevice        *device,
 192                              GdkWindow        *window,
 193                              GdkWindow       **root_window,
 194                              GdkWindow       **child_window,
 195                              gint             *root_x,
 196                              gint             *root_y,
 197                              gint             *win_x,
 198                              gint             *win_y,
 199                              GdkModifierType  *mask)
 200 {
 201   GdkWaylandDevice *wd;
 202   GdkScreen *default_screen;
 203
 204   wd = GDK_DEVICE_CORE(device)->device;
 205   default_screen = gdk_display_get_default_screen (wd->display);
 206
 207   if (root_window)
 208     *root_window = gdk_screen_get_root_window (default_screen);
 209   if (child_window)
 210     *child_window = wd->pointer_focus;
 211   /* Do something clever for relative here */
 212 #if 0
 213   if (root_x)
 214     *root_x = wd->x;
 215   if (root_y)
 216     *root_y = wd->y;
 217 #endif
 218   if (win_x)
 219     *win_x = wd->surface_x;
 220   if (win_y)
 221     *win_y = wd->surface_y;
 222   if (mask)
 223     *mask = wd->modifiers;
 224 }
 225
 226 static GdkGrabStatus
 227 gdk_device_core_grab (GdkDevice    *device,
 228                       GdkWindow    *window,
 229                       gboolean      owner_events,
 230                       GdkEventMask  event_mask,
 231                       GdkWindow    *confine_to,
 232                       GdkCursor    *cursor,
 233                       guint32       time_)
 234 {
 235   GdkWaylandDevice *wayland_device = GDK_DEVICE_CORE (device)->device;
 236
 237   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
 238     {
 239       /* Device is a keyboard */
 240       return GDK_GRAB_SUCCESS;
 241     }
 242   else
 243     {
 244       /* Device is a pointer */
 245
 246       if (wayland_device->pointer_grab_window != NULL &&
 247           time_ != 0 && wayland_device->pointer_grab_time > time_)
 248         {
 249           return GDK_GRAB_ALREADY_GRABBED;
 250         }
 251
 252       if (time_ == 0)
 253         time_ = wayland_device->time;
 254
 255       wayland_device->pointer_grab_window = window;
 256       wayland_device->pointer_grab_time = time_;
 257
 258       /* FIXME: This probably breaks if you end up with multiple grabs on the
 259        * same window - but we need to know the input device for when we are
 260        * asked to map a popup window so that the grab can be managed by the
 261        * compositor.
 262        */
 263       _gdk_wayland_window_set_device_grabbed (window,
 264                                               wayland_device->wl_seat,
 265                                               time_);
 266     }
 267
 268   return GDK_GRAB_SUCCESS;
 269 }
 270
 271 static void
 272 gdk_device_core_ungrab (GdkDevice *device,
 273                         guint32    time_)
 274 {
 275   GdkWaylandDevice *wayland_device = GDK_DEVICE_CORE (device)->device;
 276   GdkDisplay *display;
 277   GdkDeviceGrabInfo *grab;
 278
 279   display = gdk_device_get_display (device);
 280
 281   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
 282     {
 283       /* Device is a keyboard */
 284     }
 285   else
 286     {
 287       /* Device is a pointer */
 288       grab = _gdk_display_get_last_device_grab (display, device);
 289
 290       if (grab)
 291         grab->serial_end = grab->serial_start;
 292
 293       if (wayland_device->pointer_grab_window)
 294         _gdk_wayland_window_set_device_grabbed (wayland_device->pointer_grab_window,
 295                                                 NULL,
 296                                                 0);
 297     }
 298 }
 299
 300 static GdkWindow *
 301 gdk_device_core_window_at_position (GdkDevice       *device,
 302                                     gint            *win_x,
 303                                     gint            *win_y,
 304                                     GdkModifierType *mask,
 305                                     gboolean         get_toplevel)
 306 {
 307   GdkWaylandDevice *wd;
 308
 309   wd = GDK_DEVICE_CORE(device)->device;
 310   if (win_x)
 311     *win_x = wd->surface_x;
 312   if (win_y)
 313     *win_y = wd->surface_y;
 314   if (mask)
 315     *mask = wd->modifiers;
 316
 317   return wd->pointer_focus;
 318 }
 319
 320 static void
 321 gdk_device_core_select_window_events (GdkDevice    *device,
 322                                       GdkWindow    *window,
 323                                       GdkEventMask  event_mask)
 324 {
 325 }
 326
 327 static void
 328 gdk_device_core_class_init (GdkDeviceCoreClass *klass)
 329 {
 330   GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
 331
 332   device_class->get_history = gdk_device_core_get_history;
 333   device_class->get_state = gdk_device_core_get_state;
 334   device_class->set_window_cursor = gdk_device_core_set_window_cursor;
 335   device_class->warp = gdk_device_core_warp;
 336   device_class->query_state = gdk_device_core_query_state;
 337   device_class->grab = gdk_device_core_grab;
 338   device_class->ungrab = gdk_device_core_ungrab;
 339   device_class->window_at_position = gdk_device_core_window_at_position;
 340   device_class->select_window_events = gdk_device_core_select_window_events;
 341 }
 342
 343 static void
 344 gdk_device_core_init (GdkDeviceCore *device_core)
 345 {
 346   GdkDevice *device;
 347
 348   device = GDK_DEVICE (device_core);
 349
 350   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
 351   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
 352 }
 353
 354 struct wl_seat *
 355 _gdk_wayland_device_get_wl_seat (GdkDevice *device)
 356 {
 357   return GDK_DEVICE_CORE (device)->device->wl_seat;
 358 }
 359
 360 struct wl_pointer *
 361 _gdk_wayland_device_get_wl_pointer (GdkDevice *device)
 362 {
 363   return GDK_DEVICE_CORE (device)->device->wl_pointer;
 364 }
 365
 366
 367 struct wl_keyboard *
 368 _gdk_wayland_device_get_wl_keyboard (GdkDevice *device)
 369 {
 370   return GDK_DEVICE_CORE (device)->device->wl_keyboard;
 371 }
 372
 373 #if 0
 374 static void
 375 input_handle_motion(void *data, struct wl_input_device *input_device,
 376                     uint32_t time,
 377                     int32_t x, int32_t y, int32_t sx, int32_t sy)
 378 {
 379   GdkWaylandDevice *device = data;
 380   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
 381   GdkEvent *event;
 382
 383   event = gdk_event_new (GDK_NOTHING);
 384
 385   device->time = time;
 386   device->x = x;
 387   device->y = y;
 388   device->surface_x = sx;
 389   device->surface_y = sy;
 390
 391   event->motion.type = GDK_MOTION_NOTIFY;
 392   event->motion.window = g_object_ref (device->pointer_focus);
 393   gdk_event_set_device (event, device->pointer);
 394   event->motion.time = time;
 395   event->motion.x = (gdouble) sx;
 396   event->motion.y = (gdouble) sy;
 397   event->motion.x_root = (gdouble) x;
 398   event->motion.y_root = (gdouble) y;
 399   event->motion.axes = NULL;
 400   event->motion.state = device->modifiers;
 401   event->motion.is_hint = 0;
 402   gdk_event_set_screen (event, display->screen);
 403
 404   GDK_NOTE (EVENTS,
 405             g_message ("motion %d %d, state %d",
 406                        sx, sy, event->button.state));
 407
 408   _gdk_wayland_display_deliver_event (device->display, event);
 409 }
 410
 411 static void
 412 input_handle_button(void *data, struct wl_input_device *input_device,
 413                      uint32_t time, uint32_t button, uint32_t state)
 414 {
 415   GdkWaylandDevice *device = data;
 416   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
 417   GdkEvent *event;
 418   uint32_t modifier;
 419   int gdk_button;
 420
 421   switch (button) {
 422   case 273:
 423     gdk_button = 3;
 424     break;
 425   case 274:
 426     gdk_button = 2;
 427     break;
 428   default:
 429     gdk_button = button - 271;
 430     break;
 431   }
 432
 433   device->time = time;
 434   event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 435   event->button.window = g_object_ref (device->pointer_focus);
 436   gdk_event_set_device (event, device->pointer);
 437   event->button.time = time;
 438   event->button.x = (gdouble) device->surface_x;
 439   event->button.y = (gdouble) device->surface_y;
 440   event->button.x_root = (gdouble) device->x;
 441   event->button.y_root = (gdouble) device->y;
 442   event->button.axes = NULL;
 443   event->button.state = device->modifiers;
 444   event->button.button = gdk_button;
 445   gdk_event_set_screen (event, display->screen);
 446
 447   modifier = 1 << (8 + gdk_button - 1);
 448   if (state)
 449     device->modifiers |= modifier;
 450   else
 451     device->modifiers &= ~modifier;
 452
 453   GDK_NOTE (EVENTS,
 454             g_message ("button %d %s, state %d",
 455                        event->button.button,
 456                        state ? "press" : "release", event->button.state));
 457
 458   _gdk_wayland_display_deliver_event (device->display, event);
 459 }
 460
 461 static void
 462 translate_keyboard_string (GdkEventKey *event)
 463 {
 464   gunichar c = 0;
 465   gchar buf[7];
 466
 467   /* Fill in event->string crudely, since various programs
 468    * depend on it.
 469    */
 470   event->string = NULL;
 471
 472   if (event->keyval != GDK_KEY_VoidSymbol)
 473     c = gdk_keyval_to_unicode (event->keyval);
 474
 475   if (c)
 476     {
 477       gsize bytes_written;
 478       gint len;
 479
 480       /* Apply the control key - Taken from Xlib
 481        */
 482       if (event->state & GDK_CONTROL_MASK)
 483         {
 484           if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
 485           else if (c == '2')
 486             {
 487               event->string = g_memdup ("\0\0", 2);
 488               event->length = 1;
 489               buf[0] = '\0';
 490               return;
 491             }
 492           else if (c >= '3' && c <= '7') c -= ('3' - '\033');
 493           else if (c == '8') c = '\177';
 494           else if (c == '/') c = '_' & 0x1F;
 495         }
 496
 497       len = g_unichar_to_utf8 (c, buf);
 498       buf[len] = '\0';
 499
 500       event->string = g_locale_from_utf8 (buf, len,
 501                                           NULL, &bytes_written,
 502                                           NULL);
 503       if (event->string)
 504         event->length = bytes_written;
 505     }
 506   else if (event->keyval == GDK_KEY_Escape)
 507     {
 508       event->length = 1;
 509       event->string = g_strdup ("\033");
 510     }
 511   else if (event->keyval == GDK_KEY_Return ||
 512           event->keyval == GDK_KEY_KP_Enter)
 513     {
 514       event->length = 1;
 515       event->string = g_strdup ("\r");
 516     }
 517
 518   if (!event->string)
 519     {
 520       event->length = 0;
 521       event->string = g_strdup ("");
 522     }
 523 }
 524
 525 static gboolean
 526 keyboard_repeat (gpointer data);
 527
 528 static gboolean
 529 deliver_key_event(GdkWaylandDevice *device,
 530                   uint32_t time, uint32_t key, uint32_t state)
 531 {
 532   GdkEvent *event;
 533   uint32_t code, modifier, level;
 534   struct xkb_desc *xkb;
 535   GdkKeymap *keymap;
 536
 537   keymap = gdk_keymap_get_for_display (device->display);
 538   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 539
 540   device->time = time;
 541   event = gdk_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
 542   event->key.window = g_object_ref (device->keyboard_focus);
 543   gdk_event_set_device (event, device->keyboard);
 544   event->button.time = time;
 545   event->key.state = device->modifiers;
 546   event->key.group = 0;
 547   code = key + xkb->min_key_code;
 548   event->key.hardware_keycode = code;
 549
 550   level = 0;
 551   if (device->modifiers & XKB_COMMON_SHIFT_MASK &&
 552       XkbKeyGroupWidth(xkb, code, 0) > 1)
 553     level = 1;
 554
 555   event->key.keyval = XkbKeySymEntry(xkb, code, level, 0);
 556
 557   modifier = xkb->map->modmap[code];
 558   if (state)
 559     device->modifiers |= modifier;
 560   else
 561     device->modifiers &= ~modifier;
 562
 563   event->key.is_modifier = modifier > 0;
 564
 565   translate_keyboard_string (&event->key);
 566
 567   _gdk_wayland_display_deliver_event (device->display, event);
 568
 569   GDK_NOTE (EVENTS,
 570             g_message ("keyboard event, code %d, sym %d, "
 571                        "string %s, mods 0x%x",
 572                        code, event->key.keyval,
 573                        event->key.string, event->key.state));
 574
 575   device->repeat_count++;
 576   device->repeat_key = key;
 577
 578   if (state == 0)
 579     {
 580       if (device->repeat_timer)
 581         {
 582           g_source_remove (device->repeat_timer);
 583           device->repeat_timer = 0;
 584         }
 585       return FALSE;
 586     }
 587   else if (modifier)
 588     {
 589       return FALSE;
 590     }
 591   else switch (device->repeat_count)
 592     {
 593     case 1:
 594       if (device->repeat_timer)
 595         {
 596           g_source_remove (device->repeat_timer);
 597           device->repeat_timer = 0;
 598         }
 599
 600       device->repeat_timer =
 601         gdk_threads_add_timeout (400, keyboard_repeat, device);
 602       return TRUE;
 603     case 2:
 604       device->repeat_timer =
 605         gdk_threads_add_timeout (80, keyboard_repeat, device);
 606       return FALSE;
 607     default:
 608       return TRUE;
 609     }
 610 }
 611
 612 static gboolean
 613 keyboard_repeat (gpointer data)
 614 {
 615   GdkWaylandDevice *device = data;
 616
 617   return deliver_key_event (device, device->time, device->repeat_key, 1);
 618 }
 619
 620 static void
 621 input_handle_key(void *data, struct wl_input_device *input_device,
 622                  uint32_t time, uint32_t key, uint32_t state)
 623 {
 624   GdkWaylandDevice *device = data;
 625
 626   device->repeat_count = 0;
 627   deliver_key_event (data, time, key, state);
 628 }
 629
 630 static void
 631 input_handle_pointer_focus(void *data,
 632                            struct wl_input_device *input_device,
 633                            uint32_t time, struct wl_surface *surface,
 634                            int32_t x, int32_t y, int32_t sx, int32_t sy)
 635 {
 636   GdkWaylandDevice *device = data;
 637   GdkEvent *event;
 638
 639   device->time = time;
 640   if (device->pointer_focus)
 641     {
 642       event = gdk_event_new (GDK_LEAVE_NOTIFY);
 643       event->crossing.window = g_object_ref (device->pointer_focus);
 644       gdk_event_set_device (event, device->pointer);
 645       event->crossing.subwindow = NULL;
 646       event->crossing.time = time;
 647       event->crossing.x = (gdouble) device->surface_x;
 648       event->crossing.y = (gdouble) device->surface_y;
 649       event->crossing.x_root = (gdouble) device->x;
 650       event->crossing.y_root = (gdouble) device->y;
 651
 652       event->crossing.mode = GDK_CROSSING_NORMAL;
 653       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 654       event->crossing.focus = TRUE;
 655       event->crossing.state = 0;
 656
 657       _gdk_wayland_display_deliver_event (device->display, event);
 658
 659       GDK_NOTE (EVENTS,
 660                 g_message ("leave, device %p surface %p",
 661                            device, device->pointer_focus));
 662
 663       g_object_unref(device->pointer_focus);
 664       device->pointer_focus = NULL;
 665     }
 666
 667   if (surface)
 668     {
 669       device->pointer_focus = wl_surface_get_user_data(surface);
 670       g_object_ref(device->pointer_focus);
 671
 672       event = gdk_event_new (GDK_ENTER_NOTIFY);
 673       event->crossing.window = g_object_ref (device->pointer_focus);
 674       gdk_event_set_device (event, device->pointer);
 675       event->crossing.subwindow = NULL;
 676       event->crossing.time = time;
 677       event->crossing.x = (gdouble) sx;
 678       event->crossing.y = (gdouble) sy;
 679       event->crossing.x_root = (gdouble) x;
 680       event->crossing.y_root = (gdouble) y;
 681
 682       event->crossing.mode = GDK_CROSSING_NORMAL;
 683       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 684       event->crossing.focus = TRUE;
 685       event->crossing.state = 0;
 686
 687       device->surface_x = sx;
 688       device->surface_y = sy;
 689       device->x = x;
 690       device->y = y;
 691
 692       _gdk_wayland_display_deliver_event (device->display, event);
 693
 694       GDK_NOTE (EVENTS,
 695                 g_message ("enter, device %p surface %p",
 696                            device, device->pointer_focus));
 697     }
 698 }
 699
 700 static void
 701 update_modifiers(GdkWaylandDevice *device, struct wl_array *keys)
 702 {
 703   uint32_t *k, *end;
 704   GdkKeymap *keymap;
 705   struct xkb_desc *xkb;
 706
 707   keymap = gdk_keymap_get_for_display (device->display);
 708   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 709
 710   end = keys->data + keys->size;
 711   device->modifiers = 0;
 712   for (k = keys->data; k < end; k++)
 713     device->modifiers |= xkb->map->modmap[*k];
 714 }
 715
 716 static void
 717 input_handle_keyboard_focus(void *data,
 718                             struct wl_input_device *input_device,
 719                             uint32_t time,
 720                             struct wl_surface *surface,
 721                             struct wl_array *keys)
 722 {
 723   GdkWaylandDevice *device = data;
 724   GdkEvent *event;
 725
 726   device->time = time;
 727   if (device->keyboard_focus)
 728     {
 729       _gdk_wayland_window_remove_focus (device->keyboard_focus);
 730       event = gdk_event_new (GDK_FOCUS_CHANGE);
 731       event->focus_change.window = g_object_ref (device->keyboard_focus);
 732       event->focus_change.send_event = FALSE;
 733       event->focus_change.in = FALSE;
 734       gdk_event_set_device (event, device->keyboard);
 735
 736       g_object_unref(device->keyboard_focus);
 737       device->keyboard_focus = NULL;
 738
 739       GDK_NOTE (EVENTS,
 740                 g_message ("focus out, device %p surface %p",
 741                            device, device->keyboard_focus));
 742
 743       _gdk_wayland_display_deliver_event (device->display, event);
 744     }
 745
 746   if (surface)
 747     {
 748       device->keyboard_focus = wl_surface_get_user_data(surface);
 749       g_object_ref(device->keyboard_focus);
 750
 751       event = gdk_event_new (GDK_FOCUS_CHANGE);
 752       event->focus_change.window = g_object_ref (device->keyboard_focus);
 753       event->focus_change.send_event = FALSE;
 754       event->focus_change.in = TRUE;
 755       gdk_event_set_device (event, device->keyboard);
 756
 757       update_modifiers (device, keys);
 758
 759       GDK_NOTE (EVENTS,
 760                 g_message ("focus int, device %p surface %p",
 761                            device, device->keyboard_focus));
 762
 763       _gdk_wayland_display_deliver_event (device->display, event);
 764
 765       _gdk_wayland_window_add_focus (device->keyboard_focus);
 766     }
 767 }
 768
 769 static const struct wl_input_device_listener input_device_listener = {
 770   input_handle_motion,
 771   input_handle_button,
 772   input_handle_key,
 773   input_handle_pointer_focus,
 774   input_handle_keyboard_focus,
 775 };
 776 #endif
 777
 778 struct _DataOffer {
 779   struct wl_data_offer *offer;
 780   gint ref_count;
 781   GPtrArray *types;
 782 };
 783
 784 static void
 785 data_offer_offer (void                 *data,
 786                   struct wl_data_offer *wl_data_offer,
 787                   const char           *type)
 788 {
 789   DataOffer *offer = (DataOffer *)data;
 790   g_debug (G_STRLOC ": %s wl_data_offer = %p type = %s",
 791            G_STRFUNC, wl_data_offer, type);
 792
 793   g_ptr_array_add (offer->types, g_strdup (type));
 794 }
 795
 796 static void
 797 data_offer_unref (DataOffer *offer)
 798 {
 799   offer->ref_count--;
 800
 801   if (offer->ref_count == 0)
 802     {
 803       g_ptr_array_free (offer->types, TRUE);
 804       g_free (offer);
 805     }
 806 }
 807
 808 static const struct wl_data_offer_listener data_offer_listener = {
 809   data_offer_offer,
 810 };
 811
 812 static void
 813 data_device_data_offer (void                  *data,
 814                         struct wl_data_device *data_device,
 815                         uint32_t               id)
 816 {
 817   DataOffer *offer;
 818
 819   g_debug (G_STRLOC ": %s data_device = %p id = %lu",
 820            G_STRFUNC, data_device, (long unsigned int)id);
 821
 822   /* This structure is reference counted to handle the case where you get a
 823    * leave but are in the middle of transferring data
 824    */
 825   offer = g_new0 (DataOffer, 1);
 826   offer->ref_count = 1;
 827   offer->types = g_ptr_array_new_with_free_func (g_free);
 828   offer->offer = (struct wl_data_offer *)
 829     wl_proxy_create_for_id ((struct wl_proxy *) data_device,
 830                             id,
 831                             &wl_data_offer_interface);
 832
 833   /* The DataOffer structure is then retrieved later since this sets the user
 834    * data.
 835    */
 836   wl_data_offer_add_listener (offer->offer,
 837                               &data_offer_listener,
 838                               offer);
 839 }
 840
 841 static void
 842 data_device_enter (void                  *data,
 843                    struct wl_data_device *data_device,
 844                    uint32_t               time,
 845                    struct wl_surface     *surface,
 846                    int32_t                x,
 847                    int32_t                y,
 848                    struct wl_data_offer  *offer)
 849 {
 850   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 851
 852   g_debug (G_STRLOC ": %s data_device = %p time = %d, surface = %p, x = %d y = %d, offer = %p",
 853            G_STRFUNC, data_device, time, surface, x, y, offer);
 854
 855   /* Retrieve the DataOffer associated with with the wl_data_offer - this
 856    * association is made when the listener is attached.
 857    */
 858   g_assert (device->drag_offer == NULL);
 859   device->drag_offer = wl_data_offer_get_user_data (offer);
 860 }
 861
 862 static void
 863 data_device_leave (void                  *data,
 864                    struct wl_data_device *data_device)
 865 {
 866   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 867
 868   g_debug (G_STRLOC ": %s data_device = %p",
 869            G_STRFUNC, data_device);
 870
 871   data_offer_unref (device->drag_offer);
 872   device->drag_offer = NULL;
 873 }
 874
 875 static void
 876 data_device_motion (void                  *data,
 877                     struct wl_data_device *data_device,
 878                     uint32_t               time,
 879                     int32_t                x,
 880                     int32_t                y)
 881 {
 882   g_debug (G_STRLOC ": %s data_device = %p, time = %d, x = %d, y = %d",
 883            G_STRFUNC, data_device, time, x, y);
 884 }
 885
 886 static void
 887 data_device_drop (void                  *data,
 888                   struct wl_data_device *data_device)
 889 {
 890   g_debug (G_STRLOC ": %s data_device = %p",
 891            G_STRFUNC, data_device);
 892 }
 893
 894 static void
 895 data_device_selection (void                  *data,
 896                        struct wl_data_device *wl_data_device,
 897                        struct wl_data_offer  *offer)
 898 {
 899   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 900
 901   g_debug (G_STRLOC ": %s wl_data_device = %p wl_data_offer = %p",
 902            G_STRFUNC, wl_data_device, offer);
 903
 904   if (!offer)
 905     {
 906       if (device->selection_offer)
 907         {
 908           data_offer_unref (device->selection_offer);
 909           device->selection_offer = NULL;
 910         }
 911
 912       return;
 913     }
 914
 915   if (device->selection_offer)
 916     {
 917       data_offer_unref (device->selection_offer);
 918       device->selection_offer = NULL;
 919     }
 920
 921   /* Retrieve the DataOffer associated with with the wl_data_offer - this
 922    * association is made when the listener is attached.
 923    */
 924   g_assert (device->selection_offer == NULL);
 925   device->selection_offer = wl_data_offer_get_user_data (offer);
 926 }
 927
 928 static const struct wl_data_device_listener data_device_listener = {
 929   data_device_data_offer,
 930   data_device_enter,
 931   data_device_leave,
 932   data_device_motion,
 933   data_device_drop,
 934   data_device_selection
 935 };
 936
 937
 938
 939 static void
 940 pointer_handle_enter (void              *data,
 941                       struct wl_pointer *pointer,
 942                       uint32_t           serial,
 943                       struct wl_surface *surface,
 944                       wl_fixed_t         sx,
 945                       wl_fixed_t         sy)
 946 {
 947   GdkWaylandDevice *device = data;
 948   GdkEvent *event;
 949   GdkWaylandDisplay *wayland_display =
 950     GDK_WAYLAND_DISPLAY (device->display);
 951
 952   _gdk_wayland_display_update_serial (wayland_display, serial);
 953
 954   device->pointer_focus = wl_surface_get_user_data(surface);
 955   g_object_ref(device->pointer_focus);
 956
 957   event = gdk_event_new (GDK_ENTER_NOTIFY);
 958   event->crossing.window = g_object_ref (device->pointer_focus);
 959   gdk_event_set_device (event, device->pointer);
 960   event->crossing.subwindow = NULL;
 961   event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
 962   event->crossing.x = wl_fixed_to_double (sx);
 963   event->crossing.y = wl_fixed_to_double (sy);
 964
 965   event->crossing.mode = GDK_CROSSING_NORMAL;
 966   event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 967   event->crossing.focus = TRUE;
 968   event->crossing.state = 0;
 969
 970   device->surface_x = wl_fixed_to_double (sx);
 971   device->surface_y = wl_fixed_to_double (sy);
 972
 973   _gdk_wayland_display_deliver_event (device->display, event);
 974
 975   GDK_NOTE (EVENTS,
 976             g_message ("enter, device %p surface %p",
 977                        device, device->pointer_focus));
 978 }
 979
 980 static void
 981 pointer_handle_leave (void              *data,
 982                       struct wl_pointer *pointer,
 983                       uint32_t           serial,
 984                       struct wl_surface *surface)
 985 {
 986   GdkWaylandDevice *device = data;
 987   GdkEvent *event;
 988   GdkWaylandDisplay *wayland_display =
 989     GDK_WAYLAND_DISPLAY (device->display);
 990
 991   _gdk_wayland_display_update_serial (wayland_display, serial);
 992
 993   event = gdk_event_new (GDK_LEAVE_NOTIFY);
 994   event->crossing.window = g_object_ref (device->pointer_focus);
 995   gdk_event_set_device (event, device->pointer);
 996   event->crossing.subwindow = NULL;
 997   event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
 998   event->crossing.x = device->surface_x;
 999   event->crossing.y = device->surface_y;
1000
1001   event->crossing.mode = GDK_CROSSING_NORMAL;
1002   event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1003   event->crossing.focus = TRUE;
1004   event->crossing.state = 0;
1005
1006   _gdk_wayland_display_deliver_event (device->display, event);
1007
1008   GDK_NOTE (EVENTS,
1009             g_message ("leave, device %p surface %p",
1010                        device, device->pointer_focus));
1011
1012   g_object_unref(device->pointer_focus);
1013   device->pointer_focus = NULL;
1014 }
1015
1016 static void
1017 pointer_handle_motion (void              *data,
1018                        struct wl_pointer *pointer,
1019                        uint32_t           time,
1020                        wl_fixed_t         sx,
1021                        wl_fixed_t         sy)
1022 {
1023   GdkWaylandDevice *device = data;
1024   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
1025   GdkEvent *event;
1026
1027   event = gdk_event_new (GDK_NOTHING);
1028
1029   device->time = time;
1030   device->surface_x = wl_fixed_to_double (sx);
1031   device->surface_y = wl_fixed_to_double (sy);
1032
1033   event->motion.type = GDK_MOTION_NOTIFY;
1034   event->motion.window = g_object_ref (device->pointer_focus);
1035   gdk_event_set_device (event, device->pointer);
1036   event->motion.time = time;
1037   event->motion.x = wl_fixed_to_double (sx);
1038   event->motion.y = wl_fixed_to_double (sy);
1039   event->motion.axes = NULL;
1040   event->motion.state = device->modifiers;
1041   event->motion.is_hint = 0;
1042   gdk_event_set_screen (event, display->screen);
1043
1044   GDK_NOTE (EVENTS,
1045             g_message ("motion %d %d, state %d",
1046                        sx, sy, event->button.state));
1047
1048   _gdk_wayland_display_deliver_event (device->display, event);
1049 }
1050
1051 static void
1052 pointer_handle_button (void              *data,
1053                        struct wl_pointer *pointer,
1054                        uint32_t           serial,
1055                        uint32_t           time,
1056                        uint32_t           button,
1057                        uint32_t           state)
1058 {
1059   GdkWaylandDevice *device = data;
1060   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
1061   GdkEvent *event;
1062   uint32_t modifier;
1063   int gdk_button;
1064   GdkWaylandDisplay *wayland_display =
1065     GDK_WAYLAND_DISPLAY (device->display);
1066
1067   _gdk_wayland_display_update_serial (wayland_display, serial);
1068
1069   switch (button) {
1070   case 273:
1071     gdk_button = 3;
1072     break;
1073   case 274:
1074     gdk_button = 2;
1075     break;
1076   default:
1077     gdk_button = button - 271;
1078     break;
1079   }
1080
1081   device->time = time;
1082
1083   event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
1084   event->button.window = g_object_ref (device->pointer_focus);
1085   gdk_event_set_device (event, device->pointer);
1086   event->button.time = time;
1087   event->button.x = device->surface_x;
1088   event->button.y = device->surface_y;
1089   event->button.axes = NULL;
1090   event->button.state = device->modifiers;
1091   event->button.button = gdk_button;
1092   gdk_event_set_screen (event, display->screen);
1093
1094   modifier = 1 << (8 + gdk_button - 1);
1095   if (state)
1096     device->modifiers |= modifier;
1097   else
1098     device->modifiers &= ~modifier;
1099
1100   GDK_NOTE (EVENTS,
1101             g_message ("button %d %s, state %d",
1102                        event->button.button,
1103                        state ? "press" : "release", event->button.state));
1104
1105   _gdk_wayland_display_deliver_event (device->display, event);
1106 }
1107
1108 static void
1109 pointer_handle_axis (void              *data,
1110                      struct wl_pointer *pointer,
1111                      uint32_t           time,
1112                      uint32_t           axis,
1113                      wl_fixed_t         value)
1114 {
1115 }
1116
1117 static void
1118 keyboard_handle_keymap (void               *data,
1119                        struct wl_keyboard *keyboard,
1120                        uint32_t            format,
1121                        int                 fd,
1122                        uint32_t            size)
1123 {
1124 }
1125
1126 static void
1127 keyboard_handle_enter (void               *data,
1128                        struct wl_keyboard *keyboard,
1129                        uint32_t            serial,
1130                        struct wl_surface  *surface,
1131                        struct wl_array    *keys)
1132 {
1133
1134 }
1135
1136 static void
1137 keyboard_handle_leave (void               *data,
1138                        struct wl_keyboard *keyboard,
1139                        uint32_t            serial,
1140                        struct wl_surface  *surface)
1141 {
1142 }
1143
1144 static void
1145 keyboard_handle_key (void               *data,
1146                      struct wl_keyboard *keyboard,
1147                      uint32_t            serial,
1148                      uint32_t            time,
1149                      uint32_t            key,
1150                      uint32_t            state_w)
1151 {
1152 }
1153
1154 static void
1155 keyboard_handle_modifiers (void               *data,
1156                            struct wl_keyboard *keyboard,
1157                            uint32_t            serial,
1158                            uint32_t            mods_depressed,
1159                            uint32_t            mods_latched,
1160                            uint32_t            mods_locked,
1161                            uint32_t            group)
1162 {
1163 }
1164
1165 static const struct wl_pointer_listener pointer_listener = {
1166     pointer_handle_enter,
1167     pointer_handle_leave,
1168     pointer_handle_motion,
1169     pointer_handle_button,
1170     pointer_handle_axis,
1171 };
1172
1173 static const struct wl_keyboard_listener keyboard_listener = {
1174     keyboard_handle_keymap,
1175     keyboard_handle_enter,
1176     keyboard_handle_leave,
1177     keyboard_handle_key,
1178     keyboard_handle_modifiers,
1179 };
1180
1181 static void
1182 seat_handle_capabilities(void *data, struct wl_seat *seat,
1183                          enum wl_seat_capability caps)
1184 {
1185   GdkWaylandDevice *device = data;
1186   GdkDeviceManagerCore *device_manager_core =
1187     GDK_DEVICE_MANAGER_CORE(device->device_manager);
1188
1189   if ((caps & WL_SEAT_CAPABILITY_POINTER) && !device->wl_pointer)
1190     {
1191       device->wl_pointer = wl_seat_get_pointer(seat);
1192       wl_pointer_set_user_data(device->wl_pointer, device);
1193       wl_pointer_add_listener(device->wl_pointer, &pointer_listener,
1194                               device);
1195
1196       device->pointer = g_object_new (GDK_TYPE_DEVICE_CORE,
1197                                       "name", "Core Pointer",
1198                                       "type", GDK_DEVICE_TYPE_MASTER,
1199                                       "input-source", GDK_SOURCE_MOUSE,
1200                                       "input-mode", GDK_MODE_SCREEN,
1201                                       "has-cursor", TRUE,
1202                                       "display", device->display,
1203                                       "device-manager", device->device_manager,
1204                                       NULL);
1205       GDK_DEVICE_CORE (device->pointer)->device = device;
1206
1207       device_manager_core->devices =
1208         g_list_prepend (device_manager_core->devices, device->pointer);
1209     }
1210   else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && device->wl_pointer)
1211     {
1212       wl_pointer_destroy(device->wl_pointer);
1213       device->wl_pointer = NULL;
1214
1215       device_manager_core->devices =
1216         g_list_remove (device_manager_core->devices, device->pointer);
1217
1218       g_object_unref (device->pointer);
1219       device->pointer = NULL;
1220     }
1221
1222   if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !device->wl_keyboard)
1223     {
1224       device->wl_keyboard = wl_seat_get_keyboard(seat);
1225       wl_keyboard_set_user_data(device->wl_keyboard, device);
1226       wl_keyboard_add_listener(device->wl_keyboard, &keyboard_listener,
1227                                device);
1228
1229       device->keyboard = g_object_new (GDK_TYPE_DEVICE_CORE,
1230                                        "name", "Core Keyboard",
1231                                        "type", GDK_DEVICE_TYPE_MASTER,
1232                                        "input-source", GDK_SOURCE_KEYBOARD,
1233                                        "input-mode", GDK_MODE_SCREEN,
1234                                        "has-cursor", FALSE,
1235                                        "display", device->display,
1236                                        "device-manager", device->device_manager,
1237                                        NULL);
1238       GDK_DEVICE_CORE (device->keyboard)->device = device;
1239
1240       device_manager_core->devices =
1241         g_list_prepend (device_manager_core->devices, device->keyboard);
1242     }
1243   else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && device->wl_keyboard)
1244     {
1245       wl_keyboard_destroy(device->wl_keyboard);
1246       device->wl_keyboard = NULL;
1247
1248       device_manager_core->devices =
1249         g_list_remove (device_manager_core->devices, device->keyboard);
1250
1251       g_object_unref (device->keyboard);
1252       device->keyboard = NULL;
1253     }
1254
1255   if (device->keyboard && device->pointer)
1256     {
1257       _gdk_device_set_associated_device (device->pointer, device->keyboard);
1258       _gdk_device_set_associated_device (device->keyboard, device->pointer);
1259     }
1260 }
1261
1262 static const struct wl_seat_listener seat_listener = {
1263     seat_handle_capabilities,
1264 };
1265
1266 void
1267 _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,
1268                                         struct wl_seat *wl_seat)
1269 {
1270   GdkDisplay *display;
1271   GdkWaylandDisplay *display_wayland;
1272   GdkWaylandDevice *device;
1273
1274   display = gdk_device_manager_get_display (device_manager);
1275   display_wayland = GDK_WAYLAND_DISPLAY (display);
1276
1277   device = g_new0 (GdkWaylandDevice, 1);
1278   device->display = display;
1279   device->device_manager = device_manager;
1280
1281   device->wl_seat = wl_seat;
1282
1283   wl_seat_add_listener (device->wl_seat, &seat_listener, device);
1284   wl_seat_set_user_data (device->wl_seat, device);
1285
1286   device->data_device =
1287     wl_data_device_manager_get_data_device (display_wayland->data_device_manager,
1288                                             device->wl_seat);
1289   wl_data_device_add_listener (device->data_device,
1290                                &data_device_listener, device);
1291
1292   device->pointer_surface =
1293     wl_compositor_create_surface (display_wayland->compositor);
1294 }
1295
1296 static void
1297 free_device (gpointer data)
1298 {
1299   g_object_unref (data);
1300 }
1301
1302 static void
1303 gdk_device_manager_core_finalize (GObject *object)
1304 {
1305   GdkDeviceManagerCore *device_manager_core;
1306
1307   device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
1308
1309   g_list_free_full (device_manager_core->devices, free_device);
1310
1311   G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
1312 }
1313
1314 static GList *
1315 gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
1316                                       GdkDeviceType     type)
1317 {
1318   GdkDeviceManagerCore *device_manager_core;
1319   GList *devices = NULL;
1320
1321   if (type == GDK_DEVICE_TYPE_MASTER)
1322     {
1323       device_manager_core = (GdkDeviceManagerCore *) device_manager;
1324       devices = g_list_copy(device_manager_core->devices);
1325     }
1326
1327   return devices;
1328 }
1329
1330 static GdkDevice *
1331 gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
1332 {
1333   GdkDeviceManagerCore *device_manager_core;
1334   GList *l;
1335
1336   device_manager_core = (GdkDeviceManagerCore *) device_manager;
1337
1338   /* Find the first pointer device */
1339   for (l = device_manager_core->devices; l != NULL; l = l->next)
1340     {
1341       GdkDevice *device = l->data;
1342
1343       if (gdk_device_get_source (device) == GDK_SOURCE_MOUSE)
1344         return device;
1345     }
1346
1347   return NULL;
1348 }
1349
1350 static void
1351 gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
1352 {
1353   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
1354   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1355
1356   object_class->finalize = gdk_device_manager_core_finalize;
1357   device_manager_class->list_devices = gdk_device_manager_core_list_devices;
1358   device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
1359 }
1360
1361 static void
1362 gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
1363 {
1364 }
1365
1366 GdkDeviceManager *
1367 _gdk_wayland_device_manager_new (GdkDisplay *display)
1368 {
1369   return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
1370                        "display", display,
1371                        NULL);
1372 }
1373
1374 gint
1375 gdk_wayland_device_get_selection_type_atoms (GdkDevice  *gdk_device,
1376                                              GdkAtom   **atoms_out)
1377 {
1378   gint i;
1379   GdkAtom *atoms;
1380   GdkWaylandDevice *device;
1381
1382   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1383   g_return_val_if_fail (atoms_out != NULL, 0);
1384
1385   device = GDK_DEVICE_CORE (gdk_device)->device;
1386
1387   if (!device->selection_offer || device->selection_offer->types->len == 0)
1388     {
1389       *atoms_out = NULL;
1390       return 0;
1391     }
1392
1393   atoms = g_new0 (GdkAtom, device->selection_offer->types->len);
1394
1395   /* Convert list of targets to atoms */
1396   for (i = 0; i < device->selection_offer->types->len; i++)
1397     {
1398       atoms[i] = gdk_atom_intern (device->selection_offer->types->pdata[i],
1399                                   FALSE);
1400       GDK_NOTE (MISC,
1401                 g_message (G_STRLOC ": Adding atom for %s",
1402                            (char *)device->selection_offer->types->pdata[i]));
1403     }
1404
1405   *atoms_out = atoms;
1406   return device->selection_offer->types->len;
1407 }
1408
1409 typedef struct
1410 {
1411   GdkWaylandDevice *device;
1412   DataOffer *offer;
1413   GIOChannel *channel;
1414   GdkDeviceWaylandRequestContentCallback cb;
1415   gpointer userdata;
1416 } RequestContentClosure;
1417
1418 static gboolean
1419 _request_content_io_func (GIOChannel *channel,
1420                           GIOCondition condition,
1421                           gpointer userdata)
1422 {
1423   RequestContentClosure *closure = (RequestContentClosure *)userdata;
1424   gchar *data = NULL;
1425   gsize len = 0;
1426   GError *error = NULL;
1427
1428   /* FIXME: We probably want to do something better than this to avoid
1429    * blocking on the transfer of large pieces of data: call the callback
1430    * multiple times I should think.
1431    */
1432   if (g_io_channel_read_to_end (channel,
1433                                 &data,
1434                                 &len,
1435                                 &error) != G_IO_STATUS_NORMAL)
1436     {
1437       g_warning (G_STRLOC ": Error reading content from pipe: %s", error->message);
1438       g_clear_error (&error);
1439     }
1440
1441   /* Since we use _read_to_end we've got a guaranteed EOF and thus can go
1442    * ahead and close the fd
1443    */
1444   g_io_channel_shutdown (channel, TRUE, NULL);
1445
1446   closure->cb (closure->device->pointer, data, len, closure->userdata);
1447
1448   g_free (data);
1449   data_offer_unref (closure->offer);
1450   g_io_channel_unref (channel);
1451   g_free (closure);
1452
1453   return FALSE;
1454 }
1455
1456 gboolean
1457 gdk_wayland_device_request_selection_content (GdkDevice                              *gdk_device,
1458                                               const gchar                            *requested_mime_type,
1459                                               GdkDeviceWaylandRequestContentCallback  cb,
1460                                               gpointer                                userdata)
1461 {
1462   int pipe_fd[2];
1463   RequestContentClosure *closure;
1464   GdkWaylandDevice *device;
1465   GError *error = NULL;
1466
1467   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), FALSE);
1468   g_return_val_if_fail (requested_mime_type != NULL, FALSE);
1469   g_return_val_if_fail (cb != NULL, FALSE);
1470
1471   device = GDK_DEVICE_CORE (gdk_device)->device;
1472
1473   if (!device->selection_offer)
1474       return FALSE;
1475
1476   /* TODO: Check mimetypes */
1477
1478   closure = g_new0 (RequestContentClosure, 1);
1479
1480   device->selection_offer->ref_count++;
1481
1482   pipe2 (pipe_fd, O_CLOEXEC);
1483   wl_data_offer_receive (device->selection_offer->offer,
1484                          requested_mime_type,
1485                          pipe_fd[1]);
1486   close (pipe_fd[1]);
1487
1488   closure->device = device;
1489   closure->offer = device->selection_offer;
1490   closure->channel = g_io_channel_unix_new (pipe_fd[0]);
1491   closure->cb = cb;
1492   closure->userdata = userdata;
1493
1494   if (!g_io_channel_set_encoding (closure->channel, NULL, &error))
1495     {
1496       g_warning (G_STRLOC ": Error setting encoding on channel: %s",
1497                  error->message);
1498       g_clear_error (&error);
1499       goto error;
1500     }
1501
1502   g_io_add_watch (closure->channel,
1503                   G_IO_IN,
1504                   _request_content_io_func,
1505                   closure);
1506
1507   return TRUE;
1508
1509 error:
1510   data_offer_unref (closure->offer);
1511   g_io_channel_unref (closure->channel);
1512   close (pipe_fd[1]);
1513   g_free (closure);
1514
1515   return FALSE;
1516 }
1517
1518 struct _GdkWaylandSelectionOffer {
1519   GdkDeviceWaylandOfferContentCallback cb;
1520   gpointer userdata;
1521   struct wl_data_source *source;
1522   GdkWaylandDevice *device;
1523 };
1524
1525 static void
1526 data_source_target (void                  *data,
1527                     struct wl_data_source *source,
1528                     const char            *mime_type)
1529 {
1530   g_debug (G_STRLOC ": %s source = %p, mime_type = %s",
1531            G_STRFUNC, source, mime_type);
1532 }
1533
1534 static void
1535 data_source_send (void                  *data,
1536                   struct wl_data_source *source,
1537                   const char            *mime_type,
1538                   int32_t                fd)
1539 {
1540   GdkWaylandSelectionOffer *offer = (GdkWaylandSelectionOffer *)data;;
1541   gchar *buf;
1542   gssize len, bytes_written = 0;
1543
1544   g_debug (G_STRLOC ": %s source = %p, mime_type = %s fd = %d",
1545            G_STRFUNC, source, mime_type, fd);
1546
1547   buf = offer->cb (offer->device->pointer, mime_type, &len, offer->userdata);
1548
1549   while (len > 0)
1550     {
1551       bytes_written += write (fd, buf + bytes_written, len);
1552       if (bytes_written == -1)
1553         goto error;
1554       len -= bytes_written;
1555     }
1556
1557   close (fd);
1558   g_free (buf);
1559
1560   return;
1561 error:
1562
1563   g_warning (G_STRLOC ": Error writing data to client: %s",
1564              g_strerror (errno));
1565
1566   close (fd);
1567   g_free (buf);
1568 }
1569
1570 static void
1571 data_source_cancelled (void                  *data,
1572                        struct wl_data_source *source)
1573 {
1574   g_debug (G_STRLOC ": %s source = %p",
1575            G_STRFUNC, source);
1576 }
1577
1578 static const struct wl_data_source_listener data_source_listener = {
1579     data_source_target,
1580     data_source_send,
1581     data_source_cancelled
1582 };
1583
1584 static guint32
1585 _wl_time_now (void)
1586 {
1587   struct timeval tv;
1588
1589   gettimeofday(&tv, NULL);
1590
1591   return tv.tv_sec * 1000 + tv.tv_usec / 1000;
1592 }
1593
1594 gboolean
1595 gdk_wayland_device_offer_selection_content (GdkDevice                             *gdk_device,
1596                                             const gchar                          **mime_types,
1597                                             gint                                   nr_mime_types,
1598                                             GdkDeviceWaylandOfferContentCallback   cb,
1599                                             gpointer                               userdata)
1600 {
1601   GdkDisplay *display;
1602   GdkWaylandDisplay *display_wayland;
1603   GdkWaylandSelectionOffer *offer;
1604   GdkWaylandDevice *device;
1605   gint i;
1606
1607   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1608   device = GDK_DEVICE_CORE (gdk_device)->device;
1609
1610   display = device->display;
1611   display_wayland = GDK_WAYLAND_DISPLAY (display);
1612
1613   offer = g_new0 (GdkWaylandSelectionOffer, 1);
1614   offer->cb = cb;
1615   offer->userdata = userdata;
1616   offer->source =
1617     wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
1618   offer->device = device;
1619
1620   for (i = 0; i < nr_mime_types; i++)
1621     {
1622       wl_data_source_offer (offer->source,
1623                             mime_types[i]);
1624     }
1625
1626   wl_data_source_add_listener (offer->source,
1627                                &data_source_listener,
1628                                offer);
1629
1630   wl_data_device_set_selection (device->data_device,
1631                                 offer->source,
1632                                 _wl_time_now ());
1633
1634   device->selection_offer_out = offer;
1635
1636   return TRUE;
1637 }
1638
1639 gboolean
1640 gdk_wayland_device_clear_selection_content (GdkDevice *gdk_device)
1641 {
1642   GdkWaylandDevice *device;
1643
1644   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1645   device = GDK_DEVICE_CORE (gdk_device)->device;
1646
1647   if (!device->selection_offer_out)
1648     return FALSE;
1649
1650   wl_data_device_set_selection (device->data_device,
1651                                 NULL,
1652                                 _wl_time_now ());
1653
1654   wl_data_source_destroy (device->selection_offer_out->source);
1655   g_free (device->selection_offer_out);
1656   device->selection_offer_out = NULL;
1657
1658   return TRUE;
1659 }