/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,

 * Josh MacDonald, Ryan Lortie

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2007.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include "gdk.h"

#include "gdkprivate-x11.h"

#include "gdkinternals.h"

#include "gdkx.h"

#include "gdkscreen-x11.h"

#include "gdkdisplay-x11.h"

#include "gdkasync.h"

#include "gdkkeysyms.h"

#include "xsettings-client.h"

#include <string.h>

#include "gdkinputprivate.h"

#include "gdksettings.c"

#include "gdkalias.h"

#ifdef HAVE_XKB

#include <X11/XKBlib.h>

#endif

#ifdef HAVE_XSYNC

#include <X11/extensions/sync.h>

#endif

#ifdef HAVE_XFIXES

#include <X11/extensions/Xfixes.h>

#endif

#ifdef HAVE_RANDR

#include <X11/extensions/Xrandr.h>

#endif

#include <X11/Xatom.h>

typedef struct _GdkIOClosure GdkIOClosure;

typedef struct _GdkDisplaySource GdkDisplaySource;

typedef struct _GdkEventTypeX11 GdkEventTypeX11;

struct _GdkIOClosure

{

  GdkInputFunction function;

  GdkInputCondition condition;

  GDestroyNotify notify;

  gpointer data;

};

struct _GdkDisplaySource

{

  GSource source;

  GdkDisplay *display;

  GPollFD event_poll_fd;

};

struct _GdkEventTypeX11

{

  gint base;

  gint n_events;

};

/* 

 * Private function declarations

 */

static gint	 gdk_event_apply_filters (XEvent   *xevent,

					  GdkEvent *event,

					  GdkWindow *window);

static gboolean	 gdk_event_translate	 (GdkDisplay *display,

					  GdkEvent   *event, 

					  XEvent     *xevent,

					  gboolean    return_exposes);

static gboolean gdk_event_prepare  (GSource     *source,

				    gint        *timeout);

static gboolean gdk_event_check    (GSource     *source);

static gboolean gdk_event_dispatch (GSource     *source,

				    GSourceFunc  callback,

				    gpointer     user_data);

static GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev,

						GdkEvent  *event,

						gpointer   data);

static GSource *gdk_display_source_new (GdkDisplay *display);

static gboolean gdk_check_xpending     (GdkDisplay *display);

static Bool gdk_xsettings_watch_cb  (Window            window,

				     Bool              is_start,

				     long              mask,

				     void             *cb_data);

static void gdk_xsettings_notify_cb (const char       *name,

				     XSettingsAction   action,

				     XSettingsSetting *setting,

				     void             *data);

/* Private variable declarations

 */

static GList *display_sources;

static GSourceFuncs event_funcs = {

  gdk_event_prepare,

  gdk_event_check,

  gdk_event_dispatch,

  NULL

};

static GSource *

gdk_display_source_new (GdkDisplay *display)

{

  GSource *source = g_source_new (&event_funcs, sizeof (GdkDisplaySource));

  GdkDisplaySource *display_source = (GdkDisplaySource *)source;

  char *name;

  name = g_strdup_printf ("GDK X11 Event source (%s)",

			  gdk_display_get_name (display));

  g_source_set_name (source, name);

  g_free (name);

  display_source->display = display;

  return source;

}

static gboolean

gdk_check_xpending (GdkDisplay *display)

{

  return XPending (GDK_DISPLAY_XDISPLAY (display));

}

/*********************************************

 * Functions for maintaining the event queue *

 *********************************************/

static void

refcounted_grab_server (Display *xdisplay)

{

  GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);

  gdk_x11_display_grab (display);

}

static void

refcounted_ungrab_server (Display *xdisplay)

{

  GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);

  gdk_x11_display_ungrab (display);

}

void

_gdk_x11_events_init_screen (GdkScreen *screen)

