Rename GdkDevice[Manager]Core to GdkX11Device[Manager]Core

This is mainly to avoid clash with the classes of the same
name in the quartz backend.

11 files changed, 512 insertions, 511 deletions

diff --git a/gdk/x11/Makefile.am b/gdk/x11/Makefile.am
index b8f9e3e888..8b09b320dc 100644
--- a/gdk/x11/Makefile.am
+++ b/gdk/x11/Makefile.am
@@ -23,10 +23,8 @@ libgdk_x11_la_SOURCES = 	\
 	gdkasync.c		\
 	gdkasync.h		\
 	gdkcursor-x11.c		\
-	gdkdevice-core.h	\
-	gdkdevice-core.c	\
-	gdkdevicemanager-core.h	\
-	gdkdevicemanager-core.c	\
+	gdkdevice-core-x11.c	\
+	gdkdevicemanager-core-x11.c \
 	gdkdevicemanager-x11.c	\
 	gdkdisplaymanager-x11.c	\
 	gdkdisplay-x11.c	\
@@ -77,6 +75,8 @@ libgdkinclude_HEADERS = 	\
 
 libgdkx11include_HEADERS = 	\
 	gdkx11cursor.h		\
+	gdkx11device-core.h	\
+	gdkx11devicemanager-core.h \
 	gdkx11display.h		\
 	gdkx11displaymanager.h	\
 	gdkx11keys.h		\
diff --git a/gdk/x11/gdkdevice-core.c b/gdk/x11/gdkdevice-core-x11.c
index 224c3ed1ca..795cbb4836 100644
--- a/gdk/x11/gdkdevice-core.c
+++ b/gdk/x11/gdkdevice-core-x11.c
@@ -19,78 +19,77 @@
 
 #include "config.h"
 
-#include "gdkdevice-core.h"
+#include "gdkx11device-core.h"
 
 #include "gdkinternals.h"
 #include "gdkwindow.h"
 #include "gdkprivate-x11.h"
 #include "gdkasync.h"
 
-static gboolean gdk_device_core_get_history (GdkDevice      *device,
-                                             GdkWindow      *window,
-                                             guint32         start,
-                                             guint32         stop,
-                                             GdkTimeCoord ***events,
-                                             gint           *n_events);
-static void gdk_device_core_get_state (GdkDevice       *device,
-                                       GdkWindow       *window,
-                                       gdouble         *axes,
-                                       GdkModifierType *mask);
-static void gdk_device_core_set_window_cursor (GdkDevice *device,
-                                               GdkWindow *window,
-                                               GdkCursor *cursor);
-static void gdk_device_core_warp (GdkDevice *device,
-                                  GdkScreen *screen,
-                                  gint       x,
-                                  gint       y);
-static gboolean gdk_device_core_query_state (GdkDevice        *device,
-                                             GdkWindow        *window,
-                                             GdkWindow       **root_window,
-                                             GdkWindow       **child_window,
-                                             gint             *root_x,
-                                             gint             *root_y,
-                                             gint             *win_x,
-                                             gint             *win_y,
-                                             GdkModifierType  *mask);
-static GdkGrabStatus gdk_device_core_grab   (GdkDevice     *device,
-                                             GdkWindow     *window,
-                                             gboolean       owner_events,
-                                             GdkEventMask   event_mask,
-                                             GdkWindow     *confine_to,
-                                             GdkCursor     *cursor,
-                                             guint32        time_);
-static void          gdk_device_core_ungrab (GdkDevice     *device,
-                                             guint32        time_);
-static GdkWindow * gdk_device_core_window_at_position (GdkDevice       *device,
-                                                       gint            *win_x,
-                                                       gint            *win_y,
-                                                       GdkModifierType *mask,
-                                                       gboolean         get_toplevel);
-static void      gdk_device_core_select_window_events (GdkDevice       *device,
-                                                       GdkWindow       *window,
-                                                       GdkEventMask     event_mask);
-
-
-G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
+static gboolean gdk_x11_device_core_get_history (GdkDevice       *device,
+                                                 GdkWindow       *window,
+                                                 guint32          start,
+                                                 guint32          stop,
+                                                 GdkTimeCoord  ***events,
+                                                 gint            *n_events);
+static void     gdk_x11_device_core_get_state   (GdkDevice       *device,
+                                                 GdkWindow       *window,
+                                                 gdouble         *axes,
+                                                 GdkModifierType *mask);
+static void     gdk_x11_device_core_set_window_cursor (GdkDevice *device,
+                                                       GdkWindow *window,
+                                                       GdkCursor *cursor);
+static void     gdk_x11_device_core_warp (GdkDevice *device,
+                                          GdkScreen *screen,
+                                          gint       x,
+                                          gint       y);
+static gboolean gdk_x11_device_core_query_state (GdkDevice        *device,
+                                                 GdkWindow        *window,
+                                                 GdkWindow       **root_window,
+                                                 GdkWindow       **child_window,
+                                                 gint             *root_x,
+                                                 gint             *root_y,
+                                                 gint             *win_x,
+                                                 gint             *win_y,
+                                                 GdkModifierType  *mask);
+static GdkGrabStatus gdk_x11_device_core_grab   (GdkDevice     *device,
+                                                 GdkWindow     *window,
+                                                 gboolean       owner_events,
+                                                 GdkEventMask   event_mask,
+                                                 GdkWindow     *confine_to,
+                                                 GdkCursor     *cursor,
+                                                 guint32        time_);
+static void          gdk_x11_device_core_ungrab (GdkDevice     *device,
+                                                 guint32        time_);
+static GdkWindow * gdk_x11_device_core_window_at_position (GdkDevice       *device,
+                                                           gint            *win_x,
+                                                           gint            *win_y,
+                                                           GdkModifierType *mask,
+                                                           gboolean         get_toplevel);
+static void      gdk_x11_device_core_select_window_events (GdkDevice       *device,
+                                                           GdkWindow       *window,
+                                                           GdkEventMask     event_mask);
+
+G_DEFINE_TYPE (GdkX11DeviceCore, gdk_x11_device_core, GDK_TYPE_DEVICE)
 
 static void
