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
 507   if(!XGetWindowAttributes (gdk_display, anid, &attrs)) {
 508     g_warning("XGetWindowAttributes failed on window ID %d\n", anid);
 509     return NULL;
 510   }
 511
 512   private = g_new (GdkWindowPrivate, 1);
 513   window = (GdkWindow*) private;
 514
 515   /* FIXME: This is pretty expensive. Maybe the caller should supply
 516    *        the parent */
 517   XQueryTree (gdk_display, anid, &root, &parent, &children, &nchildren);
 518
 519   if (children)
 520     XFree (children);
 521   private->parent = gdk_xid_table_lookup (parent);
 522
 523   parent_private = (GdkWindowPrivate *)private->parent;
 524
 525   if (parent_private)
 526     parent_private->children = g_list_prepend (parent_private->children, window);
 527
 528   private->xwindow = anid;
 529   private->xdisplay = gdk_display;
 530   private->x = attrs.x;
 531   private->y = attrs.y;
 532   private->width = attrs.width;
 533   private->height = attrs.height;
 534   private->resize_count = 0;
 535   private->ref_count = 1;
 536   private->window_type = GDK_WINDOW_FOREIGN;
 537   private->destroyed = FALSE;
 538   private->mapped = (attrs.map_state != IsUnmapped);
 539   private->guffaw_gravity = FALSE;
 540   private->extension_events = 0;
 541
 542   private->colormap = NULL;
 543
 544   private->filters = NULL;
 545   private->children = NULL;
 546
 547   window->user_data = NULL;
 548
 549   gdk_window_ref (window);
 550   gdk_xid_table_insert (&private->xwindow, window);
 551
 552   return window;
 553 }
 554
 555 /* Call this function when you want a window and all its children to
 556  * disappear.  When xdestroy is true, a request to destroy the XWindow
 557  * is sent out.  When it is false, it is assumed that the XWindow has
 558  * been or will be destroyed by destroying some ancestor of this
 559  * window.
 560  */
 561 static void
 562 gdk_window_internal_destroy (GdkWindow *window,
 563                              gboolean   xdestroy,
 564                              gboolean   our_destroy)
 565 {
 566   GdkWindowPrivate *private;
 567   GdkWindowPrivate *temp_private;
 568   GdkWindow *temp_window;
 569   GList *children;
 570   GList *tmp;
 571
 572   g_return_if_fail (window != NULL);
 573
 574   private = (GdkWindowPrivate*) window;
 575
 576   switch (private->window_type)
 577     {
 578     case GDK_WINDOW_TOPLEVEL:
 579     case GDK_WINDOW_CHILD:
 580     case GDK_WINDOW_DIALOG:
 581     case GDK_WINDOW_TEMP:
 582     case GDK_WINDOW_FOREIGN:
 583       if (!private->destroyed)
 584         {
 585           if (private->parent)
 586             {
 587               GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
 588               if (parent_private->children)
 589                 parent_private->children = g_list_remove (parent_private->children, window);
 590             }
 591
 592           if (private->window_type != GDK_WINDOW_FOREIGN)
 593             {
 594               children = tmp = private->children;
 595               private->children = NULL;
 596
 597               while (tmp)
 598                 {
 599                   temp_window = tmp->data;
 600                   tmp = tmp->next;
 601
 602                   temp_private = (GdkWindowPrivate*) temp_window;
 603                   if (temp_private)
 604                     gdk_window_internal_destroy (temp_window, FALSE,
 605                                                  our_destroy);
 606                 }
 607
 608               g_list_free (children);
 609             }
 610
 611           if (private->extension_events != 0)
 612             gdk_input_window_destroy (window);
 613
 614           if (private->filters)
 615             {
 616               tmp = private->filters;
 617
 618               while (tmp)
 619                 {
 620                   g_free (tmp->data);
 621                   tmp = tmp->next;
 622                 }
 623
 624               g_list_free (private->filters);
 625               private->filters = NULL;
 626             }
 627
 628           if (private->window_type == GDK_WINDOW_FOREIGN)
 629             {
 630               if (our_destroy && (private->parent != NULL))
 631                 {
 632                   /* It's somebody elses window, but in our heirarchy,
 633                    * so reparent it to the root window, and then send
 634                    * it a delete event, as if we were a WM
 635                    */
 636                   XClientMessageEvent xevent;
 637
 638                   gdk_window_hide (window);
 639                   gdk_window_reparent (window, NULL, 0, 0);
 640
 641                   xevent.type = ClientMessage;
 642                   xevent.window = private->xwindow;
 643                   xevent.message_type = gdk_wm_protocols;
 644                   xevent.format = 32;
 645                   xevent.data.l[0] = gdk_wm_delete_window;
 646                   xevent.data.l[1] = CurrentTime;
 647
 648                   XSendEvent (private->xdisplay, private->xwindow,
 649                               False, 0, (XEvent *)&xevent);
 650                 }
 651             }
 652           else if (xdestroy)
 653             XDestroyWindow (private->xdisplay, private->xwindow);
 654
 655           if (private->colormap)
 656             gdk_colormap_unref (private->colormap);
 657
 658           private->mapped = FALSE;
 659           private->destroyed = TRUE;
 660         }
 661       break;
 662
 663     case GDK_WINDOW_ROOT:
 664       g_error ("attempted to destroy root window");
 665       break;
 666
 667     case GDK_WINDOW_PIXMAP:
 668       g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
 669       break;
 670     }
 671 }
 672
 673 /* Like internal_destroy, but also destroys the reference created by
 674    gdk_window_new. */
 675
 676 void
 677 gdk_window_destroy (GdkWindow *window)
 678 {
 679   gdk_window_internal_destroy (window, TRUE, TRUE);
 680   gdk_window_unref (window);
 681 }
 682
 683 /* This function is called when the XWindow is really gone.  */
 684
 685 void
 686 gdk_window_destroy_notify (GdkWindow *window)
 687 {
 688   GdkWindowPrivate *private;
 689
 690   g_return_if_fail (window != NULL);
 691
 692   private = (GdkWindowPrivate*) window;
 693
 694   if (!private->destroyed)
 695     {
 696       if (private->window_type == GDK_WINDOW_FOREIGN)
 697         gdk_window_internal_destroy (window, FALSE, FALSE);
 698       else
 699         g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
 700     }
 701
 702   gdk_xid_table_remove (private->xwindow);
 703   gdk_window_unref (window);
 704 }
 705
 706 GdkWindow*
 707 gdk_window_ref (GdkWindow *window)
 708 {
 709   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
 710   g_return_val_if_fail (window != NULL, NULL);
 711
 712   private->ref_count += 1;
 713   return window;
 714 }
 715
 716 void
 717 gdk_window_unref (GdkWindow *window)
 718 {
 719   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
 720   g_return_if_fail (window != NULL);
 721
 722   private->ref_count -= 1;
 723   if (private->ref_count == 0)
 724     {
 725       if (!private->destroyed)
 726         {
 727           if (private->window_type == GDK_WINDOW_FOREIGN)
 728             gdk_xid_table_remove (private->xwindow);
 729           else
 730             g_warning ("losing last reference to undestroyed window\n");
 731         }
 732       g_dataset_destroy (window);
 733       g_free (window);
 734     }
 735 }
 736
 737 void
 738 gdk_window_show (GdkWindow *window)
 739 {
 740   GdkWindowPrivate *private;
 741
 742   g_return_if_fail (window != NULL);
 743
 744   private = (GdkWindowPrivate*) window;
 745   if (!private->destroyed && !private->mapped)
 746     {
 747       private->mapped = TRUE;
 748       XRaiseWindow (private->xdisplay, private->xwindow);
 749       XMapWindow (private->xdisplay, private->xwindow);
 750     }
 751 }
 752
 753 void
 754 gdk_window_hide (GdkWindow *window)
 755 {
 756   GdkWindowPrivate *private;
 757
 758   g_return_if_fail (window != NULL);
 759
 760   private = (GdkWindowPrivate*) window;
 761   if (!private->destroyed && private->mapped)
 762     {
 763       private->mapped = FALSE;
 764       XUnmapWindow (private->xdisplay, private->xwindow);
 765     }
 766 }
 767
 768 void
 769 gdk_window_withdraw (GdkWindow *window)
 770 {
 771   GdkWindowPrivate *private;
 772
 773   g_return_if_fail (window != NULL);
 774
 775   private = (GdkWindowPrivate*) window;
 776   if (!private->destroyed)
 777     XWithdrawWindow (private->xdisplay, private->xwindow, 0);
 778 }
 779
 780 void
 781 gdk_window_move (GdkWindow *window,
 782                  gint       x,
 783                  gint       y)
 784 {
 785   GdkWindowPrivate *private;
 786
 787   g_return_if_fail (window != NULL);
 788
 789   private = (GdkWindowPrivate*) window;
 790   if (!private->destroyed)
 791     {
 792       XMoveWindow (private->xdisplay, private->xwindow, x, y);
 793
 794       if (private->window_type == GDK_WINDOW_CHILD)
 795         {
 796           private->x = x;
 797           private->y = y;
 798         }
 799     }
 800 }
 801
 802 void
 803 gdk_window_resize (GdkWindow *window,
 804                    gint       width,
 805                    gint       height)
 806 {
 807   GdkWindowPrivate *private;
 808
 809   g_return_if_fail (window != NULL);
 810
 811   if (width < 1)
 812     width = 1;
 813   if (height < 1)
 814     height = 1;
 815
 816   private = (GdkWindowPrivate*) window;
 817
 818   if (!private->destroyed &&
 819       ((private->resize_count > 0) ||
 820        (private->width != (guint16) width) ||
 821        (private->height != (guint16) height)))
 822     {
 823       XResizeWindow (private->xdisplay, private->xwindow, width, height);
 824       private->resize_count += 1;
 825
 826       if (private->window_type == GDK_WINDOW_CHILD)
 827         {
 828           private->width = width;
 829           private->height = height;
 830         }
 831     }
 832 }
 833
 834 void
 835 gdk_window_move_resize (GdkWindow *window,
 836                         gint       x,
 837                         gint       y,
 838                         gint       width,
 839                         gint       height)
 840 {
 841   GdkWindowPrivate *private;
 842
 843   g_return_if_fail (window != NULL);
 844
 845   if (width < 1)
 846     width = 1;
 847   if (height < 1)
 848     height = 1;
 849
 850   private = (GdkWindowPrivate*) window;
 851   if (!private->destroyed)
 852     {
 853       XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height);
 854
 855       if (private->window_type == GDK_WINDOW_CHILD)
 856         {
 857           private->x = x;
 858           private->y = y;
 859           private->width = width;
 860           private->height = height;
 861         }
 862     }
 863 }
 864
 865 void
 866 gdk_window_reparent (GdkWindow *window,
 867                      GdkWindow *new_parent,
 868                      gint       x,
 869                      gint       y)
 870 {
 871   GdkWindowPrivate *window_private;
 872   GdkWindowPrivate *parent_private;
 873   GdkWindowPrivate *old_parent_private;
 874
 875   g_return_if_fail (window != NULL);
 876
 877   if (!new_parent)
 878     new_parent = (GdkWindow*) &gdk_root_parent;
 879
 880   window_private = (GdkWindowPrivate*) window;
 881   old_parent_private = (GdkWindowPrivate*)window_private->parent;
 882   parent_private = (GdkWindowPrivate*) new_parent;
 883
 884   if (!window_private->destroyed && !parent_private->destroyed)
 885     XReparentWindow (window_private->xdisplay,
 886                      window_private->xwindow,
 887                      parent_private->xwindow,
 888                      x, y);
 889
 890   window_private->parent = new_parent;
 891
 892   if (old_parent_private)
 893     old_parent_private->children = g_list_remove (old_parent_private->children, window);
 894
 895   if ((old_parent_private &&
 896        (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
 897       (!old_parent_private && parent_private->guffaw_gravity))
 898     gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
 899
 900   parent_private->children = g_list_prepend (parent_private->children, window);
 901 }
 902
 903 void
 904 gdk_window_clear (GdkWindow *window)
 905 {
 906   GdkWindowPrivate *private;
 907
 908   g_return_if_fail (window != NULL);
 909
 910   private = (GdkWindowPrivate*) window;
 911
 912   if (!private->destroyed)
 913     XClearWindow (private->xdisplay, private->xwindow);
 914 }
 915
 916 void
 917 gdk_window_clear_area (GdkWindow *window,
 918                        gint       x,
 919                        gint       y,
 920                        gint       width,
 921                        gint       height)
 922 {
 923   GdkWindowPrivate *private;
 924
 925   g_return_if_fail (window != NULL);
 926
 927   private = (GdkWindowPrivate*) window;
 928
 929   if (!private->destroyed)
 930     XClearArea (private->xdisplay, private->xwindow,
 931                 x, y, width, height, False);
 932 }
 933
 934 void
 935 gdk_window_clear_area_e (GdkWindow *window,
 936                          gint       x,
 937                          gint       y,
 938                          gint       width,
 939                          gint       height)
 940 {
 941   GdkWindowPrivate *private;
 942
 943   g_return_if_fail (window != NULL);
 944
 945   private = (GdkWindowPrivate*) window;
 946
 947   if (!private->destroyed)
 948     XClearArea (private->xdisplay, private->xwindow,
 949                 x, y, width, height, True);
 950 }
 951
 952 void
 953 gdk_window_copy_area (GdkWindow    *window,
 954                       GdkGC        *gc,
 955                       gint          x,
 956                       gint          y,
 957                       GdkWindow    *source_window,
 958                       gint          source_x,
 959                       gint          source_y,
 960                       gint          width,
 961                       gint          height)
 962 {
 963   GdkWindowPrivate *src_private;
 964   GdkWindowPrivate *dest_private;
 965   GdkGCPrivate *gc_private;
 966
 967   g_return_if_fail (window != NULL);
 968   g_return_if_fail (gc != NULL);
 969
 970   if (source_window == NULL)
 971     source_window = window;
 972
 973   src_private = (GdkWindowPrivate*) source_window;
 974   dest_private = (GdkWindowPrivate*) window;
 975   gc_private = (GdkGCPrivate*) gc;
 976
 977   if (!src_private->destroyed && !dest_private->destroyed)
 978     {
 979       XCopyArea (dest_private->xdisplay, src_private->xwindow, dest_private->xwindow,
 980                  gc_private->xgc,
 981                  source_x, source_y,
 982                  width, height,
 983                  x, y);
 984     }
 985 }
 986
 987 void
 988 gdk_window_raise (GdkWindow *window)
 989 {
 990   GdkWindowPrivate *private;
 991
 992   g_return_if_fail (window != NULL);
 993
 994   private = (GdkWindowPrivate*) window;
 995
 996   if (!private->destroyed)
 997     XRaiseWindow (private->xdisplay, private->xwindow);
 998 }
 999
1000 void
1001 gdk_window_lower (GdkWindow *window)
1002 {
1003   GdkWindowPrivate *private;
1004
1005   g_return_if_fail (window != NULL);
1006
1007   private = (GdkWindowPrivate*) window;
1008
1009   if (!private->destroyed)
1010     XLowerWindow (private->xdisplay, private->xwindow);
1011 }
1012
1013 void
1014 gdk_window_set_user_data (GdkWindow *window,
1015                           gpointer   user_data)
1016 {
1017   g_return_if_fail (window != NULL);
1018
1019   window->user_data = user_data;
1020 }
1021
1022 void
1023 gdk_window_set_hints (GdkWindow *window,
1024                       gint       x,
1025                       gint       y,
1026                       gint       min_width,
1027                       gint       min_height,
1028                       gint       max_width,
1029                       gint       max_height,
1030                       gint       flags)
1031 {
1032   GdkWindowPrivate *private;
1033   XSizeHints size_hints;
1034
1035   g_return_if_fail (window != NULL);
1036
1037   private = (GdkWindowPrivate*) window;
1038   if (private->destroyed)
1039     return;
1040
1041   size_hints.flags = 0;
1042
1043   if (flags & GDK_HINT_POS)
1044     {
1045       size_hints.flags |= PPosition;
1046       size_hints.x = x;
1047       size_hints.y = y;
1048     }
1049
1050   if (flags & GDK_HINT_MIN_SIZE)
1051     {
1052       size_hints.flags |= PMinSize;
1053       size_hints.min_width = min_width;
1054       size_hints.min_height = min_height;
1055     }
1056
1057   if (flags & GDK_HINT_MAX_SIZE)
1058     {
1059       size_hints.flags |= PMaxSize;
1060       size_hints.max_width = max_width;
1061       size_hints.max_height = max_height;
1062     }
1063
1064   if (flags)
1065     XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
1066 }
1067
1068 void
1069 gdk_window_set_geometry_hints (GdkWindow      *window,
1070                                GdkGeometry    *geometry,
1071                                GdkWindowHints  geom_mask)
1072 {
1073   GdkWindowPrivate *private;
1074   XSizeHints size_hints;
1075
1076   g_return_if_fail (window != NULL);
1077
1078   private = (GdkWindowPrivate*) window;
1079   if (private->destroyed)
1080     return;
1081
1082   size_hints.flags = 0;
1083
1084   if (geom_mask & GDK_HINT_POS)
1085     size_hints.flags |= PPosition;
1086
1087   if (geom_mask & GDK_HINT_MIN_SIZE)
1088     {
1089       size_hints.flags |= PMinSize;
1090       size_hints.min_width = geometry->min_width;
1091       size_hints.min_height = geometry->min_height;
1092     }
1093
1094   if (geom_mask & GDK_HINT_MAX_SIZE)
1095     {
1096       size_hints.flags |= PMaxSize;
1097       size_hints.max_width = geometry->max_width;
1098       size_hints.max_height = geometry->max_height;
1099     }
1100
1101   if (geom_mask & GDK_HINT_BASE_SIZE)
1102     {
1103       size_hints.flags |= PBaseSize;
1104       size_hints.base_width = geometry->base_width;
1105       size_hints.base_height = geometry->base_height;
1106     }
1107
1108   if (geom_mask & GDK_HINT_RESIZE_INC)
1109     {
1110       size_hints.flags |= PResizeInc;
1111       size_hints.width_inc = geometry->width_inc;
1112       size_hints.height_inc = geometry->height_inc;
1113     }
1114
1115   if (geom_mask & GDK_HINT_ASPECT)
1116     {
1117       size_hints.flags |= PAspect;
1118       if (geometry->min_aspect <= 1)
1119         {
1120           size_hints.min_aspect.x = G_MAXINT * geometry->min_aspect;
1121           size_hints.min_aspect.y = G_MAXINT;
1122         }
1123       else
1124         {
1125           size_hints.min_aspect.x = G_MAXINT;
1126           size_hints.min_aspect.y = G_MAXINT / geometry->min_aspect;;
1127         }
1128       if (geometry->max_aspect <= 1)
1129         {
1130           size_hints.max_aspect.x = G_MAXINT * geometry->max_aspect;
1131           size_hints.max_aspect.y = G_MAXINT;
1132         }
1133       else
1134         {
1135           size_hints.max_aspect.x = G_MAXINT;
1136           size_hints.max_aspect.y = G_MAXINT / geometry->max_aspect;;
1137         }
1138     }
1139
1140   if (geom_mask)
1141     XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
1142 }
1143
1144 void
1145 gdk_window_set_title (GdkWindow   *window,
1146                       const gchar *title)
1147 {
1148   GdkWindowPrivate *private;
1149
1150   g_return_if_fail (window != NULL);
1151
1152   private = (GdkWindowPrivate*) window;
1153   if (!private->destroyed)
1154     XmbSetWMProperties (private->xdisplay, private->xwindow,
1155                         title, title, NULL, 0, NULL, NULL, NULL);
1156 }
1157
1158 void
1159 gdk_window_set_role (GdkWindow   *window,
1160                      const gchar *role)
1161 {
1162   GdkWindowPrivate *private;
1163
1164   g_return_if_fail (window != NULL);
1165
1166   private = (GdkWindowPrivate*) window;
1167
1168   if (role)
1169     XChangeProperty (private->xdisplay, private->xwindow,
1170                      gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
1171                      8, PropModeReplace, role, strlen(role));
1172   else
1173     XDeleteProperty (private->xdisplay, private->xwindow,
1174                      gdk_atom_intern ("WM_WINDOW_ROLE", FALSE));
1175 }
1176
1177 void
1178 gdk_window_set_transient_for (GdkWindow *window,
1179                               GdkWindow *parent)
1180 {
1181   GdkWindowPrivate *private;
1182   GdkWindowPrivate *parent_private;
1183
1184   g_return_if_fail (window != NULL);
1185
1186   private = (GdkWindowPrivate*) window;
1187   parent_private = (GdkWindowPrivate*) parent;
1188
1189   if (!private->destroyed && !parent_private->destroyed)
1190     XSetTransientForHint (private->xdisplay,
1191                           private->xwindow, parent_private->xwindow);
1192 }
1193
1194 void
1195 gdk_window_set_background (GdkWindow *window,
1196                            GdkColor  *color)
1197 {
1198   GdkWindowPrivate *private;
1199
1200   g_return_if_fail (window != NULL);
1201
1202   private = (GdkWindowPrivate*) window;
1203   if (!private->destroyed)
1204     XSetWindowBackground (private->xdisplay, private->xwindow, color->pixel);
1205 }
1206
1207 void
1208 gdk_window_set_back_pixmap (GdkWindow *window,
1209                             GdkPixmap *pixmap,
1210                             gint       parent_relative)
1211 {
1212   GdkWindowPrivate *window_private;
1213   GdkPixmapPrivate *pixmap_private;
1214   Pixmap xpixmap;
1215
1216   g_return_if_fail (window != NULL);
1217
1218   window_private = (GdkWindowPrivate*) window;
1219   pixmap_private = (GdkPixmapPrivate*) pixmap;
1220
1221   if (pixmap)
1222     xpixmap = pixmap_private->xwindow;
1223   else
1224     xpixmap = None;
1225
1226   if (parent_relative)
1227     xpixmap = ParentRelative;
1228
1229   if (!window_private->destroyed)
1230     XSetWindowBackgroundPixmap (window_private->xdisplay, window_private->xwindow, xpixmap);
1231 }
1232
1233 void
1234 gdk_window_set_cursor (GdkWindow *window,
1235                        GdkCursor *cursor)
1236 {
1237   GdkWindowPrivate *window_private;
1238   GdkCursorPrivate *cursor_private;
1239   Cursor xcursor;
1240
1241   g_return_if_fail (window != NULL);
1242
1243   window_private = (GdkWindowPrivate*) window;
1244   cursor_private = (GdkCursorPrivate*) cursor;
1245
1246   if (!cursor)
1247     xcursor = None;
1248   else
1249     xcursor = cursor_private->xcursor;
1250
1251   if (!window_private->destroyed)
1252     XDefineCursor (window_private->xdisplay, window_private->xwindow, xcursor);
1253 }
1254
1255 void
1256 gdk_window_set_colormap (GdkWindow   *window,
1257                          GdkColormap *colormap)
1258 {
1259   GdkWindowPrivate *window_private;
1260   GdkColormapPrivate *colormap_private;
1261
1262   g_return_if_fail (window != NULL);
1263   g_return_if_fail (colormap != NULL);
1264
1265   window_private = (GdkWindowPrivate*) window;
1266   colormap_private = (GdkColormapPrivate*) colormap;
1267
1268   if (!window_private->destroyed)
1269     {
1270       XSetWindowColormap (window_private->xdisplay,
1271                           window_private->xwindow,
1272                           colormap_private->xcolormap);
1273
1274       if (window_private->colormap)
1275         gdk_colormap_unref (window_private->colormap);
1276       window_private->colormap = colormap;
1277       gdk_colormap_ref (window_private->colormap);
1278
1279       if (window_private->window_type != GDK_WINDOW_TOPLEVEL)
1280         gdk_window_add_colormap_windows (window);
1281     }
1282 }
1283
1284 void
1285 gdk_window_get_user_data (GdkWindow *window,
1286                           gpointer  *data)
1287 {
1288   g_return_if_fail (window != NULL);
1289
1290   *data = window->user_data;
1291 }
1292
1293 void
1294 gdk_window_get_geometry (GdkWindow *window,
1295                          gint      *x,
1296                          gint      *y,
1297                          gint      *width,
1298                          gint      *height,
1299                          gint      *depth)
1300 {
1301   GdkWindowPrivate *window_private;
1302   Window root;
1303   gint tx;
1304   gint ty;
1305   guint twidth;
1306   guint theight;
1307   guint tborder_width;
1308   guint tdepth;
1309
1310   if (!window)
1311     window = (GdkWindow*) &gdk_root_parent;
1312
1313   window_private = (GdkWindowPrivate*) window;
1314
1315   if (!window_private->destroyed)
1316     {
1317       XGetGeometry (window_private->xdisplay, window_private->xwindow,
1318                     &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth);
1319
1320       if (x)
1321         *x = tx;
1322       if (y)
1323         *y = ty;
1324       if (width)
1325         *width = twidth;
1326       if (height)
1327         *height = theight;
1328       if (depth)
1329         *depth = tdepth;
1330     }
1331 }
1332
1333 void
1334 gdk_window_get_position (GdkWindow *window,
1335                          gint      *x,
1336                          gint      *y)
1337 {
1338   GdkWindowPrivate *window_private;
1339
1340   g_return_if_fail (window != NULL);
1341
1342   window_private = (GdkWindowPrivate*) window;
1343
1344   if (x)
1345     *x = window_private->x;
1346   if (y)
1347     *y = window_private->y;
1348 }
1349
1350 void
1351 gdk_window_get_size (GdkWindow *window,
1352                      gint       *width,
1353                      gint       *height)
1354 {
1355   GdkWindowPrivate *window_private;
1356
1357   g_return_if_fail (window != NULL);
1358
1359   window_private = (GdkWindowPrivate*) window;
1360
1361   if (width)
1362     *width = window_private->width;
1363   if (height)
1364     *height = window_private->height;
1365 }
1366
1367 GdkVisual*
1368 gdk_window_get_visual (GdkWindow *window)
1369 {
1370   GdkWindowPrivate *window_private;
1371   XWindowAttributes window_attributes;
1372
1373   g_return_val_if_fail (window != NULL, NULL);
1374
1375   window_private = (GdkWindowPrivate*) window;
1376   /* Huh? ->parent is never set for a pixmap. We should just return
1377    * null immeditately
1378    */
1379   while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP))
1380     window_private = (GdkWindowPrivate*) window_private->parent;
1381
1382   if (window_private && !window_private->destroyed)
1383     {
1384        if (window_private->colormap == NULL)
1385          {
1386             XGetWindowAttributes (window_private->xdisplay,
1387                                   window_private->xwindow,
1388                                   &window_attributes);
1389             return gdk_visual_lookup (window_attributes.visual);
1390          }
1391        else
1392          return ((GdkColormapPrivate *)window_private->colormap)->visual;
1393     }
1394
1395   return NULL;
1396 }
1397
1398 GdkColormap*
1399 gdk_window_get_colormap (GdkWindow *window)
1400 {
1401   GdkWindowPrivate *window_private;
1402   XWindowAttributes window_attributes;
1403
1404   g_return_val_if_fail (window != NULL, NULL);
1405   window_private = (GdkWindowPrivate*) window;
1406
1407   g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
1408   if (!window_private->destroyed)
1409     {
1410       if (window_private->colormap == NULL)
1411         {
1412           XGetWindowAttributes (window_private->xdisplay,
1413                                 window_private->xwindow,
1414                                 &window_attributes);
1415           return gdk_colormap_lookup (window_attributes.colormap);
1416          }
1417        else
1418          return window_private->colormap;
1419     }
1420
1421   return NULL;
1422 }
1423
1424 GdkWindowType
1425 gdk_window_get_type (GdkWindow *window)
1426 {
1427   GdkWindowPrivate *window_private;
1428
1429   g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
1430
1431   window_private = (GdkWindowPrivate*) window;
1432   return window_private->window_type;
1433 }
1434
1435 gint
1436 gdk_window_get_origin (GdkWindow *window,
1437                        gint      *x,
1438                        gint      *y)
1439 {
1440   GdkWindowPrivate *private;
1441   gint return_val;
1442   Window child;
1443   gint tx = 0;
1444   gint ty = 0;
1445
1446   g_return_val_if_fail (window != NULL, 0);
1447
1448   private = (GdkWindowPrivate*) window;
1449
1450   if (!private->destroyed)
1451     {
1452       return_val = XTranslateCoordinates (private->xdisplay,
1453                                           private->xwindow,
1454                                           gdk_root_window,
1455                                           0, 0, &tx, &ty,
1456                                           &child);
1457
1458     }
1459   else
1460     return_val = 0;
1461
1462   if (x)
1463     *x = tx;
1464   if (y)
1465     *y = ty;
1466
1467   return return_val;
1468 }
1469
1470 gboolean
1471 gdk_window_get_deskrelative_origin (GdkWindow *window,
1472                                     gint      *x,
1473                                     gint      *y)
1474 {
1475   GdkWindowPrivate *private;
1476   gboolean return_val = FALSE;
1477   gint num_children, format_return;
1478   Window win, *child, parent, root;
1479   gint tx = 0;
1480   gint ty = 0;
1481   Atom type_return;
1482   static Atom atom = 0;
1483   gulong number_return, bytes_after_return;
1484   guchar *data_return;
1485
1486   g_return_val_if_fail (window != NULL, 0);
1487
1488   private = (GdkWindowPrivate*) window;
1489
1490   if (!private->destroyed)
1491     {
1492       if (!atom)
1493         atom = XInternAtom(private->xdisplay, "ENLIGHTENMENT_DESKTOP", False);
1494       win = private->xwindow;
1495
1496       while (XQueryTree(private->xdisplay, win, &root, &parent,
1497                         &child, (unsigned int *)&num_children))
1498         {
1499           if ((child) && (num_children > 0))
1500             XFree(child);
1501
1502           if (!parent)
1503             break;
1504           else
1505             win = parent;
1506
1507           if (win == root)
1508             break;
1509
1510           data_return = NULL;
1511           XGetWindowProperty(private->xdisplay, win, atom, 0, 0,
1512                              False, XA_CARDINAL, &type_return, &format_return,
1513                              &number_return, &bytes_after_return, &data_return);
1514           if (type_return == XA_CARDINAL)
1515             {
1516               XFree(data_return);
1517               break;
1518             }
1519         }
1520
1521       return_val = XTranslateCoordinates (private->xdisplay,
1522                                           private->xwindow,
1523                                           win,
1524                                           0, 0, &tx, &ty,
1525                                           &root);
1526       if (x)
1527         *x = tx;
1528       if (y)
1529         *y = ty;
1530     }
1531
1532
1533   return return_val;
1534 }
1535
1536 void
1537 gdk_window_get_root_origin (GdkWindow *window,
1538                             gint      *x,
1539                             gint      *y)
1540 {
1541   GdkWindowPrivate *private;
1542   Window xwindow;
1543   Window xparent;
1544   Window root;
1545   Window *children;
1546   unsigned int nchildren;
1547
1548   g_return_if_fail (window != NULL);
1549
1550   private = (GdkWindowPrivate*) window;
1551   if (x)
1552     *x = 0;
1553   if (y)
1554     *y = 0;
1555   if (private->destroyed)
1556     return;
1557
1558   while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
1559     private = (GdkWindowPrivate*) private->parent;
1560   if (private->destroyed)
1561     return;
1562
1563   xparent = private->xwindow;
1564   do
1565     {
1566       xwindow = xparent;
1567       if (!XQueryTree (private->xdisplay, xwindow,
1568                        &root, &xparent,
1569                        &children, &nchildren))
1570         return;
1571
1572       if (children)
1573         XFree (children);
1574     }
1575   while (xparent != root);
1576
1577   if (xparent == root)
1578     {
1579       unsigned int ww, wh, wb, wd;
1580       int wx, wy;
1581
1582       if (XGetGeometry (private->xdisplay, xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
1583         {
1584           if (x)
1585             *x = wx;
1586           if (y)
1587             *y = wy;
1588         }
1589     }
1590 }
1591
1592 GdkWindow*
1593 gdk_window_get_pointer (GdkWindow       *window,
1594                         gint            *x,
1595                         gint            *y,
1596                         GdkModifierType *mask)
1597 {
1598   GdkWindowPrivate *private;
1599   GdkWindow *return_val;
1600   Window root;
1601   Window child;
1602   int rootx, rooty;
1603   int winx = 0;
1604   int winy = 0;
1605   unsigned int xmask = 0;
1606
1607   if (!window)
1608     window = (GdkWindow*) &gdk_root_parent;
1609
1610   private = (GdkWindowPrivate*) window;
1611
1612   return_val = NULL;
1613   if (!private->destroyed &&
1614       XQueryPointer (private->xdisplay, private->xwindow, &root, &child,
1615                      &rootx, &rooty, &winx, &winy, &xmask))
1616     {
1617       if (child)
1618         return_val = gdk_window_lookup (child);
1619     }
1620
1621   if (x)
1622     *x = winx;
1623   if (y)
1624     *y = winy;
1625   if (mask)
1626     *mask = xmask;
1627
1628   return return_val;
1629 }
1630
1631 GdkWindow*
1632 gdk_window_at_pointer (gint *win_x,
1633                        gint *win_y)
1634 {
1635   GdkWindowPrivate *private;
1636   GdkWindow *window;
1637   Window root;
1638   Window xwindow;
1639   Window xwindow_last = 0;
1640   int rootx = -1, rooty = -1;
1641   int winx, winy;
1642   unsigned int xmask;
1643
1644   private = &gdk_root_parent;
1645
1646   xwindow = private->xwindow;
1647
1648   XGrabServer (private->xdisplay);
1649   while (xwindow)
1650     {
1651       xwindow_last = xwindow;
1652       XQueryPointer (private->xdisplay,
1653                      xwindow,
1654                      &root, &xwindow,
1655                      &rootx, &rooty,
1656                      &winx, &winy,
1657                      &xmask);
1658     }
1659   XUngrabServer (private->xdisplay);
1660
1661   window = gdk_window_lookup (xwindow_last);
1662
1663   if (win_x)
1664     *win_x = window ? winx : -1;
1665   if (win_y)
1666     *win_y = window ? winy : -1;
1667
1668   return window;
1669 }
1670
1671 GdkWindow*
1672 gdk_window_get_parent (GdkWindow *window)
1673 {
1674   g_return_val_if_fail (window != NULL, NULL);
1675
1676   return ((GdkWindowPrivate*) window)->parent;
1677 }
1678
1679 GdkWindow*
1680 gdk_window_get_toplevel (GdkWindow *window)
1681 {
1682   GdkWindowPrivate *private;
1683
1684   g_return_val_if_fail (window != NULL, NULL);
1685
1686   private = (GdkWindowPrivate*) window;
1687
1688   while (private->window_type == GDK_WINDOW_CHILD)
1689     {
1690       window = ((GdkWindowPrivate*) window)->parent;
1691       private = (GdkWindowPrivate*) window;
1692     }
1693
1694   return window;
1695 }
1696
1697 GList*
1698 gdk_window_get_children (GdkWindow *window)
1699 {
1700   GdkWindowPrivate *private;
1701   GdkWindow *child;
1702   GList *children;
1703   Window root;
1704   Window parent;
1705   Window *xchildren;
1706   unsigned int nchildren;
1707   unsigned int i;
1708
1709   g_return_val_if_fail (window != NULL, NULL);
1710
1711   private = (GdkWindowPrivate*) window;
1712   if (private->destroyed)
1713     return NULL;
1714
1715   XQueryTree (private->xdisplay, private->xwindow,
1716               &root, &parent, &xchildren, &nchildren);
1717
1718   children = NULL;
1719
1720   if (nchildren > 0)
1721     {
1722       for (i = 0; i < nchildren; i++)
1723         {
1724           child = gdk_window_lookup (xchildren[i]);
1725           if (child)
1726             children = g_list_prepend (children, child);
1727         }
1728
1729       if (xchildren)
1730         XFree (xchildren);
1731     }
1732
1733   return children;
1734 }
1735
1736 GdkEventMask
1737 gdk_window_get_events      (GdkWindow       *window)
1738 {
1739   GdkWindowPrivate *private;
1740   XWindowAttributes attrs;
1741   GdkEventMask event_mask;
1742   int i;
1743
1744   g_return_val_if_fail (window != NULL, 0);
1745
1746   private = (GdkWindowPrivate*) window;
1747   if (private->destroyed)
1748     return 0;
1749
1750   XGetWindowAttributes (gdk_display, private->xwindow,
1751                         &attrs);
1752
1753   event_mask = 0;
1754   for (i = 0; i < gdk_nevent_masks; i++)
1755     {
1756       if (attrs.your_event_mask & gdk_event_mask_table[i])
1757         event_mask |= 1 << (i + 1);
1758     }
1759
1760   return event_mask;
1761 }
1762
1763 void
1764 gdk_window_set_events      (GdkWindow       *window,
1765                             GdkEventMask     event_mask)
1766 {
1767   GdkWindowPrivate *private;
1768   long xevent_mask;
1769   int i;
1770
1771   g_return_if_fail (window != NULL);
1772
1773   private = (GdkWindowPrivate*) window;
1774   if (private->destroyed)
1775     return;
1776
1777   xevent_mask = StructureNotifyMask;
1778   for (i = 0; i < gdk_nevent_masks; i++)
1779     {
1780       if (event_mask & (1 << (i + 1)))
1781         xevent_mask |= gdk_event_mask_table[i];
1782     }
1783
1784   XSelectInput (gdk_display, private->xwindow,
1785                 xevent_mask);
1786 }
1787
1788 void
1789 gdk_window_add_colormap_windows (GdkWindow *window)
1790 {
1791   GdkWindow *toplevel;
1792   GdkWindowPrivate *toplevel_private;
1793   GdkWindowPrivate *window_private;
1794   Window *old_windows;
1795   Window *new_windows;
1796   int i, count;
1797
1798   g_return_if_fail (window != NULL);
1799
1800   toplevel = gdk_window_get_toplevel (window);
1801   toplevel_private = (GdkWindowPrivate*) toplevel;
1802   window_private = (GdkWindowPrivate*) window;
1803   if (window_private->destroyed)
1804     return;
1805
1806   old_windows = NULL;
1807   if (!XGetWMColormapWindows (toplevel_private->xdisplay,
1808                               toplevel_private->xwindow,
1809                               &old_windows, &count))
1810     {
1811       count = 0;
1812     }
1813
1814   for (i = 0; i < count; i++)
1815     if (old_windows[i] == window_private->xwindow)
1816       {
1817         XFree (old_windows);
1818         return;
1819       }
1820
1821   new_windows = g_new (Window, count + 1);
1822
1823   for (i = 0; i < count; i++)
1824     new_windows[i] = old_windows[i];
1825   new_windows[count] = window_private->xwindow;
1826
1827   XSetWMColormapWindows (toplevel_private->xdisplay,
1828                          toplevel_private->xwindow,
1829                          new_windows, count + 1);
1830
1831   g_free (new_windows);
1832   if (old_windows)
1833     XFree (old_windows);
1834 }
1835
1836 static gboolean
1837 gdk_window_have_shape_ext (void)
1838 {
1839   enum { UNKNOWN, NO, YES };
1840   static gint have_shape = UNKNOWN;
1841
1842   if (have_shape == UNKNOWN)
1843     {
1844       int ignore;
1845       if (XQueryExtension(gdk_display, "SHAPE", &ignore, &ignore, &ignore))
1846         have_shape = YES;
1847       else
1848         have_shape = NO;
1849     }
1850
1851   return (have_shape == YES);
1852 }
1853
1854 /*
1855  * This needs the X11 shape extension.
1856  * If not available, shaped windows will look
1857  * ugly, but programs still work.    Stefan Wille
1858  */
1859 void
1860 gdk_window_shape_combine_mask (GdkWindow *window,
1861                                GdkBitmap *mask,
1862                                gint x, gint y)
1863 {
1864   GdkWindowPrivate *window_private;
1865   Pixmap pixmap;
1866
1867   g_return_if_fail (window != NULL);
1868
1869 #ifdef HAVE_SHAPE_EXT
1870   window_private = (GdkWindowPrivate*) window;
1871   if (window_private->destroyed)
1872     return;
1873
1874   if (gdk_window_have_shape_ext())
1875     {
1876       if (mask)
1877         {
1878           GdkWindowPrivate *pixmap_private;
1879
1880           pixmap_private = (GdkWindowPrivate*) mask;
1881           pixmap = (Pixmap) pixmap_private->xwindow;
1882         }
1883       else
1884         {
1885           x = 0;
1886           y = 0;
1887           pixmap = None;
1888         }
1889
1890       XShapeCombineMask  (window_private->xdisplay,
1891                           window_private->xwindow,
1892                           ShapeBounding,
1893                           x, y,
1894                           pixmap,
1895                           ShapeSet);
1896     }
1897 #endif /* HAVE_SHAPE_EXT */
1898 }
1899
1900 void
1901 gdk_window_add_filter     (GdkWindow     *window,
1902                            GdkFilterFunc  function,
1903                            gpointer       data)
1904 {
1905   GdkWindowPrivate *private;
1906   GList *tmp_list;
1907   GdkEventFilter *filter;
1908
1909   private = (GdkWindowPrivate*) window;
1910   if (private && private->destroyed)
1911     return;
1912
1913   if(private)
1914     tmp_list = private->filters;
1915   else
1916     tmp_list = gdk_default_filters;
1917
1918   while (tmp_list)
1919     {
1920       filter = (GdkEventFilter *)tmp_list->data;
1921       if ((filter->function == function) && (filter->data == data))
1922         return;
1923       tmp_list = tmp_list->next;
1924     }
1925
1926   filter = g_new (GdkEventFilter, 1);
1927   filter->function = function;
1928   filter->data = data;
1929
1930   if(private)
1931     private->filters = g_list_append (private->filters, filter);
1932   else
1933     gdk_default_filters = g_list_append (gdk_default_filters, filter);
1934 }
1935
1936 void
1937 gdk_window_remove_filter  (GdkWindow     *window,
1938                            GdkFilterFunc  function,
1939                            gpointer       data)
1940 {
1941   GdkWindowPrivate *private;
1942   GList *tmp_list, *node;
1943   GdkEventFilter *filter;
1944
1945   private = (GdkWindowPrivate*) window;
1946
1947   if(private)
1948     tmp_list = private->filters;
1949   else
1950     tmp_list = gdk_default_filters;
1951
1952   while (tmp_list)
1953     {
1954       filter = (GdkEventFilter *)tmp_list->data;
1955       node = tmp_list;
1956       tmp_list = tmp_list->next;
1957
1958       if ((filter->function == function) && (filter->data == data))
1959         {
1960           if(private)
1961             private->filters = g_list_remove_link (private->filters, node);
1962           else
1963             gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
1964           g_list_free_1 (node);
1965           g_free (filter);
1966
1967           return;
1968         }
1969     }
1970 }
1971
1972 void
1973 gdk_window_set_override_redirect(GdkWindow *window,
1974                                  gboolean override_redirect)
1975 {
1976   GdkWindowPrivate *private;
1977   XSetWindowAttributes attr;
1978
1979   g_return_if_fail (window != NULL);
1980   private = (GdkWindowPrivate*) window;
1981   if (private->destroyed)
1982     return;
1983
1984   attr.override_redirect = (override_redirect == FALSE)?False:True;
1985   XChangeWindowAttributes(gdk_display,
1986                           ((GdkWindowPrivate *)window)->xwindow,
1987                           CWOverrideRedirect,
1988                           &attr);
1989 }
1990
1991 void
1992 gdk_window_set_icon        (GdkWindow *window,
1993                             GdkWindow *icon_window,
1994                             GdkPixmap *pixmap,
1995                             GdkBitmap *mask)
1996 {
1997   XWMHints wm_hints;
1998   GdkWindowPrivate *window_private;
1999   GdkWindowPrivate *private;
2000
2001   g_return_if_fail (window != NULL);
2002   window_private = (GdkWindowPrivate*) window;
2003   if (window_private->destroyed)
2004     return;
2005
2006   wm_hints.flags = 0;
2007
2008   if (icon_window != NULL)
2009     {
2010       private = (GdkWindowPrivate *)icon_window;
2011       wm_hints.flags |= IconWindowHint;
2012       wm_hints.icon_window = private->xwindow;
2013     }
2014
2015   if (pixmap != NULL)
2016     {
2017       private = (GdkWindowPrivate *)pixmap;
2018       wm_hints.flags |= IconPixmapHint;
2019       wm_hints.icon_pixmap = private->xwindow;
2020     }
2021
2022   if (mask != NULL)
2023     {
2024       private = (GdkWindowPrivate *)mask;
2025       wm_hints.flags |= IconMaskHint;
2026       wm_hints.icon_mask = private->xwindow;
2027     }
2028
2029   XSetWMHints (window_private->xdisplay, window_private->xwindow, &wm_hints);
2030 }
2031
2032 void
2033 gdk_window_set_icon_name   (GdkWindow *window,
2034                             gchar *    name)
2035 {
2036   GdkWindowPrivate *window_private;
2037   XTextProperty property;
2038   gint res;
2039
2040   g_return_if_fail (window != NULL);
2041   window_private = (GdkWindowPrivate*) window;
2042   if (window_private->destroyed)
2043     return;
2044   res = XmbTextListToTextProperty (window_private->xdisplay,
2045                                    &name, 1, XStdICCTextStyle,
2046                                    &property);
2047   if (res < 0)
2048     {
2049       g_warning("Error converting icon name to text property: %d\n", res);
2050       return;
2051     }
2052
2053   XSetWMIconName (window_private->xdisplay, window_private->xwindow,
2054                   &property);
2055
2056   if (property.value)
2057     XFree (property.value);
2058 }
2059
2060 void
2061 gdk_window_set_group   (GdkWindow *window,
2062                         GdkWindow *leader)
2063 {
2064   XWMHints wm_hints;
2065   GdkWindowPrivate *window_private;
2066   GdkWindowPrivate *private;
2067
2068   g_return_if_fail (window != NULL);
2069   g_return_if_fail (leader != NULL);
2070   window_private = (GdkWindowPrivate*) window;
2071   if (window_private->destroyed)
2072     return;
2073
2074   private = (GdkWindowPrivate *)leader;
2075   wm_hints.flags = WindowGroupHint;
2076   wm_hints.window_group = private->xwindow;
2077
2078   XSetWMHints (window_private->xdisplay, window_private->xwindow, &wm_hints);
2079 }
2080
2081 static void
2082 gdk_window_set_mwm_hints (GdkWindow *window,
2083                           MotifWmHints *new_hints)
2084 {
2085   static Atom hints_atom = None;
2086   MotifWmHints *hints;
2087   Atom type;
2088   gint format;
2089   gulong nitems;
2090   gulong bytes_after;
2091
2092   GdkWindowPrivate *window_private;
2093
2094   g_return_if_fail (window != NULL);
2095   window_private = (GdkWindowPrivate*) window;
2096   if (window_private->destroyed)
2097     return;
2098
2099   if (!hints_atom)
2100     hints_atom = XInternAtom (window_private->xdisplay,
2101                               _XA_MOTIF_WM_HINTS, FALSE);
2102
2103   XGetWindowProperty (window_private->xdisplay, window_private->xwindow,
2104                       hints_atom, 0, sizeof(MotifWmHints)/4,
2105                       False, AnyPropertyType, &type, &format, &nitems,
2106                       &bytes_after, (guchar **)&hints);
2107
2108   if (type == None)
2109     hints = new_hints;
2110   else
2111     {
2112       if (new_hints->flags & MWM_HINTS_FUNCTIONS)
2113         {
2114           hints->flags |= MWM_HINTS_FUNCTIONS;
2115           hints->functions = new_hints->functions;
2116         }
2117       if (new_hints->flags & MWM_HINTS_DECORATIONS)
2118         {
2119           hints->flags |= MWM_HINTS_DECORATIONS;
2120           hints->decorations = new_hints->decorations;
2121         }
2122     }
2123
2124   XChangeProperty (window_private->xdisplay, window_private->xwindow,
2125                    hints_atom, hints_atom, 32, PropModeReplace,
2126                    (guchar *)hints, sizeof(MotifWmHints)/4);
2127
2128   if (hints != new_hints)
2129     XFree (hints);
2130 }
2131
2132 void
2133 gdk_window_set_decorations (GdkWindow      *window,
2134                             GdkWMDecoration decorations)
2135 {
2136   MotifWmHints hints;
2137
2138   hints.flags = MWM_HINTS_DECORATIONS;
2139   hints.decorations = decorations;
2140
2141   gdk_window_set_mwm_hints (window, &hints);
2142 }
2143
2144 void
2145 gdk_window_set_functions (GdkWindow    *window,
2146                           GdkWMFunction functions)
2147 {
2148   MotifWmHints hints;
2149
2150   hints.flags = MWM_HINTS_FUNCTIONS;
2151   hints.functions = functions;
2152
2153   gdk_window_set_mwm_hints (window, &hints);
2154 }
2155
2156 GList *
2157 gdk_window_get_toplevels (void)
2158 {
2159   GList *new_list = NULL;
2160   GList *tmp_list;
2161
2162   tmp_list = gdk_root_parent.children;
2163   while (tmp_list)
2164     {
2165       new_list = g_list_prepend (new_list, tmp_list->data);
2166       tmp_list = tmp_list->next;
2167     }
2168
2169   return new_list;
2170 }
2171
2172 /*
2173  * propagate the shapes from all child windows of a GDK window to the parent
2174  * window. Shamelessly ripped from Enlightenment's code
2175  *
2176  * - Raster
2177  */
2178
2179 struct _gdk_span
2180 {
2181    gint                start;
2182    gint                end;
2183    struct _gdk_span    *next;
2184 };
2185
2186 static void
2187 gdk_add_to_span(struct _gdk_span **s, int x, int xx)
2188 {
2189    struct _gdk_span   *ptr1, *ptr2, *noo, *ss;
2190    gchar               spanning;
2191
2192    ptr2 = NULL;
2193    ptr1 = *s;
2194    spanning = 0;
2195    ss = NULL;
2196    /* scan the spans for this line */
2197    while (ptr1)
2198      {
2199         /* -- -> new span */
2200         /* == -> existing span */
2201         /* ## -> spans intersect */
2202         /* if we are in the middle of spanning the span into the line */
2203         if (spanning)
2204           {
2205              /* case: ---- ==== */
2206              if (xx < ptr1->start - 1)
2207                {
2208                   /* ends before next span - extend to here */
2209                   ss->end = xx;
2210                   return;
2211                }
2212              /* case: ----##=== */
2213              else if (xx <= ptr1->end)
2214                {
2215                   /* crosses into next span - delete next span and append */
2216                   ss->end = ptr1->end;
2217                   ss->next = ptr1->next;
2218                   g_free(ptr1);
2219                   return;
2220                }
2221              /* case: ---###--- */
2222              else
2223                {
2224                   /* overlaps next span - delete and keep checking */
2225                   ss->next = ptr1->next;
2226                   g_free(ptr1);
2227                   ptr1 = ss;
2228                }
2229           }
2230         /* otherwise havent started spanning it in yet */
2231         else
2232           {
2233              /* case: ---- ==== */
2234              if (xx < ptr1->start - 1)
2235                {
2236                   /* insert span here in list */
2237                   noo = g_malloc(sizeof(struct _gdk_span));
2238
2239                   if (noo)
2240                     {
2241                        noo->start = x;
2242                        noo->end = xx;
2243                        noo->next = ptr1;
2244                        if (ptr2)
2245                          ptr2->next = noo;
2246                        else
2247                          *s = noo;
2248                     }
2249                   return;
2250                }
2251              /* case: ----##=== */
2252              else if ((x < ptr1->start) && (xx <= ptr1->end))
2253                {
2254                   /* expand this span to the left point of the new one */
2255                   ptr1->start = x;
2256                   return;
2257                }
2258              /* case: ===###=== */
2259              else if ((x >= ptr1->start) && (xx <= ptr1->end))
2260                {
2261                   /* throw the span away */
2262                   return;
2263                }
2264              /* case: ---###--- */
2265              else if ((x < ptr1->start) && (xx > ptr1->end))
2266                {
2267                   ss = ptr1;
2268                   spanning = 1;
2269                   ptr1->start = x;
2270                   ptr1->end = xx;
2271                }
2272              /* case: ===##---- */
2273              else if ((x >= ptr1->start) && (x <= ptr1->end + 1) && (xx > ptr1->end))
2274                {
2275                   ss = ptr1;
2276                   spanning = 1;
2277                   ptr1->end = xx;
2278                }
2279              /* case: ==== ---- */
2280              /* case handled by next loop iteration - first case */
2281           }
2282         ptr2 = ptr1;
2283         ptr1 = ptr1->next;
2284      }
2285    /* it started in the middle but spans beyond your current list */
2286    if (spanning)
2287      {
2288         ptr2->end = xx;
2289         return;
2290      }
2291    /* it does not start inside a span or in the middle, so add it to the end */
2292    noo = g_malloc(sizeof(struct _gdk_span));
2293
2294    if (noo)
2295      {
2296         noo->start = x;
2297         noo->end = xx;
2298         if (ptr2)
2299           {
2300              noo->next = ptr2->next;
2301              ptr2->next = noo;
2302           }
2303         else
2304           {
2305              noo->next = NULL;
2306              *s = noo;
2307           }
2308      }
2309    return;
2310 }
2311
2312 static void
2313 gdk_add_rectangles (Display *disp, Window win, struct _gdk_span **spans,
2314                     gint basew, gint baseh, gint x, gint y)
2315 {
2316   gint a, k;
2317   gint x1, y1, x2, y2;
2318   gint rn, ord;
2319   XRectangle *rl;
2320
2321   rl = XShapeGetRectangles(disp, win, ShapeBounding, &rn, &ord);
2322   if (rl)
2323     {
2324       /* go through all clip rects in this window's shape */
2325       for (k = 0; k < rn; k++)
2326         {
2327           /* for each clip rect, add it to each line's spans */
2328           x1 = x + rl[k].x;
2329           x2 = x + rl[k].x + (rl[k].width - 1);
2330           y1 = y + rl[k].y;
2331           y2 = y + rl[k].y + (rl[k].height - 1);
2332           if (x1 < 0)
2333             x1 = 0;
2334           if (y1 < 0)
2335             y1 = 0;
2336           if (x2 >= basew)
2337             x2 = basew - 1;
2338           if (y2 >= baseh)
2339             y2 = baseh - 1;
2340           for (a = y1; a <= y2; a++)
2341             {
2342               if ((x2 - x1) >= 0)
2343                 gdk_add_to_span(&spans[a], x1, x2);
2344             }
2345         }
2346       XFree(rl);
2347     }
2348 }
2349
2350 static void
2351 gdk_propagate_shapes(Display *disp, Window win, gboolean merge)
2352 {
2353    Window              rt, par, *list = NULL;
2354    gint                i, j, num = 0, num_rects = 0;
2355    gint                x, y, contig;
2356    guint               w, h, d;
2357    gint                baseh, basew;
2358    XRectangle         *rects = NULL;
2359    struct _gdk_span  **spans = NULL, *ptr1, *ptr2, *ptr3;
2360    XWindowAttributes   xatt;
2361
2362    XGetGeometry(disp, win, &rt, &x, &y, &w, &h, &d, &d);
2363    if (h <= 0)
2364      return;
2365    basew = w;
2366    baseh = h;
2367    spans = g_malloc(sizeof(struct _gdk_span *) * h);
2368
2369    for (i = 0; i < h; i++)
2370      spans[i] = NULL;
2371    XQueryTree(disp, win, &rt, &par, &list, (unsigned int *)&num);
2372    if (list)
2373      {
2374         /* go through all child windows and create/insert spans */
2375         for (i = 0; i < num; i++)
2376           {
2377              if (XGetWindowAttributes(disp, list[i], &xatt) && (xatt.map_state != IsUnmapped))
2378                if (XGetGeometry(disp, list[i], &rt, &x, &y, &w, &h, &d, &d))
2379                  gdk_add_rectangles (disp, list[i], spans, basew, baseh, x, y);
2380           }
2381         if (merge)
2382           gdk_add_rectangles (disp, win, spans, basew, baseh, x, y);
2383
2384         /* go through the spans list and build a list of rects */
2385         rects = g_malloc(sizeof(XRectangle) * 256);
2386         num_rects = 0;
2387         for (i = 0; i < baseh; i++)
2388           {
2389              ptr1 = spans[i];
2390              /* go through the line for all spans */
2391              while (ptr1)
2392                {
2393                   rects[num_rects].x = ptr1->start;
2394                   rects[num_rects].y = i;
2395                   rects[num_rects].width = ptr1->end - ptr1->start + 1;
2396                   rects[num_rects].height = 1;
2397                   j = i + 1;
2398                   /* if there are more lines */
2399                   contig = 1;
2400                   /* while contigous rects (same start/end coords) exist */
2401                   while ((contig) && (j < baseh))
2402                     {
2403                        /* search next line for spans matching this one */
2404                        contig = 0;
2405                        ptr2 = spans[j];
2406                        ptr3 = NULL;
2407                        while (ptr2)
2408                          {
2409                             /* if we have an exact span match set contig */
2410                             if ((ptr2->start == ptr1->start) &&
2411                                 (ptr2->end == ptr1->end))
2412                               {
2413                                  contig = 1;
2414                                  /* remove the span - not needed */
2415                                  if (ptr3)
2416                                    {
2417                                       ptr3->next = ptr2->next;
2418                                       g_free(ptr2);
2419                                       ptr2 = NULL;
2420                                    }
2421                                  else
2422                                    {
2423                                       spans[j] = ptr2->next;
2424                                       g_free(ptr2);
2425                                       ptr2 = NULL;
2426                                    }
2427                                  break;
2428                               }
2429                             /* gone past the span point no point looking */
2430                             else if (ptr2->start < ptr1->start)
2431                               break;
2432                             if (ptr2)
2433                               {
2434                                  ptr3 = ptr2;
2435                                  ptr2 = ptr2->next;
2436                               }
2437                          }
2438                        /* if a contiguous span was found increase the rect h */
2439                        if (contig)
2440                          {
2441                             rects[num_rects].height++;
2442                             j++;
2443                          }
2444                     }
2445                   /* up the rect count */
2446                   num_rects++;
2447                   /* every 256 new rects increase the rect array */
2448                   if ((num_rects % 256) == 0)
2449                     rects = g_realloc(rects, sizeof(XRectangle) * (num_rects + 256));
2450                   ptr1 = ptr1->next;
2451                }
2452           }
2453         /* set the rects as the shape mask */
2454         if (rects)
2455           {
2456              XShapeCombineRectangles(disp, win, ShapeBounding, 0, 0, rects, num_rects,
2457                                      ShapeSet, YXSorted);
2458              g_free(rects);
2459           }
2460         XFree(list);
2461      }
2462    /* free up all the spans we made */
2463    for (i = 0; i < baseh; i++)
2464      {
2465         ptr1 = spans[i];
2466         while (ptr1)
2467           {
2468              ptr2 = ptr1;
2469              ptr1 = ptr1->next;
2470              g_free(ptr2);
2471           }
2472      }
2473    g_free(spans);
2474 }
2475
2476 void
2477 gdk_window_set_child_shapes (GdkWindow *window)
2478 {
2479   GdkWindowPrivate *private;
2480
2481   g_return_if_fail (window != NULL);
2482
2483 #ifdef HAVE_SHAPE_EXT
2484   private = (GdkWindowPrivate*) window;
2485   if (private->destroyed)
2486     return;
2487
2488   if (gdk_window_have_shape_ext())
2489     gdk_propagate_shapes (private->xdisplay, private->xwindow, FALSE);
2490 #endif
2491 }
2492
2493 void
2494 gdk_window_merge_child_shapes (GdkWindow *window)
2495 {
2496   GdkWindowPrivate *private;
2497
2498   g_return_if_fail (window != NULL);
2499
2500 #ifdef HAVE_SHAPE_EXT
2501   private = (GdkWindowPrivate*) window;
2502   if (private->destroyed)
2503     return;
2504
2505   if (gdk_window_have_shape_ext())
2506     gdk_propagate_shapes (private->xdisplay, private->xwindow, TRUE);
2507 #endif
2508 }
2509
2510 /*************************************************************
2511  * gdk_window_is_visible:
2512  *     Check if the given window is mapped.
2513  *   arguments:
2514  *     window:
2515  *   results:
2516  *     is the window mapped
2517  *************************************************************/
2518
2519 gboolean
2520 gdk_window_is_visible (GdkWindow *window)
2521 {
2522   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2523
2524   g_return_val_if_fail (window != NULL, FALSE);
2525
2526   return private->mapped;
2527 }
2528
2529 /*************************************************************
2530  * gdk_window_is_viewable:
2531  *     Check if the window and all ancestors of the window
2532  *     are mapped. (This is not necessarily "viewable" in
2533  *     the X sense, since we only check as far as we have
2534  *     GDK window parents, not to the root window)
2535  *   arguments:
2536  *     window:
2537  *   results:
2538  *     is the window viewable
2539  *************************************************************/
2540
2541 gboolean
2542 gdk_window_is_viewable (GdkWindow *window)
2543 {
2544   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2545
2546   g_return_val_if_fail (window != NULL, FALSE);
2547
2548   while (private &&
2549          (private != &gdk_root_parent) &&
2550          (private->window_type != GDK_WINDOW_FOREIGN))
2551     {
2552       if (!private->mapped)
2553         return FALSE;
2554
2555       private = (GdkWindowPrivate *)private->parent;
2556     }
2557
2558   return TRUE;
2559 }
2560
2561 void
2562 gdk_drawable_set_data (GdkDrawable   *drawable,
2563                        const gchar   *key,
2564                        gpointer       data,
2565                        GDestroyNotify destroy_func)
2566 {
2567   g_dataset_set_data_full (drawable, key, data, destroy_func);
2568 }
2569
2570
2571 /* Support for windows that can be guffaw-scrolled
2572  * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2573  */
2574
2575 static gboolean
2576 gdk_window_gravity_works (void)
2577 {
2578   enum { UNKNOWN, NO, YES };
2579   static gint gravity_works = UNKNOWN;
2580
2581   if (gravity_works == UNKNOWN)
2582     {
2583       GdkWindowAttr attr;
2584       GdkWindow *parent;
2585       GdkWindow *child;
2586       gint y;
2587
2588       /* This particular server apparently has a bug so that the test
2589        * works but the actual code crashes it
2590        */
2591       if ((!strcmp (XServerVendor (gdk_display), "Sun Microsystems, Inc.")) &&
2592           (VendorRelease (gdk_display) == 3400))
2593         {
2594           gravity_works = NO;
2595           return FALSE;
2596         }
2597
2598       attr.window_type = GDK_WINDOW_TEMP;
2599       attr.wclass = GDK_INPUT_OUTPUT;
2600       attr.x = 0;
2601       attr.y = 0;
2602       attr.width = 100;
2603       attr.height = 100;
2604       attr.event_mask = 0;
2605
2606       parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2607
2608       attr.window_type = GDK_WINDOW_CHILD;
2609       child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2610
2611       gdk_window_set_static_win_gravity (child, TRUE);
2612
2613       gdk_window_resize (parent, 100, 110);
2614       gdk_window_move (parent, 0, -10);
2615       gdk_window_move_resize (parent, 0, 0, 100, 100);
2616
2617       gdk_window_resize (parent, 100, 110);
2618       gdk_window_move (parent, 0, -10);
2619       gdk_window_move_resize (parent, 0, 0, 100, 100);
2620
2621       gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2622
2623       gdk_window_destroy (parent);
2624       gdk_window_destroy (child);
2625
2626       gravity_works = ((y == -20) ? YES : NO);
2627     }
2628
2629   return (gravity_works == YES);
2630 }
2631
2632 static void
2633 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2634 {
2635   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2636   XSetWindowAttributes xattributes;
2637
2638   g_return_if_fail (window != NULL);
2639
2640   xattributes.bit_gravity = on ? StaticGravity : ForgetGravity;
2641   XChangeWindowAttributes (private->xdisplay,
2642                            private->xwindow,
2643                            CWBitGravity,  &xattributes);
2644 }
2645
2646 static void
2647 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2648 {
2649   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2650   XSetWindowAttributes xattributes;
2651
2652   g_return_if_fail (window != NULL);
2653
2654   xattributes.win_gravity = on ? StaticGravity : NorthWestGravity;
2655
2656   XChangeWindowAttributes (private->xdisplay,
2657                            private->xwindow,
2658                            CWWinGravity,  &xattributes);
2659 }
2660
2661 /*************************************************************
2662  * gdk_window_set_static_gravities:
2663  *     Set the bit gravity of the given window to static,
2664  *     and flag it so all children get static subwindow
2665  *     gravity.
2666  *   arguments:
2667  *     window: window for which to set static gravity
2668  *     use_static: Whether to turn static gravity on or off.
2669  *   results:
2670  *     Does the XServer support static gravity?
2671  *************************************************************/
2672
2673 gboolean
2674 gdk_window_set_static_gravities (GdkWindow *window,
2675                                  gboolean   use_static)
2676 {
2677   GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2678   GList *tmp_list;
2679
2680   g_return_val_if_fail (window != NULL, FALSE);
2681
2682   if (!use_static == !private->guffaw_gravity)
2683     return TRUE;
2684
2685   if (use_static && !gdk_window_gravity_works ())
2686     return FALSE;
2687
2688   private->guffaw_gravity = use_static;
2689
2690   gdk_window_set_static_bit_gravity (window, use_static);
2691
2692   tmp_list = private->children;
2693   while (tmp_list)
2694     {
2695       gdk_window_set_static_win_gravity (window, use_static);
2696
2697       tmp_list = tmp_list->next;
2698     }
2699
2700   return TRUE;
2701 }