Remove gdk_window_add_filter

Drop the public filtering API. The x11 backend already has
the ::xevent signal as replacement. The win32 backend needs
a similar signal to replace filtering.

gdk/gdkevents.h

@@ -148,56 +148,6 @@ typedef union  _GdkEvent	    GdkEvent;
 typedef void (*GdkEventFunc) (GdkEvent *event,
 			      gpointer	data);
 
-/* Event filtering */
-
-/**
- * GdkXEvent:
- *
- * Used to represent native events (XEvents for the X11
- * backend, MSGs for Win32).
- */
-typedef void GdkXEvent;	  /* Can be cast to window system specific
-			   * even type, XEvent on X11, MSG on Win32.
-			   */
-
-/**
- * GdkFilterReturn:
- * @GDK_FILTER_CONTINUE: event not handled, continue processing.
- * @GDK_FILTER_TRANSLATE: native event translated into a GDK event and stored
- *  in the `event` structure that was passed in.
- * @GDK_FILTER_REMOVE: event handled, terminate processing.
- *
- * Specifies the result of applying a #GdkFilterFunc to a native event.
- */
-typedef enum {
-  GDK_FILTER_CONTINUE,	  /* Event not handled, continue processesing */
-  GDK_FILTER_TRANSLATE,	  /* Native event translated into a GDK event and
-                             stored in the "event" structure that was
-                             passed in */
-  GDK_FILTER_REMOVE	  /* Terminate processing, removing event */
-} GdkFilterReturn;
-
-/**
- * GdkFilterFunc:
- * @xevent: the native event to filter.
- * @event: the GDK event to which the X event will be translated.
- * @data: (closure): user data set when the filter was installed.
- *
- * Specifies the type of function used to filter native events before they are
- * converted to GDK events.
- *
- * When a filter is called, @event is unpopulated, except for
- * `event->window`. The filter may translate the native
- * event to a GDK event and store the result in @event, or handle it without
- * translation. If the filter translates the event and processing should
- * continue, it should return %GDK_FILTER_TRANSLATE.
- *
- * Returns: a #GdkFilterReturn value.
- */
-typedef GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent,
-					  GdkEvent *event,
-					  gpointer  data);
-
 /**
  * GdkEventType:
  * @GDK_NOTHING: a special code to indicate a null event.

gdk/gdkinternals.h

@@ -42,20 +42,8 @@ G_BEGIN_DECLS
 
 /* Debugging support */
 
-typedef struct _GdkEventFilter         GdkEventFilter;
 typedef struct _GdkWindowAttr          GdkWindowAttr;
 
