}static GdkEventMaskx_event_mask_to_gdk_event_mask (long mask){  GdkEventMask event_mask = 0;  int i;  for (i = 0; i < _gdk_nenvent_masks; i++)    {      if (mask & _gdk_event_mask_table[i])	event_mask |= 1 << (i + 1);    }  return event_mask;}/** * gdk_window_foreign_new_for_display: * @display: the #GdkDisplay where the window handle comes from. * @anid: a native window handle. *  * Wraps a native window in a #GdkWindow. * This may fail if the window has been destroyed. If the window * was already known to GDK, a new reference to the existing  * #GdkWindow is returned. * * For example in the X backend, a native window handle is an Xlib * <type>XID</type>. *  * Return value: a #GdkWindow wrapper for the native window or  *   %NULL if the window has been destroyed. The wrapper will be *   newly created, if one doesn't exist already. * * Since: 2.2 **/GdkWindow *gdk_window_foreign_new_for_display (GdkDisplay     *display,				    GdkNativeWindow anid){  GdkWindow *window;  GdkWindowObject *private;  GdkWindowImplX11 *impl;  GdkDrawableImplX11 *draw_impl;  GdkDisplayX11 *display_x11;  XWindowAttributes attrs;  Window root, parent;  Window *children = NULL;  guint nchildren;  gboolean result;  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);  display_x11 = GDK_DISPLAY_X11 (display);  if ((window = gdk_xid_table_lookup_for_display (display, anid)) != NULL)    return g_object_ref (window);  gdk_error_trap_push ();  result = XGetWindowAttributes (display_x11->xdisplay, anid, &attrs);  if (gdk_error_trap_pop () || !result)    return NULL;  /* FIXME: This is pretty expensive. Maybe the caller should supply   *        the parent */  gdk_error_trap_push ();  result = XQueryTree (display_x11->xdisplay, anid, &root, &parent, &children, &nchildren);  if (gdk_error_trap_pop () || !result)    return NULL;  if (children)    XFree (children);    window = g_object_new (GDK_TYPE_WINDOW, NULL);  private = (GdkWindowObject *)window;  impl = GDK_WINDOW_IMPL_X11 (private->impl);  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);  draw_impl->wrapper = GDK_DRAWABLE (window);  draw_impl->screen = _gdk_x11_display_screen_for_xrootwin (display, root);    private->parent = gdk_xid_table_lookup_for_display (display, parent);    if (!private->parent || GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_FOREIGN)    private->parent = (GdkWindowObject *) gdk_screen_get_root_window (draw_impl->screen);    private->parent->children = g_list_prepend (private->parent->children, window);  draw_impl->xid = anid;  private->x = attrs.x;  private->y = attrs.y;  impl->width = attrs.width;  impl->height = attrs.height;  private->window_type = GDK_WINDOW_FOREIGN;  private->destroyed = FALSE;  private->event_mask = x_event_mask_to_gdk_event_mask (attrs.your_event_mask);  if (attrs.map_state == IsUnmapped)    private->state = GDK_WINDOW_STATE_WITHDRAWN;  else    private->state = 0;  private->depth = attrs.depth;    _gdk_window_init_position (GDK_WINDOW (private));  g_object_ref (window);  _gdk_xid_table_insert (display, &GDK_WINDOW_XID (window), window);  return window;}/** * gdk_window_lookup_for_display: * @display: the #GdkDisplay corresponding to the window handle * @anid: a native window handle. * * Looks up the #GdkWindow that wraps the given native window handle. * * For example in the X backend, a native window handle is an Xlib * <type>XID</type>. * * Return value: the #GdkWindow wrapper for the native window,  *    or %NULL if there is none. * * Since: 2.2 **/GdkWindow *gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid){  return (GdkWindow*) gdk_xid_table_lookup_for_display (display, anid);}/** * gdk_window_lookup: * @anid: a native window handle. * * Looks up the #GdkWindow that wraps the given native window handle.  * * For example in the X backend, a native window handle is an Xlib * <type>XID</type>. * * Return value: the #GdkWindow wrapper for the native window,  *    or %NULL if there is none. **/GdkWindow *gdk_window_lookup (GdkNativeWindow anid){  return (GdkWindow*) gdk_xid_table_lookup (anid);}static voidgdk_toplevel_x11_free_contents (GdkDisplay *display,				GdkToplevelX11 *toplevel){  if (toplevel->icon_window)    {      g_object_unref (toplevel->icon_window);      toplevel->icon_window = NULL;    }  if (toplevel->icon_pixmap)    {      g_object_unref (toplevel->icon_pixmap);      toplevel->icon_pixmap = NULL;    }  if (toplevel->icon_mask)    {      g_object_unref (toplevel->icon_mask);      toplevel->icon_mask = NULL;    }  if (toplevel->group_leader)    {      g_object_unref (toplevel->group_leader);      toplevel->group_leader = NULL;    }#ifdef HAVE_XSYNC  if (toplevel->update_counter != None)    {      XSyncDestroyCounter (GDK_DISPLAY_XDISPLAY (display), 			   toplevel->update_counter);      toplevel->update_counter = None;      XSyncIntToValue (&toplevel->current_counter_value, 0);    }#endif}void_gdk_windowing_window_destroy (GdkWindow *window,			       gboolean   recursing,			       gboolean   foreign_destroy){  GdkWindowObject *private = (GdkWindowObject *)window;  GdkToplevelX11 *toplevel;  GdkDrawableImplX11 *draw_impl;    g_return_if_fail (GDK_IS_WINDOW (window));  _gdk_selection_window_destroyed (window);    if (private->extension_events != 0)    _gdk_input_window_destroy (window);  toplevel = _gdk_x11_window_get_toplevel (window);  if (toplevel)    gdk_toplevel_x11_free_contents (GDK_WINDOW_DISPLAY (window), toplevel);  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);      if (draw_impl->xft_draw)    XftDrawDestroy (draw_impl->xft_draw);  if (!recursing && !foreign_destroy)    {      XDestroyWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));    }}void_gdk_windowing_window_destroy_foreign (GdkWindow *window){  /* It's somebody else's window, but in our heirarchy,   * so reparent it to the root window, and then send   * it a delete event, as if we were a WM   */  XClientMessageEvent xevent;    gdk_error_trap_push ();  gdk_window_hide (window);  gdk_window_reparent (window, NULL, 0, 0);    xevent.type = ClientMessage;  xevent.window = GDK_WINDOW_XID (window);  xevent.message_type = gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window),							       "WM_PROTOCOLS");  xevent.format = 32;  xevent.data.l[0] = gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window),							    "WM_DELETE_WINDOW");  xevent.data.l[1] = CurrentTime;  xevent.data.l[2] = 0;  xevent.data.l[3] = 0;  xevent.data.l[4] = 0;    XSendEvent (GDK_WINDOW_XDISPLAY (window),	      GDK_WINDOW_XID (window),	      False, 0, (XEvent *)&xevent);  gdk_display_sync (GDK_WINDOW_DISPLAY (window));  gdk_error_trap_pop ();}static GdkWindow *get_root (GdkWindow *window){  GdkScreen *screen = gdk_drawable_get_screen (window);  return gdk_screen_get_root_window (screen);}/* This function is called when the XWindow is really gone. */voidgdk_window_destroy_notify (GdkWindow *window){  GdkWindowImplX11 *window_impl;  g_return_if_fail (window != NULL);    window_impl = GDK_WINDOW_IMPL_X11 (((GdkWindowObject *)window)->impl);  if (!GDK_WINDOW_DESTROYED (window))    {      if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)	g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_WINDOW_XID (window));      _gdk_window_destroy (window, TRUE);    }    _gdk_xid_table_remove (GDK_WINDOW_DISPLAY (window), GDK_WINDOW_XID (window));  if (window_impl->toplevel && window_impl->toplevel->focus_window)    _gdk_xid_table_remove (GDK_WINDOW_DISPLAY (window), window_impl->toplevel->focus_window);  _gdk_xgrab_check_destroy (window);    g_object_unref (window);}static voidupdate_wm_hints (GdkWindow *window,		 gboolean   force){  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);  GdkWindowObject *private = (GdkWindowObject *)window;  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);  XWMHints wm_hints;  if (!force &&      !toplevel->is_leader &&      private->state & GDK_WINDOW_STATE_WITHDRAWN)    return;  wm_hints.flags = StateHint | InputHint;  wm_hints.input = private->accept_focus ? True : False;  wm_hints.initial_state = NormalState;    if (private->state & GDK_WINDOW_STATE_ICONIFIED)    {      wm_hints.flags |= StateHint;      wm_hints.initial_state = IconicState;    }  if (toplevel->icon_window && !GDK_WINDOW_DESTROYED (toplevel->icon_window))    {      wm_hints.flags |= IconWindowHint;      wm_hints.icon_window = GDK_WINDOW_XID (toplevel->icon_window);    }  if (toplevel->icon_pixmap)    {      wm_hints.flags |= IconPixmapHint;      wm_hints.icon_pixmap = GDK_PIXMAP_XID (toplevel->icon_pixmap);    }  if (toplevel->icon_mask)    {      wm_hints.flags |= IconMaskHint;      wm_hints.icon_mask = GDK_PIXMAP_XID (toplevel->icon_mask);    }    wm_hints.flags |= WindowGroupHint;  if (toplevel->group_leader && !GDK_WINDOW_DESTROYED (toplevel->group_leader))    {      wm_hints.flags |= WindowGroupHint;      wm_hints.window_group = GDK_WINDOW_XID (toplevel->group_leader);    }  else    wm_hints.window_group = GDK_DISPLAY_X11 (display)->leader_window;    XSetWMHints (GDK_WINDOW_XDISPLAY (window),	       GDK_WINDOW_XID (window),	       &wm_hints);}static voidset_initial_hints (GdkWindow *window){  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);  Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);  Window xwindow = GDK_WINDOW_XID (window);    GdkWindowObject *private;  GdkToplevelX11 *toplevel;  Atom atoms[7];  gint i;  private = (GdkWindowObject*) window;  toplevel = _gdk_x11_window_get_toplevel (window);  if (!toplevel)    return;  update_wm_hints (window, TRUE);    /* We set the spec hints regardless of whether the spec is supported,   * since it can't hurt and it's kind of expensive to check whether   * it's supported.   */    i = 0;  if (private->state & GDK_WINDOW_STATE_MAXIMIZED)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_MAXIMIZED_VERT");      ++i;      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_MAXIMIZED_HORZ");      ++i;    }  if (private->state & GDK_WINDOW_STATE_ABOVE)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_ABOVE");      ++i;    }    if (private->state & GDK_WINDOW_STATE_BELOW)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_BELOW");      ++i;    }    if (private->state & GDK_WINDOW_STATE_STICKY)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_STICKY");      ++i;    }  if (private->state & GDK_WINDOW_STATE_FULLSCREEN)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_FULLSCREEN");      ++i;    }  if (private->modal_hint)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_MODAL");      ++i;    }  if (toplevel->skip_taskbar_hint)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_SKIP_TASKBAR");      ++i;    }  if (toplevel->skip_pager_hint)    {      atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,							"_NET_WM_STATE_SKIP_PAGER");      ++i;    }  if (i > 0)    {      XChangeProperty (xdisplay,                       xwindow,		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"),                       XA_ATOM, 32, PropModeReplace,                       (guchar*) atoms, i);    }  else     {      XDeleteProperty (xdisplay,                       xwindow,		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"));    }  if (private->state & GDK_WINDOW_STATE_STICKY)    {      atoms[0] = 0xFFFFFFFF;      XChangeProperty (xdisplay,                       xwindow,		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),                       XA_CARDINAL, 32, PropModeReplace,                       (guchar*) atoms, 1);    }  else    {      XDeleteProperty (xdisplay,                       xwindow,		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"));    }  toplevel->map_serial = NextRequest (xdisplay);}static voidshow_window_internal (GdkWindow *window,                      gboolean   raise){  GdkWindowObject *private;  GdkDisplay *display;  GdkDisplayX11 *display_x11;