{

  GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);

  /* Keep a flag to avoid extra notifies that we don't need

   */

  screen_x11->xsettings_in_init = TRUE;

  screen_x11->xsettings_client = xsettings_client_new_with_grab_funcs (screen_x11->xdisplay,

						                       screen_x11->screen_num,

						                       gdk_xsettings_notify_cb,

						                       gdk_xsettings_watch_cb,

						                       screen,

                                                                       refcounted_grab_server,

                                                                       refcounted_ungrab_server);

  screen_x11->xsettings_in_init = FALSE;

}

void

_gdk_x11_events_uninit_screen (GdkScreen *screen)

{

  GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);

  if (screen_x11->xsettings_client)

    {

      xsettings_client_destroy (screen_x11->xsettings_client);

      screen_x11->xsettings_client = NULL;

    }

}

void 

_gdk_events_init (GdkDisplay *display)

{

  GSource *source;

  GdkDisplaySource *display_source;

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);

  int connection_number = ConnectionNumber (display_x11->xdisplay);

  GDK_NOTE (MISC, g_message ("connection number: %d", connection_number));

  source = display_x11->event_source = gdk_display_source_new (display);

  display_source = (GdkDisplaySource*) source;

  g_source_set_priority (source, GDK_PRIORITY_EVENTS);

  display_source->event_poll_fd.fd = connection_number;

  display_source->event_poll_fd.events = G_IO_IN;

  g_source_add_poll (source, &display_source->event_poll_fd);

  g_source_set_can_recurse (source, TRUE);

  g_source_attach (source, NULL);

  display_sources = g_list_prepend (display_sources,display_source);

  gdk_display_add_client_message_filter (display,

					 gdk_atom_intern_static_string ("WM_PROTOCOLS"), 

					 gdk_wm_protocols_filter,   

					 NULL);

}

void

_gdk_events_uninit (GdkDisplay *display)

{

  GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);

  if (display_x11->event_source)

    {

      display_sources = g_list_remove (display_sources,

                                       display_x11->event_source);

      g_source_destroy (display_x11->event_source);

      g_source_unref (display_x11->event_source);

      display_x11->event_source = NULL;

    }

}

/**

 * gdk_events_pending:

 * 

 * Checks if any events are ready to be processed for any display.

 * 

 * Return value:  %TRUE if any events are pending.

 **/

gboolean

gdk_events_pending (void)

{

  GList *tmp_list;

  for (tmp_list = display_sources; tmp_list; tmp_list = tmp_list->next)

    {

      GdkDisplaySource *tmp_source = tmp_list->data;

      GdkDisplay *display = tmp_source->display;

      if (_gdk_event_queue_find_first (display))

	return TRUE;

    }

  for (tmp_list = display_sources; tmp_list; tmp_list = tmp_list->next)

    {

      GdkDisplaySource *tmp_source = tmp_list->data;

      GdkDisplay *display = tmp_source->display;

      if (gdk_check_xpending (display))

	return TRUE;

    }

  return FALSE;

}

static Bool

graphics_expose_predicate (Display  *display,

			   XEvent   *xevent,

			   XPointer  arg)

{

  if (xevent->xany.window == GDK_DRAWABLE_XID ((GdkDrawable *)arg) &&

      (xevent->xany.type == GraphicsExpose ||

       xevent->xany.type == NoExpose))

    return True;

  else

    return False;

}

/**

 * gdk_event_get_graphics_expose:

 * @window: the #GdkWindow to wait for the events for.

 * 

 * Waits for a GraphicsExpose or NoExpose event from the X server.

 * This is used in the #GtkText and #GtkCList widgets in GTK+ to make sure any

 * GraphicsExpose events are handled before the widget is scrolled.

 *

 * Return value:  a #GdkEventExpose if a GraphicsExpose was received, or %NULL if a

 * NoExpose event was received.

 *

 * Deprecated: 2.18:

 **/

GdkEvent*

gdk_event_get_graphics_expose (GdkWindow *window)

