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 }
  63
  64 static void
  65 _gdk_event_init (GdkDisplay *display)
  66 {
  67   GdkDisplayBroadway *display_broadway;
  68
  69   display_broadway = GDK_DISPLAY_BROADWAY (display);
  70   display_broadway->event_source = gdk_event_source_new (display);
  71 }
  72
  73 static void
  74 _gdk_input_init (GdkDisplay *display)
  75 {
  76   GdkDisplayBroadway *display_broadway;
  77   GdkDeviceManager *device_manager;
  78   GdkDevice *device;
  79   GList *list, *l;
  80
  81   display_broadway = GDK_DISPLAY_BROADWAY (display);
  82   device_manager = gdk_display_get_device_manager (display);
  83
  84   /* For backwards compatibility, just add
  85    * floating devices that are not keyboards.
  86    */
  87   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
  88
  89   for (l = list; l; l = l->next)
  90     {
  91       device = l->data;
  92
  93       if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
  94         continue;
  95
  96       display_broadway->input_devices = g_list_prepend (display_broadway->input_devices,
  97                                                    g_object_ref (l->data));
  98     }
  99
 100   g_list_free (list);
 101
 102   /* Now set "core" pointer to the first
 103    * master device that is a pointer.
 104    */
 105   list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
 106
 107   for (l = list; l; l = l->next)
 108     {
 109       device = list->data;
 110
 111       if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
 112         continue;
 113
 114       display->core_pointer = device;
 115       break;
 116     }
 117
 118   /* Add the core pointer to the devices list */
 119   display_broadway->input_devices = g_list_prepend (display_broadway->input_devices,
 120                                                g_object_ref (display->core_pointer));
 121
 122   g_list_free (list);
 123 }
 124
 125 typedef struct {
 126   GdkDisplay *display;
 127   GSocketConnection *connection;
 128   GDataInputStream *data;
 129   GString *request;
 130 } HttpRequest;
 131
 132 static void
 133 http_request_free (HttpRequest *request)
 134 {
 135   g_object_unref (request->connection);
 136   g_object_unref (request->data);
 137   g_string_free (request->request, TRUE);
 138   g_free (request);
 139 }
 140
 141 #include <unistd.h>
 142 #include <fcntl.h>
 143 static void
 144 set_fd_blocking (int fd)
 145 {
 146   glong arg;
 147
 148   if ((arg = fcntl (fd, F_GETFL, NULL)) < 0)
 149     arg = 0;
 150
 151   arg = arg & ~O_NONBLOCK;
 152
 153   fcntl (fd, F_SETFL, arg);
 154 }
 155
 156 static char *
 157 parse_line (char *line, char *key)
 158 {
 159   char *p;
 160
 161   if (!g_str_has_prefix (line, key))
 162     return NULL;
 163   p = line + strlen (key);
 164   if (*p != ':')
 165     return NULL;
 166   p++;
 167   /* Skip optional initial space */
 168   if (*p == ' ')
 169     p++;
 170   return p;
 171 }
 172
 173 static void
 174 got_input (GInputStream *stream,
 175            GAsyncResult *result,
 176            HttpRequest *request)
 177 {
 178   GdkScreen *screen;
 179   GdkWindow *root, *window;
 180   char *message, *p;
 181   gsize len;
 182   GError *error = NULL;
 183   int x, y, button;
 184   guint64 time;
 185   GdkEvent *event = NULL;
 186   char cmd;
 187   GList *node;
 188   GdkDisplayBroadway *display_broadway = GDK_DISPLAY_BROADWAY (request->display);
 189
 190   message = g_data_input_stream_read_upto_finish (G_DATA_INPUT_STREAM (stream), result, &len, &error);
 191   if (message == NULL)
 192     {
 193       g_print (error->message);
 194       g_error_free (error);
 195       exit (1);
 196     }
 197   g_assert (message[0] == 0);
 198
 199   screen = gdk_display_get_default_screen (request->display);
 200   root = gdk_screen_get_root_window (screen);
 201
 202   p = message + 1;
 203   cmd = *p++;
 204   switch (cmd) {
 205   case 'm':
 206     x = strtol(p, &p, 10);
 207     p++; /* Skip , */
 208     y = strtol(p, &p, 10);
 209     p++; /* Skip , */
 210     time = strtol(p, &p, 10);
 211
 212     window = _gdk_window_find_child_at (root, x, y);
 213
 214     if (display_broadway->mouse_in_toplevel != window)
 215       {
 216         if (display_broadway->mouse_in_toplevel != NULL)
 217           {
 218             event = gdk_event_new (GDK_LEAVE_NOTIFY);
 219             event->crossing.window = g_object_ref (display_broadway->mouse_in_toplevel);
 220             event->crossing.time = time;
 221             event->crossing.x = x - GDK_WINDOW_OBJECT (display_broadway->mouse_in_toplevel)->x;
 222             event->crossing.y = y - GDK_WINDOW_OBJECT (display_broadway->mouse_in_toplevel)->y;
 223             event->crossing.x_root = x;
 224             event->crossing.y_root = y;
 225             event->crossing.mode = GDK_CROSSING_NORMAL;
 226             event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 227             gdk_event_set_device (event, request->display->core_pointer);
 228
 229             node = _gdk_event_queue_append (request->display, event);
 230             _gdk_windowing_got_event (request->display, node, event, 0);
 231
 232             event = gdk_event_new (GDK_FOCUS_CHANGE);
 233             event->focus_change.window = g_object_ref (display_broadway->mouse_in_toplevel);
 234             event->focus_change.in = FALSE;
 235             gdk_event_set_device (event, request->display->core_pointer);
 236
 237             node = _gdk_event_queue_append (request->display, event);
 238             _gdk_windowing_got_event (request->display, node, event, 0);
 239           }
 240
 241         /* TODO: Unset when it dies */
 242         display_broadway->mouse_in_toplevel = window;
 243
 244         if (window)
 245           {
 246             event = gdk_event_new (GDK_ENTER_NOTIFY);
 247             event->crossing.window = g_object_ref (window);
 248             event->crossing.time = time;
 249             event->crossing.x = x - GDK_WINDOW_OBJECT (window)->x;
 250             event->crossing.y = y - GDK_WINDOW_OBJECT (window)->y;
 251             event->crossing.x_root = x;
 252             event->crossing.y_root = y;
 253             event->crossing.mode = GDK_CROSSING_NORMAL;
 254             event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 255             gdk_event_set_device (event, request->display->core_pointer);
 256
 257             node = _gdk_event_queue_append (request->display, event);
 258             _gdk_windowing_got_event (request->display, node, event, 0);
 259
 260             event = gdk_event_new (GDK_FOCUS_CHANGE);
 261             event->focus_change.window = g_object_ref (window);
 262             event->focus_change.in = TRUE;
 263             gdk_event_set_device (event, request->display->core_pointer);
 264
 265             node = _gdk_event_queue_append (request->display, event);
 266             _gdk_windowing_got_event (request->display, node, event, 0);
 267
 268           }
 269       }
 270
 271     if (window)
 272       {
 273         event = gdk_event_new (GDK_MOTION_NOTIFY);
 274         event->motion.window = g_object_ref (window);
 275         event->motion.time = time;
 276         event->motion.x = x - GDK_WINDOW_OBJECT (window)->x;
 277         event->motion.y = y - GDK_WINDOW_OBJECT (window)->y;
 278         event->motion.x_root = x;
 279         event->motion.y_root = y;
 280         gdk_event_set_device (event, request->display->core_pointer);
 281
 282         node = _gdk_event_queue_append (request->display, event);
 283         _gdk_windowing_got_event (request->display, node, event, 0);
 284       }
 285
 286     break;
 287   case 'b':
 288   case 'B':
 289     x = strtol(p, &p, 10);
 290     p++; /* Skip , */
 291     y = strtol(p, &p, 10);
 292     p++; /* Skip , */
 293     button = strtol(p, &p, 10);
 294     p++; /* Skip , */
 295     time = strtol(p, &p, 10);
 296
 297     window = _gdk_window_find_child_at (root, x, y);
 298
 299     if (window)
 300       {
 301         event = gdk_event_new (cmd == 'b' ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 302         event->button.window = g_object_ref (window);
 303         event->button.time = time;
 304         event->button.x = x - GDK_WINDOW_OBJECT (window)->x;
 305         event->button.y = y - GDK_WINDOW_OBJECT (window)->y;
 306         event->button.x_root = x;
 307         event->button.y_root = y;
 308         event->button.button = button + 1;
 309         gdk_event_set_device (event, request->display->core_pointer);
 310
 311         node = _gdk_event_queue_append (request->display, event);
 312         _gdk_windowing_got_event (request->display, node, event, 0);
 313       }
 314
 315     break;
 316   }
 317
 318   /* Skip past ending 0xff */
 319   g_data_input_stream_read_byte (request->data, NULL, NULL);
 320   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 321                                        (GAsyncReadyCallback)got_input, request);
 322 }
 323
 324 static void
 325 start_input (HttpRequest *request)
 326 {
 327   char **lines;
 328   char *p;
 329   int num_key1, num_key2;
 330   guint64 key1, key2;
 331   int num_space;
 332   int i;
 333   guint8 challenge[16];
 334   char *res;
 335   gsize len;
 336   GChecksum *checksum;
 337   char *origin, *host;
 338
 339   lines = g_strsplit (request->request->str, "\n", 0);
 340
 341   num_key1 = 0;
 342   num_key2 = 0;
 343   key1 = 0;
 344   key2 = 0;
 345   origin = NULL;
 346   host = NULL;
 347   for (i = 0; lines[i] != NULL; i++)
 348     {
 349       if ((p = parse_line (lines[i], "Sec-WebSocket-Key1")))
 350         {
 351           num_space = 0;
 352           while (*p != 0)
 353             {
 354               if (g_ascii_isdigit (*p))
 355                 key1 = key1 * 10 + g_ascii_digit_value (*p);
 356               else if (*p == ' ')
 357                 num_space++;
 358
 359               p++;
 360             }
 361           key1 /= num_space;
 362           num_key1++;
 363         }
 364       else if ((p = parse_line (lines[i], "Sec-WebSocket-Key2")))
 365         {
 366           num_space = 0;
 367           while (*p != 0)
 368             {
 369               if (g_ascii_isdigit (*p))
 370                 key2 = key2 * 10 + g_ascii_digit_value (*p);
 371               else if (*p == ' ')
 372                 num_space++;
 373
 374               p++;
 375             }
 376           key2 /= num_space;
 377           num_key2++;
 378         }
 379       else if ((p = parse_line (lines[i], "Origin")))
 380         {
 381           origin = p;
 382         }
 383       else if ((p = parse_line (lines[i], "Host")))
 384         {
 385           host = p;
 386         }
 387     }
 388
 389
 390   if (num_key1 != 1 || num_key2 != 1 || origin == NULL || host == NULL)
 391     {
 392       g_print ("error");
 393       exit (1);
 394     }
 395
 396   challenge[0] = (key1 >> 24) & 0xff;
 397   challenge[1] = (key1 >> 16) & 0xff;
 398   challenge[2] = (key1 >>  8) & 0xff;
 399   challenge[3] = (key1 >>  0) & 0xff;
 400   challenge[4] = (key2 >> 24) & 0xff;
 401   challenge[5] = (key2 >> 16) & 0xff;
 402   challenge[6] = (key2 >>  8) & 0xff;
 403   challenge[7] = (key2 >>  0) & 0xff;
 404
 405   if (!g_input_stream_read_all (G_INPUT_STREAM (request->data), challenge+8, 8, NULL, NULL, NULL))
 406     {
 407       g_print ("error");
 408       exit (1);
 409     }
 410
 411   checksum = g_checksum_new (G_CHECKSUM_MD5);
 412   g_checksum_update (checksum, challenge, 16);
 413   len = 16;
 414   g_checksum_get_digest (checksum, challenge, &len);
 415   g_checksum_free (checksum);
 416
 417   res = g_strdup_printf ("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 418                          "Upgrade: WebSocket\r\n"
 419                          "Connection: Upgrade\r\n"
 420                          "Sec-WebSocket-Origin: %s\r\n"
 421                          "Sec-WebSocket-Location: ws://%s/input\r\n"
 422                          "Sec-WebSocket-Protocol: broadway\r\n"
 423                          "\r\n",
 424                          origin, host);
 425
 426   /* TODO: This should really be async */
 427   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 428                              res, strlen (res), NULL, NULL, NULL);
 429   g_free (res);
 430   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 431                              challenge, 16, NULL, NULL, NULL);
 432
 433   g_data_input_stream_read_upto_async (request->data, "\xff", 1, 0, NULL,
 434                                        (GAsyncReadyCallback)got_input, request);
 435 }
 436
 437 static void
 438 start_output (HttpRequest *request)
 439 {
 440   GSocket *socket;
 441   GdkDisplayBroadway *display_broadway;
 442   int fd;
 443
 444   socket = g_socket_connection_get_socket (request->connection);
 445
 446   display_broadway = GDK_DISPLAY_BROADWAY (request->display);
 447   fd = g_socket_get_fd (socket);
 448   set_fd_blocking (fd);
 449   display_broadway->output = broadway_client_new (fd);
 450   _gdk_broadway_resync_windows ();
 451
 452   /* TODO: This leaks the connection since we just keep the fd,
 453      we want to avoid using the fd at all here */
 454   g_object_ref (request->connection);
 455   http_request_free (request);
 456 }
 457
 458 static void
 459 send_error (HttpRequest *request,
 460             int error_code,
 461             const char *reason)
 462 {
 463   char *res;
 464
 465   res = g_strdup_printf ("HTTP/1.0 %d %s\r\n\r\n"
 466                          "<html><head><title>%d %s</title></head>"
 467                          "<body>%s</body></html>",
 468                          error_code, reason,
 469                          error_code, reason,
 470                          reason);
 471   /* TODO: This should really be async */
 472   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 473                              res, strlen (res), NULL, NULL, NULL);
 474   g_free (res);
 475   http_request_free (request);
 476 }
 477
 478 static void
 479 send_data (HttpRequest *request,
 480              const char *mimetype,
 481              const char *data, gsize len)
 482 {
 483   char *res;
 484
 485   res = g_strdup_printf ("HTTP/1.0 200 OK\r\n"
 486                          "Content-Type: %s\r\n"
 487                          "Content-Length: %"G_GSIZE_FORMAT"\r\n"
 488                          "\r\n",
 489                          mimetype, len);
 490   /* TODO: This should really be async */
 491   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 492                              res, strlen (res), NULL, NULL, NULL);
 493   g_free (res);
 494   g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (request->connection)),
 495                              data, len, NULL, NULL, NULL);
 496   http_request_free (request);
 497 }
 498
 499 #include "clienthtml.h"
 500 #include "broadwayjs.h"
 501
 502 static void
 503 got_request (HttpRequest *request)
 504 {
 505   char *start, *escaped, *tmp, *version;
 506
 507   if (!g_str_has_prefix (request->request->str, "GET "))
 508     {
 509       send_error (request, 501, "Only GET implemented");
 510       return;
 511     }
 512
 513   start = request->request->str + 4; /* Skip "GET " */
 514
 515   while (*start == ' ')
 516     start++;
 517
 518   for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 519     ;
 520   escaped = g_strndup (start, tmp - start);
 521   version = NULL;
 522   if (*tmp == ' ')
 523     {
 524       start = tmp;
 525       while (*start == ' ')
 526         start++;
 527       for (tmp = start; *tmp != 0 && *tmp != ' ' && *tmp != '\n'; tmp++)
 528         ;
 529       version = g_strndup (start, tmp - start);
 530     }
 531
 532   if (strcmp (escaped, "/client.html") == 0 || strcmp (escaped, "/") == 0)
 533     send_data (request, "text/html", client_html, G_N_ELEMENTS(client_html) - 1);
 534   else if (strcmp (escaped, "/broadway.js") == 0)
 535     send_data (request, "text/javascript", broadway_js, G_N_ELEMENTS(broadway_js) - 1);
 536   else if (strcmp (escaped, "/output") == 0)
 537     start_output (request);
 538   else if (strcmp (escaped, "/input") == 0)
 539     start_input (request);
 540   else
 541     send_error (request, 404, "File not found");
 542 }
 543
 544 static void
 545 got_http_request_line (GInputStream *stream,
 546                        GAsyncResult *result,
 547                        HttpRequest *request)
 548 {
 549   char *line;
 550
 551   line = g_data_input_stream_read_line_finish (G_DATA_INPUT_STREAM (stream), result, NULL, NULL);
 552   if (line == NULL)
 553     {
 554       http_request_free (request);
 555       g_printerr ("Error reading request lines\n");
 556       return;
 557     }
 558   if (strlen (line) == 0)
 559     got_request (request);
 560   else
 561     {
 562       /* Protect against overflow in request length */
 563       if (request->request->len > 1024 * 5)
 564         {
 565           send_error (request, 400, "Request to long");
 566         }
 567       else
 568         {
 569           g_string_append_printf (request->request, "%s\n", line);
 570           g_data_input_stream_read_line_async (request->data, 0, NULL,
 571                                                (GAsyncReadyCallback)got_http_request_line, request);
 572         }
 573     }
 574   g_free (line);
 575 }
 576
 577 static gboolean
 578 handle_incoming_connection (GSocketService    *service,
 579                             GSocketConnection *connection,
 580                             GObject           *source_object)
 581 {
 582   HttpRequest *request;
 583   GInputStream *in;
 584
 585   request = g_new0 (HttpRequest, 1);
 586   request->connection = g_object_ref (connection);
 587   request->display = (GdkDisplay *) source_object;
 588   request->request = g_string_new ("");
 589
 590   in = g_io_stream_get_input_stream (G_IO_STREAM (connection));
 591
 592   request->data = g_data_input_stream_new (in);
 593   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (request->data), FALSE);
 594   /* Be tolerant of input */
 595   g_data_input_stream_set_newline_type (request->data, G_DATA_STREAM_NEWLINE_TYPE_ANY);
 596
 597   g_data_input_stream_read_line_async (request->data, 0, NULL,
 598                                        (GAsyncReadyCallback)got_http_request_line, request);
 599   return TRUE;
 600 }
 601
 602 GdkDisplay *
 603 gdk_display_open (const gchar *display_name)
 604 {
 605   GdkDisplay *display;
 606   GdkDisplayBroadway *display_broadway;
 607   const char *sm_client_id;
 608   GError *error;
 609
 610   display = g_object_new (GDK_TYPE_DISPLAY_BROADWAY, NULL);
 611   display_broadway = GDK_DISPLAY_BROADWAY (display);
 612
 613   display_broadway->output = NULL;
 614
 615   /* initialize the display's screens */
 616   display_broadway->screens = g_new (GdkScreen *, 1);
 617   display_broadway->screens[0] = _gdk_broadway_screen_new (display, 0);
 618
 619   /* We need to initialize events after we have the screen
 620    * structures in places
 621    */
 622   _gdk_screen_broadway_events_init (display_broadway->screens[0]);
 623
 624   /*set the default screen */
 625   display_broadway->default_screen = display_broadway->screens[0];
 626
 627   display->device_manager = _gdk_device_manager_new (display);
 628
 629   _gdk_event_init (display);
 630
 631   sm_client_id = _gdk_get_sm_client_id ();
 632   if (sm_client_id)
 633     _gdk_windowing_display_set_sm_client_id (display, sm_client_id);
 634
 635   _gdk_input_init (display);
 636   _gdk_dnd_init (display);
 637
 638   _gdk_broadway_screen_setup (display_broadway->screens[0]);
 639
 640   display_broadway->service = g_socket_service_new ();
 641   if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (display_broadway->service),
 642                                         8080,
 643                                         G_OBJECT (display),
 644                                         &error))
 645     {
 646       g_printerr ("Unable to listen to port %d: %s\n", 8080, error->message);
 647       g_error_free (error);
 648       return NULL;
 649     }
 650   g_signal_connect (display_broadway->service, "incoming", G_CALLBACK (handle_incoming_connection), NULL);
 651
 652   g_signal_emit_by_name (display, "opened");
 653   g_signal_emit_by_name (gdk_display_manager_get (), "display-opened", display);
 654
 655   return display;
 656 }
 657
 658
 659 G_CONST_RETURN gchar *
 660 gdk_display_get_name (GdkDisplay *display)
 661 {
 662   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 663
 664   return (gchar *) "Broadway";
 665 }
 666
 667 gint
 668 gdk_display_get_n_screens (GdkDisplay *display)
 669 {
 670   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
 671
 672   return 1;
 673 }
 674
 675 GdkScreen *
 676 gdk_display_get_screen (GdkDisplay *display,
 677                         gint        screen_num)
 678 {
 679   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 680   g_return_val_if_fail (screen_num == 0, NULL);
 681
 682   return GDK_DISPLAY_BROADWAY (display)->screens[screen_num];
 683 }
 684
 685 GdkScreen *
 686 gdk_display_get_default_screen (GdkDisplay *display)
 687 {
 688   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 689
 690   return GDK_DISPLAY_BROADWAY (display)->default_screen;
 691 }
 692
 693 void
 694 gdk_device_ungrab (GdkDevice  *device,
 695                    guint32     time_)
 696 {
 697 }
 698
 699 void
 700 gdk_display_beep (GdkDisplay *display)
 701 {
 702   g_return_if_fail (GDK_IS_DISPLAY (display));
 703 }
 704
 705 void
 706 gdk_display_sync (GdkDisplay *display)
 707 {
 708   g_return_if_fail (GDK_IS_DISPLAY (display));
 709
 710 }
 711
 712 void
 713 gdk_display_flush (GdkDisplay *display)
 714 {
 715   g_return_if_fail (GDK_IS_DISPLAY (display));
 716
 717 }
 718
 719 GdkWindow *
 720 gdk_display_get_default_group (GdkDisplay *display)
 721 {
 722   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 723
 724   return NULL;
 725 }
 726
 727 void
 728 gdk_broadway_display_grab (GdkDisplay *display)
 729 {
 730 }
 731
 732 void
 733 gdk_broadway_display_ungrab (GdkDisplay *display)
 734 {
 735 }
 736
 737 static void
 738 gdk_display_broadway_dispose (GObject *object)
 739 {
 740   GdkDisplayBroadway *display_broadway = GDK_DISPLAY_BROADWAY (object);
 741
 742   g_list_foreach (display_broadway->input_devices, (GFunc) g_object_run_dispose, NULL);
 743
 744   _gdk_screen_close (display_broadway->screens[0]);
 745
 746   if (display_broadway->event_source)
 747     {
 748       g_source_destroy (display_broadway->event_source);
 749       g_source_unref (display_broadway->event_source);
 750       display_broadway->event_source = NULL;
 751     }
 752
 753   G_OBJECT_CLASS (_gdk_display_broadway_parent_class)->dispose (object);
 754 }
 755
 756 static void
 757 gdk_display_broadway_finalize (GObject *object)
 758 {
 759   GdkDisplayBroadway *display_broadway = GDK_DISPLAY_BROADWAY (object);
 760
 761   /* Keymap */
 762   if (display_broadway->keymap)
 763     g_object_unref (display_broadway->keymap);
 764
 765   _gdk_broadway_cursor_display_finalize (GDK_DISPLAY_OBJECT(display_broadway));
 766
 767   /* Atom Hashtable */
 768   g_hash_table_destroy (display_broadway->atom_from_virtual);
 769   g_hash_table_destroy (display_broadway->atom_to_virtual);
 770
 771   /* input GdkDevice list */
 772   g_list_foreach (display_broadway->input_devices, (GFunc) g_object_unref, NULL);
 773   g_list_free (display_broadway->input_devices);
 774   /* Free all GdkScreens */
 775   g_object_unref (display_broadway->screens[0]);
 776   g_free (display_broadway->screens);
 777
 778   G_OBJECT_CLASS (_gdk_display_broadway_parent_class)->finalize (object);
 779 }
 780
 781 void
 782 _gdk_windowing_set_default_display (GdkDisplay *display)
 783 {
 784 }
 785
 786 void
 787 gdk_notify_startup_complete (void)
 788 {
 789 }
 790
 791 void
 792 gdk_notify_startup_complete_with_id (const gchar* startup_id)
 793 {
 794 }
 795
 796 gboolean
 797 gdk_display_supports_selection_notification (GdkDisplay *display)
 798 {
 799   return FALSE;
 800 }
 801
 802 gboolean
 803 gdk_display_request_selection_notification (GdkDisplay *display,
 804                                             GdkAtom     selection)
 805
 806 {
 807     return FALSE;
 808 }
 809
 810 gboolean
 811 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
 812 {
 813   return FALSE;
 814 }
 815
 816 void
 817 gdk_display_store_clipboard (GdkDisplay    *display,
 818                              GdkWindow     *clipboard_window,
 819                              guint32        time_,
 820                              const GdkAtom *targets,
 821                              gint           n_targets)
 822 {
 823 }
 824
 825 guint32
 826 gdk_broadway_display_get_user_time (GdkDisplay *display)
 827 {
 828   return GDK_DISPLAY_BROADWAY (display)->user_time;
 829 }
 830
 831 gboolean
 832 gdk_display_supports_shapes (GdkDisplay *display)
 833 {
 834   return FALSE;
 835 }
 836
 837 gboolean
 838 gdk_display_supports_input_shapes (GdkDisplay *display)
 839 {
 840   return FALSE;
 841 }
 842
 843 gboolean
 844 gdk_display_supports_composite (GdkDisplay *display)
 845 {
 846   return FALSE;
 847 }
 848
 849 GList *
 850 gdk_display_list_devices (GdkDisplay *display)
 851 {
 852   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 853
 854   return GDK_DISPLAY_BROADWAY (display)->input_devices;
 855 }
 856
 857 gboolean
 858 gdk_event_send_client_message_for_display (GdkDisplay     *display,
 859                                            GdkEvent       *event,
 860                                            GdkNativeWindow winid)
 861 {
 862   return FALSE;
 863 }
 864
 865 void
 866 gdk_display_add_client_message_filter (GdkDisplay   *display,
 867                                        GdkAtom       message_type,
 868                                        GdkFilterFunc func,
 869                                        gpointer      data)
 870 {
 871 }
 872
 873 void
 874 gdk_add_client_message_filter (GdkAtom       message_type,
 875                                GdkFilterFunc func,
 876                                gpointer      data)
 877 {
 878 }
 879
 880 void
 881 gdk_flush (void)
 882 {
 883   GSList *tmp_list = _gdk_displays;
 884
 885   while (tmp_list)
 886     {
 887       gdk_display_flush (GDK_DISPLAY_OBJECT (tmp_list->data));
 888       tmp_list = tmp_list->next;
 889     }
 890 }
 891
 892 gulong
 893 _gdk_windowing_window_get_next_serial (GdkDisplay *display)
 894 {
 895   return 0;
 896 }