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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <X11/Xlib.h>
  21 #include <X11/Xutil.h>
  22 #include <X11/Xatom.h>
  23 #include <netinet/in.h>
  24 #include "gdk.h"
  25 #include "config.h"
  26 #include "gdkinput.h"
  27 #include "gdkprivate.h"
  28 #include "MwmUtil.h"
  29
  30 #if HAVE_CONFIG_H
  31 #  include <config.h>
  32 #  if STDC_HEADERS
  33 #    include <stdlib.h>
  34 #    include <stdio.h>
  35 #    include <string.h>
  36 #  endif
  37 #else
  38 #  include <stdlib.h>
  39 #  include <stdio.h>
  40 #endif
  41
  42
  43 #ifdef HAVE_SHAPE_EXT
  44 #include <X11/extensions/shape.h>
  45 #endif
  46
  47 const int gdk_event_mask_table[20] =
  48 {
  49   ExposureMask,
  50   PointerMotionMask,
  51   PointerMotionHintMask,
  52   ButtonMotionMask,
  53   Button1MotionMask,
  54   Button2MotionMask,
  55   Button3MotionMask,
  56   ButtonPressMask | OwnerGrabButtonMask,
  57   ButtonReleaseMask | OwnerGrabButtonMask,
  58   KeyPressMask,
  59   KeyReleaseMask,
  60   EnterWindowMask,
  61   LeaveWindowMask,
  62   FocusChangeMask,
  63   StructureNotifyMask,
  64   PropertyChangeMask,
  65   VisibilityChangeMask,
  66   0,                            /* PROXIMITY_IN */
  67   0,                            /* PROXIMTY_OUT */
  68   SubstructureNotifyMask
  69 };
  70 const int gdk_nevent_masks = sizeof (gdk_event_mask_table) / sizeof (int);
  71
  72 /* Forward declarations */
  73 static gboolean gdk_window_gravity_works (void);
  74 static void     gdk_window_set_static_win_gravity (GdkWindow *window,
  75                                                    gboolean   on);
  76 static gboolean gdk_window_have_shape_ext (void);
  77
  78 /* internal function created for and used by gdk_window_xid_at_coords */
  79 Window
  80 gdk_window_xid_at (Window   base,
  81                    gint     bx,
  82                    gint     by,
  83                    gint     x,
  84                    gint     y,
  85                    GList   *excludes,
  86                    gboolean excl_child)
  87 {
  88   GdkWindow *window;
  89   GdkWindowPrivate *private;
  90   Display *disp;
  91   Window *list = NULL;
  92   Window child = 0, parent_win = 0, root_win = 0;
  93   int i;
  94   unsigned int ww, wh, wb, wd, num;
  95   int wx, wy;
  96
  97   window = (GdkWindow*) &gdk_root_parent;
  98   private = (GdkWindowPrivate*) window;
  99   disp = private->xdisplay;
 100   if (!XGetGeometry (disp, base, &root_win, &wx, &wy, &ww, &wh, &wb, &wd))
 101     return 0;
 102   wx += bx;
 103   wy += by;
 104
 105   if (!((x >= wx) &&
 106         (y >= wy) &&
 107         (x < (int) (wx + ww)) &&
 108         (y < (int) (wy + wh))))
 109     return 0;
 110
 111   if (!XQueryTree (disp, base, &root_win, &parent_win, &list, &num))
 112     return base;
 113
 114   if (list)
 115     {
 116       for (i = num - 1; ; i--)
 117         {
 118           if ((!excl_child) || (!g_list_find (excludes, (gpointer *) list[i])))
 119             {
 120               if ((child = gdk_window_xid_at (list[i], wx, wy, x, y, excludes, excl_child)) != 0)
 121                 {
 122                   XFree (list);
 123                   return child;
 124                 }
 125             }
 126           if (!i)
 127             break;
 128         }
 129       XFree (list);
 130     }
 131   return base;
 132 }
 133
 134 /*
 135  * The following fucntion by The Rasterman <raster@redhat.com>
 136  * This function returns the X Window ID in which the x y location is in
 137  * (x and y being relative to the root window), excluding any windows listed
 138  * in the GList excludes (this is a list of X Window ID's - gpointer being
 139  * the Window ID).
 140  *
 141  * This is primarily designed for internal gdk use - for DND for example
 142  * when using a shaped icon window as the drag object - you exclude the
 143  * X Window ID of the "icon" (perhaps more if excludes may be needed) and
 144  * You can get back an X Window ID as to what X Window ID is infact under
 145  * those X,Y co-ordinates.
 146  */
 147 Window
 148 gdk_window_xid_at_coords (gint     x,
 149                           gint     y,
 150                           GList   *excludes,
 151                           gboolean excl_child)
 152 {
 153   GdkWindow *window;
 154   GdkWindowPrivate *private;
 155   Display *disp;
 156   Window *list = NULL;
 157   Window root, child = 0, parent_win = 0, root_win = 0;
 158   unsigned int num;
 159   int i;
 160
 161   window = (GdkWindow*) &gdk_root_parent;
 162   private = (GdkWindowPrivate*) window;
 163   disp = private->xdisplay;
 164   root = private->xwindow;
 165   num = g_list_length (excludes);
 166
 167   XGrabServer (disp);
 168   if (!XQueryTree (disp, root, &root_win, &parent_win, &list, &num))
 169     {
 170       XUngrabServer (disp);
 171       return root;
 172     }
 173   if (list)
 174     {
 175       i = num - 1;
 176       do
 177         {
 178           XWindowAttributes xwa;
 179
 180           XGetWindowAttributes (disp, list [i], &xwa);
 181
 182           if (xwa.map_state != IsViewable)
 183             continue;
 184
 185           if (excl_child && g_list_find (excludes, (gpointer *) list[i]))
 186             continue;
 187
 188           if ((child = gdk_window_xid_at (list[i], 0, 0, x, y, excludes, excl_child)) == 0)
 189             continue;
 190
 191           if (excludes)
 192             {
 193               if (!g_list_find (excludes, (gpointer *) child))
 194                 {
 195                   XFree (list);
 196                   XUngrabServer (disp);
 197                   return child;
 198                 }
 199             }
 200           else
 201             {
 202               XFree (list);
 203               XUngrabServer (disp);
 204               return child;
 205             }
 206         } while (--i > 0);
 207       XFree (list);
 208     }
 209   XUngrabServer (disp);
 210   return root;
 211 }
 212
 213 void
 214 gdk_window_init (void)
 215 {
 216   XWindowAttributes xattributes;
 217   unsigned int width;
 218   unsigned int height;
 219   unsigned int border_width;
 220   unsigned int depth;
 221   int x, y;
 222
 223   XGetGeometry (gdk_display, gdk_root_window, &gdk_root_window,
 224                 &x, &y, &width, &height, &border_width, &depth);
 225   XGetWindowAttributes (gdk_display, gdk_root_window, &xattributes);
 226
 227   gdk_root_parent.xwindow = gdk_root_window;
 228   gdk_root_parent.xdisplay = gdk_display;
 229   gdk_root_parent.window_type = GDK_WINDOW_ROOT;
 230   gdk_root_parent.window.user_data = NULL;
 231   gdk_root_parent.width = width;
 232   gdk_root_parent.height = height;
 233   gdk_root_parent.children = NULL;
 234   gdk_root_parent.colormap = NULL;
 235   gdk_root_parent.ref_count = 1;
 236
 237   gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
 238 }
 239
 240 static GdkAtom wm_client_leader_atom = GDK_NONE;
 241
 242 GdkWindow*
 243 gdk_window_new (GdkWindow     *parent,
 244                 GdkWindowAttr *attributes,
 245                 gint           attributes_mask)
 246 {
 247   GdkWindow *window;
 248   GdkWindowPrivate *private;
 249   GdkWindowPrivate *parent_private;
 250   GdkVisual *visual;
 251   Display *parent_display;
 252   Window xparent;
 253   Visual *xvisual;
 254   XSetWindowAttributes xattributes;
 255   long xattributes_mask;
 256   XSizeHints size_hints;
 257   XWMHints wm_hints;
 258   XClassHint *class_hint;
 259   int x, y, depth;
 260   unsigned int class;
 261   char *title;
 262   int i;
 263
 264   g_return_val_if_fail (attributes != NULL, NULL);
 265
 266   if (!parent)
 267     parent = (GdkWindow*) &gdk_root_parent;
 268
 269   parent_private = (GdkWindowPrivate*) parent;
 270   if (parent_private->destroyed)
 271     return NULL;
 272
 273   xparent = parent_private->xwindow;
 274   parent_display = parent_private->xdisplay;
 275
 276   private = g_new (GdkWindowPrivate, 1);
 277   window = (GdkWindow*) private;
 278
 279   private->parent = parent;
 280
 281   private->xdisplay = parent_display;
 282   private->destroyed = FALSE;
 283   private->mapped = FALSE;
 284   private->guffaw_gravity = FALSE;
 285   private->resize_count = 0;
 286   private->ref_count = 1;
 287   xattributes_mask = 0;
 288
 289   if (attributes_mask & GDK_WA_X)
 290     x = attributes->x;
 291   else
 292     x = 0;
 293
 294   if (attributes_mask & GDK_WA_Y)
 295     y = attributes->y;
 296   else
 297     y = 0;
 298
 299   private->x = x;
 300   private->y = y;
 301   private->width = (attributes->width > 1) ? (attributes->width) : (1);
 302   private->height = (attributes->height > 1) ? (attributes->height) : (1);
 303   private->window_type = attributes->window_type;
 304   private->extension_events = FALSE;
 305
 306   private->filters = NULL;
 307   private->children = NULL;
 308
 309   window->user_data = NULL;
 310
 311   if (attributes_mask & GDK_WA_VISUAL)
 312     visual = attributes->visual;
 313   else
 314     visual = gdk_visual_get_system ();
 315   xvisual = ((GdkVisualPrivate*) visual)->xvisual;
 316
 317   xattributes.event_mask = StructureNotifyMask;
 318   for (i = 0; i < gdk_nevent_masks; i++)
 319     {
 320       if (attributes->event_mask & (1 << (i + 1)))
 321         xattributes.event_mask |= gdk_event_mask_table[i];
 322     }
 323
 324   if (xattributes.event_mask)
 325     xattributes_mask |= CWEventMask;
 326
 327   if (attributes_mask & GDK_WA_NOREDIR)
 328     {
 329       xattributes.override_redirect =
 330         (attributes->override_redirect == FALSE)?False:True;
 331       xattributes_mask |= CWOverrideRedirect;
 332     }
 333   else
 334     xattributes.override_redirect = False;
 335
 336   if (parent_private && parent_private->guffaw_gravity)
 337     {
 338       xattributes.win_gravity = StaticGravity;
 339       xattributes_mask |= CWWinGravity;
 340     }
 341
 342   if (attributes->wclass == GDK_INPUT_OUTPUT)
 343     {
 344       class = InputOutput;
 345       depth = visual->depth;
 346
 347       if (attributes_mask & GDK_WA_COLORMAP)
 348         private->colormap = attributes->colormap;
 349       else
 350         {
 351           if ((((GdkVisualPrivate*)gdk_visual_get_system ())->xvisual) == xvisual)
 352             private->colormap = gdk_colormap_get_system ();
 353           else
 354             private->colormap = gdk_colormap_new (visual, False);
 355         }
 356
 357       xattributes.background_pixel = BlackPixel (gdk_display, gdk_screen);
 358       xattributes.border_pixel = BlackPixel (gdk_display, gdk_screen);
 359       xattributes_mask |= CWBorderPixel | CWBackPixel;
 360
 361       switch (private->window_type)
 362         {
 363         case GDK_WINDOW_TOPLEVEL:
 364           xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
 365           xattributes_mask |= CWColormap;
 366
 367           xparent = gdk_root_window;
 368           break;
 369
 370         case GDK_WINDOW_CHILD:
 371           xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
 372           xattributes_mask |= CWColormap;
 373           break;
 374
 375         case GDK_WINDOW_DIALOG:
 376           xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
 377           xattributes_mask |= CWColormap;
 378
 379           xparent = gdk_root_window;
 380           break;
 381
 382         case GDK_WINDOW_TEMP:
 383           xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
 384           xattributes_mask |= CWColormap;
 385
 386           xparent = gdk_root_window;
 387
 388           xattributes.save_under = True;
 389           xattributes.override_redirect = True;
 390           xattributes.cursor = None;
 391           xattributes_mask |= CWSaveUnder | CWOverrideRedirect;
 392           break;
 393         case GDK_WINDOW_ROOT:
 394           g_error ("cannot make windows of type GDK_WINDOW_ROOT");
 395           break;
 396         case GDK_WINDOW_PIXMAP:
 397           g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
 398           break;
 399         }
 400     }
 401   else
 402     {
 403       depth = 0;
 404       class = InputOnly;
 405       private->colormap = NULL;
 406     }
 407
 408   private->xwindow = XCreateWindow (private->xdisplay, xparent,
 409                                     x, y, private->width, private->height,
 410                                     0, depth, class, xvisual,
 411                                     xattributes_mask, &xattributes);
 412   gdk_window_ref (window);
 413   gdk_xid_table_insert (&private->xwindow, window);
 414
 415   if (private->colormap)
 416     gdk_colormap_ref (private->colormap);
 417
 418   gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
 419                                   (attributes->cursor) :
 420                                   NULL));
 421
 422   if (parent_private)
 423     parent_private->children = g_list_prepend (parent_private->children, window);
 424
 425   switch (private->window_type)
 426     {
 427     case GDK_WINDOW_DIALOG:
 428       XSetTransientForHint (private->xdisplay, private->xwindow, xparent);
 429     case GDK_WINDOW_TOPLEVEL:
 430     case GDK_WINDOW_TEMP:
 431       XSetWMProtocols (private->xdisplay, private->xwindow, gdk_wm_window_protocols, 2);
 432       break;
 433     case GDK_WINDOW_CHILD:
 434       if ((attributes->wclass == GDK_INPUT_OUTPUT) &&
 435           (private->colormap != gdk_colormap_get_system ()) &&
 436           (private->colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window))))
 437         {
 438           GDK_NOTE (MISC, g_message ("adding colormap window\n"));
 439           gdk_window_add_colormap_windows (window);
 440         }
 441
 442       return window;
 443     default:
 444
 445       return window;
 446     }
 447
 448   size_hints.flags = PSize;
 449   size_hints.width = private->width;
 450   size_hints.height = private->height;
 451
 452   wm_hints.flags = InputHint | StateHint | WindowGroupHint;
 453   wm_hints.window_group = gdk_leader_window;
 454   wm_hints.input = True;
 455   wm_hints.initial_state = NormalState;
 456
 457   /* FIXME: Is there any point in doing this? Do any WM's pay
 458    * attention to PSize, and even if they do, is this the
 459    * correct value???
 460    */
 461   XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
 462
 463   XSetWMHints (private->xdisplay, private->xwindow, &wm_hints);
 464
 465   if (!wm_client_leader_atom)
 466     wm_client_leader_atom = gdk_atom_intern ("WM_CLIENT_LEADER", FALSE);
 467
 468   XChangeProperty (private->xdisplay, private->xwindow,
 469                    wm_client_leader_atom,
 470                    XA_WINDOW, 32, PropModeReplace,
 471                    (guchar*) &gdk_leader_window, 1);
 472
 473   if (attributes_mask & GDK_WA_TITLE)
 474     title = attributes->title;
 475   else
 476     title = g_get_prgname ();
 477
 478   XmbSetWMProperties (private->xdisplay, private->xwindow,
 479                       title, title,
 480                       NULL, 0,
 481                       NULL, NULL, NULL);
 482
 483   if (attributes_mask & GDK_WA_WMCLASS)
 484     {
 485       class_hint = XAllocClassHint ();
 486       class_hint->res_name = attributes->wmclass_name;
 487       class_hint->res_class = attributes->wmclass_class;
 488       XSetClassHint (private->xdisplay, private->xwindow, class_hint);
 489       XFree (class_hint);
 490     }
 491
 492
 493   return window;
 494 }
 495
 496 GdkWindow *
 497 gdk_window_foreign_new (guint32 anid)
 498 {
 499   GdkWindow *window;
 500   GdkWindowPrivate *private;
 501   GdkWindowPrivate *parent_private;
 502   XWindowAttributes attrs;
 503   Window root, parent;
 504   Window *children = NULL;
 505   guint nchildren;
 506   gboolean result;
 507
 508   gdk_error_trap_push ();
 509   result = XGetWindowAttributes (gdk_display, anid, &attrs);
 510   if (gdk_error_trap_pop () || !result)
 511     return NULL;
 512
 513   /* FIXME: This is pretty expensive. Maybe the caller should supply
 514    *        the parent */
 515   gdk_error_trap_push ();
 516   result = XQueryTree (gdk_display, anid, &root, &parent, &children, &nchildren);
 517   if (gdk_error_trap_pop () || !result)
 518     return NULL;
 519
 520   private = g_new (GdkWindowPrivate, 1);
 521   window = (GdkWindow*) private;
 522
 523   if (children)
 524     XFree (children);
 525   private->parent = gdk_xid_table_lookup (parent);
 526
 527   parent_private = (GdkWindowPrivate *)private->parent;
 528
 529   if (parent_private)
 530     parent_private->children = g_list_prepend (parent_private->children, window);
 531
 532   private->xwindow = anid;
 533   private->xdisplay = gdk_display;
 534   private->x = attrs.x;
 535   private->y = attrs.y;
 536   private->width = attrs.width;
 537   private->height = attrs.height;
 538   private->resize_count = 0;
 539   private->ref_count = 1;
 540   private->window_type = GDK_WINDOW_FOREIGN;
 541   private->destroyed = FALSE;
 542   private->mapped = (attrs.map_state != IsUnmapped);
 543   private->guffaw_gravity = FALSE;
 544   private->extension_events = 0;
 545
 546   private->colormap = NULL;
 547
 548   private->filters = NULL;
 549   private->children = NULL;
 550
 551   window->user_data = NULL;
 552
 553   gdk_window_ref (window);
 554   gdk_xid_table_insert (&private->xwindow, window);
 555
 556   return window;
 557 }
 558
 559 /* Call this function when you want a window and all its children to
 560  * disappear.  When xdestroy is true, a request to destroy the XWindow
 561  * is sent out.  When it is false, it is assumed that the XWindow has
 562  * been or will be destroyed by destroying some ancestor of this
 563  * window.
 564  */
 565 static void
 566 gdk_window_internal_destroy (GdkWindow *window,
 567                              gboolean   xdestroy,
 568                              gboolean   our_destroy)
 569 {
 570   GdkWindowPrivate *private;
 571   GdkWindowPrivate *temp_private;
 572   GdkWindow *temp_window;
 573   GList *children;
 574   GList *tmp;
 575
 576   g_return_if_fail (window != NULL);
 577
 578   private = (GdkWindowPrivate*) window;
 579
 580   switch (private->window_type)
 581     {
 582     case GDK_WINDOW_TOPLEVEL:
 583     case GDK_WINDOW_CHILD:
 584     case GDK_WINDOW_DIALOG:
 585     case GDK_WINDOW_TEMP:
 586     case GDK_WINDOW_FOREIGN:
 587       if (!private->destroyed)
 588         {
 589           if (private->parent)
 590             {
 591               GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
 592               if (parent_private->children)
 593                 parent_private->children = g_list_remove (parent_private->children, window);
 594             }
 595
 596           if (private->window_type != GDK_WINDOW_FOREIGN)
 597             {
 598               children = tmp = private->children;
 599               private->children = NULL;
 600
 601               while (tmp)
 602                 {
 603                   temp_window = tmp->data;
 604                   tmp = tmp->next;
 605
 606                   temp_private = (GdkWindowPrivate*) temp_window;
 607                   if (temp_private)
 608                     gdk_window_internal_destroy (temp_window, FALSE,
 609                                                  our_destroy);
 610                 }
 611
 612               g_list_free (children);
 613             }
 614
 615           if (private->extension_events != 0)
 616             gdk_input_window_destroy (window);
 617
 618           if (private->filters)
 619             {
 620               tmp = private->filters;
 621
 622               while (tmp)
 623                 {
 624                   g_free (tmp->data);
 625                   tmp = tmp->next;
 626                 }
 627
 628               g_list_free (private->filters);
 629               private->filters = NULL;
 630             }
 631
 632           if (private->window_type == GDK_WINDOW_FOREIGN)
 633             {
 634               if (our_destroy && (private->parent != NULL))
 635                 {
 636                   /* It's somebody elses window, but in our heirarchy,
 637                    * so reparent it to the root window, and then send
 638                    * it a delete event, as if we were a WM
 639                    */
 640                   XClientMessageEvent xevent;
 641
 642                   gdk_error_trap_push ();
 643                   gdk_window_hide (window);
 644                   gdk_window_reparent (window, NULL, 0, 0);
 645
 646                   xevent.type = ClientMessage;
 647                   xevent.window = private->xwindow;
 648                   xevent.message_type = gdk_wm_protocols;
 649                   xevent.format = 32;
 650                   xevent.data.l[0] = gdk_wm_delete_window;
 651                   xevent.data.l[1] = CurrentTime;
 652
 653                   XSendEvent (private->xdisplay, private->xwindow,
 654                               False, 0, (XEvent *)&xevent);
 655                   gdk_flush ();
 656                   gdk_error_trap_pop ();
 657                 }
 658             }
 659           else if (xdestroy)
 660             XDestroyWindow (private->xdisplay, private->xwindow);
 661
 662           if (private->colormap)
 663             gdk_colormap_unref (private->colormap);
 664
 665           private->mapped = FALSE;
 666           private->destroyed = TRUE;
 667         }
 668       break;
 669
 670     case GDK_WINDOW_ROOT:
 671       g_error ("attempted to destroy root window");
 672       break;
 673
 674     case GDK_WINDOW_PIXMAP:
 675       g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
 676       break;
 677     }
 678 }
 679
 680 /* Like internal_destroy, but also destroys the reference created by
 681    gdk_window_new. */
 682
 683 void
 684 gdk_window_destroy (GdkWindow *window)
 685 {
 686   gdk_window_internal_destroy (window, TRUE, TRUE);
 687   gdk_window_unref (window);
 688 }
 689
 690 /* This function is called when the XWindow is really gone.  */
 691
 692 void
 693 gdk_window_destroy_notify (GdkWindow *window)
 694 {
 695   GdkWindowPrivate *private;
 696
 697   g_return_if_fail (window != NULL);
 698
 699   private = (GdkWindowPrivate*) window;
 700
 701   if (!private->destroyed)
 702     {
 703       if (private->window_type == GDK_WINDOW_FOREIGN)
 704         gdk_window_internal_destroy (window, FALSE, FALSE);
 705       else
 706         g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
 707     }
 708
 709   gdk_xid_table_remove (private->xwindow);
 710   gdk_window_unref (window);
 711 }
 712
 713 GdkWindow*
 714 gdk_window_ref (GdkWindow *window)
 715 {
 716   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
 717   g_return_val_if_fail (window != NULL, NULL);
 718
 719   private->ref_count += 1;
 720   return window;
 721 }
 722
 723 void
 724 gdk_window_unref (GdkWindow *window)
 725 {
 726   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
 727   g_return_if_fail (window != NULL);
 728
 729   private->ref_count -= 1;
 730   if (private->ref_count == 0)
 731     {
 732       if (!private->destroyed)
 733         {
 734           if (private->window_type == GDK_WINDOW_FOREIGN)
 735             gdk_xid_table_remove (private->xwindow);
 736           else
 737             g_warning ("losing last reference to undestroyed window\n");
 738         }
 739       g_dataset_destroy (window);
 740       g_free (window);
 741     }
 742 }
 743
 744 void
 745 gdk_window_show (GdkWindow *window)
 746 {
 747   GdkWindowPrivate *private;
 748
 749   g_return_if_fail (window != NULL);
 750
 751   private = (GdkWindowPrivate*) window;
 752   if (!private->destroyed)
 753     {
 754       private->mapped = TRUE;
 755       XRaiseWindow (private->xdisplay, private->xwindow);
 756       XMapWindow (private->xdisplay, private->xwindow);
 757     }
 758 }
 759
 760 void
 761 gdk_window_hide (GdkWindow *window)
 762 {
 763   GdkWindowPrivate *private;
 764
 765   g_return_if_fail (window != NULL);
 766
 767   private = (GdkWindowPrivate*) window;
 768   if (!private->destroyed)
 769     {
 770       private->mapped = FALSE;
 771       XUnmapWindow (private->xdisplay, private->xwindow);
 772     }
 773 }
 774
 775 void
 776 gdk_window_withdraw (GdkWindow *window)
 777 {
 778   GdkWindowPrivate *private;
 779
 780   g_return_if_fail (window != NULL);
 781
 782   private = (GdkWindowPrivate*) window;
 783   if (!private->destroyed)
 784     XWithdrawWindow (private->xdisplay, private->xwindow, 0);
 785 }
 786
 787 void
 788 gdk_window_move (GdkWindow *window,
 789                  gint       x,
 790                  gint       y)
 791 {
 792   GdkWindowPrivate *private;
 793
 794   g_return_if_fail (window != NULL);
 795
 796   private = (GdkWindowPrivate*) window;
 797   if (!private->destroyed)
 798     {
 799       XMoveWindow (private->xdisplay, private->xwindow, x, y);
 800
 801       if (private->window_type == GDK_WINDOW_CHILD)
 802         {
 803           private->x = x;
 804           private->y = y;
 805         }
 806     }
 807 }
 808
 809 void
 810 gdk_window_resize (GdkWindow *window,
 811                    gint       width,
 812                    gint       height)
 813 {
 814   GdkWindowPrivate *private;
 815
 816   g_return_if_fail (window != NULL);
 817
 818   if (width < 1)
 819     width = 1;
 820   if (height < 1)
 821     height = 1;
 822
 823   private = (GdkWindowPrivate*) window;
 824
 825   if (!private->destroyed &&
 826       ((private->resize_count > 0) ||
 827        (private->width != (guint16) width) ||
 828        (private->height != (guint16) height)))
 829     {
 830       XResizeWindow (private->xdisplay, private->xwindow, width, height);
 831       private->resize_count += 1;
 832
 833       if (private->window_type == GDK_WINDOW_CHILD)
 834         {
 835           private->width = width;
 836           private->height = height;
 837         }
 838     }
 839 }
 840
 841 void
 842 gdk_window_move_resize (GdkWindow *window,
 843                         gint       x,
 844                         gint       y,
 845                         gint       width,
 846                         gint       height)
 847 {
 848   GdkWindowPrivate *private;
 849
 850   g_return_if_fail (window != NULL);
 851
 852   if (width < 1)
 853     width = 1;
 854   if (height < 1)
 855     height = 1;
 856
 857   private = (GdkWindowPrivate*) window;
 858   if (!private->destroyed)
 859     {
 860       XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height);
 861
 862       if (private->guffaw_gravity)
 863         {
 864           GList *tmp_list = private->children;
 865           while (tmp_list)
 866             {
 867               GdkWindowPrivate *child_private = tmp_list->data;
 868
 869               child_private->x -= x - private->x;
 870               child_private->y -= y - private->y;
 871
 872               tmp_list = tmp_list->next;
 873             }
 874         }
 875
 876       if (private->window_type == GDK_WINDOW_CHILD)
 877         {
 878           private->x = x;
 879           private->y = y;
 880           private->width = width;
 881           private->height = height;
 882         }
 883     }
 884 }
 885
 886 void
 887 gdk_window_reparent (GdkWindow *window,
 888                      GdkWindow *new_parent,
 889                      gint       x,
 890                      gint       y)
 891 {
 892   GdkWindowPrivate *window_private;
 893   GdkWindowPrivate *parent_private;
 894   GdkWindowPrivate *old_parent_private;
 895
 896   g_return_if_fail (window != NULL);
 897
 898   if (!new_parent)
 899     new_parent = (GdkWindow*) &gdk_root_parent;
 900
 901   window_private = (GdkWindowPrivate*) window;
 902   old_parent_private = (GdkWindowPrivate*)window_private->parent;
 903   parent_private = (GdkWindowPrivate*) new_parent;
 904
 905   if (!window_private->destroyed && !parent_private->destroyed)
 906     XReparentWindow (window_private->xdisplay,
 907                      window_private->xwindow,
 908                      parent_private->xwindow,
 909                      x, y);
 910
 911   window_private->parent = new_parent;
 912
 913   if (old_parent_private)
 914     old_parent_private->children = g_list_remove (old_parent_private->children, window);
 915
 916   if ((old_parent_private &&
 917        (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
 918       (!old_parent_private && parent_private->guffaw_gravity))
 919     gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
 920
 921   parent_private->children = g_list_prepend (parent_private->children, window);
 922 }
 923
 924 void
 925 gdk_window_clear (GdkWindow *window)
 926 {
 927   GdkWindowPrivate *private;
 928
 929   g_return_if_fail (window != NULL);
 930
 931   private = (GdkWindowPrivate*) window;
 932
 933   if (!private->destroyed)
 934     XClearWindow (private->xdisplay, private->xwindow);
 935 }
 936
 937 void
 938 gdk_window_clear_area (GdkWindow *window,
 939                        gint       x,
 940                        gint       y,
 941                        gint       width,
 942                        gint       height)
 943 {
 944   GdkWindowPrivate *private;
 945
 946   g_return_if_fail (window != NULL);
 947
 948   private = (GdkWindowPrivate*) window;
 949
 950   if (!private->destroyed)
 951     XClearArea (private->xdisplay, private->xwindow,
 952                 x, y, width, height, False);
 953 }
 954
 955 void
 956 gdk_window_clear_area_e (GdkWindow *window,
 957                          gint       x,
 958                          gint       y,
 959                          gint       width,
 960                          gint       height)
 961 {
 962   GdkWindowPrivate *private;
 963
 964   g_return_if_fail (window != NULL);
 965
 966   private = (GdkWindowPrivate*) window;
 967
 968   if (!private->destroyed)
 969     XClearArea (private->xdisplay, private->xwindow,
 970                 x, y, width, height, True);
 971 }
 972
 973 void
 974 gdk_window_copy_area (GdkWindow    *window,
 975                       GdkGC        *gc,
 976                       gint          x,
 977                       gint          y,
 978                       GdkWindow    *source_window,
 979                       gint          source_x,
 980                       gint          source_y,
 981                       gint          width,
 982                       gint          height)
 983 {
 984   GdkWindowPrivate *src_private;
 985   GdkWindowPrivate *dest_private;
 986   GdkGCPrivate *gc_private;
 987
 988   g_return_if_fail (window != NULL);
 989   g_return_if_fail (gc != NULL);
 990
 991   if (source_window == NULL)
 992     source_window = window;
 993
 994   src_private = (GdkWindowPrivate*) source_window;
 995   dest_private = (GdkWindowPrivate*) window;
 996   gc_private = (GdkGCPrivate*) gc;
 997
 998   if (!src_private->destroyed && !dest_private->destroyed)
 999     {
1000       XCopyArea (dest_private->xdisplay, src_private->xwindow, dest_private->xwindow,
1001                  gc_private->xgc,
1002                  source_x, source_y,
1003                  width, height,
1004                  x, y);
1005     }
1006 }
1007
1008 void
1009 gdk_window_raise (GdkWindow *window)
1010 {
1011   GdkWindowPrivate *private;
1012
1013   g_return_if_fail (window != NULL);
1014
1015   private = (GdkWindowPrivate*) window;
1016
1017   if (!private->destroyed)
1018     XRaiseWindow (private->xdisplay, private->xwindow);
1019 }
1020
1021 void
1022 gdk_window_lower (GdkWindow *window)
1023 {
1024   GdkWindowPrivate *private;
1025
1026   g_return_if_fail (window != NULL);
1027
1028   private = (GdkWindowPrivate*) window;
1029
1030   if (!private->destroyed)
1031     XLowerWindow (private->xdisplay, private->xwindow);
1032 }
1033
1034 void
1035 gdk_window_set_user_data (GdkWindow *window,
1036                           gpointer   user_data)
1037 {
1038   g_return_if_fail (window != NULL);
1039
1040   window->user_data = user_data;
1041 }
1042
1043 void
1044 gdk_window_set_hints (GdkWindow *window,
1045                       gint       x,
1046                       gint       y,
1047                       gint       min_width,
1048                       gint       min_height,
1049                       gint       max_width,
1050                       gint       max_height,
1051                       gint       flags)
1052 {
1053   GdkWindowPrivate *private;
1054   XSizeHints size_hints;
1055
1056   g_return_if_fail (window != NULL);
1057
1058   private = (GdkWindowPrivate*) window;
1059   if (private->destroyed)
1060     return;
1061
1062   size_hints.flags = 0;
1063
1064   if (flags & GDK_HINT_POS)
1065     {
1066       size_hints.flags |= PPosition;
1067       size_hints.x = x;
1068       size_hints.y = y;
1069     }
1070
1071   if (flags & GDK_HINT_MIN_SIZE)
1072     {
1073       size_hints.flags |= PMinSize;
1074       size_hints.min_width = min_width;
1075       size_hints.min_height = min_height;
1076     }
1077
1078   if (flags & GDK_HINT_MAX_SIZE)
1079     {
1080       size_hints.flags |= PMaxSize;
1081       size_hints.max_width = max_width;
1082       size_hints.max_height = max_height;
1083     }
1084
1085   if (flags)
1086     XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
1087 }
1088
1089 void
1090 gdk_window_set_geometry_hints (GdkWindow      *window,
1091                                GdkGeometry    *geometry,
1092                                GdkWindowHints  geom_mask)
1093 {
1094   GdkWindowPrivate *private;
1095   XSizeHints size_hints;
1096
1097   g_return_if_fail (window != NULL);
1098
1099   private = (GdkWindowPrivate*) window;
1100   if (private->destroyed)
1101     return;
1102
1103   size_hints.flags = 0;
1104
1105   if (geom_mask & GDK_HINT_POS)
1106     size_hints.flags |= PPosition;
1107
1108   if (geom_mask & GDK_HINT_MIN_SIZE)
1109     {
1110       size_hints.flags |= PMinSize;
1111       size_hints.min_width = geometry->min_width;
1112       size_hints.min_height = geometry->min_height;
1113     }
1114
1115   if (geom_mask & GDK_HINT_MAX_SIZE)
1116     {
1117       size_hints.flags |= PMaxSize;
1118       size_hints.max_width = geometry->max_width;
1119       size_hints.max_height = geometry->max_height;
1120     }
1121
1122   if (geom_mask & GDK_HINT_BASE_SIZE)
1123     {
1124       size_hints.flags |= PBaseSize;
1125       size_hints.base_width = geometry->base_width;
1126       size_hints.base_height = geometry->base_height;
1127     }
1128
1129   if (geom_mask & GDK_HINT_RESIZE_INC)
1130     {
1131       size_hints.flags |= PResizeInc;
1132       size_hints.width_inc = geometry->width_inc;
1133       size_hints.height_inc = geometry->height_inc;
1134     }
1135
1136   if (geom_mask & GDK_HINT_ASPECT)
1137     {
1138       size_hints.flags |= PAspect;
1139       if (geometry->min_aspect <= 1)
1140         {
1141           size_hints.min_aspect.x = G_MAXINT * geometry->min_aspect;
1142           size_hints.min_aspect.y = G_MAXINT;
1143         }
1144       else
1145         {
1146           size_hints.min_aspect.x = G_MAXINT;
1147           size_hints.min_aspect.y = G_MAXINT / geometry->min_aspect;;
1148         }
1149       if (geometry->max_aspect <= 1)
1150         {
1151           size_hints.max_aspect.x = G_MAXINT * geometry->max_aspect;
1152           size_hints.max_aspect.y = G_MAXINT;
1153         }
1154       else
1155         {
1156           size_hints.max_aspect.x = G_MAXINT;
1157           size_hints.max_aspect.y = G_MAXINT / geometry->max_aspect;;
1158         }
1159     }
1160
1161   if (geom_mask)
1162     XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
1163 }
1164
1165 void
1166 gdk_window_set_title (GdkWindow   *window,
1167                       const gchar *title)
1168 {
1169   GdkWindowPrivate *private;
1170
1171   g_return_if_fail (window != NULL);
1172
1173   private = (GdkWindowPrivate*) window;
1174   if (!private->destroyed)
1175     XmbSetWMProperties (private->xdisplay, private->xwindow,
1176                         title, title, NULL, 0, NULL, NULL, NULL);
1177 }
1178
1179 void
1180 gdk_window_set_role (GdkWindow   *window,
1181                      const gchar *role)
1182 {
1183   GdkWindowPrivate *private;
1184
1185   g_return_if_fail (window != NULL);
1186
1187   private = (GdkWindowPrivate*) window;
1188
1189   if (role)
1190     XChangeProperty (private->xdisplay, private->xwindow,
1191                      gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
1192                      8, PropModeReplace, role, strlen (role));
1193   else
1194     XDeleteProperty (private->xdisplay, private->xwindow,
1195                      gdk_atom_intern ("WM_WINDOW_ROLE", FALSE));
1196 }
1197
1198 void
1199 gdk_window_set_transient_for (GdkWindow *window,
1200                               GdkWindow *parent)
1201 {
1202   GdkWindowPrivate *private;
1203   GdkWindowPrivate *parent_private;
1204
1205   g_return_if_fail (window != NULL);
1206
1207   private = (GdkWindowPrivate*) window;
1208   parent_private = (GdkWindowPrivate*) parent;
1209
1210   if (!private->destroyed && !parent_private->destroyed)
1211     XSetTransientForHint (private->xdisplay,
1212                           private->xwindow, parent_private->xwindow);
1213 }
1214
1215 void
1216 gdk_window_set_background (GdkWindow *window,
1217                            GdkColor  *color)
1218 {
1219   GdkWindowPrivate *private;
1220
1221   g_return_if_fail (window != NULL);
1222
1223   private = (GdkWindowPrivate*) window;
1224   if (!private->destroyed)
1225     XSetWindowBackground (private->xdisplay, private->xwindow, color->pixel);
1226 }
1227
1228 void
1229 gdk_window_set_back_pixmap (GdkWindow *window,
1230                             GdkPixmap *pixmap,
1231                             gint       parent_relative)
1232 {
1233   GdkWindowPrivate *window_private;
1234   GdkPixmapPrivate *pixmap_private;
1235   Pixmap xpixmap;
1236
1237   g_return_if_fail (window != NULL);
1238
1239   window_private = (GdkWindowPrivate*) window;
1240   pixmap_private = (GdkPixmapPrivate*) pixmap;
1241
1242   if (pixmap)
1243     xpixmap = pixmap_private->xwindow;
1244   else
1245     xpixmap = None;
1246
1247   if (parent_relative)
1248     xpixmap = ParentRelative;
1249
1250   if (!window_private->destroyed)
1251     XSetWindowBackgroundPixmap (window_private->xdisplay, window_private->xwindow, xpixmap);
1252 }
1253
1254 void
1255 gdk_window_set_cursor (GdkWindow *window,
1256                        GdkCursor *cursor)
1257 {
1258   GdkWindowPrivate *window_private;
1259   GdkCursorPrivate *cursor_private;
1260   Cursor xcursor;
1261
1262   g_return_if_fail (window != NULL);
1263
1264   window_private = (GdkWindowPrivate*) window;
1265   cursor_private = (GdkCursorPrivate*) cursor;
1266
1267   if (!cursor)
1268     xcursor = None;
1269   else
1270     xcursor = cursor_private->xcursor;
1271
1272   if (!window_private->destroyed)
1273     XDefineCursor (window_private->xdisplay, window_private->xwindow, xcursor);
1274 }
1275
1276 void
1277 gdk_window_set_colormap (GdkWindow   *window,
1278                          GdkColormap *colormap)
1279 {
1280   GdkWindowPrivate *window_private;
1281   GdkColormapPrivate *colormap_private;
1282
1283   g_return_if_fail (window != NULL);
1284   g_return_if_fail (colormap != NULL);
1285
1286   window_private = (GdkWindowPrivate*) window;
1287   colormap_private = (GdkColormapPrivate*) colormap;
1288
1289   if (!window_private->destroyed)
1290     {
1291       XSetWindowColormap (window_private->xdisplay,
1292                           window_private->xwindow,
1293                           colormap_private->xcolormap);
1294
1295       if (window_private->colormap)
1296         gdk_colormap_unref (window_private->colormap);
1297       window_private->colormap = colormap;
1298       gdk_colormap_ref (window_private->colormap);
1299
1300       if (window_private->window_type != GDK_WINDOW_TOPLEVEL)
1301         gdk_window_add_colormap_windows (window);
1302     }
1303 }
1304
1305 void
1306 gdk_window_get_user_data (GdkWindow *window,
1307                           gpointer  *data)
1308 {
1309   g_return_if_fail (window != NULL);
1310
1311   *data = window->user_data;
1312 }
1313
1314 void
1315 gdk_window_get_geometry (GdkWindow *window,
1316                          gint      *x,
1317                          gint      *y,
1318                          gint      *width,
1319                          gint      *height,
1320                          gint      *depth)
1321 {
1322   GdkWindowPrivate *window_private;
1323   Window root;
1324   gint tx;
1325   gint ty;
1326   guint twidth;
1327   guint theight;
1328   guint tborder_width;
1329   guint tdepth;
1330
1331   if (!window)
1332     window = (GdkWindow*) &gdk_root_parent;
1333
1334   window_private = (GdkWindowPrivate*) window;
1335
1336   if (!window_private->destroyed)
1337     {
1338       XGetGeometry (window_private->xdisplay, window_private->xwindow,
1339                     &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth);
1340
1341       if (x)
1342         *x = tx;
1343       if (y)
1344         *y = ty;
1345       if (width)
1346         *width = twidth;
1347       if (height)
1348         *height = theight;
1349       if (depth)
1350         *depth = tdepth;
1351     }
1352 }
1353
1354 void
1355 gdk_window_get_position (GdkWindow *window,
1356                          gint      *x,
1357                          gint      *y)
1358 {
1359   GdkWindowPrivate *window_private;
1360
1361   g_return_if_fail (window != NULL);
1362
1363   window_private = (GdkWindowPrivate*) window;
1364
1365   if (x)
1366     *x = window_private->x;
1367   if (y)
1368     *y = window_private->y;
1369 }
1370
1371 void
1372 gdk_window_get_size (GdkWindow *window,
1373                      gint       *width,
1374                      gint       *height)
1375 {
1376   GdkWindowPrivate *window_private;
1377
1378   g_return_if_fail (window != NULL);
1379
1380   window_private = (GdkWindowPrivate*) window;
1381
1382   if (width)
1383     *width = window_private->width;
1384   if (height)
1385     *height = window_private->height;
1386 }
1387
1388 GdkVisual*
1389 gdk_window_get_visual (GdkWindow *window)
1390 {
1391   GdkWindowPrivate *window_private;
1392   XWindowAttributes window_attributes;
1393
1394   g_return_val_if_fail (window != NULL, NULL);
1395
1396   window_private = (GdkWindowPrivate*) window;
1397   /* Huh? ->parent is never set for a pixmap. We should just return
1398    * null immeditately
1399    */
1400   while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP))
1401     window_private = (GdkWindowPrivate*) window_private->parent;
1402
1403   if (window_private && !window_private->destroyed)
1404     {
1405       if (window_private->colormap == NULL)
1406         {
1407           XGetWindowAttributes (window_private->xdisplay,
1408                                 window_private->xwindow,
1409                                 &window_attributes);
1410           return gdk_visual_lookup (window_attributes.visual);
1411         }
1412       else
1413         return ((GdkColormapPrivate *)window_private->colormap)->visual;
1414     }
1415
1416   return NULL;
1417 }
1418
1419 GdkColormap*
1420 gdk_window_get_colormap (GdkWindow *window)
1421 {
1422   GdkWindowPrivate *window_private;
1423   XWindowAttributes window_attributes;
1424
1425   g_return_val_if_fail (window != NULL, NULL);
1426   window_private = (GdkWindowPrivate*) window;
1427
1428   g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
1429   if (!window_private->destroyed)
1430     {
1431       if (window_private->colormap == NULL)
1432         {
1433           XGetWindowAttributes (window_private->xdisplay,
1434                                 window_private->xwindow,
1435                                 &window_attributes);
1436           return gdk_colormap_lookup (window_attributes.colormap);
1437         }
1438       else
1439         return window_private->colormap;
1440     }
1441
1442   return NULL;
1443 }
1444
1445 GdkWindowType
1446 gdk_window_get_type (GdkWindow *window)
1447 {
1448   GdkWindowPrivate *window_private;
1449
1450   g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
1451
1452   window_private = (GdkWindowPrivate*) window;
1453   return window_private->window_type;
1454 }
1455
1456 gint
1457 gdk_window_get_origin (GdkWindow *window,
1458                        gint      *x,
1459                        gint      *y)
1460 {
1461   GdkWindowPrivate *private;
1462   gint return_val;
1463   Window child;
1464   gint tx = 0;
1465   gint ty = 0;
1466
1467   g_return_val_if_fail (window != NULL, 0);
1468
1469   private = (GdkWindowPrivate*) window;
1470
1471   if (!private->destroyed)
1472     {
1473       return_val = XTranslateCoordinates (private->xdisplay,
1474                                           private->xwindow,
1475                                           gdk_root_window,
1476                                           0, 0, &tx, &ty,
1477                                           &child);
1478
1479     }
1480   else
1481     return_val = 0;
1482
1483   if (x)
1484     *x = tx;
1485   if (y)
1486     *y = ty;
1487
1488   return return_val;
1489 }
1490
1491 gboolean
1492 gdk_window_get_deskrelative_origin (GdkWindow *window,
1493                                     gint      *x,
1494                                     gint      *y)
1495 {
1496   GdkWindowPrivate *private;
1497   gboolean return_val = FALSE;
1498   gint num_children, format_return;
1499   Window win, *child, parent, root;
1500   gint tx = 0;
1501   gint ty = 0;
1502   Atom type_return;
1503   static Atom atom = 0;
1504   gulong number_return, bytes_after_return;
1505   guchar *data_return;
1506
1507   g_return_val_if_fail (window != NULL, 0);
1508
1509   private = (GdkWindowPrivate*) window;
1510
1511   if (!private->destroyed)
1512     {
1513       if (!atom)
1514         atom = XInternAtom (private->xdisplay, "ENLIGHTENMENT_DESKTOP", False);
1515       win = private->xwindow;
1516
1517       while (XQueryTree (private->xdisplay, win, &root, &parent,
1518                          &child, (unsigned int *)&num_children))
1519         {
1520           if ((child) && (num_children > 0))
1521             XFree (child);
1522
1523           if (!parent)
1524             break;
1525           else
1526             win = parent;
1527
1528           if (win == root)
1529             break;
1530
1531           data_return = NULL;
1532           XGetWindowProperty (private->xdisplay, win, atom, 0, 0,
1533                               False, XA_CARDINAL, &type_return, &format_return,
1534                               &number_return, &bytes_after_return, &data_return);
1535           if (type_return == XA_CARDINAL)
1536             {
1537               XFree (data_return);
1538               break;
1539             }
1540         }
1541
1542       return_val = XTranslateCoordinates (private->xdisplay,
1543                                           private->xwindow,
1544                                           win,
1545                                           0, 0, &tx, &ty,
1546                                           &root);
1547       if (x)
1548         *x = tx;
1549       if (y)
1550         *y = ty;
1551     }
1552
1553
1554   return return_val;
1555 }
1556
1557 void
1558 gdk_window_get_root_origin (GdkWindow *window,
1559                             gint      *x,
1560                             gint      *y)
1561 {
1562   GdkWindowPrivate *private;
1563   Window xwindow;
1564   Window xparent;
1565   Window root;
1566   Window *children;
1567   unsigned int nchildren;
1568
1569   g_return_if_fail (window != NULL);
1570
1571   private = (GdkWindowPrivate*) window;
1572   if (x)
1573     *x = 0;
1574   if (y)
1575     *y = 0;
1576   if (private->destroyed)
1577     return;
1578
1579   while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
1580     private = (GdkWindowPrivate*) private->parent;
1581   if (private->destroyed)
1582     return;
1583
1584   xparent = private->xwindow;
1585   do
1586     {
1587       xwindow = xparent;
1588       if (!XQueryTree (private->xdisplay, xwindow,
1589                        &root, &xparent,
1590                        &children, &nchildren))
1591         return;
1592
1593       if (children)
1594         XFree (children);
1595     }
1596   while (xparent != root);
1597
1598   if (xparent == root)
1599     {
1600       unsigned int ww, wh, wb, wd;
1601       int wx, wy;
1602
1603       if (XGetGeometry (private->xdisplay, xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
1604         {
1605           if (x)
1606             *x = wx;
1607           if (y)
1608             *y = wy;
1609         }
1610     }
1611 }
1612
1613 GdkWindow*
1614 gdk_window_get_pointer (GdkWindow       *window,
1615                         gint            *x,
1616                         gint            *y,
1617                         GdkModifierType *mask)
1618 {
1619   GdkWindowPrivate *private;
1620   GdkWindow *return_val;
1621   Window root;
1622   Window child;
1623   int rootx, rooty;
1624   int winx = 0;
1625   int winy = 0;
1626   unsigned int xmask = 0;
1627
1628   if (!window)
1629     window = (GdkWindow*) &gdk_root_parent;
1630
1631   private = (GdkWindowPrivate*) window;
1632
1633   return_val = NULL;
1634   if (!private->destroyed &&
1635       XQueryPointer (private->xdisplay, private->xwindow, &root, &child,
1636                      &rootx, &rooty, &winx, &winy, &xmask))
1637     {
1638       if (child)
1639         return_val = gdk_window_lookup (child);
1640     }
1641
1642   if (x)
1643     *x = winx;
1644   if (y)
1645     *y = winy;
1646   if (mask)
1647     *mask = xmask;
1648
1649   return return_val;
1650 }
1651
1652 GdkWindow*
1653 gdk_window_at_pointer (gint *win_x,
1654                        gint *win_y)
1655 {
1656   GdkWindowPrivate *private;
1657   GdkWindow *window;
1658   Window root;
1659   Window xwindow;
1660   Window xwindow_last = 0;
1661   int rootx = -1, rooty = -1;
1662   int winx, winy;
1663   unsigned int xmask;
1664
1665   private = &gdk_root_parent;
1666
1667   xwindow = private->xwindow;
1668
1669   XGrabServer (private->xdisplay);
1670   while (xwindow)
1671     {
1672       xwindow_last = xwindow;
1673       XQueryPointer (private->xdisplay,
1674                      xwindow,
1675                      &root, &xwindow,
1676                      &rootx, &rooty,
1677                      &winx, &winy,
1678                      &xmask);
1679     }
1680   XUngrabServer (private->xdisplay);
1681
1682   window = gdk_window_lookup (xwindow_last);
1683
1684   if (win_x)
1685     *win_x = window ? winx : -1;
1686   if (win_y)
1687     *win_y = window ? winy : -1;
1688
1689   return window;
1690 }
1691
1692 GdkWindow*
1693 gdk_window_get_parent (GdkWindow *window)
1694 {
1695   g_return_val_if_fail (window != NULL, NULL);
1696
1697   return ((GdkWindowPrivate*) window)->parent;
1698 }
1699
1700 GdkWindow*
1701 gdk_window_get_toplevel (GdkWindow *window)
1702 {
1703   GdkWindowPrivate *private;
1704
1705   g_return_val_if_fail (window != NULL, NULL);
1706
1707   private = (GdkWindowPrivate*) window;
1708
1709   while (private->window_type == GDK_WINDOW_CHILD)
1710     {
1711       window = ((GdkWindowPrivate*) window)->parent;
1712       private = (GdkWindowPrivate*) window;
1713     }
1714
1715   return window;
1716 }
1717
1718 GList*
1719 gdk_window_get_children (GdkWindow *window)
1720 {
1721   GdkWindowPrivate *private;
1722   GdkWindow *child;
1723   GList *children;
1724   Window root;
1725   Window parent;
1726   Window *xchildren;
1727   unsigned int nchildren;
1728   unsigned int i;
1729
1730   g_return_val_if_fail (window != NULL, NULL);
1731
1732   private = (GdkWindowPrivate*) window;
1733   if (private->destroyed)
1734     return NULL;
1735
1736   XQueryTree (private->xdisplay, private->xwindow,
1737               &root, &parent, &xchildren, &nchildren);
1738
1739   children = NULL;
1740
1741   if (nchildren > 0)
1742     {
1743       for (i = 0; i < nchildren; i++)
1744         {
1745           child = gdk_window_lookup (xchildren[i]);
1746           if (child)
1747             children = g_list_prepend (children, child);
1748         }
1749
1750       if (xchildren)
1751         XFree (xchildren);
1752     }
1753
1754   return children;
1755 }
1756
1757 GdkEventMask
1758 gdk_window_get_events (GdkWindow *window)
1759 {
1760   GdkWindowPrivate *private;
1761   XWindowAttributes attrs;
1762   GdkEventMask event_mask;
1763   int i;
1764
1765   g_return_val_if_fail (window != NULL, 0);
1766
1767   private = (GdkWindowPrivate*) window;
1768   if (private->destroyed)
1769     return 0;
1770
1771   XGetWindowAttributes (gdk_display, private->xwindow,
1772                         &attrs);
1773
1774   event_mask = 0;
1775   for (i = 0; i < gdk_nevent_masks; i++)
1776     {
1777       if (attrs.your_event_mask & gdk_event_mask_table[i])
1778         event_mask |= 1 << (i + 1);
1779     }
1780
1781   return event_mask;
1782 }
1783
1784 void
1785 gdk_window_set_events (GdkWindow       *window,
1786                        GdkEventMask     event_mask)
1787 {
1788   GdkWindowPrivate *private;
1789   long xevent_mask;
1790   int i;
1791
1792   g_return_if_fail (window != NULL);
1793
1794   private = (GdkWindowPrivate*) window;
1795   if (private->destroyed)
1796     return;
1797
1798   xevent_mask = StructureNotifyMask;
1799   for (i = 0; i < gdk_nevent_masks; i++)
1800     {
1801       if (event_mask & (1 << (i + 1)))
1802         xevent_mask |= gdk_event_mask_table[i];
1803     }
1804
1805   XSelectInput (gdk_display, private->xwindow,
1806                 xevent_mask);
1807 }
1808
1809 void
1810 gdk_window_add_colormap_windows (GdkWindow *window)
1811 {
1812   GdkWindow *toplevel;
1813   GdkWindowPrivate *toplevel_private;
1814   GdkWindowPrivate *window_private;
1815   Window *old_windows;
1816   Window *new_windows;
1817   int i, count;
1818
1819   g_return_if_fail (window != NULL);
1820
1821   toplevel = gdk_window_get_toplevel (window);
1822   toplevel_private = (GdkWindowPrivate*) toplevel;
1823   window_private = (GdkWindowPrivate*) window;
1824   if (window_private->destroyed)
1825     return;
1826
1827   old_windows = NULL;
1828   if (!XGetWMColormapWindows (toplevel_private->xdisplay,
1829                               toplevel_private->xwindow,
1830                               &old_windows, &count))
1831     {
1832       count = 0;
1833     }
1834
1835   for (i = 0; i < count; i++)
1836     if (old_windows[i] == window_private->xwindow)
1837       {
1838         XFree (old_windows);
1839         return;
1840       }
1841
1842   new_windows = g_new (Window, count + 1);
1843
1844   for (i = 0; i < count; i++)
1845     new_windows[i] = old_windows[i];
1846   new_windows[count] = window_private->xwindow;
1847
1848   XSetWMColormapWindows (toplevel_private->xdisplay,
1849                          toplevel_private->xwindow,
1850                          new_windows, count + 1);
1851
1852   g_free (new_windows);
1853   if (old_windows)
1854     XFree (old_windows);
1855 }
1856
1857 static gboolean
1858 gdk_window_have_shape_ext (void)
1859 {
1860   enum { UNKNOWN, NO, YES };
1861   static gint have_shape = UNKNOWN;
1862
1863   if (have_shape == UNKNOWN)
1864     {
1865       int ignore;
1866       if (XQueryExtension (gdk_display, "SHAPE", &ignore, &ignore, &ignore))
1867         have_shape = YES;
1868       else
1869         have_shape = NO;
1870     }
1871
1872   return (have_shape == YES);
1873 }
1874
1875 /*
1876  * This needs the X11 shape extension.
1877  * If not available, shaped windows will look
1878  * ugly, but programs still work.    Stefan Wille
1879  */
1880 void
1881 gdk_window_shape_combine_mask (GdkWindow *window,
1882                                GdkBitmap *mask,
1883                                gint x, gint y)
1884 {
1885   GdkWindowPrivate *window_private;
1886   Pixmap pixmap;
1887
1888   g_return_if_fail (window != NULL);
1889
1890 #ifdef HAVE_SHAPE_EXT
1891   window_private = (GdkWindowPrivate*) window;
1892   if (window_private->destroyed)
1893     return;
1894
1895   if (gdk_window_have_shape_ext ())
1896     {
1897       if (mask)
1898         {
1899           GdkWindowPrivate *pixmap_private;
1900
1901           pixmap_private = (GdkWindowPrivate*) mask;
1902           pixmap = (Pixmap) pixmap_private->xwindow;
1903         }
1904       else
1905         {
1906           x = 0;
1907           y = 0;
1908           pixmap = None;
1909         }
1910
1911       XShapeCombineMask (window_private->xdisplay,
1912                          window_private->xwindow,
1913                          ShapeBounding,
1914                          x, y,
1915                          pixmap,
1916                          ShapeSet);
1917     }
1918 #endif /* HAVE_SHAPE_EXT */
1919 }
1920
1921 void
1922 gdk_window_add_filter (GdkWindow     *window,
1923                        GdkFilterFunc  function,
1924                        gpointer       data)
1925 {
1926   GdkWindowPrivate *private;
1927   GList *tmp_list;
1928   GdkEventFilter *filter;
1929
1930   private = (GdkWindowPrivate*) window;
1931   if (private && private->destroyed)
1932     return;
1933
1934   if (private)
1935     tmp_list = private->filters;
1936   else
1937     tmp_list = gdk_default_filters;
1938
1939   while (tmp_list)
1940     {
1941       filter = (GdkEventFilter *)tmp_list->data;
1942       if ((filter->function == function) && (filter->data == data))
1943         return;
1944       tmp_list = tmp_list->next;
1945     }
1946
1947   filter = g_new (GdkEventFilter, 1);
1948   filter->function = function;
1949   filter->data = data;
1950
1951   if (private)
1952     private->filters = g_list_append (private->filters, filter);
1953   else
1954     gdk_default_filters = g_list_append (gdk_default_filters, filter);
1955 }
1956
1957 void
1958 gdk_window_remove_filter (GdkWindow     *window,
1959                           GdkFilterFunc  function,
1960                           gpointer       data)
1961 {
1962   GdkWindowPrivate *private;
1963   GList *tmp_list, *node;
1964   GdkEventFilter *filter;
1965
1966   private = (GdkWindowPrivate*) window;
1967
1968   if (private)
1969     tmp_list = private->filters;
1970   else
1971     tmp_list = gdk_default_filters;
1972
1973   while (tmp_list)
1974     {
1975       filter = (GdkEventFilter *)tmp_list->data;
1976       node = tmp_list;
1977       tmp_list = tmp_list->next;
1978
1979       if ((filter->function == function) && (filter->data == data))
1980         {
1981           if (private)
1982             private->filters = g_list_remove_link (private->filters, node);
1983           else
1984             gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
1985           g_list_free_1 (node);
1986           g_free (filter);
1987
1988           return;
1989         }
1990     }
1991 }
1992
1993 void
1994 gdk_window_set_override_redirect (GdkWindow *window,
1995                                   gboolean override_redirect)
1996 {
1997   GdkWindowPrivate *private;
1998   XSetWindowAttributes attr;
1999
2000   g_return_if_fail (window != NULL);
2001   private = (GdkWindowPrivate*) window;
2002   if (private->destroyed)
2003     return;
2004
2005   attr.override_redirect = (override_redirect == FALSE)?False:True;
2006   XChangeWindowAttributes (gdk_display,
2007                            ((GdkWindowPrivate *)window)->xwindow,
2008                            CWOverrideRedirect,
2009                            &attr);
2010 }
2011
2012 void
2013 gdk_window_set_icon (GdkWindow *window,
2014                      GdkWindow *icon_window,
2015                      GdkPixmap *pixmap,
2016                      GdkBitmap *mask)
2017 {
2018   XWMHints *wm_hints;
2019   GdkWindowPrivate *window_private;
2020   GdkWindowPrivate *private;
2021
2022   g_return_if_fail (window != NULL);
2023   window_private = (GdkWindowPrivate*) window;
2024   if (window_private->destroyed)
2025     return;
2026
2027   wm_hints = XGetWMHints (window_private->xdisplay, window_private->xwindow);
2028   if (!wm_hints)
2029     wm_hints = XAllocWMHints ();
2030
2031   if (icon_window != NULL)
2032     {
2033       private = (GdkWindowPrivate *)icon_window;
2034       wm_hints->flags |= IconWindowHint;
2035       wm_hints->icon_window = private->xwindow;
2036     }
2037
2038   if (pixmap != NULL)
2039     {
2040       private = (GdkWindowPrivate *)pixmap;
2041       wm_hints->flags |= IconPixmapHint;
2042       wm_hints->icon_pixmap = private->xwindow;
2043     }
2044
2045   if (mask != NULL)
2046     {
2047       private = (GdkWindowPrivate *)mask;
2048       wm_hints->flags |= IconMaskHint;
2049       wm_hints->icon_mask = private->xwindow;
2050     }
2051
2052   XSetWMHints (window_private->xdisplay, window_private->xwindow, wm_hints);
2053   XFree (wm_hints);
2054 }
2055
2056 void
2057 gdk_window_set_icon_name (GdkWindow *window,
2058                           gchar *    name)
2059 {
2060   GdkWindowPrivate *window_private;
2061   XTextProperty property;
2062   gint res;
2063
2064   g_return_if_fail (window != NULL);
2065   window_private = (GdkWindowPrivate*) window;
2066   if (window_private->destroyed)
2067     return;
2068   res = XmbTextListToTextProperty (window_private->xdisplay,
2069                                    &name, 1, XStdICCTextStyle,
2070                                    &property);
2071   if (res < 0)
2072     {
2073       g_warning ("Error converting icon name to text property: %d\n", res);
2074       return;
2075     }
2076
2077   XSetWMIconName (window_private->xdisplay, window_private->xwindow,
2078                   &property);
2079
2080   if (property.value)
2081     XFree (property.value);
2082 }
2083
2084 void
2085 gdk_window_set_group (GdkWindow *window,
2086                       GdkWindow *leader)
2087 {
2088   XWMHints *wm_hints;
2089   GdkWindowPrivate *window_private;
2090   GdkWindowPrivate *private;
2091
2092   g_return_if_fail (window != NULL);
2093   g_return_if_fail (leader != NULL);
2094   window_private = (GdkWindowPrivate*) window;
2095   if (window_private->destroyed)
2096     return;
2097
2098   private = (GdkWindowPrivate *)leader;
2099
2100   wm_hints = XGetWMHints (window_private->xdisplay, window_private->xwindow);
2101   if (!wm_hints)
2102     wm_hints = XAllocWMHints ();
2103
2104   wm_hints->flags |= WindowGroupHint;
2105   wm_hints->window_group = private->xwindow;
2106
2107   XSetWMHints (window_private->xdisplay, window_private->xwindow, wm_hints);
2108   XFree (wm_hints);
2109 }
2110
2111 static void
2112 gdk_window_set_mwm_hints (GdkWindow *window,
2113                           MotifWmHints *new_hints)
2114 {
2115   static Atom hints_atom = None;
2116   MotifWmHints *hints;
2117   Atom type;
2118   gint format;
2119   gulong nitems;
2120   gulong bytes_after;
2121
2122   GdkWindowPrivate *window_private;
2123
2124   g_return_if_fail (window != NULL);
2125   window_private = (GdkWindowPrivate*) window;
2126   if (window_private->destroyed)
2127     return;
2128
2129   if (!hints_atom)
2130     hints_atom = XInternAtom (window_private->xdisplay,
2131                               _XA_MOTIF_WM_HINTS, FALSE);
2132
2133   XGetWindowProperty (window_private->xdisplay, window_private->xwindow,
2134                       hints_atom, 0, sizeof (MotifWmHints)/4,
2135                       False, AnyPropertyType, &type, &format, &nitems,
2136                       &bytes_after, (guchar **)&hints);
2137
2138   if (type == None)
2139     hints = new_hints;
2140   else
2141     {
2142       if (new_hints->flags & MWM_HINTS_FUNCTIONS)
2143         {
2144           hints->flags |= MWM_HINTS_FUNCTIONS;
2145           hints->functions = new_hints->functions;
2146         }
2147       if (new_hints->flags & MWM_HINTS_DECORATIONS)
2148         {
2149           hints->flags |= MWM_HINTS_DECORATIONS;
2150           hints->decorations = new_hints->decorations;
2151         }
2152     }
2153
2154   XChangeProperty (window_private->xdisplay, window_private->xwindow,
2155                    hints_atom, hints_atom, 32, PropModeReplace,
2156                    (guchar *)hints, sizeof (MotifWmHints)/4);
2157
2158   if (hints != new_hints)
2159     XFree (hints);
2160 }
2161
2162 void
2163 gdk_window_set_decorations (GdkWindow      *window,
2164                             GdkWMDecoration decorations)
2165 {
2166   MotifWmHints hints;
2167
2168   hints.flags = MWM_HINTS_DECORATIONS;
2169   hints.decorations = decorations;
2170
2171   gdk_window_set_mwm_hints (window, &hints);
2172 }
2173
2174 void
2175 gdk_window_set_functions (GdkWindow    *window,
2176                           GdkWMFunction functions)
2177 {
2178   MotifWmHints hints;
2179
2180   hints.flags = MWM_HINTS_FUNCTIONS;
2181   hints.functions = functions;
2182
2183   gdk_window_set_mwm_hints (window, &hints);
2184 }
2185
2186 GList *
2187 gdk_window_get_toplevels (void)
2188 {
2189   GList *new_list = NULL;
2190   GList *tmp_list;
2191
2192   tmp_list = gdk_root_parent.children;
2193   while (tmp_list)
2194     {
2195       new_list = g_list_prepend (new_list, tmp_list->data);
2196       tmp_list = tmp_list->next;
2197     }
2198
2199   return new_list;
2200 }
2201
2202 /*
2203  * propagate the shapes from all child windows of a GDK window to the parent
2204  * window. Shamelessly ripped from Enlightenment's code
2205  *
2206  * - Raster
2207  */
2208
2209 struct _gdk_span
2210 {
2211   gint                start;
2212   gint                end;
2213   struct _gdk_span    *next;
2214 };
2215
2216 static void
2217 gdk_add_to_span (struct _gdk_span **s,
2218                  gint               x,
2219                  gint               xx)
2220 {
2221   struct _gdk_span *ptr1, *ptr2, *noo, *ss;
2222   gchar             spanning;
2223
2224   ptr2 = NULL;
2225   ptr1 = *s;
2226   spanning = 0;
2227   ss = NULL;
2228   /* scan the spans for this line */
2229   while (ptr1)
2230     {
2231       /* -- -> new span */
2232       /* == -> existing span */
2233       /* ## -> spans intersect */
2234       /* if we are in the middle of spanning the span into the line */
2235       if (spanning)
2236         {
2237           /* case: ---- ==== */
2238           if (xx < ptr1->start - 1)
2239             {
2240               /* ends before next span - extend to here */
2241               ss->end = xx;
2242               return;
2243             }
2244           /* case: ----##=== */
2245           else if (xx <= ptr1->end)
2246             {
2247               /* crosses into next span - delete next span and append */
2248               ss->end = ptr1->end;
2249               ss->next = ptr1->next;
2250               g_free (ptr1);
2251               return;
2252             }
2253           /* case: ---###--- */
2254           else
2255             {
2256               /* overlaps next span - delete and keep checking */
2257               ss->next = ptr1->next;
2258               g_free (ptr1);
2259               ptr1 = ss;
2260             }
2261         }
2262       /* otherwise havent started spanning it in yet */
2263       else
2264         {
2265           /* case: ---- ==== */
2266           if (xx < ptr1->start - 1)
2267             {
2268               /* insert span here in list */
2269               noo = g_malloc (sizeof (struct _gdk_span));
2270
2271               if (noo)
2272                 {
2273                   noo->start = x;
2274                   noo->end = xx;
2275                   noo->next = ptr1;
2276                   if (ptr2)
2277                     ptr2->next = noo;
2278                   else
2279                     *s = noo;
2280                 }
2281               return;
2282             }
2283           /* case: ----##=== */
2284           else if ((x < ptr1->start) && (xx <= ptr1->end))
2285             {
2286               /* expand this span to the left point of the new one */
2287               ptr1->start = x;
2288               return;
2289             }
2290           /* case: ===###=== */
2291           else if ((x >= ptr1->start) && (xx <= ptr1->end))
2292             {
2293               /* throw the span away */
2294               return;
2295             }
2296           /* case: ---###--- */
2297           else if ((x < ptr1->start) && (xx > ptr1->end))
2298             {
2299               ss = ptr1;
2300               spanning = 1;
2301               ptr1->start = x;
2302               ptr1->end = xx;
2303             }
2304           /* case: ===##---- */
2305           else if ((x >= ptr1->start) && (x <= ptr1->end + 1) && (xx > ptr1->end))
2306             {
2307               ss = ptr1;
2308               spanning = 1;
2309               ptr1->end = xx;
2310             }
2311           /* case: ==== ---- */
2312           /* case handled by next loop iteration - first case */
2313         }
2314       ptr2 = ptr1;
2315       ptr1 = ptr1->next;
2316     }
2317   /* it started in the middle but spans beyond your current list */
2318   if (spanning)
2319     {
2320       ptr2->end = xx;
2321       return;
2322     }
2323   /* it does not start inside a span or in the middle, so add it to the end */
2324   noo = g_malloc (sizeof (struct _gdk_span));
2325
2326   if (noo)
2327     {
2328       noo->start = x;
2329       noo->end = xx;
2330       if (ptr2)
2331         {
2332           noo->next = ptr2->next;
2333           ptr2->next = noo;
2334         }
2335       else
2336         {
2337           noo->next = NULL;
2338           *s = noo;
2339         }
2340     }
2341   return;
2342 }
2343
2344 static void
2345 gdk_add_rectangles (Display           *disp,
2346                     Window             win,
2347                     struct _gdk_span **spans,
2348                     gint               basew,
2349                     gint               baseh,
2350                     gint               x,
2351                     gint               y)
2352 {
2353   gint a, k;
2354   gint x1, y1, x2, y2;
2355   gint rn, ord;
2356   XRectangle *rl;
2357
2358   rl = XShapeGetRectangles (disp, win, ShapeBounding, &rn, &ord);
2359   if (rl)
2360     {
2361       /* go through all clip rects in this window's shape */
2362       for (k = 0; k < rn; k++)
2363         {
2364           /* for each clip rect, add it to each line's spans */
2365           x1 = x + rl[k].x;
2366           x2 = x + rl[k].x + (rl[k].width - 1);
2367           y1 = y + rl[k].y;
2368           y2 = y + rl[k].y + (rl[k].height - 1);
2369           if (x1 < 0)
2370             x1 = 0;
2371           if (y1 < 0)
2372             y1 = 0;
2373           if (x2 >= basew)
2374             x2 = basew - 1;
2375           if (y2 >= baseh)
2376             y2 = baseh - 1;
2377           for (a = y1; a <= y2; a++)
2378             {
2379               if ((x2 - x1) >= 0)
2380                 gdk_add_to_span (&spans[a], x1, x2);
2381             }
2382         }
2383       XFree (rl);
2384     }
2385 }
2386
2387 static void
2388 gdk_propagate_shapes (Display *disp,
2389                       Window   win,
2390                       gboolean merge)
2391 {
2392   Window              rt, par, *list = NULL;
2393   gint                i, j, num = 0, num_rects = 0;
2394   gint                x, y, contig;
2395   guint               w, h, d;
2396   gint                baseh, basew;
2397   XRectangle         *rects = NULL;
2398   struct _gdk_span  **spans = NULL, *ptr1, *ptr2, *ptr3;
2399   XWindowAttributes   xatt;
2400
2401   XGetGeometry (disp, win, &rt, &x, &y, &w, &h, &d, &d);
2402   if (h <= 0)
2403     return;
2404   basew = w;
2405   baseh = h;
2406   spans = g_malloc (sizeof (struct _gdk_span *) * h);
2407
2408   for (i = 0; i < h; i++)
2409     spans[i] = NULL;
2410   XQueryTree (disp, win, &rt, &par, &list, (unsigned int *)&num);
2411   if (list)
2412     {
2413       /* go through all child windows and create/insert spans */
2414       for (i = 0; i < num; i++)
2415         {
2416           if (XGetWindowAttributes (disp, list[i], &xatt) && (xatt.map_state != IsUnmapped))
2417             if (XGetGeometry (disp, list[i], &rt, &x, &y, &w, &h, &d, &d))
2418               gdk_add_rectangles (disp, list[i], spans, basew, baseh, x, y);
2419         }
2420       if (merge)
2421         gdk_add_rectangles (disp, win, spans, basew, baseh, x, y);
2422
2423       /* go through the spans list and build a list of rects */
2424       rects = g_malloc (sizeof (XRectangle) * 256);
2425       num_rects = 0;
2426       for (i = 0; i < baseh; i++)
2427         {
2428           ptr1 = spans[i];
2429           /* go through the line for all spans */
2430           while (ptr1)
2431             {
2432               rects[num_rects].x = ptr1->start;
2433               rects[num_rects].y = i;
2434               rects[num_rects].width = ptr1->end - ptr1->start + 1;
2435               rects[num_rects].height = 1;
2436               j = i + 1;
2437               /* if there are more lines */
2438               contig = 1;
2439               /* while contigous rects (same start/end coords) exist */
2440               while ((contig) && (j < baseh))
2441                 {
2442                   /* search next line for spans matching this one */
2443                   contig = 0;
2444                   ptr2 = spans[j];
2445                   ptr3 = NULL;
2446                   while (ptr2)
2447                     {
2448                       /* if we have an exact span match set contig */
2449                       if ((ptr2->start == ptr1->start) &&
2450                           (ptr2->end == ptr1->end))
2451                         {
2452                           contig = 1;
2453                           /* remove the span - not needed */
2454                           if (ptr3)
2455                             {
2456                               ptr3->next = ptr2->next;
2457                               g_free (ptr2);
2458                               ptr2 = NULL;
2459                             }
2460                           else
2461                             {
2462                               spans[j] = ptr2->next;
2463                               g_free (ptr2);
2464                               ptr2 = NULL;
2465                             }
2466                           break;
2467                         }
2468                       /* gone past the span point no point looking */
2469                       else if (ptr2->start < ptr1->start)
2470                         break;
2471                       if (ptr2)
2472                         {
2473                           ptr3 = ptr2;
2474                           ptr2 = ptr2->next;
2475                         }
2476                     }
2477                   /* if a contiguous span was found increase the rect h */
2478                   if (contig)
2479                     {
2480                       rects[num_rects].height++;
2481                       j++;
2482                     }
2483                 }
2484               /* up the rect count */
2485               num_rects++;
2486               /* every 256 new rects increase the rect array */
2487               if ((num_rects % 256) == 0)
2488                 rects = g_realloc (rects, sizeof (XRectangle) * (num_rects + 256));
2489               ptr1 = ptr1->next;
2490             }
2491         }
2492       /* set the rects as the shape mask */
2493       if (rects)
2494         {
2495           XShapeCombineRectangles (disp, win, ShapeBounding, 0, 0, rects, num_rects,
2496                                    ShapeSet, YXSorted);
2497           g_free (rects);
2498         }
2499       XFree (list);
2500     }
2501   /* free up all the spans we made */
2502   for (i = 0; i < baseh; i++)
2503     {
2504       ptr1 = spans[i];
2505       while (ptr1)
2506         {
2507           ptr2 = ptr1;
2508           ptr1 = ptr1->next;
2509           g_free (ptr2);
2510         }
2511     }
2512   g_free (spans);
2513 }
2514
2515 void
2516 gdk_window_set_child_shapes (GdkWindow *window)
2517 {
2518   GdkWindowPrivate *private;
2519
2520   g_return_if_fail (window != NULL);
2521
2522 #ifdef HAVE_SHAPE_EXT
2523   private = (GdkWindowPrivate*) window;
2524   if (private->destroyed)
2525     return;
2526
2527   if (gdk_window_have_shape_ext ())
2528     gdk_propagate_shapes (private->xdisplay, private->xwindow, FALSE);
2529 #endif
2530 }
2531
2532 void
2533 gdk_window_merge_child_shapes (GdkWindow *window)
2534 {
2535   GdkWindowPrivate *private;
2536
2537   g_return_if_fail (window != NULL);
2538
2539 #ifdef HAVE_SHAPE_EXT
2540   private = (GdkWindowPrivate*) window;
2541   if (private->destroyed)
2542     return;
2543
2544   if (gdk_window_have_shape_ext ())
2545     gdk_propagate_shapes (private->xdisplay, private->xwindow, TRUE);
2546 #endif
2547 }
2548
2549 /*************************************************************
2550  * gdk_window_is_visible:
2551  *     Check if the given window is mapped.
2552  *   arguments:
2553  *     window:
2554  *   results:
2555  *     is the window mapped
2556  *************************************************************/
2557
2558 gboolean
2559 gdk_window_is_visible (GdkWindow *window)
2560 {
2561   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2562
2563   g_return_val_if_fail (window != NULL, FALSE);
2564
2565   return private->mapped;
2566 }
2567
2568 /*************************************************************
2569  * gdk_window_is_viewable:
2570  *     Check if the window and all ancestors of the window
2571  *     are mapped. (This is not necessarily "viewable" in
2572  *     the X sense, since we only check as far as we have
2573  *     GDK window parents, not to the root window)
2574  *   arguments:
2575  *     window:
2576  *   results:
2577  *     is the window viewable
2578  *************************************************************/
2579
2580 gboolean
2581 gdk_window_is_viewable (GdkWindow *window)
2582 {
2583   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2584
2585   g_return_val_if_fail (window != NULL, FALSE);
2586
2587   while (private &&
2588          (private != &gdk_root_parent) &&
2589          (private->window_type != GDK_WINDOW_FOREIGN))
2590     {
2591       if (!private->mapped)
2592         return FALSE;
2593
2594       private = (GdkWindowPrivate *)private->parent;
2595     }
2596
2597   return TRUE;
2598 }
2599
2600 void
2601 gdk_drawable_set_data (GdkDrawable   *drawable,
2602                        const gchar   *key,
2603                        gpointer       data,
2604                        GDestroyNotify destroy_func)
2605 {
2606   g_dataset_set_data_full (drawable, key, data, destroy_func);
2607 }
2608
2609
2610 /* Support for windows that can be guffaw-scrolled
2611  * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2612  */
2613
2614 static gboolean
2615 gdk_window_gravity_works (void)
2616 {
2617   enum { UNKNOWN, NO, YES };
2618   static gint gravity_works = UNKNOWN;
2619
2620   if (gravity_works == UNKNOWN)
2621     {
2622       GdkWindowAttr attr;
2623       GdkWindow *parent;
2624       GdkWindow *child;
2625       gint y;
2626
2627       /* This particular server apparently has a bug so that the test
2628        * works but the actual code crashes it
2629        */
2630       if ((!strcmp (XServerVendor (gdk_display), "Sun Microsystems, Inc.")) &&
2631           (VendorRelease (gdk_display) == 3400))
2632         {
2633           gravity_works = NO;
2634           return FALSE;
2635         }
2636
2637       attr.window_type = GDK_WINDOW_TEMP;
2638       attr.wclass = GDK_INPUT_OUTPUT;
2639       attr.x = 0;
2640       attr.y = 0;
2641       attr.width = 100;
2642       attr.height = 100;
2643       attr.event_mask = 0;
2644
2645       parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2646
2647       attr.window_type = GDK_WINDOW_CHILD;
2648       child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2649
2650       gdk_window_set_static_win_gravity (child, TRUE);
2651
2652       gdk_window_resize (parent, 100, 110);
2653       gdk_window_move (parent, 0, -10);
2654       gdk_window_move_resize (parent, 0, 0, 100, 100);
2655
2656       gdk_window_resize (parent, 100, 110);
2657       gdk_window_move (parent, 0, -10);
2658       gdk_window_move_resize (parent, 0, 0, 100, 100);
2659
2660       gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2661
2662       gdk_window_destroy (parent);
2663       gdk_window_destroy (child);
2664
2665       gravity_works = ((y == -20) ? YES : NO);
2666     }
2667
2668   return (gravity_works == YES);
2669 }
2670
2671 static void
2672 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2673 {
2674   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2675   XSetWindowAttributes xattributes;
2676
2677   g_return_if_fail (window != NULL);
2678
2679   xattributes.bit_gravity = on ? StaticGravity : ForgetGravity;
2680   XChangeWindowAttributes (private->xdisplay,
2681                            private->xwindow,
2682                            CWBitGravity,  &xattributes);
2683 }
2684
2685 static void
2686 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2687 {
2688   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2689   XSetWindowAttributes xattributes;
2690
2691   g_return_if_fail (window != NULL);
2692
2693   xattributes.win_gravity = on ? StaticGravity : NorthWestGravity;
2694
2695   XChangeWindowAttributes (private->xdisplay,
2696                            private->xwindow,
2697                            CWWinGravity,  &xattributes);
2698 }
2699
2700 /*************************************************************
2701  * gdk_window_set_static_gravities:
2702  *     Set the bit gravity of the given window to static,
2703  *     and flag it so all children get static subwindow
2704  *     gravity.
2705  *   arguments:
2706  *     window: window for which to set static gravity
2707  *     use_static: Whether to turn static gravity on or off.
2708  *   results:
2709  *     Does the XServer support static gravity?
2710  *************************************************************/
2711
2712 gboolean
2713 gdk_window_set_static_gravities (GdkWindow *window,
2714                                  gboolean   use_static)
2715 {
2716   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2717   GList *tmp_list;
2718
2719   g_return_val_if_fail (window != NULL, FALSE);
2720
2721   if (!use_static == !private->guffaw_gravity)
2722     return TRUE;
2723
2724   if (use_static && !gdk_window_gravity_works ())
2725     return FALSE;
2726
2727   private->guffaw_gravity = use_static;
2728
2729   gdk_window_set_static_bit_gravity (window, use_static);
2730
2731   tmp_list = private->children;
2732   while (tmp_list)
2733     {
2734       gdk_window_set_static_win_gravity (window, use_static);
2735
2736       tmp_list = tmp_list->next;
2737     }
2738
2739   return TRUE;
2740 }