{

  XEvent xevent;

  GdkEvent *event;

  g_return_val_if_fail (window != NULL, NULL);

  XIfEvent (GDK_WINDOW_XDISPLAY (window), &xevent, 

	    graphics_expose_predicate, (XPointer) window);

  if (xevent.xany.type == GraphicsExpose)

    {

      event = gdk_event_new (GDK_NOTHING);

      if (gdk_event_translate (GDK_WINDOW_DISPLAY (window), event,

			       &xevent, TRUE))

	return event;

      else

	gdk_event_free (event);

    }

  return NULL;	

}

static gint

gdk_event_apply_filters (XEvent *xevent,

			 GdkEvent *event,

			 GdkWindow *window)

{

  GList *tmp_list;

  GdkFilterReturn result;

  if (window == NULL)

    tmp_list = _gdk_default_filters;

  else

    {

      GdkWindowObject *window_private;

      window_private = (GdkWindowObject *) window;

      tmp_list = window_private->filters;

    }

  while (tmp_list)

    {

      GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;

      GList *node;

      if ((filter->flags & GDK_EVENT_FILTER_REMOVED) != 0)

        {

          tmp_list = tmp_list->next;

          continue;

        }

      filter->ref_count++;

      result = filter->function (xevent, event, filter->data);

      /* Protect against unreffing the filter mutating the list */

      node = tmp_list->next;

      _gdk_event_filter_unref (window, filter);

      tmp_list = node;

      if (result != GDK_FILTER_CONTINUE)

        return result;

    }

  return GDK_FILTER_CONTINUE;

}

/**

 * gdk_display_add_client_message_filter:

 * @display: a #GdkDisplay for which this message filter applies

 * @message_type: the type of ClientMessage events to receive.

 *   This will be checked against the @message_type field 

 *   of the XClientMessage event struct.

 * @func: the function to call to process the event.

 * @data: user data to pass to @func.

 *

 * Adds a filter to be called when X ClientMessage events are received.

 * See gdk_window_add_filter() if you are interested in filtering other

 * types of events.

 *

 * Since: 2.2

 **/ 

void 

gdk_display_add_client_message_filter (GdkDisplay   *display,

				       GdkAtom       message_type,

				       GdkFilterFunc func,

				       gpointer      data)

{

  GdkClientFilter *filter;

  g_return_if_fail (GDK_IS_DISPLAY (display));

  filter = g_new (GdkClientFilter, 1);

  filter->type = message_type;

  filter->function = func;

  filter->data = data;

  GDK_DISPLAY_X11(display)->client_filters = 

    g_list_append (GDK_DISPLAY_X11 (display)->client_filters,

		   filter);

}

/**

 * gdk_add_client_message_filter:

 * @message_type: the type of ClientMessage events to receive. This will be

 *     checked against the <structfield>message_type</structfield> field of the

 *     XClientMessage event struct.

 * @func: the function to call to process the event.

 * @data: user data to pass to @func. 

 * 

 * Adds a filter to the default display to be called when X ClientMessage events

 * are received. See gdk_display_add_client_message_filter().

 **/

void 

gdk_add_client_message_filter (GdkAtom       message_type,

			       GdkFilterFunc func,

			       gpointer      data)

{

  gdk_display_add_client_message_filter (gdk_display_get_default (),

					 message_type, func, data);

}

static void

do_net_wm_state_changes (GdkWindow *window)

