Pileus Git - ~andy/gtk/blob - gdk/wayland/gdkdevice-wayland.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <errno.h>
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26 #include <gdk/gdkwindow.h>
  27 #include <gdk/gdktypes.h>
  28 #include "gdkprivate-wayland.h"
  29 #include "gdkwayland.h"
  30 #include "gdkkeysyms.h"
  31 #include "gdkdeviceprivate.h"
  32 #include "gdkdevicemanagerprivate.h"
  33 #include "gdkprivate-wayland.h"
  34
  35 #include <xkbcommon/xkbcommon.h>
  36 #include <X11/keysym.h>
  37
  38 #include <sys/time.h>
  39
  40 #define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
  41 #define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
  42 #define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  43 #define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
  44 #define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
  45 #define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  46
  47 typedef struct _GdkDeviceCore GdkDeviceCore;
  48 typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
  49 typedef struct _GdkWaylandDevice GdkWaylandDevice;
  50
  51 typedef struct _DataOffer DataOffer;
  52
  53 typedef struct _GdkWaylandSelectionOffer GdkWaylandSelectionOffer;
  54
  55 struct _GdkWaylandDevice
  56 {
  57   GdkDisplay *display;
  58   GdkDevice *pointer;
  59   GdkDevice *keyboard;
  60   GdkModifierType modifiers;
  61   GdkWindow *pointer_focus;
  62   GdkWindow *keyboard_focus;
  63   struct wl_input_device *device;
  64   struct wl_data_device *data_device;
  65   int32_t x, y, 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
  79 struct _GdkDeviceCore
  80 {
  81   GdkDevice parent_instance;
  82   GdkWaylandDevice *device;
  83 };
  84
  85 struct _GdkDeviceCoreClass
  86 {
  87   GdkDeviceClass parent_class;
  88 };
  89
  90 G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
  91
  92 #define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
  93 #define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
  94 #define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
  95 #define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
  96 #define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
  97 #define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
  98
  99 typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
 100 typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
 101
 102 struct _GdkDeviceManagerCore
 103 {
 104   GdkDeviceManager parent_object;
 105   GdkDevice *core_pointer;
 106   GdkDevice *core_keyboard;
 107   GList *devices;
 108 };
 109
 110 struct _GdkDeviceManagerCoreClass
 111 {
 112   GdkDeviceManagerClass parent_class;
 113 };
 114
 115 G_DEFINE_TYPE (GdkDeviceManagerCore,
 116                gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
 117
 118 static gboolean
 119 gdk_device_core_get_history (GdkDevice      *device,
 120                              GdkWindow      *window,
 121                              guint32         start,
 122                              guint32         stop,
 123                              GdkTimeCoord ***events,
 124                              gint           *n_events)
 125 {
 126   return FALSE;
 127 }
 128
 129 static void
 130 gdk_device_core_get_state (GdkDevice       *device,
 131                            GdkWindow       *window,
 132                            gdouble         *axes,
 133                            GdkModifierType *mask)
 134 {
 135   gint x_int, y_int;
 136
 137   gdk_window_get_device_position (window, device, &x_int, &y_int, mask);
 138
 139   if (axes)
 140     {
 141       axes[0] = x_int;
 142       axes[1] = y_int;
 143     }
 144 }
 145
 146 static void
 147 gdk_device_core_set_window_cursor (GdkDevice *device,
 148                                    GdkWindow *window,
 149                                    GdkCursor *cursor)
 150 {
 151   GdkWaylandDevice *wd = GDK_DEVICE_CORE(device)->device;
 152   struct wl_buffer *buffer;
 153   int x, y;
 154
 155   if (cursor)
 156     g_object_ref (cursor);
 157
 158   /* Setting the cursor to NULL means that we should use the default cursor */
 159   if (!cursor)
 160     {
 161       /* FIXME: Is this the best sensible default ? */
 162       cursor = _gdk_wayland_display_get_cursor_for_type (device->display,
 163                                                          GDK_LEFT_PTR);
 164     }
 165
 166   buffer = _gdk_wayland_cursor_get_buffer(cursor, &x, &y);
 167   wl_input_device_attach(wd->device, wd->time, buffer, x, y);
 168
 169   g_object_unref (cursor);
 170 }
 171
 172 static void
 173 gdk_device_core_warp (GdkDevice *device,
 174                       GdkScreen *screen,
 175                       gint       x,
 176                       gint       y)
 177 {
 178 }
 179
 180 static void
 181 gdk_device_core_query_state (GdkDevice        *device,
 182                              GdkWindow        *window,
 183                              GdkWindow       **root_window,
 184                              GdkWindow       **child_window,
 185                              gint             *root_x,
 186                              gint             *root_y,
 187                              gint             *win_x,
 188                              gint             *win_y,
 189                              GdkModifierType  *mask)
 190 {
 191   GdkWaylandDevice *wd;
 192   GdkScreen *default_screen;
 193
 194   wd = GDK_DEVICE_CORE(device)->device;
 195   default_screen = gdk_display_get_default_screen (wd->display);
 196
 197   if (root_window)
 198     *root_window = gdk_screen_get_root_window (default_screen);
 199   if (child_window)
 200     *child_window = wd->pointer_focus;
 201   if (root_x)
 202     *root_x = wd->x;
 203   if (root_y)
 204     *root_y = wd->y;
 205   if (win_x)
 206     *win_x = wd->surface_x;
 207   if (win_y)
 208     *win_y = wd->surface_y;
 209   if (mask)
 210     *mask = wd->modifiers;
 211 }
 212
 213 static GdkGrabStatus
 214 gdk_device_core_grab (GdkDevice    *device,
 215                       GdkWindow    *window,
 216                       gboolean      owner_events,
 217                       GdkEventMask  event_mask,
 218                       GdkWindow    *confine_to,
 219                       GdkCursor    *cursor,
 220                       guint32       time_)
 221 {
 222   GdkWaylandDevice *wayland_device = GDK_DEVICE_CORE (device)->device;
 223
 224   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
 225     {
 226       /* Device is a keyboard */
 227       return GDK_GRAB_SUCCESS;
 228     }
 229   else
 230     {
 231       /* Device is a pointer */
 232
 233       if (wayland_device->pointer_grab_window != NULL &&
 234           time_ != 0 && wayland_device->pointer_grab_time > time_)
 235         {
 236           return GDK_GRAB_ALREADY_GRABBED;
 237         }
 238
 239       if (time_ == 0)
 240         time_ = wayland_device->time;
 241
 242       wayland_device->pointer_grab_window = window;
 243       wayland_device->pointer_grab_time = time_;
 244
 245       /* FIXME: This probably breaks if you end up with multiple grabs on the
 246        * same window - but we need to know the input device for when we are
 247        * asked to map a popup window so that the grab can be managed by the
 248        * compositor.
 249        */
 250       _gdk_wayland_window_set_device_grabbed (window,
 251                                               wayland_device->device,
 252                                               time_);
 253     }
 254
 255   return GDK_GRAB_SUCCESS;
 256 }
 257
 258 static void
 259 gdk_device_core_ungrab (GdkDevice *device,
 260                         guint32    time_)
 261 {
 262   GdkWaylandDevice *wayland_device = GDK_DEVICE_CORE (device)->device;
 263   GdkDisplay *display;
 264   GdkDeviceGrabInfo *grab;
 265
 266   display = gdk_device_get_display (device);
 267
 268   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
 269     {
 270       /* Device is a keyboard */
 271     }
 272   else
 273     {
 274       /* Device is a pointer */
 275       grab = _gdk_display_get_last_device_grab (display, device);
 276
 277       if (grab)
 278         grab->serial_end = grab->serial_start;
 279
 280       if (wayland_device->pointer_grab_window)
 281         _gdk_wayland_window_set_device_grabbed (wayland_device->pointer_grab_window,
 282                                                 NULL,
 283                                                 0);
 284     }
 285 }
 286
 287 static GdkWindow *
 288 gdk_device_core_window_at_position (GdkDevice       *device,
 289                                     gint            *win_x,
 290                                     gint            *win_y,
 291                                     GdkModifierType *mask,
 292                                     gboolean         get_toplevel)
 293 {
 294   GdkWaylandDevice *wd;
 295
 296   wd = GDK_DEVICE_CORE(device)->device;
 297   if (win_x)
 298     *win_x = wd->surface_x;
 299   if (win_y)
 300     *win_y = wd->surface_y;
 301   if (mask)
 302     *mask = wd->modifiers;
 303
 304   return wd->pointer_focus;
 305 }
 306
 307 static void
 308 gdk_device_core_select_window_events (GdkDevice    *device,
 309                                       GdkWindow    *window,
 310                                       GdkEventMask  event_mask)
 311 {
 312 }
 313
 314 static void
 315 gdk_device_core_class_init (GdkDeviceCoreClass *klass)
 316 {
 317   GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
 318
 319   device_class->get_history = gdk_device_core_get_history;
 320   device_class->get_state = gdk_device_core_get_state;
 321   device_class->set_window_cursor = gdk_device_core_set_window_cursor;
 322   device_class->warp = gdk_device_core_warp;
 323   device_class->query_state = gdk_device_core_query_state;
 324   device_class->grab = gdk_device_core_grab;
 325   device_class->ungrab = gdk_device_core_ungrab;
 326   device_class->window_at_position = gdk_device_core_window_at_position;
 327   device_class->select_window_events = gdk_device_core_select_window_events;
 328 }
 329
 330 static void
 331 gdk_device_core_init (GdkDeviceCore *device_core)
 332 {
 333   GdkDevice *device;
 334
 335   device = GDK_DEVICE (device_core);
 336
 337   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
 338   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
 339 }
 340
 341 struct wl_input_device *
 342 _gdk_wayland_device_get_device (GdkDevice *device)
 343 {
 344   return GDK_DEVICE_CORE (device)->device->device;
 345 }
 346
 347 static void
 348 input_handle_motion(void *data, struct wl_input_device *input_device,
 349                     uint32_t time,
 350                     int32_t x, int32_t y, int32_t sx, int32_t sy)
 351 {
 352   GdkWaylandDevice *device = data;
 353   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
 354   GdkEvent *event;
 355
 356   event = gdk_event_new (GDK_NOTHING);
 357
 358   device->time = time;
 359   device->x = x;
 360   device->y = y;
 361   device->surface_x = sx;
 362   device->surface_y = sy;
 363
 364   event->motion.type = GDK_MOTION_NOTIFY;
 365   event->motion.window = g_object_ref (device->pointer_focus);
 366   gdk_event_set_device (event, device->pointer);
 367   event->motion.time = time;
 368   event->motion.x = (gdouble) sx;
 369   event->motion.y = (gdouble) sy;
 370   event->motion.x_root = (gdouble) x;
 371   event->motion.y_root = (gdouble) y;
 372   event->motion.axes = NULL;
 373   event->motion.state = device->modifiers;
 374   event->motion.is_hint = 0;
 375   gdk_event_set_screen (event, display->screen);
 376
 377   GDK_NOTE (EVENTS,
 378             g_message ("motion %d %d, state %d",
 379                        sx, sy, event->button.state));
 380
 381   _gdk_wayland_display_deliver_event (device->display, event);
 382 }
 383
 384 static void
 385 input_handle_button(void *data, struct wl_input_device *input_device,
 386                      uint32_t time, uint32_t button, uint32_t state)
 387 {
 388   GdkWaylandDevice *device = data;
 389   GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (device->display);
 390   GdkEvent *event;
 391   uint32_t modifier;
 392   int gdk_button;
 393
 394   switch (button) {
 395   case 273:
 396     gdk_button = 3;
 397     break;
 398   case 274:
 399     gdk_button = 2;
 400     break;
 401   default:
 402     gdk_button = button - 271;
 403     break;
 404   }
 405
 406   device->time = time;
 407   event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 408   event->button.window = g_object_ref (device->pointer_focus);
 409   gdk_event_set_device (event, device->pointer);
 410   event->button.time = time;
 411   event->button.x = (gdouble) device->surface_x;
 412   event->button.y = (gdouble) device->surface_y;
 413   event->button.x_root = (gdouble) device->x;
 414   event->button.y_root = (gdouble) device->y;
 415   event->button.axes = NULL;
 416   event->button.state = device->modifiers;
 417   event->button.button = gdk_button;
 418   gdk_event_set_screen (event, display->screen);
 419
 420   modifier = 1 << (8 + gdk_button - 1);
 421   if (state)
 422     device->modifiers |= modifier;
 423   else
 424     device->modifiers &= ~modifier;
 425
 426   GDK_NOTE (EVENTS,
 427             g_message ("button %d %s, state %d",
 428                        event->button.button,
 429                        state ? "press" : "release", event->button.state));
 430
 431   _gdk_wayland_display_deliver_event (device->display, event);
 432 }
 433
 434 static void
 435 translate_keyboard_string (GdkEventKey *event)
 436 {
 437   gunichar c = 0;
 438   gchar buf[7];
 439
 440   /* Fill in event->string crudely, since various programs
 441    * depend on it.
 442    */
 443   event->string = NULL;
 444
 445   if (event->keyval != GDK_KEY_VoidSymbol)
 446     c = gdk_keyval_to_unicode (event->keyval);
 447
 448   if (c)
 449     {
 450       gsize bytes_written;
 451       gint len;
 452
 453       /* Apply the control key - Taken from Xlib
 454        */
 455       if (event->state & GDK_CONTROL_MASK)
 456         {
 457           if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
 458           else if (c == '2')
 459             {
 460               event->string = g_memdup ("\0\0", 2);
 461               event->length = 1;
 462               buf[0] = '\0';
 463               return;
 464             }
 465           else if (c >= '3' && c <= '7') c -= ('3' - '\033');
 466           else if (c == '8') c = '\177';
 467           else if (c == '/') c = '_' & 0x1F;
 468         }
 469
 470       len = g_unichar_to_utf8 (c, buf);
 471       buf[len] = '\0';
 472
 473       event->string = g_locale_from_utf8 (buf, len,
 474                                           NULL, &bytes_written,
 475                                           NULL);
 476       if (event->string)
 477         event->length = bytes_written;
 478     }
 479   else if (event->keyval == GDK_KEY_Escape)
 480     {
 481       event->length = 1;
 482       event->string = g_strdup ("\033");
 483     }
 484   else if (event->keyval == GDK_KEY_Return ||
 485           event->keyval == GDK_KEY_KP_Enter)
 486     {
 487       event->length = 1;
 488       event->string = g_strdup ("\r");
 489     }
 490
 491   if (!event->string)
 492     {
 493       event->length = 0;
 494       event->string = g_strdup ("");
 495     }
 496 }
 497
 498 static gboolean
 499 keyboard_repeat (gpointer data);
 500
 501 static gboolean
 502 deliver_key_event(GdkWaylandDevice *device,
 503                   uint32_t time, uint32_t key, uint32_t state)
 504 {
 505   GdkEvent *event;
 506   uint32_t code, modifier, level;
 507   struct xkb_desc *xkb;
 508   GdkKeymap *keymap;
 509
 510   keymap = gdk_keymap_get_for_display (device->display);
 511   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 512
 513   device->time = time;
 514   event = gdk_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
 515   event->key.window = g_object_ref (device->keyboard_focus);
 516   gdk_event_set_device (event, device->keyboard);
 517   event->button.time = time;
 518   event->key.state = device->modifiers;
 519   event->key.group = 0;
 520   code = key + xkb->min_key_code;
 521   event->key.hardware_keycode = code;
 522
 523   level = 0;
 524   if (device->modifiers & XKB_COMMON_SHIFT_MASK &&
 525       XkbKeyGroupWidth(xkb, code, 0) > 1)
 526     level = 1;
 527
 528   event->key.keyval = XkbKeySymEntry(xkb, code, level, 0);
 529
 530   modifier = xkb->map->modmap[code];
 531   if (state)
 532     device->modifiers |= modifier;
 533   else
 534     device->modifiers &= ~modifier;
 535
 536   event->key.is_modifier = modifier > 0;
 537
 538   translate_keyboard_string (&event->key);
 539
 540   _gdk_wayland_display_deliver_event (device->display, event);
 541
 542   GDK_NOTE (EVENTS,
 543             g_message ("keyboard event, code %d, sym %d, "
 544                        "string %s, mods 0x%x",
 545                        code, event->key.keyval,
 546                        event->key.string, event->key.state));
 547
 548   device->repeat_count++;
 549   device->repeat_key = key;
 550
 551   if (state == 0)
 552     {
 553       if (device->repeat_timer)
 554         {
 555           g_source_remove (device->repeat_timer);
 556           device->repeat_timer = 0;
 557         }
 558       return FALSE;
 559     }
 560   else if (modifier)
 561     {
 562       return FALSE;
 563     }
 564   else switch (device->repeat_count)
 565     {
 566     case 1:
 567       if (device->repeat_timer)
 568         {
 569           g_source_remove (device->repeat_timer);
 570           device->repeat_timer = 0;
 571         }
 572
 573       device->repeat_timer =
 574         gdk_threads_add_timeout (400, keyboard_repeat, device);
 575       return TRUE;
 576     case 2:
 577       device->repeat_timer =
 578         gdk_threads_add_timeout (80, keyboard_repeat, device);
 579       return FALSE;
 580     default:
 581       return TRUE;
 582     }
 583 }
 584
 585 static gboolean
 586 keyboard_repeat (gpointer data)
 587 {
 588   GdkWaylandDevice *device = data;
 589
 590   return deliver_key_event (device, device->time, device->repeat_key, 1);
 591 }
 592
 593 static void
 594 input_handle_key(void *data, struct wl_input_device *input_device,
 595                  uint32_t time, uint32_t key, uint32_t state)
 596 {
 597   GdkWaylandDevice *device = data;
 598
 599   device->repeat_count = 0;
 600   deliver_key_event (data, time, key, state);
 601 }
 602
 603 static void
 604 input_handle_pointer_focus(void *data,
 605                            struct wl_input_device *input_device,
 606                            uint32_t time, struct wl_surface *surface,
 607                            int32_t x, int32_t y, int32_t sx, int32_t sy)
 608 {
 609   GdkWaylandDevice *device = data;
 610   GdkEvent *event;
 611
 612   device->time = time;
 613   if (device->pointer_focus)
 614     {
 615       event = gdk_event_new (GDK_LEAVE_NOTIFY);
 616       event->crossing.window = g_object_ref (device->pointer_focus);
 617       gdk_event_set_device (event, device->pointer);
 618       event->crossing.subwindow = NULL;
 619       event->crossing.time = time;
 620       event->crossing.x = (gdouble) device->surface_x;
 621       event->crossing.y = (gdouble) device->surface_y;
 622       event->crossing.x_root = (gdouble) device->x;
 623       event->crossing.y_root = (gdouble) device->y;
 624
 625       event->crossing.mode = GDK_CROSSING_NORMAL;
 626       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 627       event->crossing.focus = TRUE;
 628       event->crossing.state = 0;
 629
 630       _gdk_wayland_display_deliver_event (device->display, event);
 631
 632       GDK_NOTE (EVENTS,
 633                 g_message ("leave, device %p surface %p",
 634                            device, device->pointer_focus));
 635
 636       g_object_unref(device->pointer_focus);
 637       device->pointer_focus = NULL;
 638     }
 639
 640   if (surface)
 641     {
 642       device->pointer_focus = wl_surface_get_user_data(surface);
 643       g_object_ref(device->pointer_focus);
 644
 645       event = gdk_event_new (GDK_ENTER_NOTIFY);
 646       event->crossing.window = g_object_ref (device->pointer_focus);
 647       gdk_event_set_device (event, device->pointer);
 648       event->crossing.subwindow = NULL;
 649       event->crossing.time = time;
 650       event->crossing.x = (gdouble) sx;
 651       event->crossing.y = (gdouble) sy;
 652       event->crossing.x_root = (gdouble) x;
 653       event->crossing.y_root = (gdouble) y;
 654
 655       event->crossing.mode = GDK_CROSSING_NORMAL;
 656       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 657       event->crossing.focus = TRUE;
 658       event->crossing.state = 0;
 659
 660       device->surface_x = sx;
 661       device->surface_y = sy;
 662       device->x = x;
 663       device->y = y;
 664
 665       _gdk_wayland_display_deliver_event (device->display, event);
 666
 667       GDK_NOTE (EVENTS,
 668                 g_message ("enter, device %p surface %p",
 669                            device, device->pointer_focus));
 670     }
 671 }
 672
 673 static void
 674 update_modifiers(GdkWaylandDevice *device, struct wl_array *keys)
 675 {
 676   uint32_t *k, *end;
 677   GdkKeymap *keymap;
 678   struct xkb_desc *xkb;
 679
 680   keymap = gdk_keymap_get_for_display (device->display);
 681   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 682
 683   end = keys->data + keys->size;
 684   device->modifiers = 0;
 685   for (k = keys->data; k < end; k++)
 686     device->modifiers |= xkb->map->modmap[*k];
 687 }
 688
 689 static void
 690 input_handle_keyboard_focus(void *data,
 691                             struct wl_input_device *input_device,
 692                             uint32_t time,
 693                             struct wl_surface *surface,
 694                             struct wl_array *keys)
 695 {
 696   GdkWaylandDevice *device = data;
 697   GdkEvent *event;
 698
 699   device->time = time;
 700   if (device->keyboard_focus)
 701     {
 702       _gdk_wayland_window_remove_focus (device->keyboard_focus);
 703       event = gdk_event_new (GDK_FOCUS_CHANGE);
 704       event->focus_change.window = g_object_ref (device->keyboard_focus);
 705       event->focus_change.send_event = FALSE;
 706       event->focus_change.in = FALSE;
 707       gdk_event_set_device (event, device->keyboard);
 708
 709       g_object_unref(device->keyboard_focus);
 710       device->keyboard_focus = NULL;
 711
 712       GDK_NOTE (EVENTS,
 713                 g_message ("focus out, device %p surface %p",
 714                            device, device->keyboard_focus));
 715
 716       _gdk_wayland_display_deliver_event (device->display, event);
 717     }
 718
 719   if (surface)
 720     {
 721       device->keyboard_focus = wl_surface_get_user_data(surface);
 722       g_object_ref(device->keyboard_focus);
 723
 724       event = gdk_event_new (GDK_FOCUS_CHANGE);
 725       event->focus_change.window = g_object_ref (device->keyboard_focus);
 726       event->focus_change.send_event = FALSE;
 727       event->focus_change.in = TRUE;
 728       gdk_event_set_device (event, device->keyboard);
 729
 730       update_modifiers (device, keys);
 731
 732       GDK_NOTE (EVENTS,
 733                 g_message ("focus int, device %p surface %p",
 734                            device, device->keyboard_focus));
 735
 736       _gdk_wayland_display_deliver_event (device->display, event);
 737
 738       _gdk_wayland_window_add_focus (device->keyboard_focus);
 739     }
 740 }
 741
 742 static const struct wl_input_device_listener input_device_listener = {
 743   input_handle_motion,
 744   input_handle_button,
 745   input_handle_key,
 746   input_handle_pointer_focus,
 747   input_handle_keyboard_focus,
 748 };
 749
 750 struct _DataOffer {
 751   struct wl_data_offer *offer;
 752   gint ref_count;
 753   GPtrArray *types;
 754 };
 755
 756 static void
 757 data_offer_offer (void                 *data,
 758                   struct wl_data_offer *wl_data_offer,
 759                   const char           *type)
 760 {
 761   DataOffer *offer = (DataOffer *)data;
 762   g_debug (G_STRLOC ": %s wl_data_offer = %p type = %s",
 763            G_STRFUNC, wl_data_offer, type);
 764
 765   g_ptr_array_add (offer->types, g_strdup (type));
 766 }
 767
 768 static void
 769 data_offer_unref (DataOffer *offer)
 770 {
 771   offer->ref_count--;
 772
 773   if (offer->ref_count == 0)
 774     {
 775       g_ptr_array_free (offer->types, TRUE);
 776       g_free (offer);
 777     }
 778 }
 779
 780 static const struct wl_data_offer_listener data_offer_listener = {
 781   data_offer_offer,
 782 };
 783
 784 static void
 785 data_device_data_offer (void                  *data,
 786                         struct wl_data_device *data_device,
 787                         uint32_t               id)
 788 {
 789   DataOffer *offer;
 790
 791   g_debug (G_STRLOC ": %s data_device = %p id = %lu",
 792            G_STRFUNC, data_device, (long unsigned int)id);
 793
 794   /* This structure is reference counted to handle the case where you get a
 795    * leave but are in the middle of transferring data
 796    */
 797   offer = g_new0 (DataOffer, 1);
 798   offer->ref_count = 1;
 799   offer->types = g_ptr_array_new_with_free_func (g_free);
 800   offer->offer = (struct wl_data_offer *)
 801     wl_proxy_create_for_id ((struct wl_proxy *) data_device,
 802                             id,
 803                             &wl_data_offer_interface);
 804
 805   /* The DataOffer structure is then retrieved later since this sets the user
 806    * data.
 807    */
 808   wl_data_offer_add_listener (offer->offer,
 809                               &data_offer_listener,
 810                               offer);
 811 }
 812
 813 static void
 814 data_device_enter (void                  *data,
 815                    struct wl_data_device *data_device,
 816                    uint32_t               time,
 817                    struct wl_surface     *surface,
 818                    int32_t                x,
 819                    int32_t                y,
 820                    struct wl_data_offer  *offer)
 821 {
 822   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 823
 824   g_debug (G_STRLOC ": %s data_device = %p time = %d, surface = %p, x = %d y = %d, offer = %p",
 825            G_STRFUNC, data_device, time, surface, x, y, offer);
 826
 827   /* Retrieve the DataOffer associated with with the wl_data_offer - this
 828    * association is made when the listener is attached.
 829    */
 830   g_assert (device->drag_offer == NULL);
 831   device->drag_offer = wl_data_offer_get_user_data (offer);
 832 }
 833
 834 static void
 835 data_device_leave (void                  *data,
 836                    struct wl_data_device *data_device)
 837 {
 838   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 839
 840   g_debug (G_STRLOC ": %s data_device = %p",
 841            G_STRFUNC, data_device);
 842
 843   data_offer_unref (device->drag_offer);
 844   device->drag_offer = NULL;
 845 }
 846
 847 static void
 848 data_device_motion (void                  *data,
 849                     struct wl_data_device *data_device,
 850                     uint32_t               time,
 851                     int32_t                x,
 852                     int32_t                y)
 853 {
 854   g_debug (G_STRLOC ": %s data_device = %p, time = %d, x = %d, y = %d",
 855            G_STRFUNC, data_device, time, x, y);
 856 }
 857
 858 static void
 859 data_device_drop (void                  *data,
 860                   struct wl_data_device *data_device)
 861 {
 862   g_debug (G_STRLOC ": %s data_device = %p",
 863            G_STRFUNC, data_device);
 864 }
 865
 866 static void
 867 data_device_selection (void                  *data,
 868                        struct wl_data_device *wl_data_device,
 869                        struct wl_data_offer  *offer)
 870 {
 871   GdkWaylandDevice *device = (GdkWaylandDevice *)data;
 872
 873   g_debug (G_STRLOC ": %s wl_data_device = %p wl_data_offer = %p",
 874            G_STRFUNC, wl_data_device, offer);
 875
 876   if (!offer)
 877     {
 878       if (device->selection_offer)
 879         {
 880           data_offer_unref (device->selection_offer);
 881           device->selection_offer = NULL;
 882         }
 883
 884       return;
 885     }
 886
 887   if (device->selection_offer)
 888     {
 889       data_offer_unref (device->selection_offer);
 890       device->selection_offer = NULL;
 891     }
 892
 893   /* Retrieve the DataOffer associated with with the wl_data_offer - this
 894    * association is made when the listener is attached.
 895    */
 896   g_assert (device->selection_offer == NULL);
 897   device->selection_offer = wl_data_offer_get_user_data (offer);
 898 }
 899
 900 static const struct wl_data_device_listener data_device_listener = {
 901   data_device_data_offer,
 902   data_device_enter,
 903   data_device_leave,
 904   data_device_motion,
 905   data_device_drop,
 906   data_device_selection
 907 };
 908
 909 void
 910 _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,
 911                                         struct wl_input_device *wl_device)
 912 {
 913   GdkDisplay *display;
 914   GdkWaylandDisplay *display_wayland;
 915   GdkDeviceManagerCore *device_manager_core =
 916     GDK_DEVICE_MANAGER_CORE(device_manager);
 917   GdkWaylandDevice *device;
 918
 919   device = g_new0 (GdkWaylandDevice, 1);
 920   display = gdk_device_manager_get_display (device_manager);
 921   display_wayland = GDK_WAYLAND_DISPLAY (display);
 922
 923   device->display = display;
 924   device->pointer = g_object_new (GDK_TYPE_DEVICE_CORE,
 925                                   "name", "Core Pointer",
 926                                   "type", GDK_DEVICE_TYPE_MASTER,
 927                                   "input-source", GDK_SOURCE_MOUSE,
 928                                   "input-mode", GDK_MODE_SCREEN,
 929                                   "has-cursor", TRUE,
 930                                   "display", display,
 931                                   "device-manager", device_manager,
 932                                   NULL);
 933
 934   device->keyboard = g_object_new (GDK_TYPE_DEVICE_CORE,
 935                                    "name", "Core Keyboard",
 936                                    "type", GDK_DEVICE_TYPE_MASTER,
 937                                    "input-source", GDK_SOURCE_KEYBOARD,
 938                                    "input-mode", GDK_MODE_SCREEN,
 939                                    "has-cursor", FALSE,
 940                                    "display", display,
 941                                    "device-manager", device_manager,
 942                                    NULL);
 943
 944   GDK_DEVICE_CORE (device->pointer)->device = device;
 945   GDK_DEVICE_CORE (device->keyboard)->device = device;
 946   device->device = wl_device;
 947
 948   wl_input_device_add_listener(device->device,
 949                                &input_device_listener, device);
 950
 951   device->data_device =
 952     wl_data_device_manager_get_data_device (display_wayland->data_device_manager,
 953                                             device->device);
 954   wl_data_device_add_listener (device->data_device,
 955                                &data_device_listener, device);
 956
 957   device_manager_core->devices =
 958     g_list_prepend (device_manager_core->devices, device->keyboard);
 959   device_manager_core->devices =
 960     g_list_prepend (device_manager_core->devices, device->pointer);
 961
 962   _gdk_device_set_associated_device (device->pointer, device->keyboard);
 963   _gdk_device_set_associated_device (device->keyboard, device->pointer);
 964 }
 965
 966 static void
 967 free_device (gpointer data)
 968 {
 969   g_object_unref (data);
 970 }
 971
 972 static void
 973 gdk_device_manager_core_finalize (GObject *object)
 974 {
 975   GdkDeviceManagerCore *device_manager_core;
 976
 977   device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
 978
 979   g_list_free_full (device_manager_core->devices, free_device);
 980
 981   G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
 982 }
 983
 984 static GList *
 985 gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
 986                                       GdkDeviceType     type)
 987 {
 988   GdkDeviceManagerCore *device_manager_core;
 989   GList *devices = NULL;
 990
 991   if (type == GDK_DEVICE_TYPE_MASTER)
 992     {
 993       device_manager_core = (GdkDeviceManagerCore *) device_manager;
 994       devices = g_list_copy(device_manager_core->devices);
 995     }
 996
 997   return devices;
 998 }
 999
