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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <string.h>
  23 #include <gdk/gdkwindow.h>
  24 #include <gdk/gdktypes.h>
  25 #include "gdkprivate-wayland.h"
  26 #include "gdkwayland.h"
  27 #include "gdkkeysyms.h"
  28 #include "gdkdeviceprivate.h"
  29 #include "gdkdevicemanagerprivate.h"
  30 #include "gdkprivate-wayland.h"
  31
  32 #include <X11/extensions/XKBcommon.h>
  33 #include <X11/keysym.h>
  34
  35 #define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
  36 #define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
  37 #define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  38 #define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
  39 #define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
  40 #define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
  41
  42 typedef struct _GdkDeviceCore GdkDeviceCore;
  43 typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
  44 typedef struct _GdkWaylandDevice GdkWaylandDevice;
  45
  46 struct _GdkWaylandDevice
  47 {
  48   GdkDisplay *display;
  49   GdkDevice *pointer;
  50   GdkDevice *keyboard;
  51   GdkModifierType modifiers;
  52   GdkWindow *pointer_focus;
  53   GdkWindow *keyboard_focus;
  54   struct wl_input_device *device;
  55   struct wl_data_device *data_device;
  56   int32_t x, y, surface_x, surface_y;
  57   uint32_t time;
  58 };
  59
  60 struct _GdkDeviceCore
  61 {
  62   GdkDevice parent_instance;
  63   GdkWaylandDevice *device;
  64 };
  65
  66 struct _GdkDeviceCoreClass
  67 {
  68   GdkDeviceClass parent_class;
  69 };
  70
  71 G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
  72
  73 #define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
  74 #define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
  75 #define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
  76 #define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
  77 #define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
  78 #define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
  79
  80 typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
  81 typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
  82
  83 struct _GdkDeviceManagerCore
  84 {
  85   GdkDeviceManager parent_object;
  86   GdkDevice *core_pointer;
  87   GdkDevice *core_keyboard;
  88   GList *devices;
  89 };
  90
  91 struct _GdkDeviceManagerCoreClass
  92 {
  93   GdkDeviceManagerClass parent_class;
  94 };
  95
  96 G_DEFINE_TYPE (GdkDeviceManagerCore,
  97                gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
  98
  99 static gboolean
 100 gdk_device_core_get_history (GdkDevice      *device,
 101                              GdkWindow      *window,
 102                              guint32         start,
 103                              guint32         stop,
 104                              GdkTimeCoord ***events,
 105                              gint           *n_events)
 106 {
 107   return FALSE;
 108 }
 109
 110 static void
 111 gdk_device_core_get_state (GdkDevice       *device,
 112                            GdkWindow       *window,
 113                            gdouble         *axes,
 114                            GdkModifierType *mask)
 115 {
 116   gint x_int, y_int;
 117
 118   gdk_window_get_device_position (window, device, &x_int, &y_int, mask);
 119
 120   if (axes)
 121     {
 122       axes[0] = x_int;
 123       axes[1] = y_int;
 124     }
 125 }
 126
 127 static void
 128 gdk_device_core_set_window_cursor (GdkDevice *device,
 129                                    GdkWindow *window,
 130                                    GdkCursor *cursor)
 131 {
 132   GdkWaylandDevice *wd = GDK_DEVICE_CORE(device)->device;
 133   struct wl_buffer *buffer;
 134   int x, y;
 135
 136   if (cursor)
 137     {
 138       buffer = _gdk_wayland_cursor_get_buffer(cursor, &x, &y);
 139       wl_input_device_attach(wd->device, wd->time, buffer, x, y);
 140     }
 141   else
 142     {
 143       wl_input_device_attach(wd->device, wd->time, NULL, 0, 0);
 144     }
 145 }
 146
 147 static void
 148 gdk_device_core_warp (GdkDevice *device,
 149                       GdkScreen *screen,
 150                       gint       x,
 151                       gint       y)
 152 {
 153 }
 154
 155 static gboolean
 156 gdk_device_core_query_state (GdkDevice        *device,
 157                              GdkWindow        *window,
 158                              GdkWindow       **root_window,
 159                              GdkWindow       **child_window,
 160                              gint             *root_x,
 161                              gint             *root_y,
 162                              gint             *win_x,
 163                              gint             *win_y,
 164                              GdkModifierType  *mask)
 165 {
 166   GdkWaylandDevice *wd;
 167   GdkScreen *default_screen;
 168
 169   wd = GDK_DEVICE_CORE(device)->device;
 170   default_screen = gdk_display_get_default_screen (wd->display);
 171
 172   if (root_window)
 173     *root_window = gdk_screen_get_root_window (default_screen);
 174   if (child_window)
 175     *child_window = wd->pointer_focus;
 176   if (root_x)
 177     *root_x = wd->x;
 178   if (root_y)
 179     *root_y = wd->y;
 180   if (win_x)
 181     *win_x = wd->surface_x;
 182   if (win_y)
 183     *win_y = wd->surface_y;
 184   if (mask)
 185     *mask = wd->modifiers;
 186
 187   return TRUE;
 188 }
 189
 190 static GdkGrabStatus
 191 gdk_device_core_grab (GdkDevice    *device,
 192                       GdkWindow    *window,
 193                       gboolean      owner_events,
 194                       GdkEventMask  event_mask,
 195                       GdkWindow    *confine_to,
 196                       GdkCursor    *cursor,
 197                       guint32       time_)
 198 {
 199   return GDK_GRAB_SUCCESS;
 200 }
 201
 202 static void
 203 gdk_device_core_ungrab (GdkDevice *device,
 204                         guint32    time_)
 205 {
 206 }
 207
 208 static GdkWindow *
 209 gdk_device_core_window_at_position (GdkDevice       *device,
 210                                     gint            *win_x,
 211                                     gint            *win_y,
 212                                     GdkModifierType *mask,
 213                                     gboolean         get_toplevel)
 214 {
 215   GdkWaylandDevice *wd;
 216
 217   wd = GDK_DEVICE_CORE(device)->device;
 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   return wd->pointer_focus;
 226 }
 227
 228 static void
 229 gdk_device_core_select_window_events (GdkDevice    *device,
 230                                       GdkWindow    *window,
 231                                       GdkEventMask  event_mask)
 232 {
 233 }
 234
 235 static void
 236 gdk_device_core_class_init (GdkDeviceCoreClass *klass)
 237 {
 238   GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
 239
 240   device_class->get_history = gdk_device_core_get_history;
 241   device_class->get_state = gdk_device_core_get_state;
 242   device_class->set_window_cursor = gdk_device_core_set_window_cursor;
 243   device_class->warp = gdk_device_core_warp;
 244   device_class->query_state = gdk_device_core_query_state;
 245   device_class->grab = gdk_device_core_grab;
 246   device_class->ungrab = gdk_device_core_ungrab;
 247   device_class->window_at_position = gdk_device_core_window_at_position;
 248   device_class->select_window_events = gdk_device_core_select_window_events;
 249 }
 250
 251 static void
 252 gdk_device_core_init (GdkDeviceCore *device_core)
 253 {
 254   GdkDevice *device;
 255
 256   device = GDK_DEVICE (device_core);
 257
 258   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
 259   _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
 260 }
 261
 262 struct wl_input_device *
 263 _gdk_wayland_device_get_device (GdkDevice *device)
 264 {
 265   return GDK_DEVICE_CORE (device)->device->device;
 266 }
 267
 268 static void
 269 input_handle_motion(void *data, struct wl_input_device *input_device,
 270                     uint32_t time,
 271                     int32_t x, int32_t y, int32_t sx, int32_t sy)
 272 {
 273   GdkWaylandDevice *device = data;
 274   GdkDisplayWayland *display = GDK_DISPLAY_WAYLAND (device->display);
 275   GdkEvent *event;
 276
 277   event = gdk_event_new (GDK_NOTHING);
 278
 279   device->time = time;
 280   device->x = x;
 281   device->y = y;
 282   device->surface_x = sx;
 283   device->surface_y = sy;
 284
 285   event->motion.type = GDK_MOTION_NOTIFY;
 286   event->motion.window = g_object_ref (device->pointer_focus);
 287   gdk_event_set_device (event, device->pointer);
 288   event->motion.time = time;
 289   event->motion.x = (gdouble) sx;
 290   event->motion.y = (gdouble) sy;
 291   event->motion.x_root = (gdouble) x;
 292   event->motion.y_root = (gdouble) y;
 293   event->motion.axes = NULL;
 294   event->motion.state = device->modifiers;
 295   event->motion.is_hint = 0;
 296   gdk_event_set_screen (event, display->screen);
 297
 298   GDK_NOTE (EVENTS,
 299             g_message ("motion %d %d, state %d",
 300                        sx, sy, event->button.state));
 301
 302   _gdk_wayland_display_deliver_event (device->display, event);
 303 }
 304
 305 static void
 306 input_handle_button(void *data, struct wl_input_device *input_device,
 307                      uint32_t time, uint32_t button, uint32_t state)
 308 {
 309   GdkWaylandDevice *device = data;
 310   GdkDisplayWayland *display = GDK_DISPLAY_WAYLAND (device->display);
 311   GdkEvent *event;
 312   uint32_t modifier;
 313
 314   device->time = time;
 315   event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 316   event->button.window = g_object_ref (device->pointer_focus);
 317   gdk_event_set_device (event, device->pointer);
 318   event->button.time = time;
 319   event->button.x = (gdouble) device->surface_x;
 320   event->button.y = (gdouble) device->surface_y;
 321   event->button.x_root = (gdouble) device->x;
 322   event->button.y_root = (gdouble) device->y;
 323   event->button.axes = NULL;
 324   event->button.state = device->modifiers;
 325   event->button.button = button - 271;
 326   gdk_event_set_screen (event, display->screen);
 327
 328   modifier = 1 << (8 + button - 272);
 329   if (state)
 330     device->modifiers |= modifier;
 331   else
 332     device->modifiers &= ~modifier;
 333
 334   GDK_NOTE (EVENTS,
 335             g_message ("button %d %s, state %d",
 336                        event->button.button,
 337                        state ? "press" : "release", event->button.state));
 338
 339   _gdk_wayland_display_deliver_event (device->display, event);
 340 }
 341
 342 static void
 343 translate_keyboard_string (GdkEventKey *event)
 344 {
 345   gunichar c = 0;
 346   gchar buf[7];
 347
 348   /* Fill in event->string crudely, since various programs
 349    * depend on it.
 350    */
 351   event->string = NULL;
 352
 353   if (event->keyval != GDK_KEY_VoidSymbol)
 354     c = gdk_keyval_to_unicode (event->keyval);
 355
 356   if (c)
 357     {
 358       gsize bytes_written;
 359       gint len;
 360
 361       /* Apply the control key - Taken from Xlib
 362        */
 363       if (event->state & GDK_CONTROL_MASK)
 364         {
 365           if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
 366           else if (c == '2')
 367             {
 368               event->string = g_memdup ("\0\0", 2);
 369               event->length = 1;
 370               buf[0] = '\0';
 371               return;
 372             }
 373           else if (c >= '3' && c <= '7') c -= ('3' - '\033');
 374           else if (c == '8') c = '\177';
 375           else if (c == '/') c = '_' & 0x1F;
 376         }
 377
 378       len = g_unichar_to_utf8 (c, buf);
 379       buf[len] = '\0';
 380
 381       event->string = g_locale_from_utf8 (buf, len,
 382                                           NULL, &bytes_written,
 383                                           NULL);
 384       if (event->string)
 385         event->length = bytes_written;
 386     }
 387   else if (event->keyval == GDK_KEY_Escape)
 388     {
 389       event->length = 1;
 390       event->string = g_strdup ("\033");
 391     }
 392   else if (event->keyval == GDK_KEY_Return ||
 393           event->keyval == GDK_KEY_KP_Enter)
 394     {
 395       event->length = 1;
 396       event->string = g_strdup ("\r");
 397     }
 398
 399   if (!event->string)
 400     {
 401       event->length = 0;
 402       event->string = g_strdup ("");
 403     }
 404 }
 405
 406 static void
 407 input_handle_key(void *data, struct wl_input_device *input_device,
 408                  uint32_t time, uint32_t key, uint32_t state)
 409 {
 410   GdkWaylandDevice *device = data;
 411   GdkEvent *event;
 412   uint32_t code, modifier, level;
 413   struct xkb_desc *xkb;
 414   GdkKeymap *keymap;
 415
 416   keymap = gdk_keymap_get_for_display (device->display);
 417   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 418
 419   device->time = time;
 420   event = gdk_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
 421   event->key.window = g_object_ref (device->keyboard_focus);
 422   gdk_event_set_device (event, device->keyboard);
 423   event->button.time = time;
 424   event->key.state = device->modifiers;
 425   event->key.group = 0;
 426   code = key + xkb->min_key_code;
 427   event->key.hardware_keycode = code;
 428
 429   level = 0;
 430   if (device->modifiers & XKB_COMMON_SHIFT_MASK &&
 431       XkbKeyGroupWidth(xkb, code, 0) > 1)
 432     level = 1;
 433
 434   event->key.keyval = XkbKeySymEntry(xkb, code, level, 0);
 435
 436   modifier = xkb->map->modmap[code];
 437   if (state)
 438     device->modifiers |= modifier;
 439   else
 440     device->modifiers &= ~modifier;
 441
 442   event->key.is_modifier = modifier > 0;
 443
 444   translate_keyboard_string (&event->key);
 445
 446   _gdk_wayland_display_deliver_event (device->display, event);
 447
 448   GDK_NOTE (EVENTS,
 449             g_message ("keyboard event, code %d, sym %d, "
 450                        "string %s, mods 0x%x",
 451                        code, event->key.keyval,
 452                        event->key.string, event->key.state));
 453 }
 454
 455 static void
 456 input_handle_pointer_focus(void *data,
 457                            struct wl_input_device *input_device,
 458                            uint32_t time, struct wl_surface *surface,
 459                            int32_t x, int32_t y, int32_t sx, int32_t sy)
 460 {
 461   GdkWaylandDevice *device = data;
 462   GdkEvent *event;
 463
 464   device->time = time;
 465   if (device->pointer_focus)
 466     {
 467       event = gdk_event_new (GDK_LEAVE_NOTIFY);
 468       event->crossing.window = g_object_ref (device->pointer_focus);
 469       gdk_event_set_device (event, device->pointer);
 470       event->crossing.subwindow = NULL;
 471       event->crossing.time = time;
 472       event->crossing.x = (gdouble) device->surface_x;
 473       event->crossing.y = (gdouble) device->surface_y;
 474       event->crossing.x_root = (gdouble) device->x;
 475       event->crossing.y_root = (gdouble) device->y;
 476
 477       event->crossing.mode = GDK_CROSSING_NORMAL;
 478       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 479       event->crossing.focus = TRUE;
 480       event->crossing.state = 0;
 481
 482       _gdk_wayland_display_deliver_event (device->display, event);
 483
 484       GDK_NOTE (EVENTS,
 485                 g_message ("leave, device %p surface %p",
 486                            device, device->pointer_focus));
 487
 488       g_object_unref(device->pointer_focus);
 489       device->pointer_focus = NULL;
 490     }
 491
 492   if (surface)
 493     {
 494       device->pointer_focus = wl_surface_get_user_data(surface);
 495       g_object_ref(device->pointer_focus);
 496
 497       event = gdk_event_new (GDK_ENTER_NOTIFY);
 498       event->crossing.window = g_object_ref (device->pointer_focus);
 499       gdk_event_set_device (event, device->pointer);
 500       event->crossing.subwindow = NULL;
 501       event->crossing.time = time;
 502       event->crossing.x = (gdouble) sx;
 503       event->crossing.y = (gdouble) sy;
 504       event->crossing.x_root = (gdouble) x;
 505       event->crossing.y_root = (gdouble) y;
 506
 507       event->crossing.mode = GDK_CROSSING_NORMAL;
 508       event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 509       event->crossing.focus = TRUE;
 510       event->crossing.state = 0;
 511
 512       device->surface_x = sx;
 513       device->surface_y = sy;
 514       device->x = x;
 515       device->y = y;
 516
 517       _gdk_wayland_display_deliver_event (device->display, event);
 518
 519       GDK_NOTE (EVENTS,
 520                 g_message ("enter, device %p surface %p",
 521                            device, device->pointer_focus));
 522     }
 523 }
 524
 525 static void
 526 update_modifiers(GdkWaylandDevice *device, struct wl_array *keys)
 527 {
 528   uint32_t *k, *end;
 529   GdkKeymap *keymap;
 530   struct xkb_desc *xkb;
 531
 532   keymap = gdk_keymap_get_for_display (device->display);
 533   xkb = _gdk_wayland_keymap_get_xkb_desc (keymap);
 534
 535   end = keys->data + keys->size;
 536   device->modifiers = 0;
 537   for (k = keys->data; k < end; k++)
 538     device->modifiers |= xkb->map->modmap[*k];
 539 }
 540
 541 static void
 542 input_handle_keyboard_focus(void *data,
 543                             struct wl_input_device *input_device,
 544                             uint32_t time,
 545                             struct wl_surface *surface,
 546                             struct wl_array *keys)
 547 {
 548   GdkWaylandDevice *device = data;
 549   GdkEvent *event;
 550
 551   device->time = time;
 552   if (device->keyboard_focus)
 553     {
 554       event = gdk_event_new (GDK_FOCUS_CHANGE);
 555       event->focus_change.window = g_object_ref (device->keyboard_focus);
 556       event->focus_change.send_event = FALSE;
 557       event->focus_change.in = FALSE;
 558       gdk_event_set_device (event, device->keyboard);
 559
 560       g_object_unref(device->keyboard_focus);
 561       device->keyboard_focus = NULL;
 562
 563       GDK_NOTE (EVENTS,
 564                 g_message ("focus out, device %p surface %p",
 565                            device, device->keyboard_focus));
 566
 567       _gdk_wayland_display_deliver_event (device->display, event);
 568     }
 569
 570   if (surface)
 571     {
 572       device->keyboard_focus = wl_surface_get_user_data(surface);
 573       g_object_ref(device->keyboard_focus);
 574
 575       event = gdk_event_new (GDK_FOCUS_CHANGE);
 576       event->focus_change.window = g_object_ref (device->keyboard_focus);
 577       event->focus_change.send_event = FALSE;
 578       event->focus_change.in = TRUE;
 579       gdk_event_set_device (event, device->keyboard);
 580
 581       update_modifiers (device, keys);
 582
 583       GDK_NOTE (EVENTS,
 584                 g_message ("focus int, device %p surface %p",
 585                            device, device->keyboard_focus));
 586
 587       _gdk_wayland_display_deliver_event (device->display, event);
 588     }
 589 }
 590
 591 static const struct wl_input_device_listener input_device_listener = {
 592   input_handle_motion,
 593   input_handle_button,
 594   input_handle_key,
 595   input_handle_pointer_focus,
 596   input_handle_keyboard_focus,
 597 };
 598
 599 void
 600 _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,
 601                                         struct wl_input_device *wl_device)
 602 {
 603   GdkDisplay *display;
 604   GdkDisplayWayland *display_wayland;
 605   GdkDeviceManagerCore *device_manager_core =
 606     GDK_DEVICE_MANAGER_CORE(device_manager);
 607   GdkWaylandDevice *device;
 608
 609   device = g_new0 (GdkWaylandDevice, 1);
 610   display = gdk_device_manager_get_display (device_manager);
 611   display_wayland = GDK_DISPLAY_WAYLAND (display);
 612
 613   device->display = display;
 614   device->pointer = g_object_new (GDK_TYPE_DEVICE_CORE,
 615                                   "name", "Core Pointer",
 616                                   "type", GDK_DEVICE_TYPE_MASTER,
 617                                   "input-source", GDK_SOURCE_MOUSE,
 618                                   "input-mode", GDK_MODE_SCREEN,
 619                                   "has-cursor", TRUE,
 620                                   "display", display,
 621                                   "device-manager", device_manager,
 622                                   NULL);
 623
 624   device->keyboard = g_object_new (GDK_TYPE_DEVICE_CORE,
 625                                    "name", "Core Keyboard",
 626                                    "type", GDK_DEVICE_TYPE_MASTER,
 627                                    "input-source", GDK_SOURCE_KEYBOARD,
 628                                    "input-mode", GDK_MODE_SCREEN,
 629                                    "has-cursor", FALSE,
 630                                    "display", display,
 631                                    "device-manager", device_manager,
 632                                    NULL);
 633
 634   GDK_DEVICE_CORE (device->pointer)->device = device;
 635   GDK_DEVICE_CORE (device->keyboard)->device = device;
 636   device->device = wl_device;
 637
 638   wl_input_device_add_listener(device->device,
 639                                &input_device_listener, device);
 640
 641   device->data_device =
 642     wl_data_device_manager_get_data_device (display_wayland->data_device_manager,
 643                                             device->device);
 644
 645   device_manager_core->devices =
 646     g_list_prepend (device_manager_core->devices, device->keyboard);
 647   device_manager_core->devices =
 648     g_list_prepend (device_manager_core->devices, device->pointer);
 649
 650   _gdk_device_set_associated_device (device->pointer, device->keyboard);
 651   _gdk_device_set_associated_device (device->keyboard, device->pointer);
 652 }
 653
 654 static void
 655 free_device (void *data, void *user_data)
 656 {
 657   g_object_unref (data);
 658 }
 659
 660 static void
 661 gdk_device_manager_core_finalize (GObject *object)
 662 {
 663   GdkDeviceManagerCore *device_manager_core;
 664
 665   device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
 666
 667   g_list_foreach (device_manager_core->devices, free_device, NULL);
 668   g_list_free (device_manager_core->devices);
 669
 670   G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
 671 }
 672
 673 static GList *
 674 gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
 675                                       GdkDeviceType     type)
 676 {
 677   GdkDeviceManagerCore *device_manager_core;
 678   GList *devices = NULL;
 679
 680   if (type == GDK_DEVICE_TYPE_MASTER)
 681     {
 682       device_manager_core = (GdkDeviceManagerCore *) device_manager;
 683       devices = g_list_copy(device_manager_core->devices);
 684     }
 685
 686   return devices;
 687 }
 688
 689 static GdkDevice *
 690 gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
 691 {
 692   GdkDeviceManagerCore *device_manager_core;
 693
 694   device_manager_core = (GdkDeviceManagerCore *) device_manager;
 695   return device_manager_core->devices->data;
 696 }
 697
 698 static void
 699 gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
 700 {
 701   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
 702   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 703
 704   object_class->finalize = gdk_device_manager_core_finalize;
 705   device_manager_class->list_devices = gdk_device_manager_core_list_devices;
 706   device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
 707 }
 708
 709 static void
 710 gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
 711 {
 712 }
 713
 714 GdkDeviceManager *
 715 _gdk_wayland_device_manager_new (GdkDisplay *display)
 716 {
 717   return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
 718                        "display", display,
 719                        NULL);
 720 }