{

  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);

  GdkWindowState old_state;

  if (GDK_WINDOW_DESTROYED (window) ||

      gdk_window_get_window_type (window) != GDK_WINDOW_TOPLEVEL)

    return;

  old_state = gdk_window_get_state (window);

  /* For found_sticky to remain TRUE, we have to also be on desktop

   * 0xFFFFFFFF

   */

  if (old_state & GDK_WINDOW_STATE_STICKY)

    {

      if (!(toplevel->have_sticky && toplevel->on_all_desktops))

        gdk_synthesize_window_state (window,

                                     GDK_WINDOW_STATE_STICKY,

                                     0);

    }

  else

    {

      if (toplevel->have_sticky && toplevel->on_all_desktops)

        gdk_synthesize_window_state (window,

                                     0,

                                     GDK_WINDOW_STATE_STICKY);

    }

  if (old_state & GDK_WINDOW_STATE_FULLSCREEN)

    {

      if (!toplevel->have_fullscreen)

        gdk_synthesize_window_state (window,

                                     GDK_WINDOW_STATE_FULLSCREEN,

                                     0);

    }

  else

    {

      if (toplevel->have_fullscreen)

        gdk_synthesize_window_state (window,

                                     0,

                                     GDK_WINDOW_STATE_FULLSCREEN);

    }

  /* Our "maximized" means both vertical and horizontal; if only one,

   * we don't expose that via GDK

   */

  if (old_state & GDK_WINDOW_STATE_MAXIMIZED)

    {

      if (!(toplevel->have_maxvert && toplevel->have_maxhorz))

        gdk_synthesize_window_state (window,

                                     GDK_WINDOW_STATE_MAXIMIZED,

                                     0);

    }

  else

    {

      if (toplevel->have_maxvert && toplevel->have_maxhorz)

        gdk_synthesize_window_state (window,

                                     0,

                                     GDK_WINDOW_STATE_MAXIMIZED);

    }

  if (old_state & GDK_WINDOW_STATE_ICONIFIED)

    {

      if (!toplevel->have_hidden)

        gdk_synthesize_window_state (window,

                                     GDK_WINDOW_STATE_ICONIFIED,

                                     0);

    }

  else

    {

      if (toplevel->have_hidden)

        gdk_synthesize_window_state (window,

                                     0,

                                     GDK_WINDOW_STATE_ICONIFIED);

    }

}

static void

gdk_check_wm_desktop_changed (GdkWindow *window)

{

  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);

  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);

  Atom type;

  gint format;

  gulong nitems;

  gulong bytes_after;

  guchar *data;

  gulong *desktop;

  type = None;

  gdk_error_trap_push ();

  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), 

                      GDK_WINDOW_XID (window),

                      gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),

                      0, G_MAXLONG, False, XA_CARDINAL, &type, 

                      &format, &nitems,

                      &bytes_after, &data);

  gdk_error_trap_pop ();

  if (type != None)

    {

      desktop = (gulong *)data;

      toplevel->on_all_desktops = ((*desktop & 0xFFFFFFFF) == 0xFFFFFFFF);

      XFree (desktop);

    }

  else

    toplevel->on_all_desktops = FALSE;

  do_net_wm_state_changes (window);

}

static void

gdk_check_wm_state_changed (GdkWindow *window)

{

  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);

  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);

  Atom type;

  gint format;

  gulong nitems;

  gulong bytes_after;

  guchar *data;

  Atom *atoms = NULL;

  gulong i;

  gboolean had_sticky = toplevel->have_sticky;

  toplevel->have_sticky = FALSE;

  toplevel->have_maxvert = FALSE;

  toplevel->have_maxhorz = FALSE;

  toplevel->have_fullscreen = FALSE;

  toplevel->have_hidden = FALSE;

  type = None;

  gdk_error_trap_push ();

  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),

		      gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"),

		      0, G_MAXLONG, False, XA_ATOM, &type, &format, &nitems,

		      &bytes_after, &data);

  gdk_error_trap_pop ();

  if (type != None)

    {

      Atom sticky_atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_STICKY");

      Atom maxvert_atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_MAXIMIZED_VERT");

      Atom maxhorz_atom	= gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_MAXIMIZED_HORZ");

      Atom fullscreen_atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_FULLSCREEN");

      Atom hidden_atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_HIDDEN");

      atoms = (Atom *)data;

      i = 0;

      while (i < nitems)

        {

          if (atoms[i] == sticky_atom)

            toplevel->have_sticky = TRUE;

          else if (atoms[i] == maxvert_atom)

            toplevel->have_maxvert = TRUE;

          else if (atoms[i] == maxhorz_atom)

            toplevel->have_maxhorz = TRUE;

          else if (atoms[i] == fullscreen_atom)

            toplevel->have_fullscreen = TRUE;

          else if (atoms[i] == hidden_atom)

            toplevel->have_hidden = TRUE;

          ++i;

        }

      XFree (atoms);

    }

  /* When have_sticky is turned on, we have to check the DESKTOP property

   * as well.

   */

  if (toplevel->have_sticky && !had_sticky)

    gdk_check_wm_desktop_changed (window);

  else

    do_net_wm_state_changes (window);

}

