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