Pileus Git - ~andy/gtk/blob - gdk/broadway/gdkdisplay-broadway.c

   1 /* GDK - The GIMP Drawing Kit
   2  * gdkdisplay-broadway.c
   3  *
   4  * Copyright 2001 Sun Microsystems Inc.
   5  * Copyright (C) 2004 Nokia Corporation
   6  *
   7  * Erwann Chenede <erwann.chenede@sun.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "config.h"
  26
  27 #include "gdkdisplay-broadway.h"
  28
  29 #include "gdkdisplay.h"
  30 #include "gdkeventsource.h"
  31 #include "gdkscreen.h"
  32 #include "gdkscreen-broadway.h"
  33 #include "gdkinternals.h"
  34 #include "gdkdeviceprivate.h"
  35 #include "gdkdevicemanager-broadway.h"
  36
  37 #include <glib.h>
  38 #include <glib/gprintf.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <unistd.h>
  43
  44 static void   gdk_broadway_display_dispose            (GObject            *object);
  45 static void   gdk_broadway_display_finalize           (GObject            *object);
  46
  47 G_DEFINE_TYPE (GdkBroadwayDisplay, gdk_broadway_display, GDK_TYPE_DISPLAY)
  48
  49 static void
  50 gdk_broadway_display_init (GdkBroadwayDisplay *display)
  51 {
  52   _gdk_broadway_display_manager_add_display (gdk_display_manager_get (),
  53                                              GDK_DISPLAY_OBJECT (display));
  54   display->id_ht = g_hash_table_new (NULL, NULL);
  55 }
  56
  57 static void
  58 gdk_event_init (GdkDisplay *display)
  59 {
  60   GdkBroadwayDisplay *broadway_display;
  61
  62   broadway_display = GDK_BROADWAY_DISPLAY (display);
  63   broadway_display->event_source = _gdk_broadway_event_source_new (display);
  64   broadway_display->saved_serial = 1;
  65 }
  66
  67 static void
  68 gdk_broadway_display_init_input (GdkDisplay *display)
  69 {
  70   GdkBroadwayDisplay *broadway_display;
  71   GdkDeviceManager *device_manager;
  72   GdkDevice *device;
  73   GList *list, *l;
  74
  75   broadway_display = GDK_BROADWAY_DISPLAY (display);
  76   device_manager = gdk_display_get_device_manager (display);
  77
  78   /* For backwards compatibility, just add
  79    * floating devices that are not keyboards.
  80    */
  81   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
  82
  83   for (l = list; l; l = l->next)
  84     {
  85       device = l->data;
  86
  87       if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
  88         continue;
  89
  90       broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
  91                                                    g_object_ref (l->data));
  92     }
  93
  94   g_list_free (list);
  95
  96   /* Now set "core" pointer to the first
  97    * master device that is a pointer.
  98    */
  99   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
 100
 101   for (l = list; l; l = l->next)
 102     {
 103       device = list->data;
 104
 105       if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
 106         continue;
 107
 108       display->core_pointer = device;
 109       break;
 110     }
 111
 112   /* Add the core pointer to the devices list */
 113   broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
 114                                                g_object_ref (display->core_pointer));
 115
 116   g_list_free (list);
 117 }
 118
 119 struct HttpRequest {
 120   GdkDisplay *display;
 121   GSocketConnection *connection;
 122   GDataInputStream *data;
 123   GString *request;
 124 };
 125
 126 static void
 127 http_request_free (HttpRequest *request)
 128 {
 129   g_object_unref (request->connection);
 130   g_object_unref (request->data);
 131   g_string_free (request->request, TRUE);
 132   g_free (request);
 133 }
 134
 135 #include <unistd.h>
 136 #include <fcntl.h>
 137 static void
 138 set_fd_blocking (int fd)
 139 {
 140   glong arg;
 141
 142   if ((arg = fcntl (fd, F_GETFL, NULL)) < 0)
 143     arg = 0;
 144
 145   arg = arg & ~O_NONBLOCK;
 146
 147   fcntl (fd, F_SETFL, arg);
 148 }
 149
 150 static char *
 151 parse_line (char *line, char *key)
 152 {
 153   char *p;
 154
 155   if (!g_str_has_prefix (line, key))
 156     return NULL;
 157   p = line + strlen (key);
 158   if (*p != ':')
 159     return NULL;
 160   p++;
 161   /* Skip optional initial space */
 162   if (*p == ' ')
 163     p++;
 164   return p;
 165 }
 166
 167 static void
 168 got_input (GInputStream *stream,
 169            GAsyncResult *result,
 170            HttpRequest *request)
 171 {
 172   GError *error;
 173   char *message;
 174   gsize len;
 175
 176   error = NULL;
 177   message = g_data_input_stream_read_upto_finish (G_DATA_INPUT_STREAM (stream), result, &len, &error);
 178   if (message == NULL)
 179     {
 180       GDK_BROADWAY_DISPLAY (request->display)->input = NULL;
 181       http_request_free (request);
 182       return;
 183     }
 184
 185   g_assert (message[0] == 0);
 186   _gdk_broadway_events_got_input (request->display, message + 1);
 187
 188   /* Skip past ending 0xff */
 189   g_data_input_stream_read_byte (request->data, NULL, NULL);
 190   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 191                                        (GAsyncReadyCallback)got_input, request);
 192 }
 193
 194 static void
 195 send_error (HttpRequest *request,
 196             int error_code,
 197             const char *reason)
 198 {
 199   char *res;
 200
 201   res = g_strdup_printf ("HTTP/1.0 %d %s\r\n\r\n"
 202                          "<html><head><title>%d %s</title></head>"
 203                          "<body>%s</body></html>",
 204                          error_code, reason,
 205                          error_code, reason,
 206                          reason);
 207   /* TODO: This should really be async */
 208   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 209                              res, strlen (res), NULL, NULL, NULL);
 210   g_free (res);
 211   http_request_free (request);
 212 }
 213
 214 static void
 215 start_input (HttpRequest *request)
 216 {
 217   char **lines;
 218   char *p;
 219   int num_key1, num_key2;
 220   guint64 key1, key2;
 221   int num_space;
 222   int i;
 223   guint8 challenge[16];
 224   char *res;
 225   gsize len;
 226   GChecksum *checksum;
 227   char *origin, *host;
 228   GdkBroadwayDisplay *broadway_display;
 229
 230   broadway_display = GDK_BROADWAY_DISPLAY (request->display);
 231
 232   if (broadway_display->input != NULL)
 233     {
 234       send_error (request, 409, "Input already handled");
 235       return;
 236     }
 237
 238   lines = g_strsplit (request->request->str, "\n", 0);
 239
 240   num_key1 = 0;
 241   num_key2 = 0;
 242   key1 = 0;
 243   key2 = 0;
 244   origin = NULL;
 245   host = NULL;
 246   for (i = 0; lines[i] != NULL; i++)
 247     {
 248       if ((p = parse_line (lines[i], "Sec-WebSocket-Key1")))
 249         {
 250           num_space = 0;
 251           while (*p != 0)
 252             {
 253               if (g_ascii_isdigit (*p))
 254                 key1 = key1 * 10 + g_ascii_digit_value (*p);
 255               else if (*p == ' ')
 256                 num_space++;
 257
 258               p++;
 259             }
 260           key1 /= num_space;
 261           num_key1++;
 262         }
 263       else if ((p = parse_line (lines[i], "Sec-WebSocket-Key2")))
 264         {
 265           num_space = 0;
 266           while (*p != 0)
 267             {
 268               if (g_ascii_isdigit (*p))
 269                 key2 = key2 * 10 + g_ascii_digit_value (*p);
 270               else if (*p == ' ')
 271                 num_space++;
 272
 273               p++;
 274             }
 275           key2 /= num_space;
 276           num_key2++;
 277         }
 278       else if ((p = parse_line (lines[i], "Origin")))
 279         {
 280           origin = p;
 281         }
 282       else if ((p = parse_line (lines[i], "Host")))
 283         {
 284           host = p;
 285         }
 286     }
 287
 288   if (num_key1 != 1 || num_key2 != 1 || origin == NULL || host == NULL)
 289     {
 290       g_strfreev (lines);
 291       send_error (request, 400, "Bad websocket request");
 292       return;
 293     }
 294
 295   challenge[0] = (key1 >> 24) & 0xff;
 296   challenge[1] = (key1 >> 16) & 0xff;
 297   challenge[2] = (key1 >>  8) & 0xff;
 298   challenge[3] = (key1 >>  0) & 0xff;
 299   challenge[4] = (key2 >> 24) & 0xff;
 300   challenge[5] = (key2 >> 16) & 0xff;
 301   challenge[6] = (key2 >>  8) & 0xff;
 302   challenge[7] = (key2 >>  0) & 0xff;
 303
 304   if (!g_input_stream_read_all (G_INPUT_STREAM (request->data), challenge+8, 8, NULL, NULL, NULL))
 305     {
 306       g_strfreev (lines);
 307       send_error (request, 400, "Bad websocket request");
 308       return;
 309     }
 310
 311   checksum = g_checksum_new (G_CHECKSUM_MD5);
 312   g_checksum_update (checksum, challenge, 16);
 313   len = 16;
 314   g_checksum_get_digest (checksum, challenge, &len);
 315   g_checksum_free (checksum);
 316
 317   res = g_strdup_printf ("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 318                          "Upgrade: WebSocket\r\n"
 319                          "Connection: Upgrade\r\n"
 320                          "Sec-WebSocket-Origin: %s\r\n"
 321                          "Sec-WebSocket-Location: ws://%s/input\r\n"
 322                          "Sec-WebSocket-Protocol: broadway\r\n"
 323                          "\r\n",
 324                          origin, host);
 325
 326   /* TODO: This should really be async */
 327   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 328                              res, strlen (res), NULL, NULL, NULL);
 329   g_free (res);
 330   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 331                              challenge, 16, NULL, NULL, NULL);
 332
 333   broadway_display->input = request;
 334
 335   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 336                                        (GAsyncReadyCallback)got_input, request);
 337
 338   g_strfreev (lines);
 339 }
 340
 341 static void
 342 start_output (HttpRequest *request)
 343 {
 344   GSocket *socket;
 345   GdkBroadwayDisplay *broadway_display;
 346   int fd;
 347
 348   socket = g_socket_connection_get_socket (request->connection);
 349
 350   broadway_display = GDK_BROADWAY_DISPLAY (request->display);
 351   fd = g_socket_get_fd (socket);
 352   set_fd_blocking (fd);
 353   /* We dup this because otherwise it'll be closed with the request SocketConnection */
 354
 355   if (broadway_display->output)
 356     {
 357       broadway_display->saved_serial = broadway_output_get_next_serial (broadway_display->output);
 358       broadway_output_free (broadway_display->output);
 359     }
 360
 361   broadway_display->output = broadway_output_new (dup(fd), broadway_display->saved_serial);
 362   _gdk_broadway_resync_windows ();
 363   http_request_free (request);
 364 }
 365
 366 static void
 367 send_data (HttpRequest *request,
 368              const char *mimetype,
 369              const char *data, gsize len)
 370 {
 371   char *res;
 372
 373   res = g_strdup_printf ("HTTP/1.0 200 OK\r\n"
 374                          "Content-Type: %s\r\n"
 375                          "Content-Length: %"G_GSIZE_FORMAT"\r\n"
 376                          "\r\n",
 377                          mimetype, len);
 378   /* TODO: This should really be async */
 379   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 380                              res, strlen (res), NULL, NULL, NULL);
 381   g_free (res);
 382   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 383                              data, len, NULL, NULL, NULL);
 384   http_request_free (request);
 385 }
 386
 387 #include "clienthtml.h"
 388 #include "broadwayjs.h"
 389
 390 static void
 391 got_request (HttpRequest *request)
 392 {
 393   char *start, *escaped, *tmp, *version;
 394
 395   if (!g_str_has_prefix (request->request->str, "GET "))
 396     {
 397       send_error (request, 501, "Only GET implemented");
 398       return;
 399     }
 400
 401   start = request->request->str + 4; /* Skip "GET " */
 402
 403   while (*start == ' ')
 404     start++;
 405
 406   for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 407     ;
 408   escaped = g_strndup (start, tmp - start);
 409   version = NULL;
 410   if (*tmp == ' ')
 411     {
 412       start = tmp;
 413       while (*start == ' ')
 414         start++;
 415       for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 416         ;
 417       version = g_strndup (start, tmp - start);
 418     }
 419
 420   if (strcmp (escaped, "/client.html") == 0 || strcmp (escaped, "/") == 0)
 421     send_data (request, "text/html", client_html, G_N_ELEMENTS(client_html) - 1);
 422   else if (strcmp (escaped, "/broadway.js") == 0)
 423     send_data (request, "text/javascript", broadway_js, G_N_ELEMENTS(broadway_js) - 1);
 424   else if (strcmp (escaped, "/output") == 0)
 425     start_output (request);
 426   else if (strcmp (escaped, "/input") == 0)
 427     start_input (request);
 428   else
 429     send_error (request, 404, "File not found");
 430 }
 431
 432 static void
 433 got_http_request_line (GInputStream *stream,
 434                        GAsyncResult *result,
 435                        HttpRequest *request)
 436 {
 437   char *line;
 438
 439   line = g_data_input_stream_read_line_finish (G_DATA_INPUT_STREAM (stream), result, NULL, NULL);
 440   if (line == NULL)
 441     {
 442       http_request_free (request);
 443       g_printerr ("Error reading request lines\n");
 444       return;
 445     }
 446   if (strlen (line) == 0)
 447     got_request (request);
 448   else
 449     {
 450       /* Protect against overflow in request length */
 451       if (request->request->len > 1024 * 5)
 452         {
 453           send_error (request, 400, "Request to long");
 454         }
 455       else
 456         {
 457           g_string_append_printf (request->request, "%s\n", line);
 458           g_data_input_stream_read_line_async (request->data, 0, NULL,
 459                                                (GAsyncReadyCallback)got_http_request_line, request);
 460         }
 461     }
 462   g_free (line);
 463 }
 464
 465 static gboolean
 466 handle_incoming_connection (GSocketService    *service,
 467                             GSocketConnection *connection,
 468                             GObject           *source_object)
 469 {
 470   HttpRequest *request;
 471   GInputStream *in;
 472
 473   request = g_new0 (HttpRequest, 1);
 474   request->connection = g_object_ref (connection);
 475   request->display = (GdkDisplay *) source_object;
 476   request->request = g_string_new ("");
 477
 478   in = g_io_stream_get_input_stream (G_IO_STREAM (connection));
 479
 480   request->data = g_data_input_stream_new (in);
 481   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (request->data), FALSE);
 482   /* Be tolerant of input */
 483   g_data_input_stream_set_newline_type (request->data, G_DATA_STREAM_NEWLINE_TYPE_ANY);
 484
 485   g_data_input_stream_read_line_async (request->data, 0, NULL,
 486                                        (GAsyncReadyCallback)got_http_request_line, request);
 487   return TRUE;
 488 }
 489
 490 GdkDisplay *
 491 _gdk_broadway_display_open (const gchar *display_name)
 492 {
 493   GdkDisplay *display;
 494   GdkBroadwayDisplay *broadway_display;
 495   GError *error;
 496
 497   display = g_object_new (GDK_TYPE_BROADWAY_DISPLAY, NULL);
 498   broadway_display = GDK_BROADWAY_DISPLAY (display);
 499
 500   broadway_display->output = NULL;
 501
 502   /* initialize the display's screens */
 503   broadway_display->screens = g_new (GdkScreen *, 1);
 504   broadway_display->screens[0] = _gdk_broadway_screen_new (display, 0);
 505
 506   /* We need to initialize events after we have the screen
 507    * structures in places
 508    */
 509   _gdk_broadway_screen_events_init (broadway_display->screens[0]);
 510
 511   /*set the default screen */
 512   broadway_display->default_screen = broadway_display->screens[0];
 513
 514   display->device_manager = _gdk_broadway_device_manager_new (display);
 515
 516   gdk_event_init (display);
 517
 518   gdk_broadway_display_init_input (display);
 519   _gdk_broadway_display_init_dnd (display);
 520
 521   _gdk_broadway_screen_setup (broadway_display->screens[0]);
 522
 523   broadway_display->service = g_socket_service_new ();
 524   if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (broadway_display->service),
 525                                         8080,
 526                                         G_OBJECT (display),
 527                                         &error))
 528     {
 529       g_printerr ("Unable to listen to port %d: %s\n", 8080, error->message);
 530       g_error_free (error);
 531       return NULL;
 532     }
 533   g_signal_connect (broadway_display->service, "incoming", G_CALLBACK (handle_incoming_connection), NULL);
 534
 535   g_signal_emit_by_name (display, "opened");
 536   g_signal_emit_by_name (gdk_display_manager_get (), "display-opened", display);
 537
 538   return display;
 539 }
 540
 541
 542 static G_CONST_RETURN gchar *
 543 gdk_broadway_display_get_name (GdkDisplay *display)
 544 {
 545   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 546
 547   return (gchar *) "Broadway";
 548 }
 549
 550 static gint
 551 gdk_broadway_display_get_n_screens (GdkDisplay *display)
 552 {
 553   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
 554
 555   return 1;
 556 }
 557
 558 static GdkScreen *
 559 gdk_broadway_display_get_screen (GdkDisplay *display,
 560                                  gint        screen_num)
 561 {
 562   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 563   g_return_val_if_fail (screen_num == 0, NULL);
 564
 565   return GDK_BROADWAY_DISPLAY (display)->screens[screen_num];
 566 }
 567
 568 static GdkScreen *
 569 gdk_broadway_display_get_default_screen (GdkDisplay *display)
 570 {
 571   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 572
 573   return GDK_BROADWAY_DISPLAY (display)->default_screen;
 574 }
 575
 576 static void
 577 gdk_broadway_display_beep (GdkDisplay *display)
 578 {
 579   g_return_if_fail (GDK_IS_DISPLAY (display));
 580 }
 581
 582 static void
 583 gdk_broadway_display_sync (GdkDisplay *display)
 584 {
 585   g_return_if_fail (GDK_IS_DISPLAY (display));
 586
 587 }
 588
 589 static void
 590 gdk_broadway_display_flush (GdkDisplay *display)
 591 {
 592   g_return_if_fail (GDK_IS_DISPLAY (display));
 593
 594 }
 595
 596 static gboolean
 597 gdk_broadway_display_has_pending (GdkDisplay *display)
 598 {
 599   return FALSE;
 600 }
 601
 602 static GdkWindow *
 603 gdk_broadway_display_get_default_group (GdkDisplay *display)
 604 {
 605   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 606
 607   return NULL;
 608 }
 609
 610 static void
 611 gdk_broadway_display_dispose (GObject *object)
 612 {
 613   GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (object);
 614
 615   _gdk_broadway_display_manager_remove_display (gdk_display_manager_get (),
 616                                                 GDK_DISPLAY_OBJECT (object));
 617
 618   g_list_foreach (broadway_display->input_devices, (GFunc) g_object_run_dispose, NULL);
 619
 620   _gdk_screen_close (broadway_display->screens[0]);
 621
 622   if (broadway_display->event_source)
 623     {
 624       g_source_destroy (broadway_display->event_source);
 625       g_source_unref (broadway_display->event_source);
 626       broadway_display->event_source = NULL;
 627     }
 628
 629   G_OBJECT_CLASS (gdk_broadway_display_parent_class)->dispose (object);
 630 }
 631
 632 static void
 633 gdk_broadway_display_finalize (GObject *object)
 634 {
 635   GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (object);
 636
 637   /* Keymap */
 638   if (broadway_display->keymap)
 639     g_object_unref (broadway_display->keymap);
 640
 641   _gdk_broadway_cursor_display_finalize (GDK_DISPLAY_OBJECT(broadway_display));
 642
 643   /* Atom Hashtable */
 644   g_hash_table_destroy (broadway_display->atom_from_virtual);
 645   g_hash_table_destroy (broadway_display->atom_to_virtual);
 646
 647   /* input GdkDevice list */
 648   g_list_foreach (broadway_display->input_devices, (GFunc) g_object_unref, NULL);
 649   g_list_free (broadway_display->input_devices);
 650   /* Free all GdkScreens */
 651   g_object_unref (broadway_display->screens[0]);
 652   g_free (broadway_display->screens);
 653
 654   G_OBJECT_CLASS (gdk_broadway_display_parent_class)->finalize (object);
 655 }
 656
 657 void
 658 _gdk_broadway_display_make_default (GdkDisplay *display)
 659 {
 660 }
 661
 662 static void
 663 gdk_broadway_display_notify_startup_complete (GdkDisplay  *display,
 664                                               const gchar *startup_id)
 665 {
 666 }
 667
 668 static gboolean
 669 gdk_broadway_display_supports_selection_notification (GdkDisplay *display)
 670 {
 671   return FALSE;
 672 }
 673
 674 static gboolean
 675 gdk_broadway_display_request_selection_notification (GdkDisplay *display,
 676                                                      GdkAtom     selection)
 677
 678 {
 679     return FALSE;
 680 }
 681
 682 static gboolean
 683 gdk_broadway_display_supports_clipboard_persistence (GdkDisplay *display)
 684 {
 685   return FALSE;
 686 }
 687
 688 static void
 689 gdk_broadway_display_store_clipboard (GdkDisplay    *display,
 690                                       GdkWindow     *clipboard_window,
 691                                       guint32        time_,
 692                                       const GdkAtom *targets,
 693                                       gint           n_targets)
 694 {
 695 }
 696
 697 static gboolean
 698 gdk_broadway_display_supports_shapes (GdkDisplay *display)
 699 {
 700   return FALSE;
 701 }
 702
 703 static gboolean
 704 gdk_broadway_display_supports_input_shapes (GdkDisplay *display)
 705 {
 706   return FALSE;
 707 }
 708
 709 static gboolean
 710 gdk_broadway_display_supports_composite (GdkDisplay *display)
 711 {
 712   return FALSE;
 713 }
 714
 715 static GList *
 716 gdk_broadway_display_list_devices (GdkDisplay *display)
 717 {
 718   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 719
 720   return GDK_BROADWAY_DISPLAY (display)->input_devices;
 721 }
 722
 723 static gulong
 724 gdk_broadway_display_get_next_serial (GdkDisplay *display)
 725 {
 726   GdkBroadwayDisplay *broadway_display;
 727   broadway_display = GDK_BROADWAY_DISPLAY (display);
 728   if (broadway_display->output)
 729     return broadway_output_get_next_serial (broadway_display->output);
 730   return broadway_display->saved_serial;
 731 }
 732
 733
 734 static void
 735 gdk_broadway_display_event_data_copy (GdkDisplay    *display,
 736                                       const GdkEvent *src,
 737                                       GdkEvent       *dst)
 738 {
 739 }
 740
 741 static void
 742 gdk_broadway_display_event_data_free (GdkDisplay    *display,
 743                                       GdkEvent *event)
 744 {
 745 }
 746
 747 static void
 748 gdk_broadway_display_class_init (GdkBroadwayDisplayClass * class)
 749 {
 750   GObjectClass *object_class = G_OBJECT_CLASS (class);
 751   GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (class);
 752
 753   object_class->dispose = gdk_broadway_display_dispose;
 754   object_class->finalize = gdk_broadway_display_finalize;
 755
 756   display_class->window_type = GDK_TYPE_BROADWAY_WINDOW;
 757
 758   display_class->get_name = gdk_broadway_display_get_name;
 759   display_class->get_n_screens = gdk_broadway_display_get_n_screens;
 760   display_class->get_screen = gdk_broadway_display_get_screen;
 761   display_class->get_default_screen = gdk_broadway_display_get_default_screen;
 762   display_class->beep = gdk_broadway_display_beep;
 763   display_class->sync = gdk_broadway_display_sync;
 764   display_class->flush = gdk_broadway_display_flush;
 765   display_class->has_pending = gdk_broadway_display_has_pending;
 766   display_class->queue_events = _gdk_broadway_display_queue_events;
 767   display_class->get_default_group = gdk_broadway_display_get_default_group;
 768   display_class->supports_selection_notification = gdk_broadway_display_supports_selection_notification;
 769   display_class->request_selection_notification = gdk_broadway_display_request_selection_notification;
 770   display_class->supports_clipboard_persistence = gdk_broadway_display_supports_clipboard_persistence;
 771   display_class->store_clipboard = gdk_broadway_display_store_clipboard;
 772   display_class->supports_shapes = gdk_broadway_display_supports_shapes;
 773   display_class->supports_input_shapes = gdk_broadway_display_supports_input_shapes;
 774   display_class->supports_composite = gdk_broadway_display_supports_composite;
 775   display_class->list_devices = gdk_broadway_display_list_devices;
 776   display_class->get_cursor_for_type = _gdk_broadway_display_get_cursor_for_type;
 777   display_class->get_cursor_for_name = _gdk_broadway_display_get_cursor_for_name;
 778   display_class->get_cursor_for_pixbuf = _gdk_broadway_display_get_cursor_for_pixbuf;
 779   display_class->get_default_cursor_size = _gdk_broadway_display_get_default_cursor_size;
 780   display_class->get_maximal_cursor_size = _gdk_broadway_display_get_maximal_cursor_size;
 781   display_class->supports_cursor_alpha = _gdk_broadway_display_supports_cursor_alpha;
 782   display_class->supports_cursor_color = _gdk_broadway_display_supports_cursor_color;
 783
 784   display_class->before_process_all_updates = _gdk_broadway_display_before_process_all_updates;
 785   display_class->after_process_all_updates = _gdk_broadway_display_after_process_all_updates;
 786   display_class->get_next_serial = gdk_broadway_display_get_next_serial;
 787   display_class->notify_startup_complete = gdk_broadway_display_notify_startup_complete;
 788   display_class->event_data_copy = gdk_broadway_display_event_data_copy;
 789   display_class->event_data_free = gdk_broadway_display_event_data_free;
 790   display_class->create_window_impl = _gdk_broadway_display_create_window_impl;
 791   display_class->get_keymap = _gdk_broadway_display_get_keymap;
 792   display_class->get_selection_owner = _gdk_broadway_display_get_selection_owner;
 793   display_class->set_selection_owner = _gdk_broadway_display_set_selection_owner;
 794   display_class->send_selection_notify = _gdk_broadway_display_send_selection_notify;
 795   display_class->get_selection_property = _gdk_broadway_display_get_selection_property;
 796   display_class->convert_selection = _gdk_broadway_display_convert_selection;
 797   display_class->text_property_to_utf8_list = _gdk_broadway_display_text_property_to_utf8_list;
 798   display_class->utf8_to_string_target = _gdk_broadway_display_utf8_to_string_target;
 799 }
 800