#define HAS_FOCUS(toplevel)                           \

  ((toplevel)->has_focus || (toplevel)->has_pointer_focus)

static void

generate_focus_event (GdkWindow *window,

		      gboolean   in)

{

  GdkEvent event;

  event.type = GDK_FOCUS_CHANGE;

  event.focus_change.window = window;

  event.focus_change.send_event = FALSE;

  event.focus_change.in = in;

  gdk_event_put (&event);

}

static gboolean

set_screen_from_root (GdkDisplay *display,

		      GdkEvent   *event,

		      Window      xrootwin)

{

  GdkScreen *screen;

  screen = _gdk_x11_display_screen_for_xrootwin (display, xrootwin);

  if (screen)

    {

      gdk_event_set_screen (event, screen);

      return TRUE;

    }

  return FALSE;

}

static void

translate_key_event (GdkDisplay *display,

		     GdkEvent   *event,

		     XEvent     *xevent)

{

  GdkKeymap *keymap = gdk_keymap_get_for_display (display);

  gunichar c = 0;

  gchar buf[7];

  GdkModifierType consumed, state;

  event->key.type = xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;

  event->key.time = xevent->xkey.time;

  event->key.state = (GdkModifierType) xevent->xkey.state;

  event->key.group = _gdk_x11_get_group_for_state (display, xevent->xkey.state);

  event->key.hardware_keycode = xevent->xkey.keycode;

  event->key.keyval = GDK_VoidSymbol;

  gdk_keymap_translate_keyboard_state (keymap,

				       event->key.hardware_keycode,

				       event->key.state,

				       event->key.group,

				       &event->key.keyval,

                                       NULL, NULL, &consumed);

   state = event->key.state & ~consumed;

   _gdk_keymap_add_virtual_modifiers_compat (keymap, &state);

   event->key.state |= state;

  event->key.is_modifier = _gdk_keymap_key_is_modifier (keymap, event->key.hardware_keycode);

  /* Fill in event->string crudely, since various programs

   * depend on it.

   */

  event->key.string = NULL;

  if (event->key.keyval != GDK_VoidSymbol)

    c = gdk_keyval_to_unicode (event->key.keyval);

  if (c)

    {

      gsize bytes_written;

      gint len;

      /* Apply the control key - Taken from Xlib

       */

      if (event->key.state & GDK_CONTROL_MASK)

	{

	  if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;

	  else if (c == '2')

	    {

	      event->key.string = g_memdup ("\0\0", 2);

	      event->key.length = 1;

	      buf[0] = '\0';

	      goto out;

	    }

	  else if (c >= '3' && c <= '7') c -= ('3' - '\033');

	  else if (c == '8') c = '\177';

	  else if (c == '/') c = '_' & 0x1F;

	}

      len = g_unichar_to_utf8 (c, buf);

      buf[len] = '\0';

      event->key.string = g_locale_from_utf8 (buf, len,

					      NULL, &bytes_written,

					      NULL);

      if (event->key.string)

	event->key.length = bytes_written;

    }

  else if (event->key.keyval == GDK_Escape)

    {

      event->key.length = 1;

      event->key.string = g_strdup ("\033");

    }

  else if (event->key.keyval == GDK_Return ||

	  event->key.keyval == GDK_KP_Enter)

    {

      event->key.length = 1;

      event->key.string = g_strdup ("\r");

    }

  if (!event->key.string)

    {

      event->key.length = 0;

      event->key.string = g_strdup ("");

    }

 out:

#ifdef G_ENABLE_DEBUG

  if (_gdk_debug_flags & GDK_DEBUG_EVENTS)

    {

      g_message ("%s:\t\twindow: %ld	 key: %12s  %d",

		 event->type == GDK_KEY_PRESS ? "key press  " : "key release",

		 xevent->xkey.window,

		 event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",

		 event->key.keyval);

      if (event->key.length > 0)

	g_message ("\t\tlength: %4d string: \"%s\"",

		   event->key.length, buf);

    }

#endif /* G_ENABLE_DEBUG */  

  return;

}

