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.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_display_broadway_dispose            (GObject            *object);
  45 static void   gdk_display_broadway_finalize           (GObject            *object);
  46
  47 G_DEFINE_TYPE (GdkDisplayBroadway, _gdk_display_broadway, GDK_TYPE_DISPLAY)
  48
  49
  50 static void
  51 _gdk_display_broadway_class_init (GdkDisplayBroadwayClass * class)
  52 {
  53   GObjectClass *object_class = G_OBJECT_CLASS (class);
  54
  55   object_class->dispose = gdk_display_broadway_dispose;
  56   object_class->finalize = gdk_display_broadway_finalize;
  57 }
  58
  59 static void
  60 _gdk_display_broadway_init (GdkDisplayBroadway *display)
  61 {
  62   display->id_ht = g_hash_table_new (NULL, NULL);
  63 }
  64
  65 static void
  66 _gdk_event_init (GdkDisplay *display)
  67 {
  68   GdkDisplayBroadway *display_broadway;
  69
  70   display_broadway = GDK_DISPLAY_BROADWAY (display);
  71   display_broadway->event_source = gdk_event_source_new (display);
  72 }
  73
  74 static void
  75 _gdk_input_init (GdkDisplay *display)
  76 {
  77   GdkDisplayBroadway *display_broadway;
  78   GdkDeviceManager *device_manager;
  79   GdkDevice *device;
  80   GList *list, *l;
  81
  82   display_broadway = GDK_DISPLAY_BROADWAY (display);
  83   device_manager = gdk_display_get_device_manager (display);
  84
  85   /* For backwards compatibility, just add
  86    * floating devices that are not keyboards.
  87    */
  88   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
  89
  90   for (l = list; l; l = l->next)
  91     {
  92       device = l->data;
  93
  94       if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
  95         continue;
  96
  97       display_broadway->input_devices = g_list_prepend (display_broadway->input_devices,
  98                                                    g_object_ref (l->data));
  99     }
 100
 101   g_list_free (list);
 102
 103   /* Now set "core" pointer to the first
 104    * master device that is a pointer.
 105    */
 106   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
 107
 108   for (l = list; l; l = l->next)
 109     {
 110       device = list->data;
 111
 112       if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
 113         continue;
 114
 115       display->core_pointer = device;
 116       break;
 117     }
 118
 119   /* Add the core pointer to the devices list */
 120   display_broadway->input_devices = g_list_prepend (display_broadway->input_devices,
 121                                                g_object_ref (display->core_pointer));
 122
 123   g_list_free (list);
 124 }
 125
 126 struct HttpRequest {
 127   GdkDisplay *display;
 128   GSocketConnection *connection;
 129   GDataInputStream *data;
 130   GString *request;
 131 };
 132
 133 static void
 134 http_request_free (HttpRequest *request)
 135 {
 136   g_object_unref (request->connection);
 137   g_object_unref (request->data);
 138   g_string_free (request->request, TRUE);
 139   g_free (request);
 140 }
 141
 142 #include <unistd.h>
 143 #include <fcntl.h>
 144 static void
 145 set_fd_blocking (int fd)
 146 {
 147   glong arg;
 148
 149   if ((arg = fcntl (fd, F_GETFL, NULL)) < 0)
 150     arg = 0;
 151
 152   arg = arg & ~O_NONBLOCK;
 153
 154   fcntl (fd, F_SETFL, arg);
 155 }
 156
 157 static char *
 158 parse_line (char *line, char *key)
 159 {
 160   char *p;
 161
 162   if (!g_str_has_prefix (line, key))
 163     return NULL;
 164   p = line + strlen (key);
 165   if (*p != ':')
 166     return NULL;
 167   p++;
 168   /* Skip optional initial space */
 169   if (*p == ' ')
 170     p++;
 171   return p;
 172 }
 173
 174 static void
 175 got_input (GInputStream *stream,
 176            GAsyncResult *result,
 177            HttpRequest *request)
 178 {
 179   GError *error;
 180   char *message;
 181   gsize len;
 182
 183   error = NULL;
 184   message = g_data_input_stream_read_upto_finish (G_DATA_INPUT_STREAM (stream), result, &len, &error);
 185   if (message == NULL)
 186     {
 187       GDK_DISPLAY_BROADWAY (request->display)->input = NULL;
 188       http_request_free (request);
 189       return;
 190     }
 191
 192   g_assert (message[0] == 0);
 193   _gdk_events_got_input (request->display, message + 1);
 194
 195   /* Skip past ending 0xff */
 196   g_data_input_stream_read_byte (request->data, NULL, NULL);
 197   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 198                                        (GAsyncReadyCallback)got_input, request);
 199 }
 200
 201 static void
 202 send_error (HttpRequest *request,
 203             int error_code,
 204             const char *reason)
 205 {
 206   char *res;
 207
 208   res = g_strdup_printf ("HTTP/1.0 %d %s\r\n\r\n"
 209                          "<html><head><title>%d %s</title></head>"
 210                          "<body>%s</body></html>",
 211                          error_code, reason,
 212                          error_code, reason,
 213                          reason);
 214   /* TODO: This should really be async */
 215   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 216                              res, strlen (res), NULL, NULL, NULL);
 217   g_free (res);
 218   http_request_free (request);
 219 }
 220
 221 static void
 222 start_input (HttpRequest *request)
 223 {
 224   char **lines;
 225   char *p;
 226   int num_key1, num_key2;
 227   guint64 key1, key2;
 228   int num_space;
 229   int i;
 230   guint8 challenge[16];
 231   char *res;
 232   gsize len;
 233   GChecksum *checksum;
 234   char *origin, *host;
 235   GdkDisplayBroadway *display_broadway;
 236
 237   display_broadway = GDK_DISPLAY_BROADWAY (request->display);
 238
 239   if (display_broadway->input != NULL)
 240     {
 241       send_error (request, 409, "Input already handled");
 242       return;
 243     }
 244
 245   lines = g_strsplit (request->request->str, "\n", 0);
 246
 247   num_key1 = 0;
 248   num_key2 = 0;
 249   key1 = 0;
 250   key2 = 0;
 251   origin = NULL;
 252   host = NULL;
 253   for (i = 0; lines[i] != NULL; i++)
 254     {
 255       if ((p = parse_line (lines[i], "Sec-WebSocket-Key1")))
 256         {
 257           num_space = 0;
 258           while (*p != 0)
 259             {
 260               if (g_ascii_isdigit (*p))
 261                 key1 = key1 * 10 + g_ascii_digit_value (*p);
 262               else if (*p == ' ')
 263                 num_space++;
 264
 265               p++;
 266             }
 267           key1 /= num_space;
 268           num_key1++;
 269         }
 270       else if ((p = parse_line (lines[i], "Sec-WebSocket-Key2")))
 271         {
 272           num_space = 0;
 273           while (*p != 0)
 274             {
 275               if (g_ascii_isdigit (*p))
 276                 key2 = key2 * 10 + g_ascii_digit_value (*p);
 277               else if (*p == ' ')
 278                 num_space++;
 279
 280               p++;
 281             }
 282           key2 /= num_space;
 283           num_key2++;
 284         }
 285       else if ((p = parse_line (lines[i], "Origin")))
 286         {
 287           origin = p;
 288         }
 289       else if ((p = parse_line (lines[i], "Host")))
 290         {
 291           host = p;
 292         }
 293     }
 294
 295   if (num_key1 != 1 || num_key2 != 1 || origin == NULL || host == NULL)
 296     {
 297       g_strfreev (lines);
 298       send_error (request, 400, "Bad websocket request");
 299       return;
 300     }
 301
 302   challenge[0] = (key1 >> 24) & 0xff;
 303   challenge[1] = (key1 >> 16) & 0xff;
 304   challenge[2] = (key1 >>  8) & 0xff;
 305   challenge[3] = (key1 >>  0) & 0xff;
 306   challenge[4] = (key2 >> 24) & 0xff;
 307   challenge[5] = (key2 >> 16) & 0xff;
 308   challenge[6] = (key2 >>  8) & 0xff;
 309   challenge[7] = (key2 >>  0) & 0xff;
 310
 311   if (!g_input_stream_read_all (G_INPUT_STREAM (request->data), challenge+8, 8, NULL, NULL, NULL))
 312     {
 313       g_strfreev (lines);
 314       send_error (request, 400, "Bad websocket request");
 315       return;
 316     }
 317
 318   checksum = g_checksum_new (G_CHECKSUM_MD5);
 319   g_checksum_update (checksum, challenge, 16);
 320   len = 16;
 321   g_checksum_get_digest (checksum, challenge, &len);
 322   g_checksum_free (checksum);
 323
 324   res = g_strdup_printf ("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 325                          "Upgrade: WebSocket\r\n"
 326                          "Connection: Upgrade\r\n"
 327                          "Sec-WebSocket-Origin: %s\r\n"
 328                          "Sec-WebSocket-Location: ws://%s/input\r\n"
 329                          "Sec-WebSocket-Protocol: broadway\r\n"
 330                          "\r\n",
 331                          origin, host);
 332
 333   /* TODO: This should really be async */
 334   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 335                              res, strlen (res), NULL, NULL, NULL);
 336   g_free (res);
 337   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 338                              challenge, 16, NULL, NULL, NULL);
 339
 340   display_broadway->input = request;
 341
 342   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 343                                        (GAsyncReadyCallback)got_input, request);
 344
 345   g_strfreev (lines);
 346 }
 347
 348 static void
 349 start_output (HttpRequest *request)
 350 {
 351   GSocket *socket;
 352   GdkDisplayBroadway *display_broadway;
 353   int fd;
 354
 355   socket = g_socket_connection_get_socket (request->connection);
 356
 357   display_broadway = GDK_DISPLAY_BROADWAY (request->display);
 358   fd = g_socket_get_fd (socket);
 359   set_fd_blocking (fd);
 360   /* We dup this because otherwise it'll be closed with the request SocketConnection */
 361   display_broadway->output = broadway_output_new (dup(fd));
 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_display_open (const gchar *display_name)
 492 {
 493   GdkDisplay *display;
 494   GdkDisplayBroadway *display_broadway;
 495   const char *sm_client_id;
 496   GError *error;
 497
 498   display = g_object_new (GDK_TYPE_DISPLAY_BROADWAY, NULL);
 499   display_broadway = GDK_DISPLAY_BROADWAY (display);
 500
 501   display_broadway->output = NULL;
 502
 503   /* initialize the display's screens */
 504   display_broadway->screens = g_new (GdkScreen *, 1);
 505   display_broadway->screens[0] = _gdk_broadway_screen_new (display, 0);
 506
 507   /* We need to initialize events after we have the screen
 508    * structures in places
 509    */
 510   _gdk_screen_broadway_events_init (display_broadway->screens[0]);
 511
 512   /*set the default screen */
 513   display_broadway->default_screen = display_broadway->screens[0];
 514
 515   display->device_manager = _gdk_device_manager_new (display);
 516
 517   _gdk_event_init (display);
 518
 519   sm_client_id = _gdk_get_sm_client_id ();
 520   if (sm_client_id)
 521     _gdk_windowing_display_set_sm_client_id (display, sm_client_id);
 522
 523   _gdk_input_init (display);
 524   _gdk_dnd_init (display);
 525
 526   _gdk_broadway_screen_setup (display_broadway->screens[0]);
 527
 528   display_broadway->service = g_socket_service_new ();
 529   if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (display_broadway->service),
 530                                         8080,
 531                                         G_OBJECT (display),
 532                                         &error))
 533     {
 534       g_printerr ("Unable to listen to port %d: %s\n", 8080, error->message);
 535       g_error_free (error);
 536       return NULL;
 537     }
 538   g_signal_connect (display_broadway->service, "incoming", G_CALLBACK (handle_incoming_connection), NULL);
 539
 540   g_signal_emit_by_name (display, "opened");
 541   g_signal_emit_by_name (gdk_display_manager_get (), "display-opened", display);
 542
 543   return display;
 544 }
 545
 546
 547 G_CONST_RETURN gchar *
 548 gdk_display_get_name (GdkDisplay *display)
 549 {
 550   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 551
 552   return (gchar *) "Broadway";
 553 }
 554
 555 gint
 556 gdk_display_get_n_screens (GdkDisplay *display)
 557 {
 558   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
 559
 560   return 1;
 561 }
 562
 563 GdkScreen *
 564 gdk_display_get_screen (GdkDisplay *display,
 565                         gint        screen_num)
 566 {
 567   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 568   g_return_val_if_fail (screen_num == 0, NULL);
 569
 570   return GDK_DISPLAY_BROADWAY (display)->screens[screen_num];
 571 }
 572
 573 GdkScreen *
 574 gdk_display_get_default_screen (GdkDisplay *display)
 575 {
 576   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 577
 578   return GDK_DISPLAY_BROADWAY (display)->default_screen;
 579 }
 580
 581 void
 582 gdk_device_ungrab (GdkDevice  *device,
 583                    guint32     time_)
 584 {
 585 }
 586
 587 void
 588 gdk_display_beep (GdkDisplay *display)
 589 {
 590   g_return_if_fail (GDK_IS_DISPLAY (display));
 591 }
 592
 593 void
 594 gdk_display_sync (GdkDisplay *display)
 595 {
 596   g_return_if_fail (GDK_IS_DISPLAY (display));
 597
 598 }
 599
 600 void
 601 gdk_display_flush (GdkDisplay *display)
 602 {
 603   g_return_if_fail (GDK_IS_DISPLAY (display));
 604
 605 }
 606
 607 GdkWindow *
 608 gdk_display_get_default_group (GdkDisplay *display)
 609 {
 610   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 611
 612   return NULL;
 613 }
 614
 615 static void
 616 gdk_display_broadway_dispose (GObject *object)
 617 {
 618   GdkDisplayBroadway *display_broadway = GDK_DISPLAY_BROADWAY (object);
 619
 620   g_list_foreach (display_broadway->input_devices, (GFunc) g_object_run_dispose, NULL);
 621
 622   _gdk_screen_close (display_broadway->screens[0]);
 623
 624   if (display_broadway->event_source)
 625     {
 626       g_source_destroy (display_broadway->event_source);
 627       g_source_unref (display_broadway->event_source);
 628       display_broadway->event_source = NULL;
 629     }
 630
 631   G_OBJECT_CLASS (_gdk_display_broadway_parent_class)->dispose (object);
 632 }
 633
 634 static void
 635 gdk_display_broadway_finalize (GObject *object)
 636 {
 637   GdkDisplayBroadway *display_broadway = GDK_DISPLAY_BROADWAY (object);
 638
 639   /* Keymap */
 640   if (display_broadway->keymap)
 641     g_object_unref (display_broadway->keymap);
 642
 643   _gdk_broadway_cursor_display_finalize (GDK_DISPLAY_OBJECT(display_broadway));
 644
 645   /* Atom Hashtable */
 646   g_hash_table_destroy (display_broadway->atom_from_virtual);
 647   g_hash_table_destroy (display_broadway->atom_to_virtual);
 648
 649   /* input GdkDevice list */
 650   g_list_foreach (display_broadway->input_devices, (GFunc) g_object_unref, NULL);
 651   g_list_free (display_broadway->input_devices);
 652   /* Free all GdkScreens */
 653   g_object_unref (display_broadway->screens[0]);
 654   g_free (display_broadway->screens);
 655
 656   G_OBJECT_CLASS (_gdk_display_broadway_parent_class)->finalize (object);
 657 }
 658
 659 void
 660 _gdk_windowing_set_default_display (GdkDisplay *display)
 661 {
 662 }
 663
 664 void
 665 gdk_notify_startup_complete (void)
 666 {
 667 }
 668
 669 void
 670 gdk_notify_startup_complete_with_id (const gchar* startup_id)
 671 {
 672 }
 673
 674 gboolean
 675 gdk_display_supports_selection_notification (GdkDisplay *display)
 676 {
 677   return FALSE;
 678 }
 679
 680 gboolean
 681 gdk_display_request_selection_notification (GdkDisplay *display,
 682                                             GdkAtom     selection)
 683
 684 {
 685     return FALSE;
 686 }
 687
 688 gboolean
 689 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
 690 {
 691   return FALSE;
 692 }
 693
 694 void
 695 gdk_display_store_clipboard (GdkDisplay    *display,
 696                              GdkWindow     *clipboard_window,
 697                              guint32        time_,
 698                              const GdkAtom *targets,
 699                              gint           n_targets)
 700 {
 701 }
 702
 703 gboolean
 704 gdk_display_supports_shapes (GdkDisplay *display)
 705 {
 706   return FALSE;
 707 }
 708
 709 gboolean
 710 gdk_display_supports_input_shapes (GdkDisplay *display)
 711 {
 712   return FALSE;
 713 }
 714
 715 gboolean
 716 gdk_display_supports_composite (GdkDisplay *display)
 717 {
 718   return FALSE;
 719 }
 720
 721 GList *
 722 gdk_display_list_devices (GdkDisplay *display)
 723 {
 724   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 725
 726   return GDK_DISPLAY_BROADWAY (display)->input_devices;
 727 }
 728
 729 gboolean
 730 gdk_event_send_client_message_for_display (GdkDisplay     *display,
 731                                            GdkEvent       *event,
 732                                            GdkNativeWindow winid)
 733 {
 734   return FALSE;
 735 }
 736
 737 void
 738 gdk_display_add_client_message_filter (GdkDisplay   *display,
 739                                        GdkAtom       message_type,
 740                                        GdkFilterFunc func,
 741                                        gpointer      data)
 742 {
 743 }
 744
 745 void
 746 gdk_add_client_message_filter (GdkAtom       message_type,
 747                                GdkFilterFunc func,
 748                                gpointer      data)
 749 {
 750 }
 751
 752 void
 753 gdk_flush (void)
 754 {
 755   GSList *tmp_list = _gdk_displays;
 756
 757   while (tmp_list)
 758     {
 759       gdk_display_flush (GDK_DISPLAY_OBJECT (tmp_list->data));
 760       tmp_list = tmp_list->next;
 761     }
 762 }
 763
 764 gulong
 765 _gdk_windowing_window_get_next_serial (GdkDisplay *display)
 766 {
 767   return 0;
 768 }