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