-typedef enum {
-  GDK_EVENT_FILTER_REMOVED = 1 << 0
-} GdkEventFilterFlags;
-
-struct _GdkEventFilter {
-  GdkFilterFunc function;
-  gpointer data;
-  GdkEventFilterFlags flags;
-  guint ref_count;
-};
-
 typedef enum {
   GDK_DEBUG_MISC            = 1 <<  0,
   GDK_DEBUG_EVENTS          = 1 <<  1,
@@ -80,7 +68,6 @@ typedef enum {
   GDK_DEBUG_CAIRO_IMAGE     = 1 << 19
 } GdkDebugFlags;
 
-extern GList            *_gdk_default_filters;
 extern GdkWindow        *_gdk_parent_root;
 
 extern guint _gdk_debug_flags;
@@ -173,7 +160,6 @@ struct _GdkWindow
 
   gint8 toplevel_window_type;
 
-  GList *filters;
   GList *children;
   GList children_list_node;
 
@@ -267,9 +253,6 @@ extern gint       _gdk_screen_number;
 
 GdkEvent* _gdk_event_unqueue (GdkDisplay *display);
 
-void _gdk_event_filter_unref        (GdkWindow      *window,
-				     GdkEventFilter *filter);
-
 void     gdk_event_set_pointer_emulated (GdkEvent *event,
                                          gboolean  emulated);
 

gdk/gdkwindow.c

@@ -1109,58 +1109,6 @@ gdk_window_new_child (GdkWindow          *parent,
   return gdk_window_new (gdk_window_get_display (parent), parent, &attr);
 }
 
-/**
- * _gdk_event_filter_unref:
- * @window: (allow-none): A #GdkWindow, or %NULL to be the global window
- * @filter: A window filter
- *
- * Release a reference to @filter.  Note this function may
- * mutate the list storage, so you need to handle this
- * if iterating over a list of filters.
- */
-void
-_gdk_event_filter_unref (GdkWindow       *window,
-			 GdkEventFilter  *filter)
-{
-  GList **filters;
-  GList *tmp_list;
-
-  if (window == NULL)
-    filters = &_gdk_default_filters;
-  else
-    filters = &window->filters;
-
-  tmp_list = *filters;
-  while (tmp_list)
-    {
-      GdkEventFilter *iter_filter = tmp_list->data;
-      GList *node;
-
-      node = tmp_list;
-      tmp_list = tmp_list->next;
-
-      if (iter_filter != filter)
-	continue;
-
-      g_assert (iter_filter->ref_count > 0);
-
-      filter->ref_count--;
-      if (filter->ref_count != 0)
-	continue;
-
-      *filters = g_list_remove_link (*filters, node);
-      g_free (filter);
-      g_list_free_1 (node);
-    }
-}
-
-static void
-window_remove_filters (GdkWindow *window)
-{
-  while (window->filters)
-    _gdk_event_filter_unref (window, window->filters->data);
-}
-
 static void
 update_pointer_info_foreach (GdkDisplay           *display,
                              GdkDevice            *device,
@@ -1253,12 +1201,6 @@ _gdk_window_destroy_hierarchy (GdkWindow *window,
     case GDK_WINDOW_SUBSURFACE:
       if (window->window_type == GDK_WINDOW_FOREIGN && !foreign_destroy)
 	{
-	  /* For historical reasons, we remove any filters
-	   * on a foreign window when it or a parent is destroyed;
-	   * this likely causes problems if two separate portions
-	   * of code are maintaining filter lists on a foreign window.
-	   */
-	  window_remove_filters (window);
 	}
       else
 	{
@@ -1328,8 +1270,6 @@ _gdk_window_destroy_hierarchy (GdkWindow *window,
 	  window->parent = NULL;
 	  window->destroyed = TRUE;
 
-	  window_remove_filters (window);
-
 	  window_remove_from_pointer_info (window, display);
 
 	  if (window->clip_region)
@@ -1651,110 +1591,6 @@ gdk_window_get_children_with_user_data (GdkWindow *window,
 }
 
 
-/**
- * gdk_window_add_filter: (skip)
- * @window: (allow-none): a #GdkWindow
- * @function: filter callback
- * @data: data to pass to filter callback
- *
- * Adds an event filter to @window, allowing you to intercept events
- * before they reach GDK. This is a low-level operation and makes it
- * easy to break GDK and/or GTK+, so you have to know what you're
- * doing. Pass %NULL for @window to get all events for all windows,
- * instead of events for a specific window.
- *
- * If you are interested in X GenericEvents, bear in mind that
- * XGetEventData() has been already called on the event, and
- * XFreeEventData() must not be called within @function.
- **/
-void
-gdk_window_add_filter (GdkWindow     *window,
-		       GdkFilterFunc  function,
-		       gpointer       data)
-{
-  GList *tmp_list;
-  GdkEventFilter *filter;
-
-  g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
-
-  if (window && GDK_WINDOW_DESTROYED (window))
-    return;
-
-  /* Filters are for the native events on the native window, so
-     ensure there is a native window. */
-  if (window && !gdk_window_has_impl (window))
-    {
-      g_warning ("Filters only work on toplevel windows");
-      return;
-    }
-
-  if (window)
-    tmp_list = window->filters;
-  else
-    tmp_list = _gdk_default_filters;
-
-  while (tmp_list)
-    {
-      filter = (GdkEventFilter *)tmp_list->data;
-      if ((filter->function == function) && (filter->data == data))
-        {
-          filter->ref_count++;
-          return;
-        }
-      tmp_list = tmp_list->next;
-    }
-
-  filter = g_new (GdkEventFilter, 1);
-  filter->function = function;
-  filter->data = data;
-  filter->ref_count = 1;
-  filter->flags = 0;
-
-  if (window)
-    window->filters = g_list_append (window->filters, filter);
-  else
-    _gdk_default_filters = g_list_append (_gdk_default_filters, filter);
-}
-
-/**
- * gdk_window_remove_filter: (skip)
- * @window: a #GdkWindow
- * @function: previously-added filter function
- * @data: user data for previously-added filter function
- *
- * Remove a filter previously added with gdk_window_add_filter().
- */
-void
-gdk_window_remove_filter (GdkWindow     *window,
-                          GdkFilterFunc  function,
-                          gpointer       data)
-{
-  GList *tmp_list;
-  GdkEventFilter *filter;
-
-  g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
-
-  if (window)
-    tmp_list = window->filters;
-  else
-    tmp_list = _gdk_default_filters;
-
-  while (tmp_list)
-    {
-      filter = (GdkEventFilter *)tmp_list->data;
-      tmp_list = tmp_list->next;
-
-      if ((filter->function == function) && (filter->data == data))
-        {
-          filter->flags |= GDK_EVENT_FILTER_REMOVED;
-
-          _gdk_event_filter_unref (window, filter);
-
-          return;
-        }
-    }
-}
-
 /**
  * gdk_window_is_visible:
  * @window: a #GdkWindow

gdk/gdkwindow.h

@@ -514,14 +514,6 @@ GDK_AVAILABLE_IN_ALL
 void          gdk_window_set_focus_on_map      (GdkWindow     *window,
 					        gboolean       focus_on_map);
 GDK_AVAILABLE_IN_ALL
-void          gdk_window_add_filter            (GdkWindow     *window,
-                                                GdkFilterFunc  function,
-                                                gpointer       data);
-GDK_AVAILABLE_IN_ALL
-void          gdk_window_remove_filter         (GdkWindow     *window,
-                                                GdkFilterFunc  function,
-                                                gpointer       data);
-GDK_AVAILABLE_IN_ALL
 void          gdk_window_scroll                (GdkWindow     *window,
                                                 gint           dx,
                                                 gint           dy);

gdk/x11/gdkdisplay-x11.c

@@ -1197,11 +1197,10 @@ server_time_to_monotonic_time (GdkX11Display *display_x11,
 }
 
 GdkFilterReturn
-_gdk_wm_protocols_filter (GdkXEvent *xev,
-			  GdkEvent  *event,
-			  gpointer   data)
+_gdk_wm_protocols_filter (const XEvent *xevent,
+			  GdkEvent     *event,
+			  gpointer      data)
 {
-  XEvent *xevent = (XEvent *)xev;
   GdkWindow *win = event->any.window;
   GdkDisplay *display;
   Atom atom;
@@ -2499,9 +2498,6 @@ gdk_x11_display_set_startup_notification_id (GdkDisplay  *display,
  * 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.

gdk/x11/gdkdisplay-x11.h

@@ -29,6 +29,7 @@
 #include "gdkx11devicemanager.h"
 #include "gdkx11display.h"
 #include "gdkx11screen.h"
+#include "gdkprivate-x11.h"
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
@@ -180,9 +181,9 @@ gsize           gdk_x11_display_get_max_request_size            (GdkDisplay
 gboolean        gdk_x11_display_request_selection_notification  (GdkDisplay             *display,
                                                                  const char             *selection);
 
-GdkFilterReturn _gdk_wm_protocols_filter        (GdkXEvent   *xev,
-                                                 GdkEvent    *event,
-                                                 gpointer     data);
+GdkFilterReturn _gdk_wm_protocols_filter        (const XEvent   *xevent,
+                                                 GdkEvent       *event,
+                                                 gpointer        data);
 
 G_END_DECLS
 

gdk/x11/gdkdnd-x11.c

@@ -170,24 +170,24 @@ static GrabKey grab_keys[] = {
 static GdkWindowCache *gdk_window_cache_ref   (GdkWindowCache *cache);
 static void            gdk_window_cache_unref (GdkWindowCache *cache);
 
-static GdkFilterReturn xdnd_enter_filter    (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
-static GdkFilterReturn xdnd_leave_filter    (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
-static GdkFilterReturn xdnd_position_filter (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
-static GdkFilterReturn xdnd_status_filter   (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
-static GdkFilterReturn xdnd_finished_filter (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
-static GdkFilterReturn xdnd_drop_filter     (GdkXEvent *xev,
-                                             GdkEvent  *event,
-                                             gpointer   data);
+static GdkFilterReturn xdnd_enter_filter    (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
+static GdkFilterReturn xdnd_leave_filter    (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
+static GdkFilterReturn xdnd_position_filter (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
+static GdkFilterReturn xdnd_status_filter   (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
+static GdkFilterReturn xdnd_finished_filter (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
+static GdkFilterReturn xdnd_drop_filter     (const XEvent *xevent,
+                                             GdkEvent     *event,
+                                             gpointer      data);
 
 static void   xdnd_manage_source_filter (GdkDragContext *context,
                                          GdkWindow      *window,
@@ -1059,12 +1059,11 @@ xdnd_action_to_atom (GdkDisplay    *display,
 /* Source side */
 
 static GdkFilterReturn
-xdnd_status_filter (GdkXEvent *xev,
-                    GdkEvent  *event,
-                    gpointer   data)
+xdnd_status_filter (const XEvent *xevent,
+                    GdkEvent     *event,
+                    gpointer      data)
 {
   GdkDisplay *display;
-  XEvent *xevent = (XEvent *)xev;
   guint32 dest_window = xevent->xclient.data.l[0];
   guint32 flags = xevent->xclient.data.l[1];
   Atom action = xevent->xclient.data.l[4];
@@ -1107,12 +1106,11 @@ xdnd_status_filter (GdkXEvent *xev,
 }
 
 static GdkFilterReturn
-xdnd_finished_filter (GdkXEvent *xev,
-                      GdkEvent  *event,
-                      gpointer   data)
+xdnd_finished_filter (const XEvent *xevent,
+                      GdkEvent     *event,
+                      gpointer      data)
 {
   GdkDisplay *display;
-  XEvent *xevent = (XEvent *)xev;
   guint32 dest_window = xevent->xclient.data.l[0];
   GdkDragContext *context;
   GdkX11DragContext *context_x11;
@@ -1619,14 +1617,19 @@ xdnd_read_actions (GdkX11DragContext *context_x11)
  * to continually send actions. So we select on PropertyChangeMask
  * and add this filter.
  */
-static GdkFilterReturn
-xdnd_source_window_filter (GdkXEvent *xev,
-                           GdkEvent  *event,
-                           gpointer   cb_data)
+GdkFilterReturn
+xdnd_source_window_filter (const XEvent *xevent,
+                           GdkEvent     *event,
+                           gpointer      data)
 {
-  XEvent *xevent = (XEvent *)xev;
-  GdkX11DragContext *context_x11 = cb_data;
-  GdkDisplay *display = gdk_drag_context_get_display (GDK_DRAG_CONTEXT (context_x11));
+  GdkX11DragContext *context_x11;
+  GdkDisplay *display;
+
+  if (!data)
+    return GDK_FILTER_CONTINUE;
+
+  context_x11 = data;
+  display = gdk_drag_context_get_display (GDK_DRAG_CONTEXT (context_x11));
 
   if ((xevent->xany.type == PropertyNotify) &&
       (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "XdndActionList")))
@@ -1656,13 +1659,11 @@ xdnd_manage_source_filter (GdkDragContext *context,
           gdk_window_set_events (window,
                                  gdk_window_get_events (window) |
                                  GDK_PROPERTY_CHANGE_MASK);
-          gdk_window_add_filter (window, xdnd_source_window_filter, context);
+          g_object_set_data (G_OBJECT (window), "xdnd-source-context", context);
         }
       else
         {
-          gdk_window_remove_filter (window,
-                                    xdnd_source_window_filter,
-                                    context);
+          g_object_set_data (G_OBJECT (window), "xdnd-source-context", NULL);
           /* Should we remove the GDK_PROPERTY_NOTIFY mask?
            * but we might want it for other reasons. (Like
            * INCR selection transactions).
@@ -1725,13 +1726,12 @@ xdnd_precache_atoms (GdkDisplay *display)
 }
 
 static GdkFilterReturn
-xdnd_enter_filter (GdkXEvent *xev,
-                   GdkEvent  *event,
-                   gpointer   cb_data)
+xdnd_enter_filter (const XEvent *xevent,
+                   GdkEvent     *event,
+                   gpointer      cb_data)
 {
   GdkDisplay *display;
   GdkX11Display *display_x11;
-  XEvent *xevent = (XEvent *)xev;
   GdkDragContext *context;
   GdkX11DragContext *context_x11;
   GdkSeat *seat;
@@ -1855,11 +1855,10 @@ xdnd_enter_filter (GdkXEvent *xev,
 }
 
 static GdkFilterReturn
-xdnd_leave_filter (GdkXEvent *xev,
-                   GdkEvent  *event,
-                   gpointer   data)
+xdnd_leave_filter (const XEvent *xevent,
+                   GdkEvent     *event,
+                   gpointer      data)
 {
-  XEvent *xevent = (XEvent *)xev;
   guint32 source_window = xevent->xclient.data.l[0];
   GdkDisplay *display;
   GdkX11Display *display_x11;
@@ -1895,12 +1894,11 @@ xdnd_leave_filter (GdkXEvent *xev,
 }
 
 static GdkFilterReturn
-xdnd_position_filter (GdkXEvent *xev,
-                      GdkEvent  *event,
-                      gpointer   data)
+xdnd_position_filter (const XEvent *xevent,
+                      GdkEvent     *event,
+                      gpointer      data)
 {
   GdkWindowImplX11 *impl;
-  XEvent *xevent = (XEvent *)xev;
   guint32 source_window = xevent->xclient.data.l[0];
   gint16 x_root = xevent->xclient.data.l[2] >> 16;
   gint16 y_root = xevent->xclient.data.l[2] & 0xffff;
@@ -1959,11 +1957,10 @@ xdnd_position_filter (GdkXEvent *xev,
 }
 
 static GdkFilterReturn
-xdnd_drop_filter (GdkXEvent *xev,
-                  GdkEvent  *event,
-                  gpointer   data)
+xdnd_drop_filter (const XEvent *xevent,
+                  GdkEvent     *event,
+                  gpointer      data)
 {
-  XEvent *xevent = (XEvent *)xev;
   guint32 source_window = xevent->xclient.data.l[0];
   guint32 time = xevent->xclient.data.l[2];
   GdkDisplay *display;
@@ -2010,11 +2007,10 @@ xdnd_drop_filter (GdkXEvent *xev,
 }
 
 GdkFilterReturn
-_gdk_x11_dnd_filter (GdkXEvent *xev,
-                     GdkEvent  *event,
-                     gpointer   data)
+_gdk_x11_dnd_filter (const XEvent *xevent,
+                     GdkEvent     *event,
+                     gpointer      data)
 {
-  XEvent *xevent = (XEvent *) xev;
   GdkDisplay *display;
   int i;
 
@@ -2031,7 +2027,7 @@ _gdk_x11_dnd_filter (GdkXEvent *xev,
       if (xevent->xclient.message_type != gdk_x11_get_xatom_by_name_for_display (display, xdnd_filters[i].atom_name))
         continue;
 
-      return xdnd_filters[i].func (xev, event, data);
+      return xdnd_filters[i].func (xevent, event, data);
     }
 
   return GDK_FILTER_CONTINUE;

gdk/x11/gdkeventsource.c

@@ -54,47 +54,6 @@ static GSourceFuncs event_funcs = {
   gdk_event_source_finalize
 };
 
-static gint
-gdk_event_apply_filters (const XEvent *xevent,
-			 GdkEvent     *event,
-			 GdkWindow    *window)
-{
-  GList *tmp_list;
-  GdkFilterReturn result;
-
-  if (window == NULL)
-    tmp_list = _gdk_default_filters;
-  else
-    tmp_list = window->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 ((GdkXEvent *) 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;
-}
-
 static GdkWindow *
 gdk_event_source_get_filter_window (GdkEventSource      *event_source,
                                     const XEvent        *xevent,
@@ -305,19 +264,18 @@ gdk_event_source_translate_event (GdkX11Display  *x11_display,
         result = gdk_window_cache_filter (xevent, event, cache);
     }
 
-  /* Run default filters */
   if (result == GDK_FILTER_CONTINUE &&
-      _gdk_default_filters)
-    {
-      /* Apply global filters */
-      result = gdk_event_apply_filters (xevent, event, NULL);
-    }
+      xevent->xany.window == XRootWindow (dpy, 0))
+    result = _gdk_wm_protocols_filter (xevent, event, NULL);
 
   if (result == GDK_FILTER_CONTINUE &&
-      filter_window && filter_window->filters)
+      xevent->xany.window == XRootWindow (dpy, 0))
+    result = _gdk_x11_dnd_filter (xevent, event, NULL);
+
+  if (result == GDK_FILTER_CONTINUE && filter_window)
     {
-      /* Apply per-window filters */
-      result = gdk_event_apply_filters (xevent, event, filter_window);
+      gpointer context = g_object_get_data (G_OBJECT (filter_window), "xdnd-source-context");
+      result = xdnd_source_window_filter (xevent, event, context);
     }
 
   if (result != GDK_FILTER_CONTINUE)

gdk/x11/gdkmain-x11.c

@@ -106,13 +106,6 @@ _gdk_x11_windowing_init (void)
 {
   XSetErrorHandler (gdk_x_error);
   XSetIOErrorHandler (gdk_x_io_error);
-
-  gdk_window_add_filter (NULL,
-                         _gdk_wm_protocols_filter,
-                         NULL);
-  gdk_window_add_filter (NULL,
-                         _gdk_x11_dnd_filter,
-                         NULL);
 }
 
 GdkGrabStatus

gdk/x11/gdkprivate-x11.h

@@ -29,19 +29,30 @@
 #ifndef __GDK_PRIVATE_X11_H__
 #define __GDK_PRIVATE_X11_H__
 
-#include "gdkcursor.h"
-#include "gdkinternals.h"
-#include "gdkx.h"
-#include "gdkwindow-x11.h"
-#include "gdkscreen-x11.h"
-#include "gdkdisplay-x11.h"
-
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #ifdef XINPUT_2
 #include <X11/extensions/XInput2.h>
 #endif
 
+#include "gdkinternals.h"
+
+typedef enum {
+  GDK_FILTER_CONTINUE,
+  GDK_FILTER_TRANSLATE,
+  GDK_FILTER_REMOVE
+} GdkFilterReturn;
+
+typedef GdkFilterReturn (*GdkFilterFunc) (const XEvent *xevent,
+                                          GdkEvent     *event,
+                                          gpointer      data);
+
+#include "gdkcursor.h"
+#include "gdkx.h"
+#include "gdkwindow-x11.h"
+#include "gdkscreen-x11.h"
+#include "gdkdisplay-x11.h"
+
 #include <cairo-xlib.h>
 
 void _gdk_x11_error_handler_push (void);
@@ -202,9 +213,14 @@ Atom _gdk_x11_get_xatom_for_display_printf         (GdkDisplay    *display,
                                                     ...) G_GNUC_PRINTF (2, 3);
 
 GdkFilterReturn
-_gdk_x11_dnd_filter (GdkXEvent *xev,
-                     GdkEvent  *event,
-                     gpointer   data);
+_gdk_x11_dnd_filter (const XEvent *xevent,
+                     GdkEvent     *event,
+                     gpointer      data);
+
+GdkFilterReturn
+xdnd_source_window_filter (const XEvent *xevent,
+                           GdkEvent     *event,
+                           gpointer      data);
 
 typedef struct _GdkWindowCache GdkWindowCache;
 

gdk/x11/xsettings-client.h

@@ -23,6 +23,7 @@
 #ifndef XSETTINGS_CLIENT_H
 #define XSETTINGS_CLIENT_H
 
+#include <gdk/x11/gdkprivate-x11.h>
 #include <gdk/x11/gdkx11screen.h>
 
 void _gdk_x11_xsettings_init            (GdkX11Screen        *x11_screen);