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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,
   3  * Josh MacDonald, Ryan Lortie
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29
  30 #include "gdkwindow-broadway.h"
  31 #include "gdkscreen-broadway.h"
  32
  33 #include "gdkwindow.h"
  34 #include "gdkwindowimpl.h"
  35 #include "gdkdisplay-broadway.h"
  36 #include "gdkprivate-broadway.h"
  37 #include "gdkinternals.h"
  38 #include "gdkdeviceprivate.h"
  39 #include "gdkeventsource.h"
  40
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <netinet/in.h>
  45 #include <unistd.h>
  46
  47 /* Forward declarations */
  48 static void     gdk_window_broadway_set_background     (GdkWindow      *window,
  49                                                    cairo_pattern_t *pattern);
  50
  51 static void        gdk_window_impl_broadway_finalize   (GObject            *object);
  52 static void        gdk_window_impl_iface_init     (GdkWindowImplIface *iface);
  53
  54 #define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window) \
  55   (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
  56    GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
  57
  58 #define WINDOW_IS_TOPLEVEL(window)                   \
  59   (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
  60    GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
  61    GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
  62
  63 /* Return whether time1 is considered later than time2 as far as xserver
  64  * time is concerned.  Accounts for wraparound.
  65  */
  66 #define XSERVER_TIME_IS_LATER(time1, time2)                        \
  67   ( (( time1 > time2 ) && ( time1 - time2 < ((guint32)-1)/2 )) ||  \
  68     (( time1 < time2 ) && ( time2 - time1 > ((guint32)-1)/2 ))     \
  69   )
  70
  71 G_DEFINE_TYPE_WITH_CODE (GdkWindowImplBroadway,
  72                          gdk_window_impl_broadway,
  73                          GDK_TYPE_DRAWABLE_IMPL_BROADWAY,
  74                          G_IMPLEMENT_INTERFACE (GDK_TYPE_WINDOW_IMPL,
  75                                                 gdk_window_impl_iface_init));
  76
  77 static GList *all_windows;
  78
  79 GType
  80 _gdk_window_impl_get_type (void)
  81 {
  82   return gdk_window_impl_broadway_get_type ();
  83 }
  84
  85 static void
  86 gdk_window_impl_broadway_init (GdkWindowImplBroadway *impl)
  87 {
  88   static int current_id = 1; /* 0 is the root window */
  89
  90   impl->id = current_id++;
  91   all_windows = g_list_prepend (all_windows, impl);
  92   impl->toplevel_window_type = -1;
  93   impl->device_cursor = g_hash_table_new_full (NULL, NULL, NULL,
  94                                                (GDestroyNotify) gdk_cursor_unref);
  95 }
  96
  97 static void
  98 gdk_window_impl_broadway_class_init (GdkWindowImplBroadwayClass *klass)
  99 {
 100   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 101
 102   object_class->finalize = gdk_window_impl_broadway_finalize;
 103 }
 104
 105 static void
 106 gdk_window_impl_broadway_finalize (GObject *object)
 107 {
 108   GdkWindowObject *wrapper;
 109   GdkDrawableImplBroadway *draw_impl;
 110   GdkWindowImplBroadway *window_impl;
 111
 112   g_return_if_fail (GDK_IS_WINDOW_IMPL_BROADWAY (object));
 113
 114   draw_impl = GDK_DRAWABLE_IMPL_BROADWAY (object);
 115   window_impl = GDK_WINDOW_IMPL_BROADWAY (object);
 116
 117   wrapper = (GdkWindowObject*) draw_impl->wrapper;
 118
 119   if (window_impl->cursor)
 120     gdk_cursor_unref (window_impl->cursor);
 121
 122   g_hash_table_destroy (window_impl->device_cursor);
 123
 124   all_windows = g_list_remove (all_windows, window_impl);
 125
 126   G_OBJECT_CLASS (gdk_window_impl_broadway_parent_class)->finalize (object);
 127 }
 128
 129 void
 130 _gdk_windowing_window_init (GdkScreen * screen)
 131 {
 132   GdkWindowObject *private;
 133   GdkDrawableImplBroadway *draw_impl;
 134   GdkScreenBroadway *screen_broadway;
 135
 136   screen_broadway = GDK_SCREEN_BROADWAY (screen);
 137
 138   g_assert (screen_broadway->root_window == NULL);
 139
 140   screen_broadway->root_window = g_object_new (GDK_TYPE_WINDOW, NULL);
 141
 142   private = (GdkWindowObject *) screen_broadway->root_window;
 143   private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
 144   private->impl_window = private;
 145   private->visual = gdk_screen_get_system_visual (screen);
 146
 147   draw_impl = GDK_DRAWABLE_IMPL_BROADWAY (private->impl);
 148
 149   draw_impl->screen = screen;
 150   draw_impl->wrapper = GDK_DRAWABLE (private);
 151
 152   private->window_type = GDK_WINDOW_ROOT;
 153   private->depth = 24;
 154
 155   private->x = 0;
 156   private->y = 0;
 157   private->abs_x = 0;
 158   private->abs_y = 0;
 159   private->width = gdk_screen_get_width (screen);
 160   private->height = gdk_screen_get_height (screen);
 161   private->viewable = TRUE;
 162
 163   _gdk_window_update_size (screen_broadway->root_window);
 164 }
 165
 166 void
 167 _gdk_window_impl_new (GdkWindow     *window,
 168                       GdkWindow     *real_parent,
 169                       GdkScreen     *screen,
 170                       GdkEventMask   event_mask,
 171                       GdkWindowAttr *attributes,
 172                       gint           attributes_mask)
 173 {
 174   GdkWindowObject *private;
 175   GdkWindowImplBroadway *impl;
 176   GdkDrawableImplBroadway *draw_impl;
 177   GdkScreenBroadway *screen_broadway;
 178   GdkDisplayBroadway *display_broadway;
 179
 180   private = (GdkWindowObject *) window;
 181
 182   screen_broadway = GDK_SCREEN_BROADWAY (screen);
 183   display_broadway = GDK_DISPLAY_BROADWAY (GDK_SCREEN_DISPLAY (screen));
 184
 185   impl = g_object_new (_gdk_window_impl_get_type (), NULL);
 186   private->impl = (GdkDrawable *)impl;
 187   draw_impl = GDK_DRAWABLE_IMPL_BROADWAY (impl);
 188   draw_impl->wrapper = GDK_DRAWABLE (window);
 189
 190   draw_impl->screen = screen;
 191
 192   g_assert (private->window_type == GDK_WINDOW_TOPLEVEL ||
 193             private->window_type == GDK_WINDOW_TEMP);
 194   g_assert (GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_ROOT);
 195 }
 196
 197
 198 GdkWindow *
 199 gdk_window_foreign_new_for_display (GdkDisplay     *display,
 200                                     GdkNativeWindow anid)
 201 {
 202   return NULL;
 203 }
 204
 205 GdkWindow *
 206 gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
 207 {
 208   return NULL;
 209 }
 210
 211 GdkWindow *
 212 gdk_window_lookup (GdkNativeWindow anid)
 213 {
 214   return NULL;
 215 }
 216
 217 static void
 218 _gdk_broadway_window_destroy (GdkWindow *window,
 219                          gboolean   recursing,
 220                          gboolean   foreign_destroy)
 221 {
 222   GdkWindowObject *private = (GdkWindowObject *)window;
 223
 224   g_return_if_fail (GDK_IS_WINDOW (window));
 225
 226   _gdk_selection_window_destroyed (window);
 227
 228   _gdk_broadway_drawable_finish (private->impl);
 229 }
 230
 231 static cairo_surface_t *
 232 gdk_window_broadway_resize_cairo_surface (GdkWindow       *window,
 233                                      cairo_surface_t *surface,
 234                                      gint             width,
 235                                      gint             height)
 236 {
 237   /* Image surfaces cannot be resized */
 238   cairo_surface_destroy (surface);
 239
 240   return NULL;
 241 }
 242
 243 void
 244 _gdk_windowing_window_destroy_foreign (GdkWindow *window)
 245 {
 246 }
 247
 248 /* This function is called when the XWindow is really gone.
 249  */
 250 void
 251 gdk_window_destroy_notify (GdkWindow *window)
 252 {
 253   GdkWindowImplBroadway *window_impl;
 254
 255   window_impl = GDK_WINDOW_IMPL_BROADWAY (((GdkWindowObject *)window)->impl);
 256
 257   if (!GDK_WINDOW_DESTROYED (window))
 258     {
 259       if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
 260         g_warning ("GdkWindow %p unexpectedly destroyed", window);
 261
 262       _gdk_window_destroy (window, TRUE);
 263     }
 264
 265   g_object_unref (window);
 266 }
 267
 268 static void
 269 gdk_window_broadway_show (GdkWindow *window, gboolean already_mapped)
 270 {
 271   GdkWindowObject *private;
 272
 273   private = (GdkWindowObject*) window;
 274
 275   if (private->event_mask & GDK_STRUCTURE_MASK)
 276     _gdk_make_event (GDK_WINDOW (private), GDK_MAP, NULL, FALSE);
 277
 278   if (private->parent && private->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
 279     _gdk_make_event (GDK_WINDOW (private), GDK_MAP, NULL, FALSE);
 280
 281   /* TODO */
 282 }
 283
 284 static void
 285 gdk_window_broadway_hide (GdkWindow *window)
 286 {
 287   GdkWindowObject *private;
 288
 289   private = (GdkWindowObject*) window;
 290
 291   if (private->event_mask & GDK_STRUCTURE_MASK)
 292     _gdk_make_event (GDK_WINDOW (private), GDK_UNMAP, NULL, FALSE);
 293
 294   if (private->parent && private->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
 295     _gdk_make_event (GDK_WINDOW (private), GDK_UNMAP, NULL, FALSE);
 296
 297   _gdk_window_clear_update_area (window);
 298 }
 299
 300 static void
 301 gdk_window_broadway_withdraw (GdkWindow *window)
 302 {
 303   gdk_window_broadway_hide (window);
 304 }
 305
 306 static inline void
 307 window_broadway_move (GdkWindow *window,
 308                  gint       x,
 309                  gint       y)
 310 {
 311   GdkWindowObject *private = (GdkWindowObject *) window;
 312
 313   // XMoveWindow (GDK_WINDOW_XDISPLAY (window),  GDK_WINDOW_XID (window),  x, y);
 314   private->x = x;
 315   private->y = y;
 316 }
 317
 318 static inline void
 319 window_broadway_resize (GdkWindow *window,
 320                    gint       width,
 321                    gint       height)
 322 {
 323   GdkWindowObject *private = (GdkWindowObject *) window;
 324
 325   if (width < 1)
 326     width = 1;
 327
 328   if (height < 1)
 329     height = 1;
 330
 331   //XResizeWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window), width, height);
 332
 333   private->width = width;
 334   private->height = height;
 335   _gdk_broadway_drawable_update_size (private->impl);
 336
 337   _gdk_broadway_drawable_update_size (private->impl);
 338 }
 339
 340 static inline void
 341 window_broadway_move_resize (GdkWindow *window,
 342                         gint       x,
 343                         gint       y,
 344                         gint       width,
 345                         gint       height)
 346 {
 347   GdkWindowObject *private = (GdkWindowObject *) window;;
 348
 349   if (width < 1)
 350     width = 1;
 351
 352   if (height < 1)
 353     height = 1;
 354
 355   //XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window), x, y, width, height);
 356
 357   private->x = x;
 358   private->y = y;
 359
 360   private->width = width;
 361   private->height = height;
 362
 363   _gdk_broadway_drawable_update_size (private->impl);
 364 }
 365
 366 static void
 367 gdk_window_broadway_move_resize (GdkWindow *window,
 368                             gboolean   with_move,
 369                             gint       x,
 370                             gint       y,
 371                             gint       width,
 372                             gint       height)
 373 {
 374   if (with_move && (width < 0 && height < 0))
 375     window_broadway_move (window, x, y);
 376   else
 377     {
 378       if (with_move)
 379         window_broadway_move_resize (window, x, y, width, height);
 380       else
 381         window_broadway_resize (window, width, height);
 382     }
 383 }
 384
 385 static gboolean
 386 gdk_window_broadway_reparent (GdkWindow *window,
 387                          GdkWindow *new_parent,
 388                          gint       x,
 389                          gint       y)
 390 {
 391   return FALSE;
 392 }
 393
 394 static void
 395 gdk_window_broadway_raise (GdkWindow *window)
 396 {
 397 }
 398
 399 static void
 400 gdk_window_broadway_restack_under (GdkWindow *window,
 401                               GList *native_siblings /* in requested order, first is bottom-most */)
 402 {
 403 }
 404
 405 static void
 406 gdk_window_broadway_restack_toplevel (GdkWindow *window,
 407                                  GdkWindow *sibling,
 408                                  gboolean   above)
 409 {
 410 }
 411
 412 static void
 413 gdk_window_broadway_lower (GdkWindow *window)
 414 {
 415 }
 416
 417
 418 void
 419 gdk_window_focus (GdkWindow *window,
 420                   guint32    timestamp)
 421 {
 422 }
 423
 424 void
 425 gdk_window_set_type_hint (GdkWindow        *window,
 426                           GdkWindowTypeHint hint)
 427 {
 428 }
 429
 430 GdkWindowTypeHint
 431 gdk_window_get_type_hint (GdkWindow *window)
 432 {
 433   return GDK_WINDOW_TYPE_HINT_NORMAL;
 434 }
 435
 436 void
 437 gdk_window_set_modal_hint (GdkWindow *window,
 438                            gboolean   modal)
 439 {
 440 }
 441
 442 void
 443 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
 444                                   gboolean   skips_taskbar)
 445 {
 446 }
 447
 448 void
 449 gdk_window_set_skip_pager_hint (GdkWindow *window,
 450                                 gboolean   skips_pager)
 451 {
 452 }
 453
 454 void
 455 gdk_window_set_urgency_hint (GdkWindow *window,
 456                              gboolean   urgent)
 457 {
 458 }
 459
 460 void
 461 gdk_window_set_geometry_hints (GdkWindow         *window,
 462                                const GdkGeometry *geometry,
 463                                GdkWindowHints     geom_mask)
 464 {
 465 }
 466
 467 void
 468 gdk_window_set_title (GdkWindow   *window,
 469                       const gchar *title)
 470 {
 471 }
 472
 473 void
 474 gdk_window_set_role (GdkWindow   *window,
 475                      const gchar *role)
 476 {
 477 }
 478
 479 void
 480 gdk_window_set_startup_id (GdkWindow   *window,
 481                            const gchar *startup_id)
 482 {
 483 }
 484
 485 void
 486 gdk_window_set_transient_for (GdkWindow *window,
 487                               GdkWindow *parent)
 488 {
 489 }
 490
 491 static void
 492 gdk_window_broadway_set_background (GdkWindow      *window,
 493                                cairo_pattern_t *pattern)
 494 {
 495   return;
 496 }
 497
 498 static void
 499 gdk_window_broadway_set_device_cursor (GdkWindow *window,
 500                                   GdkDevice *device,
 501                                   GdkCursor *cursor)
 502 {
 503   GdkWindowObject *private;
 504   GdkWindowImplBroadway *impl;
 505
 506   g_return_if_fail (GDK_IS_WINDOW (window));
 507   g_return_if_fail (GDK_IS_DEVICE (device));
 508
 509   private = (GdkWindowObject *) window;
 510   impl = GDK_WINDOW_IMPL_BROADWAY (private->impl);
 511
 512   if (!cursor)
 513     g_hash_table_remove (impl->device_cursor, device);
 514   else
 515     {
 516       _gdk_broadway_cursor_update_theme (cursor);
 517       g_hash_table_replace (impl->device_cursor,
 518                             device, gdk_cursor_ref (cursor));
 519     }
 520
 521   if (!GDK_WINDOW_DESTROYED (window))
 522     GDK_DEVICE_GET_CLASS (device)->set_window_cursor (device, window, cursor);
 523 }
 524
 525 GdkCursor *
 526 _gdk_broadway_window_get_cursor (GdkWindow *window)
 527 {
 528   GdkWindowObject *private;
 529   GdkWindowImplBroadway *impl;
 530
 531   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 532
 533   private = (GdkWindowObject *)window;
 534   impl = GDK_WINDOW_IMPL_BROADWAY (private->impl);
 535
 536   return impl->cursor;
 537 }
 538
 539 static void
 540 gdk_window_broadway_get_geometry (GdkWindow *window,
 541                              gint      *x,
 542                              gint      *y,
 543                              gint      *width,
 544                              gint      *height,
 545                              gint      *depth)
 546 {
 547 }
 548
 549 static gint
 550 gdk_window_broadway_get_root_coords (GdkWindow *window,
 551                                 gint       x,
 552                                 gint       y,
 553                                 gint      *root_x,
 554                                 gint      *root_y)
 555 {
 556   if (root_x)
 557     *root_x = x;
 558   if (root_y)
 559     *root_y = y;
 560
 561   return 1;
 562 }
 563
 564 void
 565 gdk_window_get_root_origin (GdkWindow *window,
 566                             gint      *x,
 567                             gint      *y)
 568 {
 569   if (x)
 570     *x = 0;
 571
 572   if (y)
 573     *y = 0;
 574 }
 575
 576 void
 577 gdk_window_get_frame_extents (GdkWindow    *window,
 578                               GdkRectangle *rect)
 579 {
 580   GdkWindowObject *private;
 581
 582   g_return_if_fail (rect != NULL);
 583
 584   private = (GdkWindowObject*) window;
 585
 586   rect->x = private->x;
 587   rect->y = private->y;
 588   rect->width = private->width;
 589   rect->height = private->height;
 590 }
 591
 592 void
 593 _gdk_windowing_get_device_state (GdkDisplay       *display,
 594                                  GdkDevice        *device,
 595                                  GdkScreen       **screen,
 596                                  gint             *x,
 597                                  gint             *y,
 598                                  GdkModifierType  *mask)
 599 {
 600   if (display->closed)
 601     return;
 602
 603 }
 604
 605 static gboolean
 606 gdk_window_broadway_get_device_state (GdkWindow       *window,
 607                                  GdkDevice       *device,
 608                                  gint            *x,
 609                                  gint            *y,
 610                                  GdkModifierType *mask)
 611 {
 612   return FALSE;
 613 }
 614
 615 void
 616 gdk_display_warp_pointer (GdkDisplay *display,
 617                           GdkScreen  *screen,
 618                           gint        x,
 619                           gint        y)
 620 {
 621   GdkDevice *device;
 622
 623   g_return_if_fail (GDK_IS_DISPLAY (display));
 624   g_return_if_fail (GDK_IS_SCREEN (screen));
 625
 626   device = display->core_pointer;
 627   GDK_DEVICE_GET_CLASS (device)->warp (device, screen, x, y);
 628 }
 629
 630 void
 631 gdk_display_warp_device (GdkDisplay *display,
 632                          GdkDevice  *device,
 633                          GdkScreen  *screen,
 634                          gint        x,
 635                          gint        y)
 636 {
 637   g_return_if_fail (GDK_IS_DISPLAY (display));
 638   g_return_if_fail (GDK_IS_DEVICE (device));
 639   g_return_if_fail (GDK_IS_SCREEN (screen));
 640   g_return_if_fail (display == gdk_device_get_display (device));
 641
 642   GDK_DEVICE_GET_CLASS (device)->warp (device, screen, x, y);
 643 }
 644
 645 GdkWindow*
 646 _gdk_windowing_window_at_device_position (GdkDisplay      *display,
 647                                           GdkDevice       *device,
 648                                           gint            *win_x,
 649                                           gint            *win_y,
 650                                           GdkModifierType *mask,
 651                                           gboolean         get_toplevel)
 652 {
 653   return NULL;
 654 }
 655
 656 static GdkEventMask
 657 gdk_window_broadway_get_events (GdkWindow *window)
 658 {
 659   if (GDK_WINDOW_DESTROYED (window))
 660     return 0;
 661
 662   return 0;
 663 }
 664 static void
 665 gdk_window_broadway_set_events (GdkWindow    *window,
 666                            GdkEventMask  event_mask)
 667 {
 668   if (!GDK_WINDOW_DESTROYED (window))
 669     {
 670     }
 671 }
 672
 673 static void
 674 gdk_window_broadway_shape_combine_region (GdkWindow       *window,
 675                                      const cairo_region_t *shape_region,
 676                                      gint             offset_x,
 677                                      gint             offset_y)
 678 {
 679 }
 680
 681 static void
 682 gdk_window_broadway_input_shape_combine_region (GdkWindow       *window,
 683                                            const cairo_region_t *shape_region,
 684                                            gint             offset_x,
 685                                            gint             offset_y)
 686 {
 687 }
 688
 689
 690 void
 691 gdk_window_set_override_redirect (GdkWindow *window,
 692                                   gboolean override_redirect)
 693 {
 694 }
 695
 696 void
 697 gdk_window_set_accept_focus (GdkWindow *window,
 698                              gboolean accept_focus)
 699 {
 700   GdkWindowObject *private;
 701
 702   private = (GdkWindowObject *)window;
 703
 704   accept_focus = accept_focus != FALSE;
 705
 706   if (private->accept_focus != accept_focus)
 707     {
 708       private->accept_focus = accept_focus;
 709     }
 710 }
 711
 712 void
 713 gdk_window_set_focus_on_map (GdkWindow *window,
 714                              gboolean focus_on_map)
 715 {
 716   GdkWindowObject *private;
 717
 718   private = (GdkWindowObject *)window;
 719
 720   focus_on_map = focus_on_map != FALSE;
 721
 722   if (private->focus_on_map != focus_on_map)
 723     {
 724       private->focus_on_map = focus_on_map;
 725     }
 726 }
 727
 728
 729 void
 730 gdk_window_set_icon_list (GdkWindow *window,
 731                           GList     *pixbufs)
 732 {
 733 }
 734
 735 void
 736 gdk_window_set_icon_name (GdkWindow   *window,
 737                           const gchar *name)
 738 {
 739   GdkDisplay *display;
 740
 741   if (GDK_WINDOW_DESTROYED (window) ||
 742       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 743     return;
 744
 745   display = gdk_window_get_display (window);
 746
 747   g_object_set_qdata (G_OBJECT (window), g_quark_from_static_string ("gdk-icon-name-set"),
 748                       GUINT_TO_POINTER (name != NULL));
 749 }
 750
 751 void
 752 gdk_window_iconify (GdkWindow *window)
 753 {
 754   if (GDK_WINDOW_DESTROYED (window) ||
 755       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 756     return;
 757 }
 758
 759 void
 760 gdk_window_deiconify (GdkWindow *window)
 761 {
 762   if (GDK_WINDOW_DESTROYED (window) ||
 763       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 764     return;
 765 }
 766
 767 void
 768 gdk_window_stick (GdkWindow *window)
 769 {
 770   if (GDK_WINDOW_DESTROYED (window) ||
 771       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 772     return;
 773
 774 }
 775
 776 void
 777 gdk_window_unstick (GdkWindow *window)
 778 {
 779   if (GDK_WINDOW_DESTROYED (window) ||
 780       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 781     return;
 782
 783 }
 784
 785 void
 786 gdk_window_maximize (GdkWindow *window)
 787 {
 788   if (GDK_WINDOW_DESTROYED (window) ||
 789       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 790     return;
 791
 792 }
 793
 794 void
 795 gdk_window_unmaximize (GdkWindow *window)
 796 {
 797   if (GDK_WINDOW_DESTROYED (window) ||
 798       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 799     return;
 800
 801 }
 802
 803 void
 804 gdk_window_fullscreen (GdkWindow *window)
 805 {
 806   if (GDK_WINDOW_DESTROYED (window) ||
 807       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 808     return;
 809
 810 }
 811
 812 void
 813 gdk_window_unfullscreen (GdkWindow *window)
 814 {
 815   if (GDK_WINDOW_DESTROYED (window) ||
 816       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 817     return;
 818
 819 }
 820
 821 void
 822 gdk_window_set_keep_above (GdkWindow *window,
 823                            gboolean   setting)
 824 {
 825   g_return_if_fail (GDK_IS_WINDOW (window));
 826
 827   if (GDK_WINDOW_DESTROYED (window) ||
 828       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 829     return;
 830
 831 }
 832
 833 void
 834 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
 835 {
 836   g_return_if_fail (GDK_IS_WINDOW (window));
 837
 838   if (GDK_WINDOW_DESTROYED (window) ||
 839       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 840     return;
 841
 842 }
 843
 844 GdkWindow *
 845 gdk_window_get_group (GdkWindow *window)
 846 {
 847   if (GDK_WINDOW_DESTROYED (window) ||
 848       !WINDOW_IS_TOPLEVEL (window))
 849     return NULL;
 850
 851   return window;
 852 }
 853
 854 void
 855 gdk_window_set_group (GdkWindow *window,
 856                       GdkWindow *leader)
 857 {
 858 }
 859
 860 void
 861 gdk_window_set_decorations (GdkWindow      *window,
 862                             GdkWMDecoration decorations)
 863 {
 864   if (GDK_WINDOW_DESTROYED (window) ||
 865       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 866     return;
 867
 868 }
 869
 870 gboolean
 871 gdk_window_get_decorations(GdkWindow       *window,
 872                            GdkWMDecoration *decorations)
 873 {
 874   gboolean result = FALSE;
 875
 876   if (GDK_WINDOW_DESTROYED (window) ||
 877       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 878     return FALSE;
 879
 880   return result;
 881 }
 882
 883 void
 884 gdk_window_set_functions (GdkWindow    *window,
 885                           GdkWMFunction functions)
 886 {
 887   g_return_if_fail (GDK_IS_WINDOW (window));
 888
 889   if (GDK_WINDOW_DESTROYED (window) ||
 890       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 891     return;
 892 }
 893
 894 cairo_region_t *
 895 _gdk_windowing_window_get_shape (GdkWindow *window)
 896 {
 897   return NULL;
 898 }
 899
 900 cairo_region_t *
 901 _gdk_windowing_window_get_input_shape (GdkWindow *window)
 902 {
 903   return NULL;
 904 }
 905
 906
 907 static gboolean
 908 gdk_window_broadway_set_static_gravities (GdkWindow *window,
 909                                      gboolean   use_static)
 910 {
 911   return TRUE;
 912 }
 913
 914 void
 915 gdk_window_begin_resize_drag (GdkWindow     *window,
 916                               GdkWindowEdge  edge,
 917                               gint           button,
 918                               gint           root_x,
 919                               gint           root_y,
 920                               guint32        timestamp)
 921 {
 922   if (GDK_WINDOW_DESTROYED (window) ||
 923       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 924     return;
 925
 926 }
 927
 928 void
 929 gdk_window_begin_move_drag (GdkWindow *window,
 930                             gint       button,
 931                             gint       root_x,
 932                             gint       root_y,
 933                             guint32    timestamp)
 934 {
 935   if (GDK_WINDOW_DESTROYED (window) ||
 936       !WINDOW_IS_TOPLEVEL (window))
 937     return;
 938
 939 }
 940
 941 void
 942 gdk_window_enable_synchronized_configure (GdkWindow *window)
 943 {
 944   GdkWindowObject *private = (GdkWindowObject *)window;
 945
 946   if (!GDK_IS_WINDOW_IMPL_BROADWAY (private->impl))
 947     return;
 948 }
 949
 950 void
 951 gdk_window_configure_finished (GdkWindow *window)
 952 {
 953   if (!WINDOW_IS_TOPLEVEL (window))
 954     return;
 955 }
 956
 957 void
 958 _gdk_windowing_window_beep (GdkWindow *window)
 959 {
 960   GdkDisplay *display;
 961
 962   g_return_if_fail (GDK_IS_WINDOW (window));
 963
 964   display = GDK_WINDOW_DISPLAY (window);
 965
 966   gdk_display_beep (display);
 967 }
 968
 969 void
 970 gdk_window_set_opacity (GdkWindow *window,
 971                         gdouble    opacity)
 972 {
 973   GdkDisplay *display;
 974
 975   g_return_if_fail (GDK_IS_WINDOW (window));
 976
 977   if (GDK_WINDOW_DESTROYED (window) ||
 978       !WINDOW_IS_TOPLEVEL (window))
 979     return;
 980
 981   display = gdk_window_get_display (window);
 982
 983   if (opacity < 0)
 984     opacity = 0;
 985   else if (opacity > 1)
 986     opacity = 1;
 987
 988 }
 989
 990 void
 991 _gdk_windowing_window_set_composited (GdkWindow *window,
 992                                       gboolean   composited)
 993 {
 994 }
 995
 996 void
 997 _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
 998                                                cairo_region_t *region)
 999 {
1000   GdkWindowObject *private;
1001   GdkWindowImplBroadway *impl;
1002
1003   _gdk_window_process_updates_recurse (window, region);
1004
1005   private = (GdkWindowObject *)window;
1006   impl = GDK_WINDOW_IMPL_BROADWAY (private->impl);
1007   impl->dirty = TRUE;
1008 }
1009
1010 void
1011 _gdk_windowing_before_process_all_updates (void)
1012 {
1013 }
1014
1015 void
1016 _gdk_windowing_after_process_all_updates (void)
1017 {
1018   GList *l;
1019
1020   for (l = all_windows; l != NULL; l = l->next)
1021     {
1022       GdkWindowImplBroadway *impl = l->data;
1023
1024       if (impl->dirty)
1025         {
1026           /* TODO: Flush dirty windows */
1027           impl->dirty = FALSE;
1028         }
1029     }
1030 }
1031
1032 gboolean
1033 _gdk_broadway_window_queue_antiexpose (GdkWindow *window,
1034                                   cairo_region_t *area)
1035 {
1036   return TRUE;
1037 }
1038
1039 void
1040 _gdk_broadway_window_translate (GdkWindow      *window,
1041                            cairo_region_t *area,
1042                            gint            dx,
1043                            gint            dy)
1044 {
1045   GdkWindowObject *private;
1046   GdkWindowImplBroadway *impl;
1047   cairo_surface_t *surface;
1048
1049   private = (GdkWindowObject *)window;
1050   impl = GDK_WINDOW_IMPL_BROADWAY (private->impl);
1051
1052   surface = GDK_DRAWABLE_IMPL_BROADWAY (impl)->surface;
1053   if (surface)
1054     {
1055       cairo_t *cr;
1056
1057       cr = cairo_create (surface);
1058
1059       area = cairo_region_copy (area);
1060
1061       gdk_cairo_region (cr, area);
1062       cairo_clip (cr);
1063
1064       /* NB: This is a self-copy and Cairo doesn't support that yet.
1065        * So we do a litle trick.
1066        */
1067       cairo_push_group (cr);
1068
1069       cairo_set_source_surface (cr, surface, dx, dy);
1070       cairo_paint (cr);
1071
1072       cairo_pop_group_to_source (cr);
1073       cairo_paint (cr);
1074
1075       cairo_destroy (cr);
1076     }
1077 }
1078
1079 static void
1080 gdk_window_impl_iface_init (GdkWindowImplIface *iface)
1081 {
1082   iface->show = gdk_window_broadway_show;
1083   iface->hide = gdk_window_broadway_hide;
1084   iface->withdraw = gdk_window_broadway_withdraw;
1085   iface->set_events = gdk_window_broadway_set_events;
1086   iface->get_events = gdk_window_broadway_get_events;
1087   iface->raise = gdk_window_broadway_raise;
1088   iface->lower = gdk_window_broadway_lower;
1089   iface->restack_under = gdk_window_broadway_restack_under;
1090   iface->restack_toplevel = gdk_window_broadway_restack_toplevel;
1091   iface->move_resize = gdk_window_broadway_move_resize;
1092   iface->set_background = gdk_window_broadway_set_background;
1093   iface->reparent = gdk_window_broadway_reparent;
1094   iface->set_device_cursor = gdk_window_broadway_set_device_cursor;
1095   iface->get_geometry = gdk_window_broadway_get_geometry;
1096   iface->get_root_coords = gdk_window_broadway_get_root_coords;
1097   iface->get_device_state = gdk_window_broadway_get_device_state;
1098   iface->shape_combine_region = gdk_window_broadway_shape_combine_region;
1099   iface->input_shape_combine_region = gdk_window_broadway_input_shape_combine_region;
1100   iface->set_static_gravities = gdk_window_broadway_set_static_gravities;
1101   iface->queue_antiexpose = _gdk_broadway_window_queue_antiexpose;
1102   iface->translate = _gdk_broadway_window_translate;
1103   iface->destroy = _gdk_broadway_window_destroy;
1104   iface->resize_cairo_surface = gdk_window_broadway_resize_cairo_surface;
1105 }