-gdk_device_core_class_init (GdkDeviceCoreClass *klass)
+gdk_x11_device_core_class_init (GdkX11DeviceCoreClass *klass)
 {
   GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
 
-  device_class->get_history = gdk_device_core_get_history;
-  device_class->get_state = gdk_device_core_get_state;
-  device_class->set_window_cursor = gdk_device_core_set_window_cursor;
-  device_class->warp = gdk_device_core_warp;
-  device_class->query_state = gdk_device_core_query_state;
-  device_class->grab = gdk_device_core_grab;
-  device_class->ungrab = gdk_device_core_ungrab;
-  device_class->window_at_position = gdk_device_core_window_at_position;
-  device_class->select_window_events = gdk_device_core_select_window_events;
+  device_class->get_history = gdk_x11_device_core_get_history;
+  device_class->get_state = gdk_x11_device_core_get_state;
+  device_class->set_window_cursor = gdk_x11_device_core_set_window_cursor;
+  device_class->warp = gdk_x11_device_core_warp;
+  device_class->query_state = gdk_x11_device_core_query_state;
+  device_class->grab = gdk_x11_device_core_grab;
+  device_class->ungrab = gdk_x11_device_core_ungrab;
+  device_class->window_at_position = gdk_x11_device_core_window_at_position;
+  device_class->select_window_events = gdk_x11_device_core_select_window_events;
 }
 
 static void