/**

 * gdk_x11_register_standard_event_type:

 * @display: a #GdkDisplay

 * @event_base: first event type code to register

 * @n_events: number of event type codes to register

 * 

 * Registers interest in receiving extension events with type codes

 * between @event_base and <literal>event_base + n_events - 1</literal>.

 * The registered events must have the window field in the same place

 * as core X events (this is not the case for e.g. XKB extension events).

 *

 * If an event type is registered, events of this type will go through

 * global and window-specific filters (see gdk_window_add_filter()). 

 * Unregistered events will only go through global filters.

 * GDK may register the events of some X extensions on its own.

 * 

 * This function should only be needed in unusual circumstances, e.g.

 * when filtering XInput extension events on the root window.

 *

 * Since: 2.4

 **/

void

gdk_x11_register_standard_event_type (GdkDisplay          *display,

				      gint                 event_base,

				      gint                 n_events)

{

  GdkEventTypeX11 *event_type;

  GdkDisplayX11 *display_x11;

  display_x11 = GDK_DISPLAY_X11 (display);

  event_type = g_new (GdkEventTypeX11, 1);

  event_type->base = event_base;

  event_type->n_events = n_events;

  display_x11->event_types = g_slist_prepend (display_x11->event_types, event_type);

}

/* Return the window this has to do with, if any, rather

 * than the frame or root window that was selecting

 * for substructure

 */

static void

get_real_window (GdkDisplay *display,

		 XEvent     *event,

		 Window     *event_window,

		 Window     *filter_window)

{

  /* Core events all have an event->xany.window field, but that's

   * not true for extension events

   */

  if (event->type >= KeyPress &&

      event->type <= MappingNotify)

    {

      *filter_window = event->xany.window;

      switch (event->type)

	{      

	case CreateNotify:

	  *event_window = event->xcreatewindow.window;

	  break;

	case DestroyNotify:

	  *event_window = event->xdestroywindow.window;

	  break;

	case UnmapNotify:

	  *event_window = event->xunmap.window;

	  break;

	case MapNotify:

	  *event_window = event->xmap.window;

	  break;

	case MapRequest:

	  *event_window = event->xmaprequest.window;

	  break;

	case ReparentNotify:

	  *event_window = event->xreparent.window;

	  break;

	case ConfigureNotify:

	  *event_window = event->xconfigure.window;

	  break;

	case ConfigureRequest:

	  *event_window = event->xconfigurerequest.window;

	  break;

	case GravityNotify:

	  *event_window = event->xgravity.window;

	  break;

	case CirculateNotify:

	  *event_window = event->xcirculate.window;

	  break;

	case CirculateRequest:

	  *event_window = event->xcirculaterequest.window;

	  break;

	default:

	  *event_window = event->xany.window;

	}

    }

  else

    {

      GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);

      GSList *tmp_list;

      for (tmp_list = display_x11->event_types;

	   tmp_list;

	   tmp_list = tmp_list->next)

	{

	  GdkEventTypeX11 *event_type = tmp_list->data;

	  if (event->type >= event_type->base &&

	      event->type < event_type->base + event_type->n_events)

	    {

	      *event_window = event->xany.window;

	      *filter_window = event->xany.window;

	      return;

	    }

	}

      *event_window = None;