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
 948   GdkWaylandDevice *device = data;
 949   GdkEvent *event;
 950
 951   device->pointer_focus = wl_surface_get_user_data(surface);
 952   g_object_ref(device->pointer_focus);
 953
 954   event = gdk_event_new (GDK_ENTER_NOTIFY);
 955   event->crossing.window = g_object_ref (device->pointer_focus);
 956   gdk_event_set_device (event, device->pointer);
 957   event->crossing.subwindow = NULL;
 958   event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
 959   event->crossing.x = wl_fixed_to_double (sx);
 960   event->crossing.y = wl_fixed_to_double (sy);
 961
 962   event->crossing.mode = GDK_CROSSING_NORMAL;
 963   event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 964   event->crossing.focus = TRUE;
 965   event->crossing.state = 0;
 966
 967   device->surface_x = wl_fixed_to_double (sx);
 968   device->surface_y = wl_fixed_to_double (sy);
 969
 970   _gdk_wayland_display_deliver_event (device->display, event);
 971
 972   GDK_NOTE (EVENTS,
 973             g_message ("enter, device %p surface %p",
 974                        device, device->pointer_focus));
 975 }
 976
 977 static void
 978 pointer_handle_leave (void              *data,
 979                       struct wl_pointer *pointer,
 980                       uint32_t           serial,
 981                       struct wl_surface *surface)
 982 {
 983   GdkWaylandDevice *device = data;
 984   GdkEvent *event;
 985
 986   event = gdk_event_new (GDK_LEAVE_NOTIFY);
 987   event->crossing.window = g_object_ref (device->pointer_focus);
 988   gdk_event_set_device (event, device->pointer);
 989   event->crossing.subwindow = NULL;
 990   event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
 991   event->crossing.x = device->surface_x;
 992   event->crossing.y = device->surface_y;
 993
 994   event->crossing.mode = GDK_CROSSING_NORMAL;
 995   event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 996   event->crossing.focus = TRUE;
 997   event->crossing.state = 0;
 998
 999   _gdk_wayland_display_deliver_event (device->display, event);
1000
1001   GDK_NOTE (EVENTS,
1002             g_message ("leave, device %p surface %p",
1003                        device, device->pointer_focus));
1004
1005   g_object_unref(device->pointer_focus);
1006   device->pointer_focus = NULL;
1007 }
1008
1009 static void
1010 pointer_handle_motion (void              *data,
1011                        struct wl_pointer *pointer,
1012                        uint32_t           time,
1013                        wl_fixed_t         sx,
1014                        wl_fixed_t         sy)
1015 {
1016   GdkWaylandDevice *device = data;
1017   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
1018   GdkEvent *event;
1019
1020   event = gdk_event_new (GDK_NOTHING);
1021
1022   device->time = time;
1023   device->surface_x = wl_fixed_to_double (sx);
1024   device->surface_y = wl_fixed_to_double (sy);
1025
1026   event->motion.type = GDK_MOTION_NOTIFY;
1027   event->motion.window = g_object_ref (device->pointer_focus);
1028   gdk_event_set_device (event, device->pointer);
1029   event->motion.time = time;
1030   event->motion.x = wl_fixed_to_double (sx);
1031   event->motion.y = wl_fixed_to_double (sy);
1032   event->motion.axes = NULL;
1033   event->motion.state = device->modifiers;
1034   event->motion.is_hint = 0;
1035   gdk_event_set_screen (event, display->screen);
1036
1037   GDK_NOTE (EVENTS,
1038             g_message ("motion %d %d, state %d",
1039                        sx, sy, event->button.state));
1040
1041   _gdk_wayland_display_deliver_event (device->display, event);
1042 }
1043
1044 static void
1045 pointer_handle_button (void              *data,
1046                        struct wl_pointer *pointer,
1047                        uint32_t           serial,
1048                        uint32_t           time,
1049                        uint32_t           button,
1050                        uint32_t           state)
1051 {
1052   GdkWaylandDevice *device = data;
1053   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
1054   GdkEvent *event;
1055   uint32_t modifier;
1056   int gdk_button;
1057
1058   switch (button) {
1059   case 273:
1060     gdk_button = 3;
1061     break;
1062   case 274:
1063     gdk_button = 2;
1064     break;
1065   default:
1066     gdk_button = button - 271;
1067     break;
1068   }
1069
1070   device->time = time;
1071
1072   event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
1073   event->button.window = g_object_ref (device->pointer_focus);
1074   gdk_event_set_device (event, device->pointer);
1075   event->button.time = time;
1076   event->button.x = device->surface_x;
1077   event->button.y = device->surface_y;
1078   event->button.axes = NULL;
1079   event->button.state = device->modifiers;
1080   event->button.button = gdk_button;
1081   gdk_event_set_screen (event, display->screen);
1082
1083   modifier = 1 << (8 + gdk_button - 1);
1084   if (state)
1085     device->modifiers |= modifier;
1086   else
1087     device->modifiers &= ~modifier;
1088
1089   GDK_NOTE (EVENTS,
1090             g_message ("button %d %s, state %d",
1091                        event->button.button,
1092                        state ? "press" : "release", event->button.state));
1093
1094   _gdk_wayland_display_deliver_event (device->display, event);
1095 }
1096
1097 static void
1098 pointer_handle_axis (void              *data,
1099                      struct wl_pointer *pointer,
1100                      uint32_t           time,
1101                      uint32_t           axis,
1102                      wl_fixed_t         value)
1103 {
1104 }
1105
1106 static void
1107 keyboard_handle_keymap (void               *data,
1108                        struct wl_keyboard *keyboard,
1109                        uint32_t            format,
1110                        int                 fd,
1111                        uint32_t            size)
1112 {
1113 }
1114
1115 static void
1116 keyboard_handle_enter (void               *data,
1117                        struct wl_keyboard *keyboard,
1118                        uint32_t            serial,
1119                        struct wl_surface  *surface,
1120                        struct wl_array    *keys)
1121 {
1122
1123 }
1124
1125 static void
1126 keyboard_handle_leave (void               *data,
1127                        struct wl_keyboard *keyboard,
1128                        uint32_t            serial,
1129                        struct wl_surface  *surface)
1130 {
1131 }
1132
1133 static void
1134 keyboard_handle_key (void               *data,
1135                      struct wl_keyboard *keyboard,
1136                      uint32_t            serial,
1137                      uint32_t            time,
1138                      uint32_t            key,
1139                      uint32_t            state_w)
1140 {
1141 }
1142
1143 static void
1144 keyboard_handle_modifiers (void               *data,
1145                            struct wl_keyboard *keyboard,
1146                            uint32_t            serial,
1147                            uint32_t            mods_depressed,
1148                            uint32_t            mods_latched,
1149                            uint32_t            mods_locked,
1150                            uint32_t            group)
1151 {
1152 }
1153
1154 static const struct wl_pointer_listener pointer_listener = {
1155     pointer_handle_enter,
1156     pointer_handle_leave,
1157     pointer_handle_motion,
1158     pointer_handle_button,
1159     pointer_handle_axis,
1160 };
1161
1162 static const struct wl_keyboard_listener keyboard_listener = {
1163     keyboard_handle_keymap,
1164     keyboard_handle_enter,
1165     keyboard_handle_leave,
1166     keyboard_handle_key,
1167     keyboard_handle_modifiers,
1168 };
1169
1170 static void
1171 seat_handle_capabilities(void *data, struct wl_seat *seat,
1172                          enum wl_seat_capability caps)
1173 {
1174   GdkWaylandDevice *device = data;
1175   GdkDeviceManagerCore *device_manager_core =
1176     GDK_DEVICE_MANAGER_CORE(device->device_manager);
1177
1178   if ((caps & WL_SEAT_CAPABILITY_POINTER) && !device->wl_pointer)
1179     {
1180       device->wl_pointer = wl_seat_get_pointer(seat);
1181       wl_pointer_set_user_data(device->wl_pointer, device);
1182       wl_pointer_add_listener(device->wl_pointer, &pointer_listener,
1183                               device);
1184
1185       device->pointer = g_object_new (GDK_TYPE_DEVICE_CORE,
1186                                       "name", "Core Pointer",
1187                                       "type", GDK_DEVICE_TYPE_MASTER,
1188                                       "input-source", GDK_SOURCE_MOUSE,
1189                                       "input-mode", GDK_MODE_SCREEN,
1190                                       "has-cursor", TRUE,
1191                                       "display", device->display,
1192                                       "device-manager", device->device_manager,
1193                                       NULL);
1194       GDK_DEVICE_CORE (device->pointer)->device = device;
1195
1196       device_manager_core->devices =
1197         g_list_prepend (device_manager_core->devices, device->pointer);
1198     }
1199   else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && device->wl_pointer)
1200     {
1201       wl_pointer_destroy(device->wl_pointer);
1202       device->wl_pointer = NULL;
1203
1204       device_manager_core->devices =
1205         g_list_remove (device_manager_core->devices, device->pointer);
1206
1207       g_object_unref (device->pointer);
1208       device->pointer = NULL;
1209     }
1210
1211   if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !device->wl_keyboard)
1212     {
1213       device->wl_keyboard = wl_seat_get_keyboard(seat);
1214       wl_keyboard_set_user_data(device->wl_keyboard, device);
1215       wl_keyboard_add_listener(device->wl_keyboard, &keyboard_listener,
1216                                device);
1217
1218       device->keyboard = g_object_new (GDK_TYPE_DEVICE_CORE,
1219                                        "name", "Core Keyboard",
1220                                        "type", GDK_DEVICE_TYPE_MASTER,
1221                                        "input-source", GDK_SOURCE_KEYBOARD,
1222                                        "input-mode", GDK_MODE_SCREEN,
1223                                        "has-cursor", FALSE,
1224                                        "display", device->display,
1225                                        "device-manager", device->device_manager,
1226                                        NULL);
1227       GDK_DEVICE_CORE (device->keyboard)->device = device;
1228
1229       device_manager_core->devices =
1230         g_list_prepend (device_manager_core->devices, device->keyboard);
1231     }
1232   else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && device->wl_keyboard)
1233     {
1234       wl_keyboard_destroy(device->wl_keyboard);
1235       device->wl_keyboard = NULL;
1236
1237       device_manager_core->devices =
1238         g_list_remove (device_manager_core->devices, device->keyboard);
1239
1240       g_object_unref (device->keyboard);
1241       device->keyboard = NULL;
1242     }
1243
1244   if (device->keyboard && device->pointer)
1245     {
1246       _gdk_device_set_associated_device (device->pointer, device->keyboard);
1247       _gdk_device_set_associated_device (device->keyboard, device->pointer);
1248     }
1249 }
1250
1251 static const struct wl_seat_listener seat_listener = {
1252     seat_handle_capabilities,
1253 };
1254
1255 void
1256 _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,
1257                                         struct wl_seat *wl_seat)
1258 {
1259   GdkDisplay *display;
1260   GdkWaylandDisplay *display_wayland;
1261   GdkWaylandDevice *device;
1262
1263   display = gdk_device_manager_get_display (device_manager);
1264   display_wayland = GDK_WAYLAND_DISPLAY (display);
1265
1266   device = g_new0 (GdkWaylandDevice, 1);
1267   device->display = display;
1268   device->device_manager = device_manager;
1269
1270   device->wl_seat = wl_seat;
1271
1272   wl_seat_add_listener (device->wl_seat, &seat_listener, device);
1273   wl_seat_set_user_data (device->wl_seat, device);
1274
1275   device->data_device =
1276     wl_data_device_manager_get_data_device (display_wayland->data_device_manager,
1277                                             device->wl_seat);
1278   wl_data_device_add_listener (device->data_device,
1279                                &data_device_listener, device);
1280
1281   device->pointer_surface =
1282     wl_compositor_create_surface (display_wayland->compositor);
1283 }
1284
1285 static void
1286 free_device (gpointer data)
1287 {
1288   g_object_unref (data);
1289 }
1290
1291 static void
1292 gdk_device_manager_core_finalize (GObject *object)
1293 {
1294   GdkDeviceManagerCore *device_manager_core;
1295
1296   device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
1297
1298   g_list_free_full (device_manager_core->devices, free_device);
1299
1300   G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
1301 }
1302
1303 static GList *
1304 gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
1305                                       GdkDeviceType     type)
1306 {
1307   GdkDeviceManagerCore *device_manager_core;
1308   GList *devices = NULL;
1309
1310   if (type == GDK_DEVICE_TYPE_MASTER)
1311     {
1312       device_manager_core = (GdkDeviceManagerCore *) device_manager;
1313       devices = g_list_copy(device_manager_core->devices);
1314     }
1315
1316   return devices;
1317 }
1318
1319 static GdkDevice *
1320 gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
1321 {
1322   GdkDeviceManagerCore *device_manager_core;
1323
1324   device_manager_core = (GdkDeviceManagerCore *) device_manager;
1325   return device_manager_core->devices->data;
1326 }
1327
1328 static void
1329 gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
1330 {
1331   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
1332   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1333
1334   object_class->finalize = gdk_device_manager_core_finalize;
1335   device_manager_class->list_devices = gdk_device_manager_core_list_devices;
1336   device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
1337 }
1338
1339 static void
1340 gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
1341 {
1342 }
1343
1344 GdkDeviceManager *
1345 _gdk_wayland_device_manager_new (GdkDisplay *display)
1346 {
1347   return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
1348                        "display", display,
1349                        NULL);
1350 }
1351
1352 gint
1353 gdk_wayland_device_get_selection_type_atoms (GdkDevice  *gdk_device,
1354                                              GdkAtom   **atoms_out)
1355 {
1356   gint i;
1357   GdkAtom *atoms;
1358   GdkWaylandDevice *device;
1359
1360   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1361   g_return_val_if_fail (atoms_out != NULL, 0);
1362
1363   device = GDK_DEVICE_CORE (gdk_device)->device;
1364
1365   if (!device->selection_offer || device->selection_offer->types->len == 0)
1366     {
1367       *atoms_out = NULL;
1368       return 0;
1369     }
1370
1371   atoms = g_new0 (GdkAtom, device->selection_offer->types->len);
1372
1373   /* Convert list of targets to atoms */
1374   for (i = 0; i < device->selection_offer->types->len; i++)
1375     {
1376       atoms[i] = gdk_atom_intern (device->selection_offer->types->pdata[i],
1377                                   FALSE);
1378       GDK_NOTE (MISC,
1379                 g_message (G_STRLOC ": Adding atom for %s",
1380                            (char *)device->selection_offer->types->pdata[i]));
1381     }
1382
1383   *atoms_out = atoms;
1384   return device->selection_offer->types->len;
1385 }
1386
1387 typedef struct
1388 {
1389   GdkWaylandDevice *device;
1390   DataOffer *offer;
1391   GIOChannel *channel;
1392   GdkDeviceWaylandRequestContentCallback cb;
1393   gpointer userdata;
1394 } RequestContentClosure;
1395
1396 static gboolean
1397 _request_content_io_func (GIOChannel *channel,
1398                           GIOCondition condition,
1399                           gpointer userdata)
1400 {
1401   RequestContentClosure *closure = (RequestContentClosure *)userdata;
1402   gchar *data = NULL;
1403   gsize len = 0;
1404   GError *error = NULL;
1405
1406   /* FIXME: We probably want to do something better than this to avoid
1407    * blocking on the transfer of large pieces of data: call the callback
1408    * multiple times I should think.
1409    */
1410   if (g_io_channel_read_to_end (channel,
1411                                 &data,
1412                                 &len,
1413                                 &error) != G_IO_STATUS_NORMAL)
1414     {
1415       g_warning (G_STRLOC ": Error reading content from pipe: %s", error->message);
1416       g_clear_error (&error);
1417     }
1418
1419   /* Since we use _read_to_end we've got a guaranteed EOF and thus can go
1420    * ahead and close the fd
1421    */
1422   g_io_channel_shutdown (channel, TRUE, NULL);
1423
1424   closure->cb (closure->device->pointer, data, len, closure->userdata);
1425
1426   g_free (data);
1427   data_offer_unref (closure->offer);
1428   g_io_channel_unref (channel);
1429   g_free (closure);
1430
1431   return FALSE;
1432 }
1433
1434 gboolean
1435 gdk_wayland_device_request_selection_content (GdkDevice                              *gdk_device,
1436                                               const gchar                            *requested_mime_type,
1437                                               GdkDeviceWaylandRequestContentCallback  cb,
1438                                               gpointer                                userdata)
1439 {
1440   int pipe_fd[2];
1441   RequestContentClosure *closure;
1442   GdkWaylandDevice *device;
1443   GError *error = NULL;
1444
1445   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), FALSE);
1446   g_return_val_if_fail (requested_mime_type != NULL, FALSE);
1447   g_return_val_if_fail (cb != NULL, FALSE);
1448
1449   device = GDK_DEVICE_CORE (gdk_device)->device;
1450
1451   if (!device->selection_offer)
1452       return FALSE;
1453
1454   /* TODO: Check mimetypes */
1455
1456   closure = g_new0 (RequestContentClosure, 1);
1457
1458   device->selection_offer->ref_count++;
1459
1460   pipe2 (pipe_fd, O_CLOEXEC);
1461   wl_data_offer_receive (device->selection_offer->offer,
1462                          requested_mime_type,
1463                          pipe_fd[1]);
1464   close (pipe_fd[1]);
1465
1466   closure->device = device;
1467   closure->offer = device->selection_offer;
1468   closure->channel = g_io_channel_unix_new (pipe_fd[0]);
1469   closure->cb = cb;
1470   closure->userdata = userdata;
1471
1472   if (!g_io_channel_set_encoding (closure->channel, NULL, &error))
1473     {
1474       g_warning (G_STRLOC ": Error setting encoding on channel: %s",
1475                  error->message);
1476       g_clear_error (&error);
1477       goto error;
1478     }
1479
1480   g_io_add_watch (closure->channel,
1481                   G_IO_IN,
1482                   _request_content_io_func,
1483                   closure);
1484
1485   return TRUE;
1486
1487 error:
1488   data_offer_unref (closure->offer);
1489   g_io_channel_unref (closure->channel);
1490   close (pipe_fd[1]);
1491   g_free (closure);
1492
1493   return FALSE;
1494 }
1495
1496 struct _GdkWaylandSelectionOffer {
1497   GdkDeviceWaylandOfferContentCallback cb;
1498   gpointer userdata;
1499   struct wl_data_source *source;
1500   GdkWaylandDevice *device;
1501 };
1502
1503 static void
1504 data_source_target (void                  *data,
1505                     struct wl_data_source *source,
1506                     const char            *mime_type)
1507 {
1508   g_debug (G_STRLOC ": %s source = %p, mime_type = %s",
1509            G_STRFUNC, source, mime_type);
1510 }
1511
1512 static void
1513 data_source_send (void                  *data,
1514                   struct wl_data_source *source,
1515                   const char            *mime_type,
1516                   int32_t                fd)
1517 {
1518   GdkWaylandSelectionOffer *offer = (GdkWaylandSelectionOffer *)data;;
1519   gchar *buf;
1520   gssize len, bytes_written = 0;
1521
1522   g_debug (G_STRLOC ": %s source = %p, mime_type = %s fd = %d",
1523            G_STRFUNC, source, mime_type, fd);
1524
1525   buf = offer->cb (offer->device->pointer, mime_type, &len, offer->userdata);
1526
1527   while (len > 0)
1528     {
1529       bytes_written += write (fd, buf + bytes_written, len);
1530       if (bytes_written == -1)
1531         goto error;
1532       len -= bytes_written;
1533     }
1534
1535   close (fd);
1536   g_free (buf);
1537
1538   return;
1539 error:
1540
1541   g_warning (G_STRLOC ": Error writing data to client: %s",
1542              g_strerror (errno));
1543
1544   close (fd);
1545   g_free (buf);
1546 }
1547
1548 static void
1549 data_source_cancelled (void                  *data,
1550                        struct wl_data_source *source)
1551 {
1552   g_debug (G_STRLOC ": %s source = %p",
1553            G_STRFUNC, source);
1554 }
1555
1556 static const struct wl_data_source_listener data_source_listener = {
1557     data_source_target,
1558     data_source_send,
1559     data_source_cancelled
1560 };
1561
1562 static guint32
1563 _wl_time_now (void)
1564 {
1565   struct timeval tv;
1566
1567   gettimeofday(&tv, NULL);
1568
1569   return tv.tv_sec * 1000 + tv.tv_usec / 1000;
1570 }
1571
1572 gboolean
1573 gdk_wayland_device_offer_selection_content (GdkDevice                             *gdk_device,
1574                                             const gchar                          **mime_types,
1575                                             gint                                   nr_mime_types,
1576                                             GdkDeviceWaylandOfferContentCallback   cb,
1577                                             gpointer                               userdata)
1578 {
1579   GdkDisplay *display;
1580   GdkWaylandDisplay *display_wayland;
1581   GdkWaylandSelectionOffer *offer;
1582   GdkWaylandDevice *device;
1583   gint i;
1584
1585   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1586   device = GDK_DEVICE_CORE (gdk_device)->device;
1587
1588   display = device->display;
1589   display_wayland = GDK_WAYLAND_DISPLAY (display);
1590
1591   offer = g_new0 (GdkWaylandSelectionOffer, 1);
1592   offer->cb = cb;
1593   offer->userdata = userdata;
1594   offer->source =
1595     wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
1596   offer->device = device;
1597
1598   for (i = 0; i < nr_mime_types; i++)
1599     {
1600       wl_data_source_offer (offer->source,
1601                             mime_types[i]);
1602     }
1603
1604   wl_data_source_add_listener (offer->source,
1605                                &data_source_listener,
1606                                offer);
1607
1608   wl_data_device_set_selection (device->data_device,
1609                                 offer->source,
1610                                 _wl_time_now ());
1611
1612   device->selection_offer_out = offer;
1613
1614   return TRUE;
1615 }
1616
1617 gboolean
1618 gdk_wayland_device_clear_selection_content (GdkDevice *gdk_device)
1619 {
1620   GdkWaylandDevice *device;
1621
1622   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1623   device = GDK_DEVICE_CORE (gdk_device)->device;
1624
1625   if (!device->selection_offer_out)
1626     return FALSE;
1627
1628   wl_data_device_set_selection (device->data_device,
1629                                 NULL,
1630                                 _wl_time_now ());
1631
1632   wl_data_source_destroy (device->selection_offer_out->source);
1633   g_free (device->selection_offer_out);
1634   device->selection_offer_out = NULL;
1635
1636   return TRUE;
1637 }