-gdk_device_core_init (GdkDeviceCore *device_core)
+gdk_x11_device_core_init (GdkX11DeviceCore *device_core)
 {
   GdkDevice *device;
 
@@ -117,12 +116,12 @@ impl_coord_in_window (GdkWindow *window,
 }
 
 static gboolean
-gdk_device_core_get_history (GdkDevice      *device,
-                             GdkWindow      *window,
-                             guint32         start,
-                             guint32         stop,
-                             GdkTimeCoord ***events,
-                             gint           *n_events)
+gdk_x11_device_core_get_history (GdkDevice      *device,
+                                 GdkWindow      *window,
+                                 guint32         start,
+                                 guint32         stop,
+                                 GdkTimeCoord ***events,
+                                 gint           *n_events)
 {
   XTimeCoord *xcoords;
   GdkTimeCoord **coords;
@@ -179,10 +178,10 @@ gdk_device_core_get_history (GdkDevice      *device,
 }
 
 static void
-gdk_device_core_get_state (GdkDevice       *device,
-                           GdkWindow       *window,
-                           gdouble         *axes,
-                           GdkModifierType *mask)
+gdk_x11_device_core_get_state (GdkDevice       *device,
+                               GdkWindow       *window,
+                               gdouble         *axes,
+                               GdkModifierType *mask)
 {
   gint x_int, y_int;
 
@@ -196,9 +195,9 @@ gdk_device_core_get_state (GdkDevice       *device,
 }
 
 static void
-gdk_device_core_set_window_cursor (GdkDevice *device,
-                                   GdkWindow *window,
-                                   GdkCursor *cursor)
+gdk_x11_device_core_set_window_cursor (GdkDevice *device,
+                                       GdkWindow *window,
+                                       GdkCursor *cursor)
 {
   Cursor xcursor;
 
@@ -213,10 +212,10 @@ gdk_device_core_set_window_cursor (GdkDevice *device,
 }
 
 static void
-gdk_device_core_warp (GdkDevice *device,
-                      GdkScreen *screen,
-                      gint       x,
-                      gint       y)
+gdk_x11_device_core_warp (GdkDevice *device,
+                          GdkScreen *screen,
+                          gint       x,
+                          gint       y)
 {
   Display *xdisplay;
   Window dest;
@@ -228,15 +227,15 @@ gdk_device_core_warp (GdkDevice *device,
 }
 
 static gboolean
-gdk_device_core_query_state (GdkDevice        *device,
-                             GdkWindow        *window,
-                             GdkWindow       **root_window,
-                             GdkWindow       **child_window,
-                             gint             *root_x,
-                             gint             *root_y,
-                             gint             *win_x,
-                             gint             *win_y,
-                             GdkModifierType  *mask)
+gdk_x11_device_core_query_state (GdkDevice        *device,
+                                 GdkWindow        *window,
+                                 GdkWindow       **root_window,
+                                 GdkWindow       **child_window,
+                                 gint             *root_x,
+                                 gint             *root_y,
+                                 gint             *win_x,
+                                 gint             *win_y,
+                                 GdkModifierType  *mask)
 {
   GdkDisplay *display;
   GdkScreen *default_screen;
@@ -253,10 +252,8 @@ gdk_device_core_query_state (GdkDevice        *device,
                           GDK_WINDOW_XID (window),
                           &xroot_window,
                           &xchild_window,
-                          &xroot_x,
-                          &xroot_y,
-                          &xwin_x,
-                          &xwin_y,
+                          &xroot_x, &xroot_y,
+                          &xwin_x, &xwin_y,
                           &xmask))
         return FALSE;
     }
@@ -276,10 +273,8 @@ gdk_device_core_query_state (GdkDevice        *device,
       XQueryPointer (xdisplay, w,
                      &xroot_window,
                      &xchild_window,
-                     &xroot_x,
-                     &xroot_y,
-                     &xwin_x,
-                     &xwin_y,
+                     &xroot_x, &xroot_y,
+                     &xwin_x, &xwin_y,
                      &xmask);
       XDestroyWindow (xdisplay, w);
     }
@@ -309,13 +304,13 @@ gdk_device_core_query_state (GdkDevice        *device,
 }
 
 static GdkGrabStatus
-gdk_device_core_grab (GdkDevice    *device,
-                      GdkWindow    *window,
-                      gboolean      owner_events,
-                      GdkEventMask  event_mask,
-                      GdkWindow    *confine_to,
-                      GdkCursor    *cursor,
-                      guint32       time_)
+gdk_x11_device_core_grab (GdkDevice    *device,
+                          GdkWindow    *window,
+                          gboolean      owner_events,
+                          GdkEventMask  event_mask,
+                          GdkWindow    *confine_to,
+                          GdkCursor    *cursor,
+                          guint32       time_)
 {
   GdkDisplay *display;
   Window xwindow, xconfine_to;
@@ -391,8 +386,8 @@ gdk_device_core_grab (GdkDevice    *device,
 }
 
 static void
-gdk_device_core_ungrab (GdkDevice *device,
-                        guint32    time_)
+gdk_x11_device_core_ungrab (GdkDevice *device,
+                            guint32    time_)
 {
   GdkDisplay *display;
   gulong serial;
@@ -409,11 +404,11 @@ gdk_device_core_ungrab (GdkDevice *device,
 }
 
 static GdkWindow *
-gdk_device_core_window_at_position (GdkDevice       *device,
-                                    gint            *win_x,
-                                    gint            *win_y,
-                                    GdkModifierType *mask,
-                                    gboolean         get_toplevel)
+gdk_x11_device_core_window_at_position (GdkDevice       *device,
+                                        gint            *win_x,
+                                        gint            *win_y,
+                                        GdkModifierType *mask,
+                                        gboolean         get_toplevel)
 {
   GdkDisplay *display;
   GdkScreen *screen;
@@ -473,7 +468,10 @@ gdk_device_core_window_at_position (GdkDevice       *device,
               xwindow = GDK_WINDOW_XID (window);
               gdk_x11_display_error_trap_push (display);
               XQueryPointer (xdisplay, xwindow,
-                             &root, &child, &rootx, &rooty, &winx, &winy, &xmask);
+                             &root, &child,
+                             &rootx, &rooty,
+                             &winx, &winy,
+                             &xmask);
               if (gdk_x11_display_error_trap_pop (display))
                 continue;
               if (child != None)
@@ -494,7 +492,9 @@ gdk_device_core_window_at_position (GdkDevice       *device,
                   XMapWindow (xdisplay, w);
                   XQueryPointer (xdisplay, xwindow,
                                  &root, &child,
-                                 &rootx, &rooty, &winx, &winy, &xmask);
+                                 &rootx, &rooty,
+                                 &winx, &winy,
+                                 &xmask);
                   XDestroyWindow (xdisplay, w);
                   if (child == w)
                     {
@@ -550,9 +550,9 @@ gdk_device_core_window_at_position (GdkDevice       *device,
 }
 
 static void
-gdk_device_core_select_window_events (GdkDevice    *device,
-                                      GdkWindow    *window,
-                                      GdkEventMask  event_mask)
+gdk_x11_device_core_select_window_events (GdkDevice    *device,
+                                         GdkWindow    *window,
+                                         GdkEventMask  event_mask)
 {
   GdkEventMask filter_mask, window_mask;
   guint xmask = 0;
diff --git a/gdk/x11/gdkdevice-core.h b/gdk/x11/gdkdevice-core.h
deleted file mode 100644
index af425da417..0000000000
--- a/gdk/x11/gdkdevice-core.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
- *
- * 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.
- */
-
-#ifndef __GDK_DEVICE_CORE_H__
-#define __GDK_DEVICE_CORE_H__
-
-#include "gdkdeviceprivate.h"
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
-#define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
-#define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
-#define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
-#define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
-#define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
-
-typedef struct _GdkDeviceCore GdkDeviceCore;
-typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
-
-struct _GdkDeviceCore
-{
-  GdkDevice parent_instance;
-};
-
-struct _GdkDeviceCoreClass
-{
-  GdkDeviceClass parent_class;
-};
-
-G_GNUC_INTERNAL
-GType gdk_device_core_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-#endif /* __GDK_DEVICE_CORE_H__ */
diff --git a/gdk/x11/gdkdevicemanager-core.c b/gdk/x11/gdkdevicemanager-core-x11.c
index e332cbc3c1..99c0b07640 100644
--- a/gdk/x11/gdkdevicemanager-core.c
+++ b/gdk/x11/gdkdevicemanager-core-x11.c
@@ -19,13 +19,13 @@
 
 #include "config.h"
 
-#include "gdkdevicemanager-core.h"
+#include "gdkx11devicemanager-core.h"
+#include "gdkx11device-core.h"
 
 #include "gdkkeysyms.h"
 #include "gdkdevicemanagerprivate.h"
 #include "gdkdisplayprivate.h"
 #include "gdkeventtranslator.h"
-#include "gdkdevice-core.h"
 #include "gdkprivate-x11.h"
 
 #ifdef HAVE_XKB
@@ -36,48 +36,48 @@
 #define HAS_FOCUS(toplevel)                           \
   ((toplevel)->has_focus || (toplevel)->has_pointer_focus)
 
-static void    gdk_device_manager_core_finalize    (GObject *object);
-static void    gdk_device_manager_core_constructed (GObject *object);
+static void    gdk_x11_device_manager_core_finalize    (GObject *object);
+static void    gdk_x11_device_manager_core_constructed (GObject *object);
 
-static GList * gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
-                                                     GdkDeviceType     type);
-static GdkDevice * gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager);
+static GList * gdk_x11_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                                         GdkDeviceType     type);
+static GdkDevice * gdk_x11_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager);
 
-static void     gdk_device_manager_event_translator_init (GdkEventTranslatorIface *iface);
+static void     gdk_x11_device_manager_event_translator_init (GdkEventTranslatorIface *iface);
 
-static gboolean gdk_device_manager_core_translate_event  (GdkEventTranslator *translator,
-                                                          GdkDisplay         *display,
-                                                          GdkEvent           *event,
-                                                          XEvent             *xevent);
+static gboolean gdk_x11_device_manager_core_translate_event  (GdkEventTranslator *translator,
+                                                              GdkDisplay         *display,
+                                                              GdkEvent           *event,
+                                                              XEvent             *xevent);
 
 
-G_DEFINE_TYPE_WITH_CODE (GdkDeviceManagerCore, gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER,
+G_DEFINE_TYPE_WITH_CODE (GdkX11DeviceManagerCore, gdk_x11_device_manager_core, GDK_TYPE_DEVICE_MANAGER,
                          G_IMPLEMENT_INTERFACE (GDK_TYPE_EVENT_TRANSLATOR,
-                                                gdk_device_manager_event_translator_init))
+                                                gdk_x11_device_manager_event_translator_init))
 
 static void
-gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
+gdk_x11_device_manager_core_class_init (GdkX11DeviceManagerCoreClass *klass)
 {
   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->finalize = gdk_device_manager_core_finalize;
-  object_class->constructed = gdk_device_manager_core_constructed;
-  device_manager_class->list_devices = gdk_device_manager_core_list_devices;
-  device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
+  object_class->finalize = gdk_x11_device_manager_core_finalize;
+  object_class->constructed = gdk_x11_device_manager_core_constructed;
+  device_manager_class->list_devices = gdk_x11_device_manager_core_list_devices;
+  device_manager_class->get_client_pointer = gdk_x11_device_manager_core_get_client_pointer;
 }
 
 static void
-gdk_device_manager_event_translator_init (GdkEventTranslatorIface *iface)
+gdk_x11_device_manager_event_translator_init (GdkEventTranslatorIface *iface)
 {
-  iface->translate_event = gdk_device_manager_core_translate_event;
+  iface->translate_event = gdk_x11_device_manager_core_translate_event;
 }
 
 static GdkDevice *
 create_core_pointer (GdkDeviceManager *device_manager,
                      GdkDisplay       *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_CORE,
+  return g_object_new (GDK_TYPE_X11_DEVICE_CORE,
                        "name", "Core Pointer",
                        "type", GDK_DEVICE_TYPE_MASTER,
                        "input-source", GDK_SOURCE_MOUSE,
@@ -92,7 +92,7 @@ static GdkDevice *
 create_core_keyboard (GdkDeviceManager *device_manager,
                       GdkDisplay       *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_CORE,
+  return g_object_new (GDK_TYPE_X11_DEVICE_CORE,
                        "name", "Core Keyboard",
                        "type", GDK_DEVICE_TYPE_MASTER,
                        "input-source", GDK_SOURCE_KEYBOARD,
@@ -104,30 +104,30 @@ create_core_keyboard (GdkDeviceManager *device_manager,
 }
 
 static void
-gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
+gdk_x11_device_manager_core_init (GdkX11DeviceManagerCore *device_manager)
 {
 }
 
 static void
-gdk_device_manager_core_finalize (GObject *object)
+gdk_x11_device_manager_core_finalize (GObject *object)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkX11DeviceManagerCore *device_manager_core;
 
-  device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
+  device_manager_core = GDK_X11_DEVICE_MANAGER_CORE (object);
 
   g_object_unref (device_manager_core->core_pointer);
   g_object_unref (device_manager_core->core_keyboard);
 
-  G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
+  G_OBJECT_CLASS (gdk_x11_device_manager_core_parent_class)->finalize (object);
 }
 
 static void
-gdk_device_manager_core_constructed (GObject *object)
+gdk_x11_device_manager_core_constructed (GObject *object)
 {
-  GdkDeviceManagerCore *device_manager;
+  GdkX11DeviceManagerCore *device_manager;
   GdkDisplay *display;
 
-  device_manager = GDK_DEVICE_MANAGER_CORE (object);
+  device_manager = GDK_X11_DEVICE_MANAGER_CORE (object);
   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (object));
   device_manager->core_pointer = create_core_pointer (GDK_DEVICE_MANAGER (device_manager), display);
   device_manager->core_keyboard = create_core_keyboard (GDK_DEVICE_MANAGER (device_manager), display);
@@ -137,10 +137,10 @@ gdk_device_manager_core_constructed (GObject *object)
 }
 
 static void
-translate_key_event (GdkDisplay           *display,
-                     GdkDeviceManagerCore *device_manager,
-		     GdkEvent             *event,
-		     XEvent               *xevent)
+translate_key_event (GdkDisplay              *display,
+                     GdkX11DeviceManagerCore *device_manager,
+                     GdkEvent                *event,
+                     XEvent                  *xevent)
 {
   GdkKeymap *keymap = gdk_keymap_get_for_display (display);
   GdkModifierType consumed, state;
@@ -158,10 +158,10 @@ translate_key_event (GdkDisplay           *display,
   event->key.keyval = GDK_KEY_VoidSymbol;
 
   gdk_keymap_translate_keyboard_state (keymap,
-				       event->key.hardware_keycode,
-				       event->key.state,
-				       event->key.group,
-				       &event->key.keyval,
+                                       event->key.hardware_keycode,
+                                       event->key.state,
+                                       event->key.group,
+                                       &event->key.keyval,
                                        NULL, NULL, &consumed);
 
   state = event->key.state & ~consumed;
@@ -186,28 +186,28 @@ translate_key_event (GdkDisplay           *display,
       /* 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;
-	}
+        {
+          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);
+                                              NULL, &bytes_written,
+                                              NULL);
       if (event->key.string)
-	event->key.length = bytes_written;
+        event->key.length = bytes_written;
     }
   else if (event->key.keyval == GDK_KEY_Escape)
     {
@@ -215,7 +215,7 @@ translate_key_event (GdkDisplay           *display,
       event->key.string = g_strdup ("\033");
     }
   else if (event->key.keyval == GDK_KEY_Return ||
-	  event->key.keyval == GDK_KEY_KP_Enter)
+          event->key.keyval == GDK_KEY_KP_Enter)
     {
       event->key.length = 1;
       event->key.string = g_strdup ("\r");
@@ -231,15 +231,15 @@ translate_key_event (GdkDisplay           *display,
 #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);
+      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);
+        g_message ("\t\tlength: %4d string: \"%s\"",
+                   event->key.length, buf);
     }
 #endif /* G_ENABLE_DEBUG */
   return;
@@ -267,7 +267,7 @@ static const char notify_details[][23] = {
 
 static void
 set_user_time (GdkWindow *window,
-	       GdkEvent  *event)
+               GdkEvent  *event)
 {
   g_return_if_fail (event != NULL);
 
@@ -283,9 +283,9 @@ set_user_time (GdkWindow *window,
 }
 
 static void
-generate_focus_event (GdkDeviceManagerCore *device_manager,
-                      GdkWindow            *window,
-		      gboolean              in)
+generate_focus_event (GdkX11DeviceManagerCore *device_manager,
+                      GdkWindow               *window,
+                      gboolean                 in)
 {
   GdkEvent *event;
 
@@ -301,8 +301,8 @@ generate_focus_event (GdkDeviceManagerCore *device_manager,
 
 static gboolean
 set_screen_from_root (GdkDisplay *display,
-		      GdkEvent   *event,
-		      Window      xrootwin)
+                      GdkEvent   *event,
+                      Window      xrootwin)
 {
   GdkScreen *screen;
 
@@ -364,7 +364,7 @@ is_parent_of (GdkWindow *parent,
   while (w != NULL)
     {
       if (w == parent)
-	return TRUE;
+        return TRUE;
 
       w = gdk_window_get_parent (w);
     }
@@ -392,7 +392,7 @@ get_event_window (GdkEventTranslator *translator,
 
       serial = _gdk_display_get_next_serial (display);
       info = _gdk_display_has_device_grab (display,
-                                           GDK_DEVICE_MANAGER_CORE (device_manager)->core_keyboard,
+                                           GDK_X11_DEVICE_MANAGER_CORE (device_manager)->core_keyboard,
                                            serial);
       if (info &&
           (!is_parent_of (info->window, window) ||
@@ -407,19 +407,19 @@ get_event_window (GdkEventTranslator *translator,
 }
 
 static gboolean
-gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
-                                         GdkDisplay         *display,
-                                         GdkEvent           *event,
-                                         XEvent             *xevent)
+gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
+                                             GdkDisplay         *display,
+                                             GdkEvent           *event,
+                                             XEvent             *xevent)
 {
-  GdkDeviceManagerCore *device_manager;
+  GdkX11DeviceManagerCore *device_manager;
   GdkWindow *window;
   GdkWindowImplX11 *window_impl = NULL;
   gboolean return_val;
   GdkToplevelX11 *toplevel = NULL;
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
 
-  device_manager = GDK_DEVICE_MANAGER_CORE (translator);
+  device_manager = GDK_X11_DEVICE_MANAGER_CORE (translator);
   return_val = FALSE;
 
   window = get_event_window (translator, xevent);
@@ -440,10 +440,10 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
   if (window && GDK_WINDOW_DESTROYED (window))
     {
       if (xevent->type != DestroyNotify)
-	{
-	  return_val = FALSE;
-	  goto done;
-	}
+        {
+          return_val = FALSE;
+          goto done;
+        }
     }
 
   if (window &&
@@ -491,45 +491,45 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
        */
 
       if (!display_x11->have_xkb_autorepeat && XPending (xevent->xkey.display))
-	{
-	  XEvent next_event;
+        {
+          XEvent next_event;
 
-	  XPeekEvent (xevent->xkey.display, &next_event);
+          XPeekEvent (xevent->xkey.display, &next_event);
 
-	  if (next_event.type == KeyPress &&
-	      next_event.xkey.keycode == xevent->xkey.keycode &&
-	      next_event.xkey.time == xevent->xkey.time)
-	    {
-	      return_val = FALSE;
-	      break;
-	    }
-	}
+          if (next_event.type == KeyPress &&
+              next_event.xkey.keycode == xevent->xkey.keycode &&
+              next_event.xkey.time == xevent->xkey.time)
+            {
+              return_val = FALSE;
+              break;
+            }
+        }
 
       translate_key_event (display, device_manager, event, xevent);
       break;
 
     case ButtonPress:
       GDK_NOTE (EVENTS,
-		g_message ("button press:\t\twindow: %ld  x,y: %d %d  button: %d",
-			   xevent->xbutton.window,
-			   xevent->xbutton.x, xevent->xbutton.y,
-			   xevent->xbutton.button));
+                g_message ("button press:\t\twindow: %ld  x,y: %d %d  button: %d",
+                           xevent->xbutton.window,
+                           xevent->xbutton.x, xevent->xbutton.y,
+                           xevent->xbutton.button));
 
       if (window == NULL)
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       /* If we get a ButtonPress event where the button is 4 or 5,
-	 it's a Scroll event */
+         it's a Scroll event */
       switch (xevent->xbutton.button)
         {
         case 4: /* up */
         case 5: /* down */
         case 6: /* left */
         case 7: /* right */
-	  event->scroll.type = GDK_SCROLL;
+          event->scroll.type = GDK_SCROLL;
 
           if (xevent->xbutton.button == 4)
             event->scroll.direction = GDK_SCROLL_UP;
@@ -540,41 +540,41 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
           else
             event->scroll.direction = GDK_SCROLL_RIGHT;
 
-	  event->scroll.window = window;
-	  event->scroll.time = xevent->xbutton.time;
-	  event->scroll.x = (gdouble) xevent->xbutton.x;
-	  event->scroll.y = (gdouble) xevent->xbutton.y;
-	  event->scroll.x_root = (gdouble) xevent->xbutton.x_root;
-	  event->scroll.y_root = (gdouble) xevent->xbutton.y_root;
-	  event->scroll.state = (GdkModifierType) xevent->xbutton.state;
-	  event->scroll.device = device_manager->core_pointer;
-
-	  if (!set_screen_from_root (display, event, xevent->xbutton.root))
-	    {
-	      return_val = FALSE;
-	      break;
-	    }
+          event->scroll.window = window;
+          event->scroll.time = xevent->xbutton.time;
+          event->scroll.x = (gdouble) xevent->xbutton.x;
+          event->scroll.y = (gdouble) xevent->xbutton.y;
+          event->scroll.x_root = (gdouble) xevent->xbutton.x_root;
+          event->scroll.y_root = (gdouble) xevent->xbutton.y_root;
+          event->scroll.state = (GdkModifierType) xevent->xbutton.state;
+          event->scroll.device = device_manager->core_pointer;
+
+          if (!set_screen_from_root (display, event, xevent->xbutton.root))
+            {
+              return_val = FALSE;
+              break;
+            }
 
           break;
 
         default:
-	  event->button.type = GDK_BUTTON_PRESS;
-	  event->button.window = window;
-	  event->button.time = xevent->xbutton.time;
-	  event->button.x = (gdouble) xevent->xbutton.x;
-	  event->button.y = (gdouble) xevent->xbutton.y;
-	  event->button.x_root = (gdouble) xevent->xbutton.x_root;
-	  event->button.y_root = (gdouble) xevent->xbutton.y_root;
-	  event->button.axes = NULL;
-	  event->button.state = (GdkModifierType) xevent->xbutton.state;
-	  event->button.button = xevent->xbutton.button;
-	  event->button.device = device_manager->core_pointer;
-
-	  if (!set_screen_from_root (display, event, xevent->xbutton.root))
+          event->button.type = GDK_BUTTON_PRESS;
+          event->button.window = window;
+          event->button.time = xevent->xbutton.time;
+          event->button.x = (gdouble) xevent->xbutton.x;
+          event->button.y = (gdouble) xevent->xbutton.y;
+          event->button.x_root = (gdouble) xevent->xbutton.x_root;
+          event->button.y_root = (gdouble) xevent->xbutton.y_root;
+          event->button.axes = NULL;
+          event->button.state = (GdkModifierType) xevent->xbutton.state;
+          event->button.button = xevent->xbutton.button;
+          event->button.device = device_manager->core_pointer;
+
+          if (!set_screen_from_root (display, event, xevent->xbutton.root))
             return_val = FALSE;
 
           break;
-	}
+        }
 
       set_user_time (window, event);
 
@@ -582,24 +582,24 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 
     case ButtonRelease:
       GDK_NOTE (EVENTS,
-		g_message ("button release:\twindow: %ld  x,y: %d %d  button: %d",
-			   xevent->xbutton.window,
-			   xevent->xbutton.x, xevent->xbutton.y,
-			   xevent->xbutton.button));
+                g_message ("button release:\twindow: %ld  x,y: %d %d  button: %d",
+                           xevent->xbutton.window,
+                           xevent->xbutton.x, xevent->xbutton.y,
+                           xevent->xbutton.button));
 
       if (window == NULL)
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       /* We treat button presses as scroll wheel events, so ignore the release */
       if (xevent->xbutton.button == 4 || xevent->xbutton.button == 5 ||
           xevent->xbutton.button == 6 || xevent->xbutton.button == 7)
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       event->button.type = GDK_BUTTON_RELEASE;
       event->button.window = window;
@@ -620,16 +620,16 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 
     case MotionNotify:
       GDK_NOTE (EVENTS,
-		g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s",
-			   xevent->xmotion.window,
-			   xevent->xmotion.x, xevent->xmotion.y,
-			   (xevent->xmotion.is_hint) ? "true" : "false"));
+                g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s",
+                           xevent->xmotion.window,
+                           xevent->xmotion.x, xevent->xmotion.y,
+                           (xevent->xmotion.is_hint) ? "true" : "false"));
 
       if (window == NULL)
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       event->motion.type = GDK_MOTION_NOTIFY;
       event->motion.window = window;
@@ -644,19 +644,19 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
       event->motion.device = device_manager->core_pointer;
 
       if (!set_screen_from_root (display, event, xevent->xbutton.root))
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       break;
 
     case EnterNotify:
       GDK_NOTE (EVENTS,
-		g_message ("enter notify:\t\twindow: %ld  detail: %d subwin: %ld",
-			   xevent->xcrossing.window,
-			   xevent->xcrossing.detail,
-			   xevent->xcrossing.subwindow));
+                g_message ("enter notify:\t\twindow: %ld  detail: %d subwin: %ld",
+                           xevent->xcrossing.window,
+                           xevent->xcrossing.detail,
+                           xevent->xcrossing.subwindow));
 
       if (window == NULL)
         {
@@ -665,10 +665,10 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
         }
 
       if (!set_screen_from_root (display, event, xevent->xbutton.root))
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       event->crossing.type = GDK_ENTER_NOTIFY;
       event->crossing.window = window;
@@ -678,9 +678,9 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
        *  lookup the corresponding GdkWindow.
        */
       if (xevent->xcrossing.subwindow != None)
-	event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
+        event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
       else
-	event->crossing.subwindow = NULL;
+        event->crossing.subwindow = NULL;
 
       event->crossing.time = xevent->xcrossing.time;
       event->crossing.x = (gdouble) xevent->xcrossing.x;
@@ -698,9 +698,9 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 
     case LeaveNotify:
       GDK_NOTE (EVENTS,
-		g_message ("leave notify:\t\twindow: %ld  detail: %d subwin: %ld",
-			   xevent->xcrossing.window,
-			   xevent->xcrossing.detail, xevent->xcrossing.subwindow));
+                g_message ("leave notify:\t\twindow: %ld  detail: %d subwin: %ld",
+                           xevent->xcrossing.window,
+                           xevent->xcrossing.detail, xevent->xcrossing.subwindow));
 
       if (window == NULL)
         {
@@ -709,10 +709,10 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
         }
 
       if (!set_screen_from_root (display, event, xevent->xbutton.root))
-	{
-	  return_val = FALSE;
-	  break;
-	}
+        {
+          return_val = FALSE;
+          break;
+        }
 
       event->crossing.type = GDK_LEAVE_NOTIFY;
       event->crossing.window = window;
@@ -722,9 +722,9 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
        *  lookup the corresponding GdkWindow.
        */
       if (xevent->xcrossing.subwindow != None)
-	event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
+        event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
       else
-	event->crossing.subwindow = NULL;
+        event->crossing.subwindow = NULL;
 
       event->crossing.time = xevent->xcrossing.time;
       event->crossing.x = (gdouble) xevent->xcrossing.x;
@@ -745,113 +745,113 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
        */
     case FocusIn:
       GDK_NOTE (EVENTS,
-		g_message ("focus in:\t\twindow: %ld, detail: %s, mode: %s",
-			   xevent->xfocus.window,
-			   notify_details[xevent->xfocus.detail],
-			   notify_modes[xevent->xfocus.mode]));
+                g_message ("focus in:\t\twindow: %ld, detail: %s, mode: %s",
+                           xevent->xfocus.window,
+                           notify_details[xevent->xfocus.detail],
+                           notify_modes[xevent->xfocus.mode]));
 
       if (toplevel)
-	{
-	  gboolean had_focus = HAS_FOCUS (toplevel);
-
-	  switch (xevent->xfocus.detail)
-	    {
-	    case NotifyAncestor:
-	    case NotifyVirtual:
-	      /* When the focus moves from an ancestor of the window to
-	       * the window or a descendent of the window, *and* the
-	       * pointer is inside the window, then we were previously
-	       * receiving keystroke events in the has_pointer_focus
-	       * case and are now receiving them in the
-	       * has_focus_window case.
-	       */
-	      if (toplevel->has_pointer &&
-		  xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_pointer_focus = FALSE;
-
-	      /* fall through */
-	    case NotifyNonlinear:
-	    case NotifyNonlinearVirtual:
-	      if (xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_focus_window = TRUE;
-	      /* We pretend that the focus moves to the grab
-	       * window, so we pay attention to NotifyGrab
-	       * NotifyUngrab, and ignore NotifyWhileGrabbed
-	       */
-	      if (xevent->xfocus.mode != NotifyWhileGrabbed)
-		toplevel->has_focus = TRUE;
-	      break;
-	    case NotifyPointer:
-	      /* The X server sends NotifyPointer/NotifyGrab,
-	       * but the pointer focus is ignored while a
-	       * grab is in effect
-	       */
-	      if (xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_pointer_focus = TRUE;
-	      break;
-	    case NotifyInferior:
-	    case NotifyPointerRoot:
-	    case NotifyDetailNone:
-	      break;
-	    }
-
-	  if (HAS_FOCUS (toplevel) != had_focus)
-	    generate_focus_event (device_manager, window, TRUE);
-	}
+        {
+          gboolean had_focus = HAS_FOCUS (toplevel);
+
+          switch (xevent->xfocus.detail)
+            {
+            case NotifyAncestor:
+            case NotifyVirtual:
+              /* When the focus moves from an ancestor of the window to
+               * the window or a descendent of the window, *and* the
+               * pointer is inside the window, then we were previously
+               * receiving keystroke events in the has_pointer_focus
+               * case and are now receiving them in the
+               * has_focus_window case.
+               */
+              if (toplevel->has_pointer &&
+                  xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_pointer_focus = FALSE;
+
+              /* fall through */
+            case NotifyNonlinear:
+            case NotifyNonlinearVirtual:
+              if (xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_focus_window = TRUE;
+              /* We pretend that the focus moves to the grab
+               * window, so we pay attention to NotifyGrab
+               * NotifyUngrab, and ignore NotifyWhileGrabbed
+               */
+              if (xevent->xfocus.mode != NotifyWhileGrabbed)
+                toplevel->has_focus = TRUE;
+              break;
+            case NotifyPointer:
+              /* The X server sends NotifyPointer/NotifyGrab,
+               * but the pointer focus is ignored while a
+               * grab is in effect
+               */
+              if (xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_pointer_focus = TRUE;
+              break;
+            case NotifyInferior:
+            case NotifyPointerRoot:
+            case NotifyDetailNone:
+              break;
+            }
+
+          if (HAS_FOCUS (toplevel) != had_focus)
+            generate_focus_event (device_manager, window, TRUE);
+        }
       break;
     case FocusOut:
       GDK_NOTE (EVENTS,
-		g_message ("focus out:\t\twindow: %ld, detail: %s, mode: %s",
-			   xevent->xfocus.window,
-			   notify_details[xevent->xfocus.detail],
-			   notify_modes[xevent->xfocus.mode]));
+                g_message ("focus out:\t\twindow: %ld, detail: %s, mode: %s",
+                           xevent->xfocus.window,
+                           notify_details[xevent->xfocus.detail],
+                           notify_modes[xevent->xfocus.mode]));
 
       if (toplevel)
-	{
-	  gboolean had_focus = HAS_FOCUS (toplevel);
-
-	  switch (xevent->xfocus.detail)
-	    {
-	    case NotifyAncestor:
-	    case NotifyVirtual:
-	      /* When the focus moves from the window or a descendent
-	       * of the window to an ancestor of the window, *and* the
-	       * pointer is inside the window, then we were previously
-	       * receiving keystroke events in the has_focus_window
-	       * case and are now receiving them in the
-	       * has_pointer_focus case.
-	       */
-	      if (toplevel->has_pointer &&
-		  xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_pointer_focus = TRUE;
-
-	      /* fall through */
-	    case NotifyNonlinear:
-	    case NotifyNonlinearVirtual:
-	      if (xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_focus_window = FALSE;
-	      if (xevent->xfocus.mode != NotifyWhileGrabbed)
-		toplevel->has_focus = FALSE;
-	      break;
-	    case NotifyPointer:
-	      if (xevent->xfocus.mode != NotifyGrab &&
-		  xevent->xfocus.mode != NotifyUngrab)
-		toplevel->has_pointer_focus = FALSE;
-	    break;
-	    case NotifyInferior:
-	    case NotifyPointerRoot:
-	    case NotifyDetailNone:
-	      break;
-	    }
-
-	  if (HAS_FOCUS (toplevel) != had_focus)
-	    generate_focus_event (device_manager, window, FALSE);
-	}
+        {
+          gboolean had_focus = HAS_FOCUS (toplevel);
+
+          switch (xevent->xfocus.detail)
+            {
+            case NotifyAncestor:
+            case NotifyVirtual:
+              /* When the focus moves from the window or a descendent
+               * of the window to an ancestor of the window, *and* the
+               * pointer is inside the window, then we were previously
+               * receiving keystroke events in the has_focus_window
+               * case and are now receiving them in the
+               * has_pointer_focus case.
+               */
+              if (toplevel->has_pointer &&
+                  xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_pointer_focus = TRUE;
+
+              /* fall through */
+            case NotifyNonlinear:
+            case NotifyNonlinearVirtual:
+              if (xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_focus_window = FALSE;
+              if (xevent->xfocus.mode != NotifyWhileGrabbed)
+                toplevel->has_focus = FALSE;
+              break;
+            case NotifyPointer:
+              if (xevent->xfocus.mode != NotifyGrab &&
+                  xevent->xfocus.mode != NotifyUngrab)
+                toplevel->has_pointer_focus = FALSE;
+            break;
+            case NotifyInferior:
+            case NotifyPointerRoot:
+            case NotifyDetailNone:
+              break;
+            }
+
+          if (HAS_FOCUS (toplevel) != had_focus)
+            generate_focus_event (device_manager, window, FALSE);
+        }
       break;
 
     default:
@@ -862,12 +862,12 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
   if (return_val)
     {
       if (event->any.window)
-	g_object_ref (event->any.window);
+        g_object_ref (event->any.window);
 
       if (((event->any.type == GDK_ENTER_NOTIFY) ||
-	   (event->any.type == GDK_LEAVE_NOTIFY)) &&
-	  (event->crossing.subwindow != NULL))
-	g_object_ref (event->crossing.subwindow);
+           (event->any.type == GDK_LEAVE_NOTIFY)) &&
+          (event->crossing.subwindow != NULL))
+        g_object_ref (event->crossing.subwindow);
     }
   else
     {
@@ -883,15 +883,15 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 }
 
 static GList *
-gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
-                                      GdkDeviceType     type)
+gdk_x11_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                          GdkDeviceType     type)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkX11DeviceManagerCore *device_manager_core;
   GList *devices = NULL;
 
   if (type == GDK_DEVICE_TYPE_MASTER)
     {
-      device_manager_core = (GdkDeviceManagerCore *) device_manager;
+      device_manager_core = (GdkX11DeviceManagerCore *) device_manager;
       devices = g_list_prepend (devices, device_manager_core->core_keyboard);
       devices = g_list_prepend (devices, device_manager_core->core_pointer);
     }
@@ -900,10 +900,10 @@ gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
 }
 
 static GdkDevice *
-gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
+gdk_x11_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkX11DeviceManagerCore *device_manager_core;
 
-  device_manager_core = (GdkDeviceManagerCore *) device_manager;
+  device_manager_core = (GdkX11DeviceManagerCore *) device_manager;
   return device_manager_core->core_pointer;
 }
diff --git a/gdk/x11/gdkdevicemanager-core.h b/gdk/x11/gdkdevicemanager-core.h
deleted file mode 100644
index 774b21ef8d..0000000000
--- a/gdk/x11/gdkdevicemanager-core.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
- *
- * 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.
- */
-
-#ifndef __GDK_DEVICE_MANAGER_CORE_H__
-#define __GDK_DEVICE_MANAGER_CORE_H__
-
-#include "gdkdevicemanagerprivate.h"
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
-#define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
-#define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
-#define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
-#define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
-#define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
-
-typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
-typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
-
-struct _GdkDeviceManagerCore
-{
-  GdkDeviceManager parent_object;
-  GdkDevice *core_pointer;
-  GdkDevice *core_keyboard;
-};
-
-struct _GdkDeviceManagerCoreClass
-{
-  GdkDeviceManagerClass parent_class;
-};
-
-GType gdk_device_manager_core_get_type (void) G_GNUC_CONST;
-
-
-G_END_DECLS
-
-#endif /* __GDK_DEVICE_MANAGER_CORE_H__ */
diff --git a/gdk/x11/gdkdevicemanager-x11.c b/gdk/x11/gdkdevicemanager-x11.c
index 25c61005b1..026ae769b7 100644
--- a/gdk/x11/gdkdevicemanager-x11.c
+++ b/gdk/x11/gdkdevicemanager-x11.c
@@ -19,7 +19,7 @@
 
 #include "config.h"
 
-#include "gdkdevicemanager-core.h"
+#include "gdkx11devicemanager-core.h"
 #ifdef XINPUT_XFREE
 #include "gdkdevicemanager-xi.h"
 #ifdef XINPUT_2
@@ -79,7 +79,7 @@ _gdk_x11_device_manager_new (GdkDisplay *display)
 
   GDK_NOTE (INPUT, g_print ("Creating core device manager\n"));
 
-  return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
+  return g_object_new (GDK_TYPE_X11_DEVICE_MANAGER_CORE,
                        "display", display,
                        NULL);
 }
diff --git a/gdk/x11/gdkdevicemanager-xi.c b/gdk/x11/gdkdevicemanager-xi.c
index 9433a1fbcd..138d133f36 100644
--- a/gdk/x11/gdkdevicemanager-xi.c
+++ b/gdk/x11/gdkdevicemanager-xi.c
@@ -57,7 +57,7 @@ static GList *  gdk_device_manager_xi_list_devices     (GdkDeviceManager  *devic
                                                         GdkDeviceType      type);
 
 
-G_DEFINE_TYPE_WITH_CODE (GdkDeviceManagerXI, gdk_device_manager_xi, GDK_TYPE_DEVICE_MANAGER_CORE,
+G_DEFINE_TYPE_WITH_CODE (GdkDeviceManagerXI, gdk_device_manager_xi, GDK_TYPE_X11_DEVICE_MANAGER_CORE,
                          G_IMPLEMENT_INTERFACE (GDK_TYPE_EVENT_TRANSLATOR,
                                                 gdk_device_manager_xi_event_translator_init))
 
diff --git a/gdk/x11/gdkdevicemanager-xi.h b/gdk/x11/gdkdevicemanager-xi.h
index e2028fdb8d..bffa2cbf02 100644
--- a/gdk/x11/gdkdevicemanager-xi.h
+++ b/gdk/x11/gdkdevicemanager-xi.h
@@ -20,7 +20,7 @@
 #ifndef __GDK_DEVICE_MANAGER_XI_H__
 #define __GDK_DEVICE_MANAGER_XI_H__
 
-#include "gdkdevicemanager-core.h"
+#include "gdkx11devicemanager-core.h"
 
 G_BEGIN_DECLS
 
@@ -37,7 +37,7 @@ typedef struct _GdkDeviceManagerXIClass GdkDeviceManagerXIClass;
 
 struct _GdkDeviceManagerXI
 {
-  GdkDeviceManagerCore parent_object;
+  GdkX11DeviceManagerCore parent_object;
   GdkDevice *core_pointer;
   GdkDevice *core_keyboard;
 
@@ -47,7 +47,7 @@ struct _GdkDeviceManagerXI
 
 struct _GdkDeviceManagerXIClass
 {
-  GdkDeviceManagerCoreClass parent_class;
+  GdkX11DeviceManagerCoreClass parent_class;
 };
 
 GType gdk_device_manager_xi_get_type (void) G_GNUC_CONST;
diff --git a/gdk/x11/gdkx.h b/gdk/x11/gdkx.h
index c8a3f20f68..f3eef28c3a 100644
--- a/gdk/x11/gdkx.h
+++ b/gdk/x11/gdkx.h
@@ -56,6 +56,8 @@
 #define __GDKX_H_INSIDE__
 
 #include <gdk/x11/gdkx11cursor.h>
+#include <gdk/x11/gdkx11device-core.h>
+#include <gdk/x11/gdkx11devicemanager-core.h>
 #include <gdk/x11/gdkx11display.h>
 #include <gdk/x11/gdkx11displaymanager.h>
 #include <gdk/x11/gdkx11keys.h>
diff --git a/gdk/x11/gdkx11device-core.h b/gdk/x11/gdkx11device-core.h
new file mode 100644
index 0000000000..e6aea0a1df
--- /dev/null
+++ b/gdk/x11/gdkx11device-core.h
@@ -0,0 +1,51 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_X11_DEVICE_CORE_H__
+#define __GDK_X11_DEVICE_CORE_H__
+
+#include "gdkdeviceprivate.h"
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_X11_DEVICE_CORE         (gdk_x11_device_core_get_type ())
+#define GDK_X11_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCore))
+#define GDK_X11_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCoreClass))
+#define GDK_IS_X11_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_CORE))
+#define GDK_IS_X11_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_CORE))
+#define GDK_X11_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCoreClass))
+
+typedef struct _GdkX11DeviceCore GdkX11DeviceCore;
+typedef struct _GdkX11DeviceCoreClass GdkX11DeviceCoreClass;
+
+struct _GdkX11DeviceCore
+{
+  GdkDevice parent_instance;
+};
+
+struct _GdkX11DeviceCoreClass
+{
+  GdkDeviceClass parent_class;
+};
+
+GType gdk_x11_device_core_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __GDK_X11_DEVICE_CORE_H__ */
diff --git a/gdk/x11/gdkx11devicemanager-core.h b/gdk/x11/gdkx11devicemanager-core.h
new file mode 100644
index 0000000000..420c7ad0ab
--- /dev/null
+++ b/gdk/x11/gdkx11devicemanager-core.h
@@ -0,0 +1,54 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_X11_DEVICE_MANAGER_CORE_H__
+#define __GDK_X11_DEVICE_MANAGER_CORE_H__
+
+#include "gdkdevicemanagerprivate.h"
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_X11_DEVICE_MANAGER_CORE         (gdk_x11_device_manager_core_get_type ())
+#define GDK_X11_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCore))
+#define GDK_X11_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCoreClass))
+#define GDK_IS_X11_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE))
+#define GDK_IS_X11_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_CORE))
+#define GDK_X11_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCoreClass))
+
+typedef struct _GdkX11DeviceManagerCore GdkX11DeviceManagerCore;
+typedef struct _GdkX11DeviceManagerCoreClass GdkX11DeviceManagerCoreClass;
+
+struct _GdkX11DeviceManagerCore
+{
+  GdkDeviceManager parent_object;
+  GdkDevice *core_pointer;
+  GdkDevice *core_keyboard;
+};
+
+struct _GdkX11DeviceManagerCoreClass
+{
+  GdkDeviceManagerClass parent_class;
+};
+
+GType gdk_x11_device_manager_core_get_type (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __GDK_X11_DEVICE_MANAGER_CORE_H__ */