1000 static GdkDevice *
1001 gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
1002 {
1003   GdkDeviceManagerCore *device_manager_core;
1004
1005   device_manager_core = (GdkDeviceManagerCore *) device_manager;
1006   return device_manager_core->devices->data;
1007 }
1008
1009 static void
1010 gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
1011 {
1012   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
1013   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1014
1015   object_class->finalize = gdk_device_manager_core_finalize;
1016   device_manager_class->list_devices = gdk_device_manager_core_list_devices;
1017   device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
1018 }
1019
1020 static void
1021 gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
1022 {
1023 }
1024
1025 GdkDeviceManager *
1026 _gdk_wayland_device_manager_new (GdkDisplay *display)
1027 {
1028   return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
1029                        "display", display,
1030                        NULL);
1031 }
1032
1033 gint
1034 gdk_wayland_device_get_selection_type_atoms (GdkDevice  *gdk_device,
1035                                              GdkAtom   **atoms_out)
1036 {
1037   gint i;
1038   GdkAtom *atoms;
1039   GdkWaylandDevice *device;
1040
1041   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1042   g_return_val_if_fail (atoms_out != NULL, 0);
1043
1044   device = GDK_DEVICE_CORE (gdk_device)->device;
1045
1046   if (!device->selection_offer || device->selection_offer->types->len == 0)
1047     {
1048       *atoms_out = NULL;
1049       return 0;
1050     }
1051
1052   atoms = g_new0 (GdkAtom, device->selection_offer->types->len);
1053
1054   /* Convert list of targets to atoms */
1055   for (i = 0; i < device->selection_offer->types->len; i++)
1056     {
1057       atoms[i] = gdk_atom_intern (device->selection_offer->types->pdata[i],
1058                                   FALSE);
1059       GDK_NOTE (MISC,
1060                 g_message (G_STRLOC ": Adding atom for %s",
1061                            (char *)device->selection_offer->types->pdata[i]));
1062     }
1063
1064   *atoms_out = atoms;
1065   return device->selection_offer->types->len;
1066 }
1067
1068 typedef struct
1069 {
1070   GdkWaylandDevice *device;
1071   DataOffer *offer;
1072   GIOChannel *channel;
1073   GdkDeviceWaylandRequestContentCallback cb;
1074   gpointer userdata;
1075 } RequestContentClosure;
1076
1077 static gboolean
1078 _request_content_io_func (GIOChannel *channel,
1079                           GIOCondition condition,
1080                           gpointer userdata)
1081 {
1082   RequestContentClosure *closure = (RequestContentClosure *)userdata;
1083   gchar *data = NULL;
1084   gsize len = 0;
1085   GError *error = NULL;
1086
1087   /* FIXME: We probably want to do something better than this to avoid
1088    * blocking on the transfer of large pieces of data: call the callback
1089    * multiple times I should think.
1090    */
1091   if (g_io_channel_read_to_end (channel,
1092                                 &data,
1093                                 &len,
1094                                 &error) != G_IO_STATUS_NORMAL)
1095     {
1096       g_warning (G_STRLOC ": Error reading content from pipe: %s", error->message);
1097       g_clear_error (&error);
1098     }
1099
1100   /* Since we use _read_to_end we've got a guaranteed EOF and thus can go
1101    * ahead and close the fd
1102    */
1103   g_io_channel_shutdown (channel, TRUE, NULL);
1104
1105   closure->cb (closure->device->pointer, data, len, closure->userdata);
1106
1107   g_free (data);
1108   data_offer_unref (closure->offer);
1109   g_io_channel_unref (channel);
1110   g_free (closure);
1111
1112   return FALSE;
1113 }
1114
1115 gboolean
1116 gdk_wayland_device_request_selection_content (GdkDevice                              *gdk_device,
1117                                               const gchar                            *requested_mime_type,
1118                                               GdkDeviceWaylandRequestContentCallback  cb,
1119                                               gpointer                                userdata)
1120 {
1121   int pipe_fd[2];
1122   RequestContentClosure *closure;
1123   GdkWaylandDevice *device;
1124   GError *error = NULL;
1125
1126   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), FALSE);
1127   g_return_val_if_fail (requested_mime_type != NULL, FALSE);
1128   g_return_val_if_fail (cb != NULL, FALSE);
1129
1130   device = GDK_DEVICE_CORE (gdk_device)->device;
1131
1132   if (!device->selection_offer)
1133       return FALSE;
1134
1135   /* TODO: Check mimetypes */
1136
1137   closure = g_new0 (RequestContentClosure, 1);
1138
1139   device->selection_offer->ref_count++;
1140
1141   pipe2 (pipe_fd, O_CLOEXEC);
1142   wl_data_offer_receive (device->selection_offer->offer,
1143                          requested_mime_type,
1144                          pipe_fd[1]);
1145   close (pipe_fd[1]);
1146
1147   closure->device = device;
1148   closure->offer = device->selection_offer;
1149   closure->channel = g_io_channel_unix_new (pipe_fd[0]);
1150   closure->cb = cb;
1151   closure->userdata = userdata;
1152
1153   if (!g_io_channel_set_encoding (closure->channel, NULL, &error))
1154     {
1155       g_warning (G_STRLOC ": Error setting encoding on channel: %s",
1156                  error->message);
1157       g_clear_error (&error);
1158       goto error;
1159     }
1160
1161   g_io_add_watch (closure->channel,
1162                   G_IO_IN,
1163                   _request_content_io_func,
1164                   closure);
1165
1166   return TRUE;
1167
1168 error:
1169   data_offer_unref (closure->offer);
1170   g_io_channel_unref (closure->channel);
1171   close (pipe_fd[1]);
1172   g_free (closure);
1173
1174   return FALSE;
1175 }
1176
1177 struct _GdkWaylandSelectionOffer {
1178   GdkDeviceWaylandOfferContentCallback cb;
1179   gpointer userdata;
1180   struct wl_data_source *source;
1181   GdkWaylandDevice *device;
1182 };
1183
1184 static void
1185 data_source_target (void                  *data,
1186                     struct wl_data_source *source,
1187                     const char            *mime_type)
1188 {
1189   g_debug (G_STRLOC ": %s source = %p, mime_type = %s",
1190            G_STRFUNC, source, mime_type);
1191 }
1192
1193 static void
1194 data_source_send (void                  *data,
1195                   struct wl_data_source *source,
1196                   const char            *mime_type,
1197                   int32_t                fd)
1198 {
1199   GdkWaylandSelectionOffer *offer = (GdkWaylandSelectionOffer *)data;;
1200   gchar *buf;
1201   gssize len, bytes_written = 0;
1202
1203   g_debug (G_STRLOC ": %s source = %p, mime_type = %s fd = %d",
1204            G_STRFUNC, source, mime_type, fd);
1205
1206   buf = offer->cb (offer->device->pointer, mime_type, &len, offer->userdata);
1207
1208   while (len > 0)
1209     {
1210       bytes_written += write (fd, buf + bytes_written, len);
1211       if (bytes_written == -1)
1212         goto error;
1213       len -= bytes_written;
1214     }
1215
1216   close (fd);
1217   g_free (buf);
1218
1219   return;
1220 error:
1221
1222   g_warning (G_STRLOC ": Error writing data to client: %s",
1223              g_strerror (errno));
1224
1225   close (fd);
1226   g_free (buf);
1227 }
1228
1229 static void
1230 data_source_cancelled (void                  *data,
1231                        struct wl_data_source *source)
1232 {
1233   g_debug (G_STRLOC ": %s source = %p",
1234            G_STRFUNC, source);
1235 }
1236
1237 static const struct wl_data_source_listener data_source_listener = {
1238     data_source_target,
1239     data_source_send,
1240     data_source_cancelled
1241 };
1242
1243 static guint32
1244 _wl_time_now (void)
1245 {
1246   struct timeval tv;
1247
1248   gettimeofday(&tv, NULL);
1249
1250   return tv.tv_sec * 1000 + tv.tv_usec / 1000;
1251 }
1252
1253 gboolean
1254 gdk_wayland_device_offer_selection_content (GdkDevice                             *gdk_device,
1255                                             const gchar                          **mime_types,
1256                                             gint                                   nr_mime_types,
1257                                             GdkDeviceWaylandOfferContentCallback   cb,
1258                                             gpointer                               userdata)
1259 {
1260   GdkDisplay *display;
1261   GdkWaylandDisplay *display_wayland;
1262   GdkWaylandSelectionOffer *offer;
1263   GdkWaylandDevice *device;
1264   gint i;
1265
1266   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1267   device = GDK_DEVICE_CORE (gdk_device)->device;
1268
1269   display = device->display;
1270   display_wayland = GDK_WAYLAND_DISPLAY (display);
1271
1272   offer = g_new0 (GdkWaylandSelectionOffer, 1);
1273   offer->cb = cb;
1274   offer->userdata = userdata;
1275   offer->source =
1276     wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
1277   offer->device = device;
1278
1279   for (i = 0; i < nr_mime_types; i++)
1280     {
1281       wl_data_source_offer (offer->source,
1282                             mime_types[i]);
1283     }
1284
1285   wl_data_source_add_listener (offer->source,
1286                                &data_source_listener,
1287                                offer);
1288
1289   wl_data_device_set_selection (device->data_device,
1290                                 offer->source,
1291                                 _wl_time_now ());
1292
1293   device->selection_offer_out = offer;
1294
1295   return TRUE;
1296 }
1297
1298 gboolean
1299 gdk_wayland_device_clear_selection_content (GdkDevice *gdk_device)
1300 {
1301   GdkWaylandDevice *device;
1302
1303   g_return_val_if_fail (GDK_IS_DEVICE_CORE (gdk_device), 0);
1304   device = GDK_DEVICE_CORE (gdk_device)->device;
1305
1306   if (!device->selection_offer_out)
1307     return FALSE;
1308
1309   wl_data_device_set_selection (device->data_device,
1310                                 NULL,
1311                                 _wl_time_now ());
1312
1313   wl_data_source_destroy (device->selection_offer_out->source);
1314   g_free (device->selection_offer_out);
1315   device->selection_offer_out = NULL;
1316
1317   return TRUE;
1318 }