GdkWindow -> GdkSurface initial type rename

This renames the GdkWindow class and related classes (impl, backend
subclasses) to surface. Additionally it renames related types:
GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType,
GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge

This is an automatic conversion using the below commands:

git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass

git sed -f g GdkWindow GdkSurface
git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing
git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING
git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2"
git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE
git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo

git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE"
git sed -f g "broadway_window" "broadway_surface"
git sed -f g "BroadwayWindow" "BroadwaySurface"
git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE"
git sed -f g "wayland_window" "wayland_surface"
git sed -f g "WaylandWindow" "WaylandSurface"
git sed -f g "X11_WINDOW" "X11_SURFACE"
git sed -f g "x11_window" "x11_surface"
git sed -f g "X11Window" "X11Surface"
git sed -f g "WIN32_WINDOW" "WIN32_SURFACE"
git sed -f g "win32_window" "win32_surface"
git sed -f g "Win32Window" "Win32Surface"
git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE"
git sed -f g "quartz_window" "quartz_surface"
git sed -f g "QuartzWindow" "QuartzSurface"

git checkout NEWS* po-properties

24 files changed, 1357 insertions, 1357 deletions

diff --git a/gdk/x11/gdkdevice-core-x11.c b/gdk/x11/gdkdevice-core-x11.c
index 8cd0408661..6bbdda6693 100644
--- a/gdk/x11/gdkdevice-core-x11.c
+++ b/gdk/x11/gdkdevice-core-x11.c
@@ -40,45 +40,45 @@ struct _GdkX11DeviceCoreClass
 };
 
 static gboolean gdk_x11_device_core_get_history (GdkDevice       *device,
-                                                 GdkWindow       *window,
+                                                 GdkSurface       *window,
                                                  guint32          start,
                                                  guint32          stop,
                                                  GdkTimeCoord  ***events,
                                                  gint            *n_events);
 static void     gdk_x11_device_core_get_state   (GdkDevice       *device,
-                                                 GdkWindow       *window,
+                                                 GdkSurface       *window,
                                                  gdouble         *axes,
                                                  GdkModifierType *mask);
 static void     gdk_x11_device_core_set_window_cursor (GdkDevice *device,
-                                                       GdkWindow *window,
+                                                       GdkSurface *window,
                                                        GdkCursor *cursor);
 static void     gdk_x11_device_core_warp (GdkDevice *device,
                                           gdouble    x,
                                           gdouble    y);
 static void gdk_x11_device_core_query_state (GdkDevice        *device,
-                                             GdkWindow        *window,
-                                             GdkWindow       **child_window,
+                                             GdkSurface        *window,
+                                             GdkSurface       **child_window,
                                              gdouble          *root_x,
                                              gdouble          *root_y,
                                              gdouble          *win_x,
                                              gdouble          *win_y,
                                              GdkModifierType  *mask);
 static GdkGrabStatus gdk_x11_device_core_grab   (GdkDevice     *device,
-                                                 GdkWindow     *window,
+                                                 GdkSurface     *window,
                                                  gboolean       owner_events,
                                                  GdkEventMask   event_mask,
-                                                 GdkWindow     *confine_to,
+                                                 GdkSurface     *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,
+static GdkSurface * gdk_x11_device_core_window_at_position (GdkDevice       *device,
                                                            gdouble         *win_x,
                                                            gdouble         *win_y,
                                                            GdkModifierType *mask,
                                                            gboolean         get_toplevel);
 static void      gdk_x11_device_core_select_window_events (GdkDevice       *device,
-                                                           GdkWindow       *window,
+                                                           GdkSurface       *window,
                                                            GdkEventMask     event_mask);
 
 G_DEFINE_TYPE (GdkX11DeviceCore, gdk_x11_device_core, GDK_TYPE_DEVICE)
@@ -111,7 +111,7 @@ gdk_x11_device_core_init (GdkX11DeviceCore *device_core)
 }
 
 static gboolean
-impl_coord_in_window (GdkWindow *window,
+impl_coord_in_window (GdkSurface *window,
 		      int        impl_x,
 		      int        impl_y)
 {
@@ -128,7 +128,7 @@ impl_coord_in_window (GdkWindow *window,
 
 static gboolean
 gdk_x11_device_core_get_history (GdkDevice      *device,
-                                 GdkWindow      *window,
+                                 GdkSurface      *window,
                                  guint32         start,
                                  guint32         stop,
                                  GdkTimeCoord ***events,
@@ -136,15 +136,15 @@ gdk_x11_device_core_get_history (GdkDevice      *device,
 {
   XTimeCoord *xcoords;
   GdkTimeCoord **coords;
-  GdkWindow *impl_window;
-  GdkWindowImplX11 *impl;
+  GdkSurface *impl_window;
+  GdkSurfaceImplX11 *impl;
   int tmp_n_events;
   int i, j;
 
-  impl_window = _gdk_window_get_impl_window (window);
-  impl =  GDK_WINDOW_IMPL_X11 (impl_window->impl);
-  xcoords = XGetMotionEvents (GDK_WINDOW_XDISPLAY (window),
-                              GDK_WINDOW_XID (impl_window),
+  impl_window = _gdk_surface_get_impl_window (window);
+  impl =  GDK_SURFACE_IMPL_X11 (impl_window->impl);
+  xcoords = XGetMotionEvents (GDK_SURFACE_XDISPLAY (window),
+                              GDK_SURFACE_XID (impl_window),
                               start, stop, &tmp_n_events);
   if (!xcoords)
     return FALSE;
@@ -194,13 +194,13 @@ gdk_x11_device_core_get_history (GdkDevice      *device,
 
 static void
 gdk_x11_device_core_get_state (GdkDevice       *device,
-                               GdkWindow       *window,
+                               GdkSurface       *window,
                                gdouble         *axes,
                                GdkModifierType *mask)
 {
   gdouble x, y;
 
-  gdk_window_get_device_position_double (window, device, &x, &y, mask);
+  gdk_surface_get_device_position_double (window, device, &x, &y, mask);
 
   if (axes)
     {
@@ -211,7 +211,7 @@ gdk_x11_device_core_get_state (GdkDevice       *device,
 
 static void
 gdk_x11_device_core_set_window_cursor (GdkDevice *device,
-                                       GdkWindow *window,
+                                       GdkSurface *window,
                                        GdkCursor *cursor)
 {
   GdkDisplay *display = gdk_device_get_display (device);
@@ -223,7 +223,7 @@ gdk_x11_device_core_set_window_cursor (GdkDevice *device,
     xcursor = gdk_x11_display_get_xcursor (display, cursor);
 
   XDefineCursor (GDK_DISPLAY_XDISPLAY (display),
-                 GDK_WINDOW_XID (window),
+                 GDK_SURFACE_XID (window),
                  xcursor);
 }
 
@@ -249,8 +249,8 @@ gdk_x11_device_core_warp (GdkDevice *device,
 
 static void
 gdk_x11_device_core_query_state (GdkDevice        *device,
-                                 GdkWindow        *window,
-                                 GdkWindow       **child_window,
+                                 GdkSurface        *window,
+                                 GdkSurface       **child_window,
                                  gdouble          *root_x,
                                  gdouble          *root_y,
                                  gdouble          *win_x,
@@ -274,12 +274,12 @@ gdk_x11_device_core_query_state (GdkDevice        *device,
     }
   else
     {
-      xwindow = GDK_WINDOW_XID (window);
-      scale = GDK_WINDOW_IMPL_X11 (window->impl)->window_scale;
+      xwindow = GDK_SURFACE_XID (window);
+      scale = GDK_SURFACE_IMPL_X11 (window->impl)->window_scale;
     }
 
   if (!GDK_X11_DISPLAY (display)->trusted_client ||
-      !XQueryPointer (GDK_WINDOW_XDISPLAY (window),
+      !XQueryPointer (GDK_SURFACE_XDISPLAY (window),
                       xwindow,
                       &xroot_window,
                       &xchild_window,
@@ -307,7 +307,7 @@ gdk_x11_device_core_query_state (GdkDevice        *device,
     }
 
   if (child_window)
-    *child_window = gdk_x11_window_lookup_for_display (display, xchild_window);
+    *child_window = gdk_x11_surface_lookup_for_display (display, xchild_window);
 
   if (root_x)
     *root_x = (double)xroot_x / scale;
@@ -327,10 +327,10 @@ gdk_x11_device_core_query_state (GdkDevice        *device,
 
 static GdkGrabStatus
 gdk_x11_device_core_grab (GdkDevice    *device,
-                          GdkWindow    *window,
+                          GdkSurface    *window,
                           gboolean      owner_events,
                           GdkEventMask  event_mask,
-                          GdkWindow    *confine_to,
+                          GdkSurface    *confine_to,
                           GdkCursor    *cursor,
                           guint32       time_)
 {
@@ -340,15 +340,15 @@ gdk_x11_device_core_grab (GdkDevice    *device,
 
   display = gdk_device_get_display (device);
 
-  xwindow = GDK_WINDOW_XID (window);
+  xwindow = GDK_SURFACE_XID (window);
 
   if (confine_to)
-    confine_to = _gdk_window_get_impl_window (confine_to);
+    confine_to = _gdk_surface_get_impl_window (confine_to);
 
-  if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
+  if (!confine_to || GDK_SURFACE_DESTROYED (confine_to))
     xconfine_to = None;
   else
-    xconfine_to = GDK_WINDOW_XID (confine_to);
+    xconfine_to = GDK_SURFACE_XID (confine_to);
 
 #ifdef G_ENABLE_DEBUG
   if (GDK_DISPLAY_DEBUG_CHECK (display, NOGRABS))
@@ -424,17 +424,17 @@ gdk_x11_device_core_ungrab (GdkDevice *device,
   _gdk_x11_display_update_grab_info_ungrab (display, device, time_, serial);
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_device_core_window_at_position (GdkDevice       *device,
                                         gdouble         *win_x,
                                         gdouble         *win_y,
                                         GdkModifierType *mask,
                                         gboolean         get_toplevel)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   GdkDisplay *display;
   Display *xdisplay;
-  GdkWindow *window;
+  GdkSurface *window;
   GdkX11Screen *screen;
   Window xwindow, root, child, last;
   int xroot_x, xroot_y, xwin_x, xwin_y;
@@ -480,9 +480,9 @@ gdk_x11_device_core_window_at_position (GdkDevice       *device,
       toplevels = gdk_x11_display_get_toplevel_windows (display);
       for (list = toplevels; list != NULL; list = list->next)
         {
-          window = GDK_WINDOW (list->data);
-          impl = GDK_WINDOW_IMPL_X11 (window->impl);
-          xwindow = GDK_WINDOW_XID (window);
+          window = GDK_SURFACE (list->data);
+          impl = GDK_SURFACE_IMPL_X11 (window->impl);
+          xwindow = GDK_SURFACE_XID (window);
           gdk_x11_display_error_trap_push (display);
           XQueryPointer (xdisplay, xwindow,
                          &root, &child,
@@ -496,7 +496,7 @@ gdk_x11_device_core_window_at_position (GdkDevice       *device,
               pointer_window = child;
               break;
             }
-          gdk_window_get_geometry (window, NULL, NULL, &width, &height);
+          gdk_surface_get_geometry (window, NULL, NULL, &width, &height);
           if (winx >= 0 && winy >= 0 && winx < width * impl->window_scale && winy < height * impl->window_scale)
             {
               /* A childless toplevel, or below another window? */
@@ -537,8 +537,8 @@ gdk_x11_device_core_window_at_position (GdkDevice       *device,
         break;
 
       if (get_toplevel && last != root &&
-          (window = gdk_x11_window_lookup_for_display (display, last)) != NULL &&
-          window->window_type != GDK_WINDOW_FOREIGN)
+          (window = gdk_x11_surface_lookup_for_display (display, last)) != NULL &&
+          window->window_type != GDK_SURFACE_FOREIGN)
         {
           xwindow = last;
           break;
@@ -547,10 +547,10 @@ gdk_x11_device_core_window_at_position (GdkDevice       *device,
 
   gdk_x11_display_ungrab (display);
 
-  window = gdk_x11_window_lookup_for_display (display, last);
+  window = gdk_x11_surface_lookup_for_display (display, last);
   impl = NULL;
   if (window)
-    impl = GDK_WINDOW_IMPL_X11 (window->impl);
+    impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (win_x)
     *win_x = (window) ? (double)xwin_x / impl->window_scale : -1;
@@ -566,14 +566,14 @@ gdk_x11_device_core_window_at_position (GdkDevice       *device,
 
 static void
 gdk_x11_device_core_select_window_events (GdkDevice    *device,
-                                          GdkWindow    *window,
+                                          GdkSurface    *window,
                                           GdkEventMask  event_mask)
 {
   GdkEventMask filter_mask, window_mask;
   guint xmask = 0;
   gint i;
 
-  window_mask = gdk_window_get_events (window);
+  window_mask = gdk_surface_get_events (window);
   filter_mask = GDK_POINTER_MOTION_MASK
                 | GDK_BUTTON_MOTION_MASK
                 | GDK_BUTTON1_MOTION_MASK
@@ -605,10 +605,10 @@ gdk_x11_device_core_select_window_events (GdkDevice    *device,
         xmask |= _gdk_x11_event_mask_table[i];
     }
 
-  if (GDK_WINDOW_XID (window) != GDK_WINDOW_XROOTWIN (window))
+  if (GDK_SURFACE_XID (window) != GDK_SURFACE_XROOTWIN (window))
     xmask |= StructureNotifyMask | PropertyChangeMask;
 
-  XSelectInput (GDK_WINDOW_XDISPLAY (window),
-                GDK_WINDOW_XID (window),
+  XSelectInput (GDK_SURFACE_XDISPLAY (window),
+                GDK_SURFACE_XID (window),
                 xmask);
 }
diff --git a/gdk/x11/gdkdevice-xi2.c b/gdk/x11/gdkdevice-xi2.c
index 98d3ce38a5..a73a036023 100644
--- a/gdk/x11/gdkdevice-xi2.c
+++ b/gdk/x11/gdkdevice-xi2.c
@@ -71,18 +71,18 @@ static void gdk_x11_device_xi2_set_property (GObject      *object,
                                              GParamSpec   *pspec);
 
 static void gdk_x11_device_xi2_get_state (GdkDevice       *device,
-                                          GdkWindow       *window,
+                                          GdkSurface       *window,
                                           gdouble         *axes,
                                           GdkModifierType *mask);
 static void gdk_x11_device_xi2_set_window_cursor (GdkDevice *device,
-                                                  GdkWindow *window,
+                                                  GdkSurface *window,
                                                   GdkCursor *cursor);
 static void gdk_x11_device_xi2_warp (GdkDevice *device,
                                      gdouble    x,
                                      gdouble    y);
 static void gdk_x11_device_xi2_query_state (GdkDevice        *device,
-                                            GdkWindow        *window,
-                                            GdkWindow       **child_window,
+                                            GdkSurface        *window,
+                                            GdkSurface       **child_window,
                                             gdouble          *root_x,
                                             gdouble          *root_y,
                                             gdouble          *win_x,
@@ -90,22 +90,22 @@ static void gdk_x11_device_xi2_query_state (GdkDevice        *device,
                                             GdkModifierType  *mask);
 
 static GdkGrabStatus gdk_x11_device_xi2_grab   (GdkDevice     *device,
-                                                GdkWindow     *window,
+                                                GdkSurface     *window,
                                                 gboolean       owner_events,
                                                 GdkEventMask   event_mask,
-                                                GdkWindow     *confine_to,
+                                                GdkSurface     *confine_to,
                                                 GdkCursor     *cursor,
                                                 guint32        time_);
 static void          gdk_x11_device_xi2_ungrab (GdkDevice     *device,
                                                 guint32        time_);
 
-static GdkWindow * gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
+static GdkSurface * gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
                                                           gdouble         *win_x,
                                                           gdouble         *win_y,
                                                           GdkModifierType *mask,
                                                           gboolean         get_toplevel);
 static void  gdk_x11_device_xi2_select_window_events (GdkDevice    *device,
-                                                      GdkWindow    *window,
+                                                      GdkSurface    *window,
                                                       GdkEventMask  event_mask);
 
 
@@ -200,7 +200,7 @@ gdk_x11_device_xi2_set_property (GObject      *object,
 
 static void
 gdk_x11_device_xi2_get_state (GdkDevice       *device,
-                              GdkWindow       *window,
+                              GdkSurface       *window,
                               gdouble         *axes,
                               GdkModifierType *mask)
 {
@@ -245,7 +245,7 @@ gdk_x11_device_xi2_get_state (GdkDevice       *device,
                   gint root_x, root_y;
 
                   /* FIXME: Maybe root coords chaching should happen here */
-                  gdk_window_get_origin (window, &root_x, &root_y);
+                  gdk_surface_get_origin (window, &root_x, &root_y);
                   _gdk_device_translate_screen_coord (device, window,
                                                       root_x, root_y,
                                                       WidthOfScreen (xscreen),
@@ -276,7 +276,7 @@ gdk_x11_device_xi2_get_state (GdkDevice       *device,
 
 static void
 gdk_x11_device_xi2_set_window_cursor (GdkDevice *device,
-                                      GdkWindow *window,
+                                      GdkSurface *window,
                                       GdkCursor *cursor)
 {
   GdkX11DeviceXI2 *device_xi2 = GDK_X11_DEVICE_XI2 (device);
@@ -286,14 +286,14 @@ gdk_x11_device_xi2_set_window_cursor (GdkDevice *device,
     return;
 
   if (cursor)
-    XIDefineCursor (GDK_WINDOW_XDISPLAY (window),
+    XIDefineCursor (GDK_SURFACE_XDISPLAY (window),
                     device_xi2->device_id,
-                    GDK_WINDOW_XID (window),
-                    gdk_x11_display_get_xcursor (GDK_WINDOW_DISPLAY (window), cursor));
+                    GDK_SURFACE_XID (window),
+                    gdk_x11_display_get_xcursor (GDK_SURFACE_DISPLAY (window), cursor));
   else
-    XIUndefineCursor (GDK_WINDOW_XDISPLAY (window),
+    XIUndefineCursor (GDK_SURFACE_XDISPLAY (window),
                       device_xi2->device_id,
-                      GDK_WINDOW_XID (window));
+                      GDK_SURFACE_XID (window));
 }
 
 static void
@@ -316,8 +316,8 @@ gdk_x11_device_xi2_warp (GdkDevice *device,
 
 static void
 gdk_x11_device_xi2_query_state (GdkDevice        *device,
-                                GdkWindow        *window,
-                                GdkWindow       **child_window,
+                                GdkSurface        *window,
+                                GdkSurface       **child_window,
                                 gdouble          *root_x,
                                 gdouble          *root_y,
                                 gdouble          *win_x,
@@ -343,8 +343,8 @@ gdk_x11_device_xi2_query_state (GdkDevice        *device,
     }
   else
     {
-      xwindow = GDK_WINDOW_XID (window);
-      scale = GDK_WINDOW_IMPL_X11 (window->impl)->window_scale;
+      xwindow = GDK_SURFACE_XID (window);
+      scale = GDK_SURFACE_IMPL_X11 (window->impl)->window_scale;
     }
 
   if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_SLAVE)
@@ -393,7 +393,7 @@ gdk_x11_device_xi2_query_state (GdkDevice        *device,
     }
 
   if (child_window)
-    *child_window = gdk_x11_window_lookup_for_display (display, xchild_window);
+    *child_window = gdk_x11_surface_lookup_for_display (display, xchild_window);
 
   if (root_x)
     *root_x = xroot_x / scale;
@@ -415,10 +415,10 @@ gdk_x11_device_xi2_query_state (GdkDevice        *device,
 
 static GdkGrabStatus
 gdk_x11_device_xi2_grab (GdkDevice    *device,
-                         GdkWindow    *window,
+                         GdkSurface    *window,
                          gboolean      owner_events,
                          GdkEventMask  event_mask,
-                         GdkWindow    *confine_to,
+                         GdkSurface    *confine_to,
                          GdkCursor    *cursor,
                          guint32       time_)
 {
@@ -435,7 +435,7 @@ gdk_x11_device_xi2_grab (GdkDevice    *device,
 
   /* FIXME: confine_to is actually unused */
 
-  xwindow = GDK_WINDOW_XID (window);
+  xwindow = GDK_SURFACE_XID (window);
 
   if (!cursor)
     xcursor = None;
@@ -486,19 +486,19 @@ gdk_x11_device_xi2_ungrab (GdkDevice *device,
   _gdk_x11_display_update_grab_info_ungrab (display, device, time_, serial);
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
                                        gdouble         *win_x,
                                        gdouble         *win_y,
                                        GdkModifierType *mask,
                                        gboolean         get_toplevel)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   GdkX11DeviceXI2 *device_xi2 = GDK_X11_DEVICE_XI2 (device);
   GdkDisplay *display;
   GdkX11Screen *screen;
   Display *xdisplay;
-  GdkWindow *window;
+  GdkSurface *window;
   Window xwindow, root, child, last = None;
   gdouble xroot_x, xroot_y, xwin_x, xwin_y;
   XIButtonState button_state = { 0 };
@@ -550,8 +550,8 @@ gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
       toplevels = gdk_x11_display_get_toplevel_windows (display);
       for (list = toplevels; list != NULL; list = list->next)
         {
-          window = GDK_WINDOW (list->data);
-          xwindow = GDK_WINDOW_XID (window);
+          window = GDK_SURFACE (list->data);
+          xwindow = GDK_SURFACE_XID (window);
 
           /* Free previous button mask, if any */
           g_free (button_state.mask);
@@ -573,7 +573,7 @@ gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
               pointer_window = child;
               break;
             }
-          gdk_window_get_geometry (window, NULL, NULL, &width, &height);
+          gdk_surface_get_geometry (window, NULL, NULL, &width, &height);
           if (xwin_x >= 0 && xwin_y >= 0 && xwin_x < width && xwin_y < height)
             {
               /* A childless toplevel, or below another window? */
@@ -628,8 +628,8 @@ gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
         break;
 
       if (get_toplevel && last != root &&
-          (window = gdk_x11_window_lookup_for_display (display, last)) != NULL &&
-          GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+          (window = gdk_x11_surface_lookup_for_display (display, last)) != NULL &&
+          GDK_SURFACE_TYPE (window) != GDK_SURFACE_FOREIGN)
         {
           xwindow = last;
           break;
@@ -640,10 +640,10 @@ gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
 
   if (gdk_x11_display_error_trap_pop (display) == 0)
     {
-      window = gdk_x11_window_lookup_for_display (display, last);
+      window = gdk_x11_surface_lookup_for_display (display, last);
       impl = NULL;
       if (window)
-        impl = GDK_WINDOW_IMPL_X11 (window->impl);
+        impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
       if (mask)
         *mask = _gdk_x11_device_xi2_translate_state (&mod_state, &button_state, &group_state);
@@ -670,7 +670,7 @@ gdk_x11_device_xi2_window_at_position (GdkDevice       *device,
 
 static void
 gdk_x11_device_xi2_select_window_events (GdkDevice    *device,
-                                         GdkWindow    *window,
+                                         GdkSurface    *window,
                                          GdkEventMask  event_mask)
 {
   GdkX11DeviceXI2 *device_xi2 = GDK_X11_DEVICE_XI2 (device);
@@ -686,8 +686,8 @@ gdk_x11_device_xi2_select_window_events (GdkDevice    *device,
                                                           event_mask,
                                                           &evmask.mask_len);
 
-  XISelectEvents (GDK_WINDOW_XDISPLAY (window),
-                  GDK_WINDOW_XID (window),
+  XISelectEvents (GDK_SURFACE_XDISPLAY (window),
+                  GDK_SURFACE_XID (window),
                   &evmask, 1);
 
   g_free (evmask.mask);
diff --git a/gdk/x11/gdkdevicemanager-core-x11.c b/gdk/x11/gdkdevicemanager-core-x11.c
index 5606d8949d..f5c4a35701 100644
--- a/gdk/x11/gdkdevicemanager-core-x11.c
+++ b/gdk/x11/gdkdevicemanager-core-x11.c
@@ -261,19 +261,19 @@ static const char notify_details[][23] = {
 #endif
 
 static void
-set_user_time (GdkWindow *window,
+set_user_time (GdkSurface *window,
                GdkEvent  *event)
 {
   g_return_if_fail (event != NULL);
 
-  window = gdk_window_get_toplevel (event->any.window);
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  window = gdk_surface_get_toplevel (event->any.window);
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
   /* If an event doesn't have a valid timestamp, we shouldn't use it
    * to update the latest user interaction time.
    */
   if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
-    gdk_x11_window_set_user_time (gdk_window_get_toplevel (window),
+    gdk_x11_surface_set_user_time (gdk_surface_get_toplevel (window),
                                   gdk_event_get_time (event));
 }
 
@@ -316,10 +316,10 @@ translate_notify_type (int detail)
 }
 
 static gboolean
-is_parent_of (GdkWindow *parent,
-              GdkWindow *child)
+is_parent_of (GdkSurface *parent,
+              GdkSurface *child)
 {
-  GdkWindow *w;
+  GdkSurface *w;
 
   w = child;
   while (w != NULL)
@@ -327,21 +327,21 @@ is_parent_of (GdkWindow *parent,
       if (w == parent)
         return TRUE;
 
-      w = gdk_window_get_parent (w);
+      w = gdk_surface_get_parent (w);
     }
 
   return FALSE;
 }
 
-static GdkWindow *
+static GdkSurface *
 get_event_window (GdkEventTranslator *translator,
                   const XEvent       *xevent)
 {
   GdkDisplay *display;
-  GdkWindow *window;
+  GdkSurface *window;
 
   display = GDK_X11_DEVICE_MANAGER_CORE (translator)->display;
-  window = gdk_x11_window_lookup_for_display (display, xevent->xany.window);
+  window = gdk_x11_surface_lookup_for_display (display, xevent->xany.window);
 
   /* Apply keyboard grabs to non-native windows */
   if (xevent->type == KeyPress || xevent->type == KeyRelease)
@@ -371,9 +371,9 @@ gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
                                              GdkEvent           *event,
                                              const XEvent       *xevent)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   GdkX11DeviceManagerCore *device_manager;
-  GdkWindow *window;
+  GdkSurface *window;
   gboolean return_val;
   int scale;
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
@@ -385,18 +385,18 @@ gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
   scale = 1;
   if (window)
     {
-      if (GDK_WINDOW_DESTROYED (window) || !GDK_IS_WINDOW (window))
+      if (GDK_SURFACE_DESTROYED (window) || !GDK_IS_SURFACE (window))
         return FALSE;
 
       g_object_ref (window);
-      impl = GDK_WINDOW_IMPL_X11 (window->impl);
+      impl = GDK_SURFACE_IMPL_X11 (window->impl);
       scale = impl->window_scale;
     }
 
   event->any.window = window;
   event->any.send_event = xevent->xany.send_event ? TRUE : FALSE;
 
-  if (window && GDK_WINDOW_DESTROYED (window))
+  if (window && GDK_SURFACE_DESTROYED (window))
     {
       if (xevent->type != DestroyNotify)
         {
@@ -622,10 +622,10 @@ gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
       gdk_event_set_device (event, device_manager->core_pointer);
 
       /* If the subwindow field of the XEvent is non-NULL, then
-       *  lookup the corresponding GdkWindow.
+       *  lookup the corresponding GdkSurface.
        */
       if (xevent->xcrossing.subwindow != None)
-        event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
+        event->crossing.subwindow = gdk_x11_surface_lookup_for_display (display, xevent->xcrossing.subwindow);
       else
         event->crossing.subwindow = NULL;
 
@@ -662,10 +662,10 @@ gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
       gdk_event_set_device (event, device_manager->core_pointer);
 
       /* If the subwindow field of the XEvent is non-NULL, then
-       *  lookup the corresponding GdkWindow.
+       *  lookup the corresponding GdkSurface.
        */
       if (xevent->xcrossing.subwindow != None)
-        event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
+        event->crossing.subwindow = gdk_x11_surface_lookup_for_display (display, xevent->xcrossing.subwindow);
       else
         event->crossing.subwindow = NULL;
 
@@ -792,7 +792,7 @@ _gdk_x11_event_translate_keyboard_string (GdkEventKey *event)
  * window (not a ancestor or child) got or lost the focus
  */
 void
-_gdk_device_manager_core_handle_focus (GdkWindow *window,
+_gdk_device_manager_core_handle_focus (GdkSurface *window,
                                        Window     original,
                                        GdkDevice *device,
                                        GdkDevice *source_device,
@@ -804,17 +804,17 @@ _gdk_device_manager_core_handle_focus (GdkWindow *window,
   GdkX11Screen *x11_screen;
   gboolean had_focus;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
   g_return_if_fail (GDK_IS_DEVICE (device));
   g_return_if_fail (source_device == NULL || GDK_IS_DEVICE (source_device));
 
-  GDK_DISPLAY_NOTE (gdk_window_get_display (window), EVENTS,
+  GDK_DISPLAY_NOTE (gdk_surface_get_display (window), EVENTS,
             g_message ("focus out:\t\twindow: %ld, detail: %s, mode: %s",
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        notify_details[detail],
                        notify_modes[mode]));
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (!toplevel)
     return;
@@ -823,7 +823,7 @@ _gdk_device_manager_core_handle_focus (GdkWindow *window,
     return;
 
   had_focus = HAS_FOCUS (toplevel);
-  x11_screen = GDK_X11_SCREEN (GDK_WINDOW_SCREEN (window));
+  x11_screen = GDK_X11_SCREEN (GDK_SURFACE_SCREEN (window));
 
   switch (detail)
     {
@@ -896,7 +896,7 @@ _gdk_device_manager_core_handle_focus (GdkWindow *window,
       if (source_device)
         gdk_event_set_source_device (event, source_device);
 
-      gdk_display_put_event (gdk_window_get_display (window), event);
+      gdk_display_put_event (gdk_surface_get_display (window), event);
       g_object_unref (event);
     }
 }
diff --git a/gdk/x11/gdkdevicemanager-xi2.c b/gdk/x11/gdkdevicemanager-xi2.c
index 2c12bdd203..19c4002537 100644
--- a/gdk/x11/gdkdevicemanager-xi2.c
+++ b/gdk/x11/gdkdevicemanager-xi2.c
@@ -85,7 +85,7 @@ static GdkEventMask gdk_x11_device_manager_xi2_get_handled_events   (GdkEventTra
 static void         gdk_x11_device_manager_xi2_select_window_events (GdkEventTranslator *translator,
                                                                      Window              window,
                                                                      GdkEventMask        event_mask);
-static GdkWindow *  gdk_x11_device_manager_xi2_get_window           (GdkEventTranslator *translator,
+static GdkSurface *  gdk_x11_device_manager_xi2_get_window           (GdkEventTranslator *translator,
                                                                      const XEvent       *xevent);
 
 enum {
@@ -1061,11 +1061,11 @@ translate_notify_type (gint detail)
 static void
 set_user_time (GdkEvent *event)
 {
-  GdkWindow *window;
+  GdkSurface *window;
   guint32 time;
 
-  window = gdk_window_get_toplevel (event->any.window);
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  window = gdk_surface_get_toplevel (event->any.window);
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
   time = gdk_event_get_time (event);
 
@@ -1073,14 +1073,14 @@ set_user_time (GdkEvent *event)
    * to update the latest user interaction time.
    */
   if (time != GDK_CURRENT_TIME)
-    gdk_x11_window_set_user_time (window, time);
+    gdk_x11_surface_set_user_time (window, time);
 }
 
 static gdouble *
 translate_axes (GdkDevice       *device,
                 gdouble          x,
                 gdouble          y,
-                GdkWindow       *window,
+                GdkSurface       *window,
                 XIValuatorState *valuators)
 {
   guint n_axes, i;
@@ -1132,10 +1132,10 @@ translate_axes (GdkDevice       *device,
 }
 
 static gboolean
-is_parent_of (GdkWindow *parent,
-              GdkWindow *child)
+is_parent_of (GdkSurface *parent,
+              GdkSurface *child)
 {
-  GdkWindow *w;
+  GdkSurface *w;
 
   w = child;
   while (w != NULL)
@@ -1143,7 +1143,7 @@ is_parent_of (GdkWindow *parent,
       if (w == parent)
         return TRUE;
 
-      w = gdk_window_get_parent (w);
+      w = gdk_surface_get_parent (w);
     }
 
   return FALSE;
@@ -1152,10 +1152,10 @@ is_parent_of (GdkWindow *parent,
 static gboolean
 get_event_window (GdkEventTranslator *translator,
                   XIEvent            *ev,
-                  GdkWindow         **window_p)
+                  GdkSurface         **window_p)
 {
   GdkDisplay *display;
-  GdkWindow *window = NULL;
+  GdkSurface *window = NULL;
   gboolean should_have_window = TRUE;
 
   display = GDK_X11_DEVICE_MANAGER_CORE (translator)->display;
@@ -1175,7 +1175,7 @@ get_event_window (GdkEventTranslator *translator,
       {
         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
 
-        window = gdk_x11_window_lookup_for_display (display, xev->event);
+        window = gdk_x11_surface_lookup_for_display (display, xev->event);
 
         /* Apply keyboard grabs to non-native windows */
         if (ev->evtype == XI_KeyPress || ev->evtype == XI_KeyRelease)
@@ -1207,7 +1207,7 @@ get_event_window (GdkEventTranslator *translator,
       {
         XIEnterEvent *xev = (XIEnterEvent *) ev;
 
-        window = gdk_x11_window_lookup_for_display (display, xev->event);
+        window = gdk_x11_surface_lookup_for_display (display, xev->event);
       }
       break;
     default:
@@ -1349,8 +1349,8 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
   const XGenericEventCookie *cookie;
   GdkDevice *device, *source_device;
   gboolean return_val = TRUE;
-  GdkWindow *window;
-  GdkWindowImplX11 *impl;
+  GdkSurface *window;
+  GdkSurfaceImplX11 *impl;
   int scale;
   XIEvent *ev;
 
@@ -1370,13 +1370,13 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
   if (!get_event_window (translator, ev, &window))
     return FALSE;
 
-  if (window && GDK_WINDOW_DESTROYED (window))
+  if (window && GDK_SURFACE_DESTROYED (window))
     return FALSE;
 
   scale = 1;
   if (window)
     {
-      impl = GDK_WINDOW_IMPL_X11 (window->impl);
+      impl = GDK_SURFACE_IMPL_X11 (window->impl);
       scale = impl->window_scale;
     }
 
@@ -1805,7 +1805,7 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
         event->crossing.focus = xev->focus;
 
         event->any.window = window;
-        event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xev->child);
+        event->crossing.subwindow = gdk_x11_surface_lookup_for_display (display, xev->child);
 
         device = g_hash_table_lookup (device_manager->id_table,
                                       GINT_TO_POINTER (xev->deviceid));
@@ -1817,7 +1817,7 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
 
         if (ev->evtype == XI_Enter &&
             xev->detail != XINotifyInferior && xev->mode != XINotifyPassiveUngrab &&
-	    gdk_window_get_window_type (window) == GDK_WINDOW_TOPLEVEL)
+	    gdk_surface_get_window_type (window) == GDK_SURFACE_TOPLEVEL)
           {
             if (gdk_device_get_device_type (source_device) != GDK_DEVICE_TYPE_MASTER)
               _gdk_device_xi2_reset_scroll_valuators (GDK_X11_DEVICE_XI2 (source_device));
@@ -1926,13 +1926,13 @@ gdk_x11_device_manager_xi2_select_window_events (GdkEventTranslator *translator,
   g_free (event_mask.mask);
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_device_manager_xi2_get_window (GdkEventTranslator *translator,
                                        const XEvent       *xevent)
 {
   GdkX11DeviceManagerXI2 *device_manager;
   XIEvent *ev;
-  GdkWindow *window = NULL;
+  GdkSurface *window = NULL;
 
   device_manager = (GdkX11DeviceManagerXI2 *) translator;
 
diff --git a/gdk/x11/gdkdevicemanagerprivate-core.h b/gdk/x11/gdkdevicemanagerprivate-core.h
index 55aa45c748..47ea27dfd1 100644
--- a/gdk/x11/gdkdevicemanagerprivate-core.h
+++ b/gdk/x11/gdkdevicemanagerprivate-core.h
@@ -37,7 +37,7 @@ struct _GdkX11DeviceManagerCoreClass
   GObjectClass parent_class;
 };
 
-void            _gdk_device_manager_core_handle_focus           (GdkWindow   *window,
+void            _gdk_device_manager_core_handle_focus           (GdkSurface   *window,
                                                                  Window       original,
                                                                  GdkDevice   *device,
                                                                  GdkDevice   *source_device,
diff --git a/gdk/x11/gdkdisplay-x11.c b/gdk/x11/gdkdisplay-x11.c
index 28a5344c24..0a2bfbff53 100644
--- a/gdk/x11/gdkdisplay-x11.c
+++ b/gdk/x11/gdkdisplay-x11.c
@@ -199,19 +199,19 @@ gdk_x11_display_event_translator_init (GdkEventTranslatorIface *iface)
   iface->translate_event = gdk_x11_display_translate_event;
 }
 
-#define ANY_EDGE_TILED (GDK_WINDOW_STATE_LEFT_TILED | \
-                        GDK_WINDOW_STATE_RIGHT_TILED | \
-                        GDK_WINDOW_STATE_TOP_TILED | \
-                        GDK_WINDOW_STATE_BOTTOM_TILED)
+#define ANY_EDGE_TILED (GDK_SURFACE_STATE_LEFT_TILED | \
+                        GDK_SURFACE_STATE_RIGHT_TILED | \
+                        GDK_SURFACE_STATE_TOP_TILED | \
+                        GDK_SURFACE_STATE_BOTTOM_TILED)
 
 static void
-do_edge_constraint_state_check (GdkWindow      *window,
-                                GdkWindowState  old_state,
-                                GdkWindowState *set,
-                                GdkWindowState *unset)
+do_edge_constraint_state_check (GdkSurface      *window,
+                                GdkSurfaceState  old_state,
+                                GdkSurfaceState *set,
+                                GdkSurfaceState *unset)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkWindowState local_set, local_unset;
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkSurfaceState local_set, local_unset;
   guint edge_constraints;
 
   local_set = *set;
@@ -220,130 +220,130 @@ do_edge_constraint_state_check (GdkWindow      *window,
 
   /* If the WM doesn't support _GTK_EDGE_CONSTRAINTS, rely on the fallback
    * implementation. If it supports _GTK_EDGE_CONSTRAINTS, arrange for
-   * GDK_WINDOW_STATE_TILED to be set if any edge is tiled, and cleared
+   * GDK_SURFACE_STATE_TILED to be set if any edge is tiled, and cleared
    * if no edge is tiled.
    */
-  if (!gdk_window_supports_edge_constraints (window))
+  if (!gdk_surface_supports_edge_constraints (window))
     {
       /* FIXME: we rely on implementation details of mutter here:
        * mutter only tiles horizontally, and sets maxvert when it does
        * and if it tiles, it always affects all edges
        */
-      if (old_state & GDK_WINDOW_STATE_TILED)
+      if (old_state & GDK_SURFACE_STATE_TILED)
         {
           if (!toplevel->have_maxvert)
-            local_unset |= GDK_WINDOW_STATE_TILED;
+            local_unset |= GDK_SURFACE_STATE_TILED;
         }
       else
         {
           if (toplevel->have_maxvert && !toplevel->have_maxhorz)
-            local_set |= GDK_WINDOW_STATE_TILED;
+            local_set |= GDK_SURFACE_STATE_TILED;
         }
     }
   else
     {
-      if (old_state & GDK_WINDOW_STATE_TILED)
+      if (old_state & GDK_SURFACE_STATE_TILED)
         {
           if (!(edge_constraints & ANY_EDGE_TILED))
-            local_unset |= GDK_WINDOW_STATE_TILED;
+            local_unset |= GDK_SURFACE_STATE_TILED;
         }
       else
         {
           if (edge_constraints & ANY_EDGE_TILED)
-            local_set |= GDK_WINDOW_STATE_TILED;
+            local_set |= GDK_SURFACE_STATE_TILED;
         }
     }
 
   /* Top edge */
-  if (old_state & GDK_WINDOW_STATE_TOP_TILED)
+  if (old_state & GDK_SURFACE_STATE_TOP_TILED)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_TOP_TILED) == 0)
-        local_unset |= GDK_WINDOW_STATE_TOP_TILED;
+      if ((edge_constraints & GDK_SURFACE_STATE_TOP_TILED) == 0)
+        local_unset |= GDK_SURFACE_STATE_TOP_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_TOP_TILED)
-        local_set |= GDK_WINDOW_STATE_TOP_TILED;
+      if (edge_constraints & GDK_SURFACE_STATE_TOP_TILED)
+        local_set |= GDK_SURFACE_STATE_TOP_TILED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_TOP_RESIZABLE)
+  if (old_state & GDK_SURFACE_STATE_TOP_RESIZABLE)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_TOP_RESIZABLE) == 0)
-        local_unset |= GDK_WINDOW_STATE_TOP_RESIZABLE;
+      if ((edge_constraints & GDK_SURFACE_STATE_TOP_RESIZABLE) == 0)
+        local_unset |= GDK_SURFACE_STATE_TOP_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_TOP_RESIZABLE)
-        local_set |= GDK_WINDOW_STATE_TOP_RESIZABLE;
+      if (edge_constraints & GDK_SURFACE_STATE_TOP_RESIZABLE)
+        local_set |= GDK_SURFACE_STATE_TOP_RESIZABLE;
     }
 
   /* Right edge */
-  if (old_state & GDK_WINDOW_STATE_RIGHT_TILED)
+  if (old_state & GDK_SURFACE_STATE_RIGHT_TILED)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_RIGHT_TILED) == 0)
-        local_unset |= GDK_WINDOW_STATE_RIGHT_TILED;
+      if ((edge_constraints & GDK_SURFACE_STATE_RIGHT_TILED) == 0)
+        local_unset |= GDK_SURFACE_STATE_RIGHT_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_RIGHT_TILED)
-        local_set |= GDK_WINDOW_STATE_RIGHT_TILED;
+      if (edge_constraints & GDK_SURFACE_STATE_RIGHT_TILED)
+        local_set |= GDK_SURFACE_STATE_RIGHT_TILED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_RIGHT_RESIZABLE)
+  if (old_state & GDK_SURFACE_STATE_RIGHT_RESIZABLE)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_RIGHT_RESIZABLE) == 0)
-        local_unset |= GDK_WINDOW_STATE_RIGHT_RESIZABLE;
+      if ((edge_constraints & GDK_SURFACE_STATE_RIGHT_RESIZABLE) == 0)
+        local_unset |= GDK_SURFACE_STATE_RIGHT_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_RIGHT_RESIZABLE)
-        local_set |= GDK_WINDOW_STATE_RIGHT_RESIZABLE;
+      if (edge_constraints & GDK_SURFACE_STATE_RIGHT_RESIZABLE)
+        local_set |= GDK_SURFACE_STATE_RIGHT_RESIZABLE;
     }
 
   /* Bottom edge */
-  if (old_state & GDK_WINDOW_STATE_BOTTOM_TILED)
+  if (old_state & GDK_SURFACE_STATE_BOTTOM_TILED)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_BOTTOM_TILED) == 0)
-        local_unset |= GDK_WINDOW_STATE_BOTTOM_TILED;
+      if ((edge_constraints & GDK_SURFACE_STATE_BOTTOM_TILED) == 0)
+        local_unset |= GDK_SURFACE_STATE_BOTTOM_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_BOTTOM_TILED)
-        local_set |= GDK_WINDOW_STATE_BOTTOM_TILED;
+      if (edge_constraints & GDK_SURFACE_STATE_BOTTOM_TILED)
+        local_set |= GDK_SURFACE_STATE_BOTTOM_TILED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_BOTTOM_RESIZABLE)
+  if (old_state & GDK_SURFACE_STATE_BOTTOM_RESIZABLE)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_BOTTOM_RESIZABLE) == 0)
-        local_unset |= GDK_WINDOW_STATE_BOTTOM_RESIZABLE;
+      if ((edge_constraints & GDK_SURFACE_STATE_BOTTOM_RESIZABLE) == 0)
+        local_unset |= GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_BOTTOM_RESIZABLE)
-        local_set |= GDK_WINDOW_STATE_BOTTOM_RESIZABLE;
+      if (edge_constraints & GDK_SURFACE_STATE_BOTTOM_RESIZABLE)
+        local_set |= GDK_SURFACE_STATE_BOTTOM_RESIZABLE;
     }
 
   /* Left edge */
-  if (old_state & GDK_WINDOW_STATE_LEFT_TILED)
+  if (old_state & GDK_SURFACE_STATE_LEFT_TILED)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_LEFT_TILED) == 0)
-        local_unset |= GDK_WINDOW_STATE_LEFT_TILED;
+      if ((edge_constraints & GDK_SURFACE_STATE_LEFT_TILED) == 0)
+        local_unset |= GDK_SURFACE_STATE_LEFT_TILED;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_LEFT_TILED)
-        local_set |= GDK_WINDOW_STATE_LEFT_TILED;
+      if (edge_constraints & GDK_SURFACE_STATE_LEFT_TILED)
+        local_set |= GDK_SURFACE_STATE_LEFT_TILED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_LEFT_RESIZABLE)
+  if (old_state & GDK_SURFACE_STATE_LEFT_RESIZABLE)
     {
-      if ((edge_constraints & GDK_WINDOW_STATE_LEFT_RESIZABLE) == 0)
-        local_unset |= GDK_WINDOW_STATE_LEFT_RESIZABLE;
+      if ((edge_constraints & GDK_SURFACE_STATE_LEFT_RESIZABLE) == 0)
+        local_unset |= GDK_SURFACE_STATE_LEFT_RESIZABLE;
     }
   else
     {
-      if (edge_constraints & GDK_WINDOW_STATE_LEFT_RESIZABLE)
-        local_set |= GDK_WINDOW_STATE_LEFT_RESIZABLE;
+      if (edge_constraints & GDK_SURFACE_STATE_LEFT_RESIZABLE)
+        local_set |= GDK_SURFACE_STATE_LEFT_RESIZABLE;
     }
 
   *set = local_set;
@@ -351,78 +351,78 @@ do_edge_constraint_state_check (GdkWindow      *window,
 }
 
 static void
-do_net_wm_state_changes (GdkWindow *window)
+do_net_wm_state_changes (GdkSurface *window)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkWindowState old_state, set, unset;
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkSurfaceState old_state, set, unset;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
-      gdk_window_get_window_type (window) != GDK_WINDOW_TOPLEVEL)
+  if (GDK_SURFACE_DESTROYED (window) ||
+      gdk_surface_get_window_type (window) != GDK_SURFACE_TOPLEVEL)
     return;
 
-  old_state = gdk_window_get_state (window);
+  old_state = gdk_surface_get_state (window);
 
   set = unset = 0;
 
   /* For found_sticky to remain TRUE, we have to also be on desktop
    * 0xFFFFFFFF
    */
-  if (old_state & GDK_WINDOW_STATE_STICKY)
+  if (old_state & GDK_SURFACE_STATE_STICKY)
     {
       if (!(toplevel->have_sticky && toplevel->on_all_desktops))
-        unset |= GDK_WINDOW_STATE_STICKY;
+        unset |= GDK_SURFACE_STATE_STICKY;
     }
   else
     {
       if (toplevel->have_sticky && toplevel->on_all_desktops)
-        set |= GDK_WINDOW_STATE_STICKY;
+        set |= GDK_SURFACE_STATE_STICKY;
     }
 
-  if (old_state & GDK_WINDOW_STATE_FULLSCREEN)
+  if (old_state & GDK_SURFACE_STATE_FULLSCREEN)
     {
       if (!toplevel->have_fullscreen)
-        unset |= GDK_WINDOW_STATE_FULLSCREEN;
+        unset |= GDK_SURFACE_STATE_FULLSCREEN;
     }
   else
     {
       if (toplevel->have_fullscreen)
-        set |= GDK_WINDOW_STATE_FULLSCREEN;
+        set |= GDK_SURFACE_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 (old_state & GDK_SURFACE_STATE_MAXIMIZED)
     {
       if (!(toplevel->have_maxvert && toplevel->have_maxhorz))
-        unset |= GDK_WINDOW_STATE_MAXIMIZED;
+        unset |= GDK_SURFACE_STATE_MAXIMIZED;
     }
   else
     {
       if (toplevel->have_maxvert && toplevel->have_maxhorz)
-        set |= GDK_WINDOW_STATE_MAXIMIZED;
+        set |= GDK_SURFACE_STATE_MAXIMIZED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_FOCUSED)
+  if (old_state & GDK_SURFACE_STATE_FOCUSED)
     {
       if (!toplevel->have_focused)
-        unset |= GDK_WINDOW_STATE_FOCUSED;
+        unset |= GDK_SURFACE_STATE_FOCUSED;
     }
   else
     {
       if (toplevel->have_focused)
-        set |= GDK_WINDOW_STATE_FOCUSED;
+        set |= GDK_SURFACE_STATE_FOCUSED;
     }
 
-  if (old_state & GDK_WINDOW_STATE_ICONIFIED)
+  if (old_state & GDK_SURFACE_STATE_ICONIFIED)
     {
       if (!toplevel->have_hidden)
-        unset |= GDK_WINDOW_STATE_ICONIFIED;
+        unset |= GDK_SURFACE_STATE_ICONIFIED;
     }
   else
     {
       if (toplevel->have_hidden)
-        set |= GDK_WINDOW_STATE_ICONIFIED;
+        set |= GDK_SURFACE_STATE_ICONIFIED;
     }
 
   /* Update edge constraints and tiling */
@@ -432,10 +432,10 @@ do_net_wm_state_changes (GdkWindow *window)
 }
 
 static void
-gdk_check_wm_desktop_changed (GdkWindow *window)
+gdk_check_wm_desktop_changed (GdkSurface *window)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
 
   Atom type;
   gint format;
@@ -447,7 +447,7 @@ gdk_check_wm_desktop_changed (GdkWindow *window)
   type = None;
   gdk_x11_display_error_trap_push (display);
   XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
-                      GDK_WINDOW_XID (window),
+                      GDK_SURFACE_XID (window),
                       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),
                       0, G_MAXLONG, False, XA_CARDINAL, &type,
                       &format, &nitems,
@@ -467,11 +467,11 @@ gdk_check_wm_desktop_changed (GdkWindow *window)
 }
 
 static void
-gdk_check_wm_state_changed (GdkWindow *window)
+gdk_check_wm_state_changed (GdkSurface *window)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
-  GdkX11Screen *screen = GDK_WINDOW_SCREEN (window);
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
+  GdkX11Screen *screen = GDK_SURFACE_SCREEN (window);
 
   Atom type;
   gint format;
@@ -492,7 +492,7 @@ gdk_check_wm_state_changed (GdkWindow *window)
 
   type = None;
   gdk_x11_display_error_trap_push (display);
-  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_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);
@@ -545,10 +545,10 @@ gdk_check_wm_state_changed (GdkWindow *window)
 }
 
 static void
-gdk_check_edge_constraints_changed (GdkWindow *window)
+gdk_check_edge_constraints_changed (GdkSurface *window)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
 
   Atom type;
   gint format;
@@ -560,7 +560,7 @@ gdk_check_edge_constraints_changed (GdkWindow *window)
   type = None;
   gdk_x11_display_error_trap_push (display);
   XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
-                      GDK_WINDOW_XID (window),
+                      GDK_SURFACE_XID (window),
                       gdk_x11_get_xatom_by_name_for_display (display, "_GTK_EDGE_CONSTRAINTS"),
                       0, G_MAXLONG, False, XA_CARDINAL, &type,
                       &format, &nitems,
@@ -635,15 +635,15 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
                                  const XEvent       *xevent)
 {
   Window xwindow;
-  GdkWindow *window;
+  GdkSurface *window;
   gboolean is_substructure;
-  GdkWindowImplX11 *window_impl = NULL;
+  GdkSurfaceImplX11 *window_impl = NULL;
   GdkX11Screen *x11_screen = NULL;
   GdkToplevelX11 *toplevel = NULL;
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
   gboolean return_val;
 
-  /* Find the GdkWindow that this event relates to. If that's
+  /* Find the GdkSurface that this event relates to. If that's
    * not the same as the window that the event was sent to,
    * we are getting an event from SubstructureNotifyMask.
    * We ignore such events for internal operation, but we
@@ -656,18 +656,18 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
   xwindow = get_event_xwindow (xevent);
   is_substructure = xwindow != xevent->xany.window;
 
-  window = gdk_x11_window_lookup_for_display (display, xwindow);
+  window = gdk_x11_surface_lookup_for_display (display, xwindow);
   if (window)
     {
       /* We may receive events such as NoExpose/GraphicsExpose
        * and ShmCompletion for pixmaps
        */
-      if (!GDK_IS_WINDOW (window))
+      if (!GDK_IS_SURFACE (window))
         return FALSE;
 
-      x11_screen = GDK_WINDOW_SCREEN (window);
-      toplevel = _gdk_x11_window_get_toplevel (window);
-      window_impl = GDK_WINDOW_IMPL_X11 (window->impl);
+      x11_screen = GDK_SURFACE_SCREEN (window);
+      toplevel = _gdk_x11_surface_get_toplevel (window);
+      window_impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
       g_object_ref (window);
     }
@@ -675,7 +675,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
   event->any.window = window;
   event->any.send_event = xevent->xany.send_event ? TRUE : FALSE;
 
-  if (window && GDK_WINDOW_DESTROYED (window))
+  if (window && GDK_SURFACE_DESTROYED (window))
     {
       if (xevent->type != DestroyNotify)
 	{
@@ -748,7 +748,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
         y2 = (xevent->xexpose.y + xevent->xexpose.height + window_impl->window_scale -1) / window_impl->window_scale;
         expose_rect.height = y2 - expose_rect.y;
 
-        _gdk_x11_window_process_expose (window, xevent->xexpose.serial, &expose_rect);
+        _gdk_x11_surface_process_expose (window, xevent->xexpose.serial, &expose_rect);
         return_val = FALSE;
       }
 
@@ -778,7 +778,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
         y2 = (xevent->xgraphicsexpose.y + xevent->xgraphicsexpose.height + window_impl->window_scale -1) / window_impl->window_scale;
         expose_rect.height = y2 - expose_rect.y;
 
-        _gdk_x11_window_process_expose (window, xevent->xgraphicsexpose.serial, &expose_rect);
+        _gdk_x11_surface_process_expose (window, xevent->xgraphicsexpose.serial, &expose_rect);
         return_val = FALSE;
       }
       break;
@@ -832,10 +832,10 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
 	  event->any.type = GDK_DESTROY;
 	  event->any.window = window;
 
-	  return_val = window && !GDK_WINDOW_DESTROYED (window);
+	  return_val = window && !GDK_SURFACE_DESTROYED (window);
 
-	  if (window && GDK_WINDOW_XID (window) != x11_screen->xroot_window)
-	    gdk_window_destroy_notify (window);
+	  if (window && GDK_SURFACE_XID (window) != x11_screen->xroot_window)
+	    gdk_surface_destroy_notify (window);
 	}
       else
 	return_val = FALSE;
@@ -865,23 +865,23 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
                * means we hid the window ourselves, so we will have already flipped
                * the iconified bit off.
                */
-              if (GDK_WINDOW_IS_MAPPED (window))
+              if (GDK_SURFACE_IS_MAPPED (window))
                 gdk_synthesize_window_state (window,
                                              0,
-                                             GDK_WINDOW_STATE_ICONIFIED);
+                                             GDK_SURFACE_STATE_ICONIFIED);
             }
 
           if (window_impl->toplevel &&
               window_impl->toplevel->frame_pending)
             {
               window_impl->toplevel->frame_pending = FALSE;
-              _gdk_frame_clock_thaw (gdk_window_get_frame_clock (event->any.window));
+              _gdk_frame_clock_thaw (gdk_surface_get_frame_clock (event->any.window));
             }
 
 	  if (toplevel)
-            gdk_window_freeze_toplevel_updates (window);
+            gdk_surface_freeze_toplevel_updates (window);
 
-          _gdk_x11_window_grab_check_unmap (window, xevent->xany.serial);
+          _gdk_x11_surface_grab_check_unmap (window, xevent->xany.serial);
         }
 
       break;
@@ -897,13 +897,13 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
       if (window && !is_substructure)
 	{
 	  /* Unset iconified if it was set */
-	  if (window->state & GDK_WINDOW_STATE_ICONIFIED)
+	  if (window->state & GDK_SURFACE_STATE_ICONIFIED)
 	    gdk_synthesize_window_state (window,
-					 GDK_WINDOW_STATE_ICONIFIED,
+					 GDK_SURFACE_STATE_ICONIFIED,
 					 0);
 
 	  if (toplevel)
-	    gdk_window_thaw_toplevel_updates (window);
+	    gdk_surface_thaw_toplevel_updates (window);
 	}
 
       break;
@@ -934,7 +934,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
 			   xevent->xconfigure.override_redirect,
 			   !window
 			   ? " (discarding)"
-			   : window->window_type == GDK_WINDOW_CHILD
+			   : window->window_type == GDK_SURFACE_CHILD
 			   ? " (discarding child)"
 			   : xevent->xconfigure.event != xevent->xconfigure.window
 			   ? " (discarding substructure)"
@@ -955,7 +955,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
 
     if (!window ||
 	  xevent->xconfigure.event != xevent->xconfigure.window ||
-          GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
+          GDK_SURFACE_TYPE (window) == GDK_SURFACE_CHILD)
 	return_val = FALSE;
       else
 	{
@@ -966,15 +966,15 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
 
 	  if (!xevent->xconfigure.send_event &&
 	      !xevent->xconfigure.override_redirect &&
-	      !GDK_WINDOW_DESTROYED (window))
+	      !GDK_SURFACE_DESTROYED (window))
 	    {
 	      gint tx = 0;
 	      gint ty = 0;
 	      Window child_window = 0;
 
 	      gdk_x11_display_error_trap_push (display);
-	      if (XTranslateCoordinates (GDK_WINDOW_XDISPLAY (window),
-					 GDK_WINDOW_XID (window),
+	      if (XTranslateCoordinates (GDK_SURFACE_XDISPLAY (window),
+					 GDK_SURFACE_XID (window),
 					 x11_screen->xroot_window,
 					 0, 0,
 					 &tx, &ty,
@@ -1003,8 +1003,8 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
                   window->width = event->configure.width;
                   window->height = event->configure.height;
 
-                  _gdk_window_update_size (window);
-                  _gdk_x11_window_update_size (window_impl);
+                  _gdk_surface_update_size (window);
+                  _gdk_x11_surface_update_size (window_impl);
                 }
 
 	      if (window->resize_count >= 1)
@@ -1172,7 +1172,7 @@ server_time_to_monotonic_time (GdkX11Display *display_x11,
       (!display_x11->server_time_is_monotonic_time &&
        server_time > display_x11->server_time_query_time + 10*1000*1000)) /* 10 seconds */
     {
-      gint64 current_server_time = gdk_x11_get_server_time (display_x11->leader_gdk_window);
+      gint64 current_server_time = gdk_x11_get_server_time (display_x11->leader_gdk_surface);
       gint64 current_server_time_usec = (gint64)current_server_time * 1000;
       gint64 current_monotonic_time = g_get_monotonic_time ();
       display_x11->server_time_query_time = current_monotonic_time;
@@ -1201,24 +1201,24 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
 			  GdkEvent     *event,
 			  gpointer      data)
 {
-  GdkWindow *win = event->any.window;
+  GdkSurface *win = event->any.window;
   GdkDisplay *display;
   Atom atom;
 
-  if (!GDK_IS_X11_WINDOW (win) || GDK_WINDOW_DESTROYED (win))
+  if (!GDK_IS_X11_SURFACE (win) || GDK_SURFACE_DESTROYED (win))
     return GDK_FILTER_CONTINUE;
 
   if (xevent->type != ClientMessage)
     return GDK_FILTER_CONTINUE;
 
-  display = GDK_WINDOW_DISPLAY (win);
+  display = GDK_SURFACE_DISPLAY (win);
 
   /* This isn't actually WM_PROTOCOLS because that wouldn't leave enough space
    * in the message for everything that gets stuffed in */
   if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_FRAME_DRAWN"))
     {
-      GdkWindowImplX11 *window_impl;
-      window_impl = GDK_WINDOW_IMPL_X11 (win->impl);
+      GdkSurfaceImplX11 *window_impl;
+      window_impl = GDK_SURFACE_IMPL_X11 (win->impl);
       if (window_impl->toplevel)
         {
           guint32 d0 = xevent->xclient.data.l[0];
@@ -1230,7 +1230,7 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
           gint64 frame_drawn_time = server_time_to_monotonic_time (GDK_X11_DISPLAY (display), ((guint64)d3 << 32) | d2);
           gint64 refresh_interval, presentation_time;
 
-          GdkFrameClock *clock = gdk_window_get_frame_clock (win);
+          GdkFrameClock *clock = gdk_surface_get_frame_clock (win);
           GdkFrameTimings *timings = find_frame_timings (clock, serial);
 
           if (timings)
@@ -1255,8 +1255,8 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
 
   if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_FRAME_TIMINGS"))
     {
-      GdkWindowImplX11 *window_impl;
-      window_impl = GDK_WINDOW_IMPL_X11 (win->impl);
+      GdkSurfaceImplX11 *window_impl;
+      window_impl = GDK_SURFACE_IMPL_X11 (win->impl);
       if (window_impl->toplevel)
         {
           guint32 d0 = xevent->xclient.data.l[0];
@@ -1266,7 +1266,7 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
 
           guint64 serial = ((guint64)d1 << 32) | d0;
 
-          GdkFrameClock *clock = gdk_window_get_frame_clock (win);
+          GdkFrameClock *clock = gdk_surface_get_frame_clock (win);
           GdkFrameTimings *timings = find_frame_timings (clock, serial);
 
           if (timings)
@@ -1310,13 +1310,13 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
 
       event->any.type = GDK_DELETE;
 
-      gdk_x11_window_set_user_time (win, xevent->xclient.data.l[1]);
+      gdk_x11_surface_set_user_time (win, xevent->xclient.data.l[1]);
 
       return GDK_FILTER_TRANSLATE;
     }
   else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "WM_TAKE_FOCUS"))
     {
-      GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (win);
+      GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (win);
 
       /* There is no way of knowing reliably whether we are viewable;
        * so trap errors asynchronously around the XSetInputFocus call
@@ -1338,8 +1338,8 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
     {
       XClientMessageEvent xclient = xevent->xclient;
 
-      xclient.window = GDK_WINDOW_XROOTWIN (win);
-      XSendEvent (GDK_WINDOW_XDISPLAY (win),
+      xclient.window = GDK_SURFACE_XROOTWIN (win);
+      XSendEvent (GDK_SURFACE_XDISPLAY (win),
 		  xclient.window,
 		  False,
 		  SubstructureRedirectMask | SubstructureNotifyMask, (XEvent *)&xclient);
@@ -1349,7 +1349,7 @@ _gdk_wm_protocols_filter (const XEvent *xevent,
   else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_SYNC_REQUEST") &&
 	   GDK_X11_DISPLAY (display)->use_sync)
     {
-      GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (win);
+      GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (win);
       if (toplevel)
 	{
 #ifdef HAVE_XSYNC
@@ -1493,10 +1493,10 @@ gdk_x11_display_open (const gchar *display_name)
 
   gdk_event_init (display);
 
-  display_x11->leader_gdk_window = gdk_window_new_temp (display);
-  (_gdk_x11_window_get_toplevel (display_x11->leader_gdk_window))->is_leader = TRUE;
+  display_x11->leader_gdk_surface = gdk_surface_new_temp (display);
+  (_gdk_x11_surface_get_toplevel (display_x11->leader_gdk_surface))->is_leader = TRUE;
 
-  display_x11->leader_window = GDK_WINDOW_XID (display_x11->leader_gdk_window);
+  display_x11->leader_window = GDK_SURFACE_XID (display_x11->leader_gdk_surface);
 
   display_x11->leader_window_title_set = FALSE;
 
@@ -1811,7 +1811,7 @@ device_grab_update_callback (GdkDisplay *display,
                              gpointer    data,
                              gulong      serial)
 {
-  GdkPointerWindowInfo *pointer_info;
+  GdkPointerSurfaceInfo *pointer_info;
   GdkDevice *device = data;
 
   pointer_info = _gdk_display_get_pointer_info (display, device);
@@ -1884,12 +1884,12 @@ gdk_x11_display_has_pending (GdkDisplay *display)
   return XPending (GDK_DISPLAY_XDISPLAY (display));
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_display_get_default_group (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
-  return GDK_X11_DISPLAY (display)->leader_gdk_window;
+  return GDK_X11_DISPLAY (display)->leader_gdk_surface;
 }
 
 /**
@@ -1982,7 +1982,7 @@ gdk_x11_display_finalize (GObject *object)
   /* List of event window extraction functions */
   g_slist_free_full (display_x11->event_types, g_free);
 
-  /* input GdkWindow list */
+  /* input GdkSurface list */
   g_list_free_full (display_x11->input_windows, g_free);
 
   /* Free all GdkX11Screens */
@@ -2378,7 +2378,7 @@ gdk_x11_display_request_selection_notification (GdkDisplay *display,
  * Returns the timestamp of the last user interaction on 
  * @display. The timestamp is taken from events caused
  * by user interaction such as key presses or pointer 
- * movements. See gdk_x11_window_set_user_time().
+ * movements. See gdk_x11_surface_set_user_time().
  *
  * Returns: the timestamp of the last user interaction 
  */
@@ -3006,7 +3006,7 @@ gdk_x11_display_get_toplevel_windows (GdkDisplay *display)
 static guint32
 gdk_x11_display_get_last_seen_time (GdkDisplay *display)
 {
-  return gdk_x11_get_server_time (GDK_X11_DISPLAY (display)->leader_gdk_window);
+  return gdk_x11_get_server_time (GDK_X11_DISPLAY (display)->leader_gdk_surface);
 }
 
 static gboolean
@@ -3034,7 +3034,7 @@ gdk_x11_display_class_init (GdkX11DisplayClass * class)
   object_class->dispose = gdk_x11_display_dispose;
   object_class->finalize = gdk_x11_display_finalize;
 
-  display_class->window_type = GDK_TYPE_X11_WINDOW;
+  display_class->window_type = GDK_TYPE_X11_SURFACE;
 #ifdef GDK_RENDERING_VULKAN
   display_class->vk_context_type = GDK_TYPE_X11_VULKAN_CONTEXT;
   display_class->vk_extension_name = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
@@ -3105,5 +3105,5 @@ gdk_x11_display_class_init (GdkX11DisplayClass * class)
                   _gdk_marshal_BOOLEAN__POINTER,
                   G_TYPE_BOOLEAN, 1, G_TYPE_POINTER);
 
-  _gdk_x11_windowing_init ();
+  _gdk_x11_surfaceing_init ();
 }
diff --git a/gdk/x11/gdkdisplay-x11.h b/gdk/x11/gdkdisplay-x11.h
index ff000857e9..ed08da2ff1 100644
--- a/gdk/x11/gdkdisplay-x11.h
+++ b/gdk/x11/gdkdisplay-x11.h
@@ -96,7 +96,7 @@ struct _GdkX11Display
   /* Session Management leader window see ICCCM */
   char *program_class;
   Window leader_window;
-  GdkWindow *leader_gdk_window;
+  GdkSurface *leader_gdk_surface;
   gboolean leader_window_title_set;
 
   /* List of functions to go from extension event => X window */
@@ -111,7 +111,7 @@ struct _GdkX11Display
   /* streams reading selections */
   GSList *streams;
 
-  /* input GdkWindow list */
+  /* input GdkSurface list */
   GList *input_windows;
 
   /* GdkCursor => XCursor */
diff --git a/gdk/x11/gdkdnd-x11.c b/gdk/x11/gdkdnd-x11.c
index 10b25dad51..eff6658986 100644
--- a/gdk/x11/gdkdnd-x11.c
+++ b/gdk/x11/gdkdnd-x11.c
@@ -84,7 +84,7 @@ typedef struct {
   cairo_region_t *shape;
 } GdkCacheChild;
 
-struct _GdkWindowCache {
+struct _GdkSurfaceCache {
   GList *children;
   GHashTable *child_hash;
   guint old_event_mask;
@@ -109,11 +109,11 @@ struct _GdkX11DragContext
   GdkDragAction xdnd_actions;  /* What is currently set in XdndActionList */
   guint version;               /* Xdnd protocol version */
 
-  GdkWindowCache *cache;
+  GdkSurfaceCache *cache;
 
-  GdkWindow *drag_window;
+  GdkSurface *drag_window;
 
-  GdkWindow *ipc_window;
+  GdkSurface *ipc_window;
   GdkCursor *cursor;
   GdkSeat *grab_seat;
   GdkDragAction actions;
@@ -167,8 +167,8 @@ static GrabKey grab_keys[] = {
 
 /* Forward declarations */
 
-static GdkWindowCache *gdk_window_cache_ref   (GdkWindowCache *cache);
-static void            gdk_window_cache_unref (GdkWindowCache *cache);
+static GdkSurfaceCache *gdk_surface_cache_ref   (GdkSurfaceCache *cache);
+static void            gdk_surface_cache_unref (GdkSurfaceCache *cache);
 
 static GdkFilterReturn xdnd_enter_filter    (const XEvent *xevent,
                                              GdkEvent     *event,
@@ -190,7 +190,7 @@ static GdkFilterReturn xdnd_drop_filter     (const XEvent *xevent,
                                              gpointer      data);
 
 static void   xdnd_manage_source_filter (GdkDragContext *context,
-                                         GdkWindow      *window,
+                                         GdkSurface      *window,
                                          gboolean        add_filter);
 
 gboolean gdk_x11_drag_context_handle_event (GdkDragContext *context,
@@ -223,13 +223,13 @@ gdk_x11_drag_context_init (GdkX11DragContext *context)
 }
 
 static void        gdk_x11_drag_context_finalize (GObject *object);
-static GdkWindow * gdk_x11_drag_context_find_window (GdkDragContext  *context,
-                                                     GdkWindow       *drag_window,
+static GdkSurface * gdk_x11_drag_context_find_window (GdkDragContext  *context,
+                                                     GdkSurface       *drag_window,
                                                      gint             x_root,
                                                      gint             y_root,
                                                      GdkDragProtocol *protocol);
 static gboolean    gdk_x11_drag_context_drag_motion (GdkDragContext  *context,
-                                                     GdkWindow       *dest_window,
+                                                     GdkSurface       *dest_window,
                                                      GdkDragProtocol  protocol,
                                                      gint             x_root,
                                                      gint             y_root,
@@ -250,7 +250,7 @@ static void        gdk_x11_drag_context_drop_finish (GdkDragContext  *context,
                                                      gboolean         success,
                                                      guint32          time_);
 static gboolean    gdk_x11_drag_context_drop_status (GdkDragContext  *context);
-static GdkWindow * gdk_x11_drag_context_get_drag_window (GdkDragContext *context);
+static GdkSurface * gdk_x11_drag_context_get_drag_window (GdkDragContext *context);
 static void        gdk_x11_drag_context_set_hotspot (GdkDragContext  *context,
                                                      gint             hot_x,
                                                      gint             hot_y);
@@ -423,7 +423,7 @@ gdk_x11_drag_context_finalize (GObject *object)
 {
   GdkDragContext *context = GDK_DRAG_CONTEXT (object);
   GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (object);
-  GdkWindow *drag_window, *ipc_window;
+  GdkSurface *drag_window, *ipc_window;
 
   if (context->source_window)
     {
@@ -432,7 +432,7 @@ gdk_x11_drag_context_finalize (GObject *object)
     }
 
   if (x11_context->cache)
-    gdk_window_cache_unref (x11_context->cache);
+    gdk_surface_cache_unref (x11_context->cache);
 
   contexts = g_list_remove (contexts, context);
 
@@ -442,9 +442,9 @@ gdk_x11_drag_context_finalize (GObject *object)
   G_OBJECT_CLASS (gdk_x11_drag_context_parent_class)->finalize (object);
 
   if (drag_window)
-    gdk_window_destroy (drag_window);
+    gdk_surface_destroy (drag_window);
   if (ipc_window)
-    gdk_window_destroy (ipc_window);
+    gdk_surface_destroy (ipc_window);
 }
 
 /* Drag Contexts */
@@ -465,19 +465,19 @@ gdk_drag_context_find (GdkDisplay *display,
       context = (GdkDragContext *)tmp_list->data;
       context_x11 = (GdkX11DragContext *)context;
 
-      if ((context->source_window && gdk_window_get_display (context->source_window) != display) ||
-          (context->dest_window && gdk_window_get_display (context->dest_window) != display))
+      if ((context->source_window && gdk_surface_get_display (context->source_window) != display) ||
+          (context->dest_window && gdk_surface_get_display (context->dest_window) != display))
         continue;
 
       context_dest_xid = context->dest_window
                             ? (context_x11->drop_xid
                                   ? context_x11->drop_xid
-                                  : GDK_WINDOW_XID (context->dest_window))
+                                  : GDK_SURFACE_XID (context->dest_window))
                             : None;
 
       if ((!context->is_source == !is_source) &&
           ((source_xid == None) || (context->source_window &&
-            (GDK_WINDOW_XID (context->source_window) == source_xid))) &&
+            (GDK_SURFACE_XID (context->source_window) == source_xid))) &&
           ((dest_xid == None) || (context_dest_xid == dest_xid)))
         return context;
     }
@@ -521,7 +521,7 @@ free_cache_child (GdkCacheChild *child,
 }
 
 static void
-gdk_window_cache_add (GdkWindowCache *cache,
+gdk_surface_cache_add (GdkSurfaceCache *cache,
                       guint32         xid,
                       gint            x,
                       gint            y,
@@ -547,11 +547,11 @@ gdk_window_cache_add (GdkWindowCache *cache,
 }
 
 GdkFilterReturn
-gdk_window_cache_shape_filter (const XEvent *xevent,
+gdk_surface_cache_shape_filter (const XEvent *xevent,
                                GdkEvent     *event,
                                gpointer      data)
 {
-  GdkWindowCache *cache = data;
+  GdkSurfaceCache *cache = data;
 
   GdkX11Display *display = GDK_X11_DISPLAY (cache->display);
 
@@ -581,11 +581,11 @@ gdk_window_cache_shape_filter (const XEvent *xevent,
 }
 
 GdkFilterReturn
-gdk_window_cache_filter (const XEvent *xevent,
+gdk_surface_cache_filter (const XEvent *xevent,
                          GdkEvent     *event,
                          gpointer      data)
 {
-  GdkWindowCache *cache = data;
+  GdkSurfaceCache *cache = data;
 
   switch (xevent->type)
     {
@@ -639,7 +639,7 @@ gdk_window_cache_filter (const XEvent *xevent,
 
         if (!g_hash_table_lookup (cache->child_hash,
                                   GUINT_TO_POINTER (xcwe->window)))
-          gdk_window_cache_add (cache, xcwe->window,
+          gdk_surface_cache_add (cache, xcwe->window,
                                 xcwe->x, xcwe->y, xcwe->width, xcwe->height,
                                 FALSE);
         break;
@@ -700,8 +700,8 @@ gdk_window_cache_filter (const XEvent *xevent,
   return GDK_FILTER_REMOVE;
 }
 
-static GdkWindowCache *
-gdk_window_cache_new (GdkDisplay *display)
+static GdkSurfaceCache *
+gdk_surface_cache_new (GdkDisplay *display)
 {
   XWindowAttributes xwa;
   GdkX11Screen *screen = GDK_X11_DISPLAY (display)->screen;
@@ -713,7 +713,7 @@ gdk_window_cache_new (GdkDisplay *display)
   Window cow;
 #endif
 
-  GdkWindowCache *result = g_new (GdkWindowCache, 1);
+  GdkSurfaceCache *result = g_new (GdkSurfaceCache, 1);
 
   result->children = NULL;
   result->child_hash = g_hash_table_new (g_direct_hash, NULL);
@@ -726,21 +726,21 @@ gdk_window_cache_new (GdkDisplay *display)
   if (G_UNLIKELY (!GDK_X11_DISPLAY (display)->trusted_client))
     {
       GList *toplevel_windows, *list;
-      GdkWindow *window;
-      GdkWindowImplX11 *impl;
+      GdkSurface *window;
+      GdkSurfaceImplX11 *impl;
       gint x, y, width, height;
 
       toplevel_windows = gdk_x11_display_get_toplevel_windows (display);
       for (list = toplevel_windows; list; list = list->next)
         {
-          window = GDK_WINDOW (list->data);
-	  impl = GDK_WINDOW_IMPL_X11 (window->impl);
-          gdk_window_get_geometry (window, &x, &y, &width, &height);
-          gdk_window_cache_add (result, GDK_WINDOW_XID (window),
+          window = GDK_SURFACE (list->data);
+	  impl = GDK_SURFACE_IMPL_X11 (window->impl);
+          gdk_surface_get_geometry (window, &x, &y, &width, &height);
+          gdk_surface_cache_add (result, GDK_SURFACE_XID (window),
                                 x * impl->window_scale, y * impl->window_scale, 
 				width * impl->window_scale, 
 				height * impl->window_scale,
-                                gdk_window_is_visible (window));
+                                gdk_surface_is_visible (window));
         }
       return result;
     }
@@ -755,7 +755,7 @@ gdk_window_cache_new (GdkDisplay *display)
 
   for (i = 0; i < nchildren ; i++)
     {
-      gdk_window_cache_add (result, children[i].window,
+      gdk_surface_cache_add (result, children[i].window,
                             children[i].x, children[i].y, children[i].width, children[i].height,
                             children[i].is_mapped);
     }
@@ -773,7 +773,7 @@ gdk_window_cache_new (GdkDisplay *display)
   if (gdk_display_is_composited (display))
     {
       cow = XCompositeGetOverlayWindow (xdisplay, xroot_window);
-      gdk_window_cache_add (result, cow, 0, 0,
+      gdk_surface_cache_add (result, cow, 0, 0,
 			    WidthOfScreen (GDK_X11_SCREEN (screen)->xscreen) * GDK_X11_SCREEN (screen)->window_scale,
 			    HeightOfScreen (GDK_X11_SCREEN (screen)->xscreen) * GDK_X11_SCREEN (screen)->window_scale,
 			    TRUE);
@@ -785,7 +785,7 @@ gdk_window_cache_new (GdkDisplay *display)
 }
 
 static void
-gdk_window_cache_destroy (GdkWindowCache *cache)
+gdk_surface_cache_destroy (GdkSurfaceCache *cache)
 {
   XSelectInput (GDK_DISPLAY_XDISPLAY (cache->display),
                 GDK_DISPLAY_XROOTWIN (cache->display),
@@ -801,8 +801,8 @@ gdk_window_cache_destroy (GdkWindowCache *cache)
   g_free (cache);
 }
 
-static GdkWindowCache *
-gdk_window_cache_ref (GdkWindowCache *cache)
+static GdkSurfaceCache *
+gdk_surface_cache_ref (GdkSurfaceCache *cache)
 {
   cache->ref_count += 1;
 
@@ -810,7 +810,7 @@ gdk_window_cache_ref (GdkWindowCache *cache)
 }
 
 static void
-gdk_window_cache_unref (GdkWindowCache *cache)
+gdk_surface_cache_unref (GdkSurfaceCache *cache)
 {
   g_assert (cache->ref_count > 0);
 
@@ -819,24 +819,24 @@ gdk_window_cache_unref (GdkWindowCache *cache)
   if (cache->ref_count == 0)
     {
       window_caches = g_slist_remove (window_caches, cache);
-      gdk_window_cache_destroy (cache);
+      gdk_surface_cache_destroy (cache);
     }
 }
 
-GdkWindowCache *
-gdk_window_cache_get (GdkDisplay *display)
+GdkSurfaceCache *
+gdk_surface_cache_get (GdkDisplay *display)
 {
   GSList *list;
-  GdkWindowCache *cache;
+  GdkSurfaceCache *cache;
 
   for (list = window_caches; list; list = list->next)
     {
       cache = list->data;
       if (cache->display == display)
-        return gdk_window_cache_ref (cache);
+        return gdk_surface_cache_ref (cache);
     }
 
-  cache = gdk_window_cache_new (display);
+  cache = gdk_surface_cache_new (display);
 
   window_caches = g_slist_prepend (window_caches, cache);
 
@@ -944,7 +944,7 @@ get_client_window_at_coords_recurse (GdkDisplay *display,
 }
 
 static Window
-get_client_window_at_coords (GdkWindowCache *cache,
+get_client_window_at_coords (GdkSurfaceCache *cache,
                              Window          ignore,
                              gint            x_root,
                              gint            y_root)
@@ -1070,10 +1070,10 @@ xdnd_status_filter (const XEvent *xevent,
   GdkDragContext *context;
 
   if (!event->any.window ||
-      gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+      gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
     return GDK_FILTER_CONTINUE;                 /* Not for us */
 
-  display = gdk_window_get_display (event->any.window);
+  display = gdk_surface_get_display (event->any.window);
   context = gdk_drag_context_find (display, TRUE, xevent->xclient.window, dest_window);
 
   GDK_DISPLAY_NOTE (display, DND,
@@ -1116,10 +1116,10 @@ xdnd_finished_filter (const XEvent *xevent,
   GdkX11DragContext *context_x11;
 
   if (!event->any.window ||
-      gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+      gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
     return GDK_FILTER_CONTINUE;                 /* Not for us */
 
-  display = gdk_window_get_display (event->any.window);
+  display = gdk_surface_get_display (event->any.window);
   context = gdk_drag_context_find (display, TRUE, xevent->xclient.window, dest_window);
 
   GDK_DISPLAY_NOTE (display, DND,
@@ -1157,7 +1157,7 @@ xdnd_set_targets (GdkX11DragContext *context_x11)
     atomlist[i] = gdk_x11_get_xatom_by_name_for_display (display, atoms[i]);
 
   XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (context_x11->ipc_window),
+                   GDK_SURFACE_XID (context_x11->ipc_window),
                    gdk_x11_get_xatom_by_name_for_display (display, "XdndTypeList"),
                    XA_ATOM, 32, PropModeReplace,
                    (guchar *)atomlist, n_atoms);
@@ -1203,7 +1203,7 @@ xdnd_set_actions (GdkX11DragContext *context_x11)
     }
 
   XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (context_x11->ipc_window),
+                   GDK_SURFACE_XID (context_x11->ipc_window),
                    gdk_x11_get_xatom_by_name_for_display (display, "XdndActionList"),
                    XA_ATOM, 32, PropModeReplace,
                    (guchar *)atomlist, n_atoms);
@@ -1229,7 +1229,7 @@ send_client_message_async_cb (Window   window,
    */
   if (!success &&
       context->dest_window &&
-      window == GDK_WINDOW_XID (context->dest_window))
+      window == GDK_SURFACE_XID (context->dest_window))
     {
       GdkX11DragContext *context_x11 = data;
 
@@ -1265,7 +1265,7 @@ send_client_message_async (GdkDragContext      *context,
 
 static gboolean
 xdnd_send_xevent (GdkX11DragContext *context_x11,
-                  GdkWindow         *window,
+                  GdkSurface         *window,
                   gboolean           propagate,
                   XEvent            *event_send)
 {
@@ -1277,7 +1277,7 @@ xdnd_send_xevent (GdkX11DragContext *context_x11,
   g_assert (event_send->xany.type == ClientMessage);
 
   /* We short-circuit messages to ourselves */
-  if (gdk_window_get_window_type (window) != GDK_WINDOW_FOREIGN)
+  if (gdk_surface_get_window_type (window) != GDK_SURFACE_FOREIGN)
     {
       gint i;
 
@@ -1301,7 +1301,7 @@ xdnd_send_xevent (GdkX11DragContext *context_x11,
         }
     }
 
-  xwindow = GDK_WINDOW_XID (window);
+  xwindow = GDK_SURFACE_XID (window);
 
   if (_gdk_x11_display_is_root_window (display, xwindow))
     event_mask = ButtonPressMask;
@@ -1328,8 +1328,8 @@ xdnd_send_enter (GdkX11DragContext *context_x11)
   xev.xclient.format = 32;
   xev.xclient.window = context_x11->drop_xid
                            ? context_x11->drop_xid
-                           : GDK_WINDOW_XID (context->dest_window);
-  xev.xclient.data.l[0] = GDK_WINDOW_XID (context_x11->ipc_window);
+                           : GDK_SURFACE_XID (context->dest_window);
+  xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_window);
   xev.xclient.data.l[1] = (context_x11->version << 24); /* version */
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
@@ -1337,7 +1337,7 @@ xdnd_send_enter (GdkX11DragContext *context_x11)
 
   GDK_DISPLAY_NOTE (display, DND,
            g_message ("Sending enter source window %#lx XDND protocol version %d\n",
-                      GDK_WINDOW_XID (context_x11->ipc_window), context_x11->version));
+                      GDK_SURFACE_XID (context_x11->ipc_window), context_x11->version));
   atoms = gdk_content_formats_get_mime_types (context->formats, &n_atoms);
 
   if (n_atoms > 3)
@@ -1358,7 +1358,7 @@ xdnd_send_enter (GdkX11DragContext *context_x11)
     {
       GDK_DISPLAY_NOTE (display, DND,
                 g_message ("Send event to %lx failed",
-                           GDK_WINDOW_XID (context->dest_window)));
+                           GDK_SURFACE_XID (context->dest_window)));
       g_object_unref (context->dest_window);
       context->dest_window = NULL;
     }
@@ -1376,8 +1376,8 @@ xdnd_send_leave (GdkX11DragContext *context_x11)
   xev.xclient.format = 32;
   xev.xclient.window = context_x11->drop_xid
                            ? context_x11->drop_xid
-                           : GDK_WINDOW_XID (context->dest_window);
-  xev.xclient.data.l[0] = GDK_WINDOW_XID (context_x11->ipc_window);
+                           : GDK_SURFACE_XID (context->dest_window);
+  xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_window);
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
@@ -1387,7 +1387,7 @@ xdnd_send_leave (GdkX11DragContext *context_x11)
     {
       GDK_DISPLAY_NOTE (display, DND,
                 g_message ("Send event to %lx failed",
-                           GDK_WINDOW_XID (context->dest_window)));
+                           GDK_SURFACE_XID (context->dest_window)));
       g_object_unref (context->dest_window);
       context->dest_window = NULL;
     }
@@ -1406,8 +1406,8 @@ xdnd_send_drop (GdkX11DragContext *context_x11,
   xev.xclient.format = 32;
   xev.xclient.window = context_x11->drop_xid
                            ? context_x11->drop_xid
-                           : GDK_WINDOW_XID (context->dest_window);
-  xev.xclient.data.l[0] = GDK_WINDOW_XID (context_x11->ipc_window);
+                           : GDK_SURFACE_XID (context->dest_window);
+  xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_window);
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = time;
   xev.xclient.data.l[3] = 0;
@@ -1417,7 +1417,7 @@ xdnd_send_drop (GdkX11DragContext *context_x11,
     {
       GDK_DISPLAY_NOTE (display, DND,
                 g_message ("Send event to %lx failed",
-                           GDK_WINDOW_XID (context->dest_window)));
+                           GDK_SURFACE_XID (context->dest_window)));
       g_object_unref (context->dest_window);
       context->dest_window = NULL;
     }
@@ -1439,8 +1439,8 @@ xdnd_send_motion (GdkX11DragContext *context_x11,
   xev.xclient.format = 32;
   xev.xclient.window = context_x11->drop_xid
                            ? context_x11->drop_xid
-                           : GDK_WINDOW_XID (context->dest_window);
-  xev.xclient.data.l[0] = GDK_WINDOW_XID (context_x11->ipc_window);
+                           : GDK_SURFACE_XID (context->dest_window);
+  xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_window);
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = (x_root << 16) | y_root;
   xev.xclient.data.l[3] = time;
@@ -1450,7 +1450,7 @@ xdnd_send_motion (GdkX11DragContext *context_x11,
     {
       GDK_DISPLAY_NOTE (display, DND,
                 g_message ("Send event to %lx failed",
-                           GDK_WINDOW_XID (context->dest_window)));
+                           GDK_SURFACE_XID (context->dest_window)));
       g_object_unref (context->dest_window);
       context->dest_window = NULL;
     }
@@ -1546,13 +1546,13 @@ xdnd_read_actions (GdkX11DragContext *context_x11)
 
   context_x11->xdnd_have_actions = FALSE;
 
-  if (gdk_window_get_window_type (context->source_window) == GDK_WINDOW_FOREIGN)
+  if (gdk_surface_get_window_type (context->source_window) == GDK_SURFACE_FOREIGN)
     {
       /* Get the XdndActionList, if set */
 
       gdk_x11_display_error_trap_push (display);
       if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
-                              GDK_WINDOW_XID (context->source_window),
+                              GDK_SURFACE_XID (context->source_window),
                               gdk_x11_get_xatom_by_name_for_display (display, "XdndActionList"),
                               0, 65536,
                               False, XA_ATOM, &type, &format, &nitems,
@@ -1600,8 +1600,8 @@ xdnd_read_actions (GdkX11DragContext *context_x11)
       GdkDragContext *source_context;
 
       source_context = gdk_drag_context_find (display, TRUE,
-                                              GDK_WINDOW_XID (context->source_window),
-                                              GDK_WINDOW_XID (context->dest_window));
+                                              GDK_SURFACE_XID (context->source_window),
+                                              GDK_SURFACE_XID (context->dest_window));
 
       if (source_context)
         {
@@ -1644,11 +1644,11 @@ xdnd_source_window_filter (const XEvent *xevent,
 
 static void
 xdnd_manage_source_filter (GdkDragContext *context,
-                           GdkWindow      *window,
+                           GdkSurface      *window,
                            gboolean        add_filter)
 {
-  if (!GDK_WINDOW_DESTROYED (window) &&
-      gdk_window_get_window_type (window) == GDK_WINDOW_FOREIGN)
+  if (!GDK_SURFACE_DESTROYED (window) &&
+      gdk_surface_get_window_type (window) == GDK_SURFACE_FOREIGN)
     {
       GdkDisplay *display = gdk_drag_context_get_display (context);
 
@@ -1656,8 +1656,8 @@ xdnd_manage_source_filter (GdkDragContext *context,
 
       if (add_filter)
         {
-          gdk_window_set_events (window,
-                                 gdk_window_get_events (window) |
+          gdk_surface_set_events (window,
+                                 gdk_surface_get_events (window) |
                                  GDK_PROPERTY_CHANGE_MASK);
           g_object_set_data (G_OBJECT (window), "xdnd-source-context", context);
         }
@@ -1747,14 +1747,14 @@ xdnd_enter_filter (const XEvent *xevent,
   gint version;
 
   if (!event->any.window ||
-      gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+      gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
     return GDK_FILTER_CONTINUE;                 /* Not for us */
 
   source_window = xevent->xclient.data.l[0];
   get_types = ((xevent->xclient.data.l[1] & 1) != 0);
   version = (xevent->xclient.data.l[1] & 0xff000000) >> 24;
 
-  display = GDK_WINDOW_DISPLAY (event->any.window);
+  display = GDK_SURFACE_DISPLAY (event->any.window);
   display_x11 = GDK_X11_DISPLAY (display);
 
   xdnd_precache_atoms (display);
@@ -1788,7 +1788,7 @@ xdnd_enter_filter (const XEvent *xevent,
   seat = gdk_display_get_default_seat (display);
   gdk_drag_context_set_device (context, gdk_seat_get_pointer (seat));
 
-  context->source_window = gdk_x11_window_foreign_new_for_display (display, source_window);
+  context->source_window = gdk_x11_surface_foreign_new_for_display (display, source_window);
   if (!context->source_window)
     {
       g_object_unref (context);
@@ -1801,7 +1801,7 @@ xdnd_enter_filter (const XEvent *xevent,
   if (get_types)
     {
       gdk_x11_display_error_trap_push (display);
-      XGetWindowProperty (GDK_WINDOW_XDISPLAY (event->any.window),
+      XGetWindowProperty (GDK_SURFACE_XDISPLAY (event->any.window),
                           source_window,
                           gdk_x11_get_xatom_by_name_for_display (display, "XdndTypeList"),
                           0, 65536,
@@ -1864,10 +1864,10 @@ xdnd_leave_filter (const XEvent *xevent,
   GdkX11Display *display_x11;
 
   if (!event->any.window ||
-      gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+      gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
     return GDK_FILTER_CONTINUE;                 /* Not for us */
 
-  display = GDK_WINDOW_DISPLAY (event->any.window);
+  display = GDK_SURFACE_DISPLAY (event->any.window);
   display_x11 = GDK_X11_DISPLAY (display);
 
   GDK_DISPLAY_NOTE (display, DND,
@@ -1878,7 +1878,7 @@ xdnd_leave_filter (const XEvent *xevent,
 
   if ((display_x11->current_dest_drag != NULL) &&
       (GDK_X11_DRAG_CONTEXT (display_x11->current_dest_drag)->protocol == GDK_DRAG_PROTO_XDND) &&
-      (GDK_WINDOW_XID (display_x11->current_dest_drag->source_window) == source_window))
+      (GDK_SURFACE_XID (display_x11->current_dest_drag->source_window) == source_window))
     {
       event->any.type = GDK_DRAG_LEAVE;
       /* Pass ownership of context to the event */
@@ -1898,7 +1898,7 @@ xdnd_position_filter (const XEvent *xevent,
                       GdkEvent     *event,
                       gpointer      data)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   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;
@@ -1910,10 +1910,10 @@ xdnd_position_filter (const XEvent *xevent,
   GdkX11DragContext *context_x11;
 
    if (!event->any.window ||
-       gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+       gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
      return GDK_FILTER_CONTINUE;                        /* Not for us */
 
-  display = GDK_WINDOW_DISPLAY (event->any.window);
+  display = GDK_SURFACE_DISPLAY (event->any.window);
   display_x11 = GDK_X11_DISPLAY (display);
 
   GDK_DISPLAY_NOTE (display, DND,
@@ -1926,9 +1926,9 @@ xdnd_position_filter (const XEvent *xevent,
 
   if ((context != NULL) &&
       (GDK_X11_DRAG_CONTEXT (context)->protocol == GDK_DRAG_PROTO_XDND) &&
-      (GDK_WINDOW_XID (context->source_window) == source_window))
+      (GDK_SURFACE_XID (context->source_window) == source_window))
     {
-      impl = GDK_WINDOW_IMPL_X11 (event->any.window->impl);
+      impl = GDK_SURFACE_IMPL_X11 (event->any.window->impl);
 
       context_x11 = GDK_X11_DRAG_CONTEXT (context);
 
@@ -1969,10 +1969,10 @@ xdnd_drop_filter (const XEvent *xevent,
   GdkX11DragContext *context_x11;
 
   if (!event->any.window ||
-      gdk_window_get_window_type (event->any.window) == GDK_WINDOW_FOREIGN)
+      gdk_surface_get_window_type (event->any.window) == GDK_SURFACE_FOREIGN)
     return GDK_FILTER_CONTINUE;                 /* Not for us */
 
-  display = GDK_WINDOW_DISPLAY (event->any.window);
+  display = GDK_SURFACE_DISPLAY (event->any.window);
   display_x11 = GDK_X11_DISPLAY (display);
 
   GDK_DISPLAY_NOTE (display, DND,
@@ -1985,7 +1985,7 @@ xdnd_drop_filter (const XEvent *xevent,
 
   if ((context != NULL) &&
       (GDK_X11_DRAG_CONTEXT (context)->protocol == GDK_DRAG_PROTO_XDND) &&
-      (GDK_WINDOW_XID (context->source_window) == source_window))
+      (GDK_SURFACE_XID (context->source_window) == source_window))
     {
       context_x11 = GDK_X11_DRAG_CONTEXT (context);
       event->any.type = GDK_DROP_START;
@@ -1998,7 +1998,7 @@ xdnd_drop_filter (const XEvent *xevent,
       event->dnd.x_root = context_x11->last_x;
       event->dnd.y_root = context_x11->last_y;
 
-      gdk_x11_window_set_user_time (event->any.window, time);
+      gdk_x11_surface_set_user_time (event->any.window, time);
 
       return GDK_FILTER_TRANSLATE;
     }
@@ -2014,13 +2014,13 @@ _gdk_x11_dnd_filter (const XEvent *xevent,
   GdkDisplay *display;
   int i;
 
-  if (!GDK_IS_X11_WINDOW (event->any.window))
+  if (!GDK_IS_X11_SURFACE (event->any.window))
     return GDK_FILTER_CONTINUE;
 
   if (xevent->type != ClientMessage)
     return GDK_FILTER_CONTINUE;
 
-  display = GDK_WINDOW_DISPLAY (event->any.window);
+  display = GDK_SURFACE_DISPLAY (event->any.window);
 
   for (i = 0; i < G_N_ELEMENTS (xdnd_filters); i++)
     {
@@ -2059,14 +2059,14 @@ gdk_drag_do_leave (GdkX11DragContext *context_x11,
     }
 }
 
-static GdkWindow *
+static GdkSurface *
 create_drag_window (GdkDisplay *display)
 {
-  GdkWindow *window;
+  GdkSurface *window;
 
-  window = gdk_window_new_popup (display, &(GdkRectangle) { 0, 0, 100, 100 });
+  window = gdk_surface_new_popup (display, &(GdkRectangle) { 0, 0, 100, 100 });
 
-  gdk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_DND);
+  gdk_surface_set_type_hint (window, GDK_SURFACE_TYPE_HINT_DND);
   
   return window;
 }
@@ -2078,14 +2078,14 @@ _gdk_x11_display_get_drag_protocol (GdkDisplay      *display,
                                     guint           *version)
 
 {
-  GdkWindow *window;
+  GdkSurface *window;
   Window retval;
 
   base_precache_atoms (display);
 
   /* Check for a local drag */
-  window = gdk_x11_window_lookup_for_display (display, xid);
-  if (window && gdk_window_get_window_type (window) != GDK_WINDOW_FOREIGN)
+  window = gdk_x11_surface_lookup_for_display (display, xid);
+  if (window && gdk_surface_get_window_type (window) != GDK_SURFACE_FOREIGN)
     {
       if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
         {
@@ -2130,37 +2130,37 @@ _gdk_x11_display_get_drag_protocol (GdkDisplay      *display,
   return 0; /* a.k.a. None */
 }
 
-static GdkWindowCache *
+static GdkSurfaceCache *
 drag_context_find_window_cache (GdkX11DragContext *context_x11,
                                 GdkDisplay        *display)
 {
   if (!context_x11->cache)
-    context_x11->cache = gdk_window_cache_get (display);
+    context_x11->cache = gdk_surface_cache_get (display);
 
   return context_x11->cache;
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_drag_context_find_window (GdkDragContext  *context,
-                                  GdkWindow       *drag_window,
+                                  GdkSurface       *drag_window,
                                   gint             x_root,
                                   gint             y_root,
                                   GdkDragProtocol *protocol)
 {
   GdkX11Screen *screen_x11 = GDK_X11_SCREEN(GDK_X11_DISPLAY (context->display)->screen);
   GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
-  GdkWindowCache *window_cache;
+  GdkSurfaceCache *window_cache;
   GdkDisplay *display;
   Window dest;
-  GdkWindow *dest_window;
+  GdkSurface *dest_window;
 
   display = gdk_drag_context_get_display (context);
 
   window_cache = drag_context_find_window_cache (context_x11, display);
 
   dest = get_client_window_at_coords (window_cache,
-                                      drag_window && GDK_WINDOW_IS_X11 (drag_window) ?
-                                      GDK_WINDOW_XID (drag_window) : None,
+                                      drag_window && GDK_SURFACE_IS_X11 (drag_window) ?
+                                      GDK_SURFACE_XID (drag_window) : None,
                                       x_root * screen_x11->window_scale,
 				      y_root * screen_x11->window_scale);
 
@@ -2183,7 +2183,7 @@ gdk_x11_drag_context_find_window (GdkDragContext  *context,
                                                       &context_x11->version);
 
       if (recipient != None)
-        dest_window = gdk_x11_window_foreign_new_for_display (display, recipient);
+        dest_window = gdk_x11_surface_foreign_new_for_display (display, recipient);
       else
         dest_window = NULL;
     }
@@ -2205,15 +2205,15 @@ move_drag_window (GdkDragContext *context,
 {
   GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
 
-  gdk_window_move (context_x11->drag_window,
+  gdk_surface_move (context_x11->drag_window,
                    x_root - context_x11->hot_x,
                    y_root - context_x11->hot_y);
-  gdk_window_raise (context_x11->drag_window);
+  gdk_surface_raise (context_x11->drag_window);
 }
 
 static gboolean
 gdk_x11_drag_context_drag_motion (GdkDragContext *context,
-                                  GdkWindow      *dest_window,
+                                  GdkSurface      *dest_window,
                                   GdkDragProtocol protocol,
                                   gint            x_root,
                                   gint            y_root,
@@ -2222,7 +2222,7 @@ gdk_x11_drag_context_drag_motion (GdkDragContext *context,
                                   guint32         time)
 {
   GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
 
   if (context_x11->drag_window)
     move_drag_window (context, x_root, y_root);
@@ -2245,10 +2245,10 @@ gdk_x11_drag_context_drag_motion (GdkDragContext *context,
        */
       if (dest_window)
         {
-          GdkDisplay *display = GDK_WINDOW_DISPLAY (dest_window);
+          GdkDisplay *display = GDK_SURFACE_DISPLAY (dest_window);
 
           xdnd_check_dest (display,
-                           GDK_WINDOW_XID (dest_window),
+                           GDK_SURFACE_XID (dest_window),
                            &context_x11->version);
         }
     }
@@ -2260,16 +2260,16 @@ gdk_x11_drag_context_drag_motion (GdkDragContext *context,
     {
       if (dest_window)
         {
-          if (gdk_window_get_window_type (dest_window) == GDK_WINDOW_FOREIGN)
+          if (gdk_surface_get_window_type (dest_window) == GDK_SURFACE_FOREIGN)
             xdnd_set_actions (context_x11);
           else if (context->dest_window == dest_window)
             {
-              GdkDisplay *display = GDK_WINDOW_DISPLAY (dest_window);
+              GdkDisplay *display = GDK_SURFACE_DISPLAY (dest_window);
               GdkDragContext *dest_context;
 
               dest_context = gdk_drag_context_find (display, FALSE,
-                                                    GDK_WINDOW_XID (context->source_window),
-                                                    GDK_WINDOW_XID (dest_window));
+                                                    GDK_SURFACE_XID (context->source_window),
+                                                    GDK_SURFACE_XID (dest_window));
 
               if (dest_context)
                 {
@@ -2339,7 +2339,7 @@ gdk_x11_drag_context_drag_motion (GdkDragContext *context,
 
   if (context->dest_window)
     {
-      impl = GDK_WINDOW_IMPL_X11 (context->dest_window->impl);
+      impl = GDK_SURFACE_IMPL_X11 (context->dest_window->impl);
 
       if (context_x11->drag_status == GDK_DRAG_STATUS_DRAG)
         {
@@ -2435,9 +2435,9 @@ gdk_x11_drag_context_drag_status (GdkDragContext *context,
       xev.xclient.type = ClientMessage;
       xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndStatus");
       xev.xclient.format = 32;
-      xev.xclient.window = GDK_WINDOW_XID (context->source_window);
+      xev.xclient.window = GDK_SURFACE_XID (context->source_window);
 
-      xev.xclient.data.l[0] = GDK_WINDOW_XID (context->dest_window);
+      xev.xclient.data.l[0] = GDK_SURFACE_XID (context->dest_window);
       xev.xclient.data.l[1] = (action != 0) ? (2 | 1) : 0;
       xev.xclient.data.l[2] = 0;
       xev.xclient.data.l[3] = 0;
@@ -2446,7 +2446,7 @@ gdk_x11_drag_context_drag_status (GdkDragContext *context,
         {
           GDK_DISPLAY_NOTE (display, DND,
                     g_message ("Send event to %lx failed",
-                               GDK_WINDOW_XID (context->source_window)));
+                               GDK_SURFACE_XID (context->source_window)));
         }
     }
 
@@ -2476,7 +2476,7 @@ gdk_x11_drag_context_drop_finish (GdkDragContext *context,
                              gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection"),
                              gdk_x11_get_xatom_by_name_for_display (display, "DELETE"),
                              gdk_x11_get_xatom_by_name_for_display (display, "GDK_SELECTION"),
-                             GDK_WINDOW_XID (context->source_window),
+                             GDK_SURFACE_XID (context->source_window),
                              time);
           /* XXX: Do we need to wait for a reply here before sending the next message? */
         }
@@ -2484,9 +2484,9 @@ gdk_x11_drag_context_drop_finish (GdkDragContext *context,
       xev.xclient.type = ClientMessage;
       xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndFinished");
       xev.xclient.format = 32;
-      xev.xclient.window = GDK_WINDOW_XID (context->source_window);
+      xev.xclient.window = GDK_SURFACE_XID (context->source_window);
 
-      xev.xclient.data.l[0] = GDK_WINDOW_XID (context->dest_window);
+      xev.xclient.data.l[0] = GDK_SURFACE_XID (context->dest_window);
       if (success)
         {
           xev.xclient.data.l[1] = 1;
@@ -2505,16 +2505,16 @@ gdk_x11_drag_context_drop_finish (GdkDragContext *context,
         {
           GDK_DISPLAY_NOTE (display, DND,
                     g_message ("Send event to %lx failed",
-                               GDK_WINDOW_XID (context->source_window)));
+                               GDK_SURFACE_XID (context->source_window)));
         }
     }
 }
 
 void
-_gdk_x11_window_register_dnd (GdkWindow *window)
+_gdk_x11_surface_register_dnd (GdkSurface *window)
 {
   static const gulong xdnd_version = 5;
-  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDisplay *display = gdk_surface_get_display (window);
 
   g_return_if_fail (window != NULL);
 
@@ -2529,7 +2529,7 @@ _gdk_x11_window_register_dnd (GdkWindow *window)
 
   /* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
   XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (window),
+                   GDK_SURFACE_XID (window),
                    gdk_x11_get_xatom_by_name_for_display (display, "XdndAware"),
                    XA_ATOM, 32, PropModeReplace,
                    (guchar *)&xdnd_version, 1);
@@ -2541,7 +2541,7 @@ gdk_x11_drag_context_drop_status (GdkDragContext *context)
   return ! GDK_X11_DRAG_CONTEXT (context)->drop_failed;
 }
 
-static GdkWindow *
+static GdkSurface *
 gdk_x11_drag_context_get_drag_window (GdkDragContext *context)
 {
   return GDK_X11_DRAG_CONTEXT (context)->drag_window;
@@ -2603,7 +2603,7 @@ gdk_x11_drag_context_xevent (GdkDisplay   *display,
   Window xwindow;
   Atom xselection;
 
-  xwindow = GDK_WINDOW_XID (x11_context->ipc_window);
+  xwindow = GDK_SURFACE_XID (x11_context->ipc_window);
   xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
 
   if (xevent->xany.window != xwindow)
@@ -2713,11 +2713,11 @@ gdk_drag_anim_timeout (gpointer data)
 
   t = ease_out_cubic (f);
 
-  gdk_window_show (context->drag_window);
-  gdk_window_move (context->drag_window,
+  gdk_surface_show (context->drag_window);
+  gdk_surface_move (context->drag_window,
                    context->last_x + (context->start_x - context->last_x) * t,
                    context->last_y + (context->start_y - context->last_y) * t);
-  gdk_window_set_opacity (context->drag_window, 1.0 - f);
+  gdk_surface_set_opacity (context->drag_window, 1.0 - f);
 
   return G_SOURCE_CONTINUE;
 }
@@ -2734,7 +2734,7 @@ gdk_x11_drag_context_release_selection (GdkDragContext *context)
   display = gdk_drag_context_get_display (context);
   xdisplay = GDK_DISPLAY_XDISPLAY (display);
   xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
-  xwindow = GDK_WINDOW_XID (x11_context->ipc_window);
+  xwindow = GDK_SURFACE_XID (x11_context->ipc_window);
 
   if (XGetSelectionOwner (xdisplay, xselection) == xwindow)
     XSetSelectionOwner (xdisplay, xselection, None, CurrentTime);
@@ -2758,15 +2758,15 @@ gdk_x11_drag_context_drop_done (GdkDragContext *context,
                                         context);
   if (success)
     {
-      gdk_window_hide (x11_context->drag_window);
+      gdk_surface_hide (x11_context->drag_window);
       return;
     }
 
-  win_surface = _gdk_window_ref_cairo_surface (x11_context->drag_window);
-  surface = gdk_window_create_similar_surface (x11_context->drag_window,
+  win_surface = _gdk_surface_ref_cairo_surface (x11_context->drag_window);
+  surface = gdk_surface_create_similar_surface (x11_context->drag_window,
                                                cairo_surface_get_content (win_surface),
-                                               gdk_window_get_width (x11_context->drag_window),
-                                               gdk_window_get_height (x11_context->drag_window));
+                                               gdk_surface_get_width (x11_context->drag_window),
+                                               gdk_surface_get_height (x11_context->drag_window));
   cr = cairo_create (surface);
   cairo_set_source_surface (cr, win_surface, 0, 0);
   cairo_paint (cr);
@@ -2776,7 +2776,7 @@ gdk_x11_drag_context_drop_done (GdkDragContext *context,
 /*
   pattern = cairo_pattern_create_for_surface (surface);
 
-  gdk_window_set_background_pattern (x11_context->drag_window, pattern);
+  gdk_surface_set_background_pattern (x11_context->drag_window, pattern);
 
   cairo_pattern_destroy (pattern);
 */
@@ -2784,7 +2784,7 @@ gdk_x11_drag_context_drop_done (GdkDragContext *context,
 
   anim = g_slice_new0 (GdkDragAnim);
   anim->context = g_object_ref (x11_context);
-  anim->frame_clock = gdk_window_get_frame_clock (x11_context->drag_window);
+  anim->frame_clock = gdk_surface_get_frame_clock (x11_context->drag_window);
   anim->start_time = gdk_frame_clock_get_frame_time (anim->frame_clock);
 
   id = g_timeout_add_full (G_PRIORITY_DEFAULT, 17,
@@ -2939,7 +2939,7 @@ drag_context_ungrab (GdkDragContext *context)
 }
 
 GdkDragContext *
-_gdk_x11_window_drag_begin (GdkWindow          *window,
+_gdk_x11_surface_drag_begin (GdkSurface          *window,
                             GdkDevice          *device,
                             GdkContentProvider *content,
                             GdkDragAction       actions,
@@ -2952,7 +2952,7 @@ _gdk_x11_window_drag_begin (GdkWindow          *window,
   int x_root, y_root;
   Atom xselection;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   context = (GdkDragContext *) g_object_new (GDK_TYPE_X11_DRAG_CONTEXT,
                                              "display", display,
@@ -2978,10 +2978,10 @@ _gdk_x11_window_drag_begin (GdkWindow          *window,
 
   x11_context->protocol = GDK_DRAG_PROTO_XDND;
   x11_context->actions = actions;
-  x11_context->ipc_window = gdk_window_new_popup (display, &(GdkRectangle) { -99, -99, 1, 1 });
-  if (gdk_window_get_group (window))
-    gdk_window_set_group (x11_context->ipc_window, window);
-  gdk_window_show (x11_context->ipc_window);
+  x11_context->ipc_window = gdk_surface_new_popup (display, &(GdkRectangle) { -99, -99, 1, 1 });
+  if (gdk_surface_get_group (window))
+    gdk_surface_set_group (x11_context->ipc_window, window);
+  gdk_surface_show (x11_context->ipc_window);
 
   context->source_window = x11_context->ipc_window;
   g_object_ref (context->source_window);
@@ -3000,9 +3000,9 @@ _gdk_x11_window_drag_begin (GdkWindow          *window,
   xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
   XSetSelectionOwner (GDK_DISPLAY_XDISPLAY (display),
                       xselection,
-                      GDK_WINDOW_XID (x11_context->ipc_window),
+                      GDK_SURFACE_XID (x11_context->ipc_window),
                       x11_context->timestamp);
-  if (XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), xselection) != GDK_WINDOW_XID (x11_context->ipc_window))
+  if (XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), xselection) != GDK_SURFACE_XID (x11_context->ipc_window))
     {
       GDK_DISPLAY_NOTE (display, DND, g_printerr ("failed XSetSelectionOwner() on \"XdndSelection\", aborting DND\n"));
       g_object_unref (context);
@@ -3118,7 +3118,7 @@ gdk_drag_update (GdkDragContext  *context,
 {
   GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
   GdkDragAction action, possible_actions;
-  GdkWindow *dest_window;
+  GdkSurface *dest_window;
   GdkDragProtocol protocol;
 
   gdk_drag_get_current_actions (mods, GDK_BUTTON_PRIMARY, x11_context->actions,
diff --git a/gdk/x11/gdkeventsource.c b/gdk/x11/gdkeventsource.c
index 45b5df94ad..2a26669c1a 100644
--- a/gdk/x11/gdkeventsource.c
+++ b/gdk/x11/gdkeventsource.c
@@ -55,13 +55,13 @@ static GSourceFuncs event_funcs = {
   gdk_event_source_finalize
 };
 
-static GdkWindow *
+static GdkSurface *
 gdk_event_source_get_filter_window (GdkEventSource      *event_source,
                                     const XEvent        *xevent,
                                     GdkEventTranslator **event_translator)
 {
   GList *list = event_source->translators;
-  GdkWindow *window;
+  GdkSurface *window;
 
   *event_translator = NULL;
 
@@ -80,10 +80,10 @@ gdk_event_source_get_filter_window (GdkEventSource      *event_source,
         }
     }
 
-  window = gdk_x11_window_lookup_for_display (event_source->display,
+  window = gdk_x11_surface_lookup_for_display (event_source->display,
                                               xevent->xany.window);
 
-  if (window && !GDK_IS_WINDOW (window))
+  if (window && !GDK_IS_SURFACE (window))
     window = NULL;
 
   return window;
@@ -96,8 +96,8 @@ handle_focus_change (GdkEventCrossing *event)
   GdkX11Screen *x11_screen;
   gboolean focus_in, had_focus;
 
-  toplevel = _gdk_x11_window_get_toplevel (event->any.window);
-  x11_screen = GDK_X11_SCREEN (GDK_WINDOW_SCREEN (event->any.window));
+  toplevel = _gdk_x11_surface_get_toplevel (event->any.window);
+  x11_screen = GDK_X11_SCREEN (GDK_SURFACE_SCREEN (event->any.window));
   focus_in = (event->any.type == GDK_ENTER_NOTIFY);
 
   if (x11_screen->wmspec_check_window)
@@ -124,7 +124,7 @@ handle_focus_change (GdkEventCrossing *event)
       focus_event->focus_change.in = focus_in;
       gdk_event_set_device (focus_event, gdk_event_get_device ((GdkEvent *) event));
 
-      gdk_display_put_event (gdk_window_get_display (event->any.window), focus_event);
+      gdk_display_put_event (gdk_surface_get_display (event->any.window), focus_event);
       g_object_unref (focus_event);
     }
 }
@@ -232,7 +232,7 @@ gdk_event_source_translate_event (GdkX11Display  *x11_display,
   GdkFilterReturn result = GDK_FILTER_CONTINUE;
   GdkDisplay *display = GDK_DISPLAY (x11_display);
   GdkEventTranslator *event_translator;
-  GdkWindow *filter_window;
+  GdkSurface *filter_window;
   Display *dpy;
   GdkX11Screen *x11_screen;
   gpointer cache;
@@ -254,15 +254,15 @@ gdk_event_source_translate_event (GdkX11Display  *x11_display,
       xevent->xany.window == x11_screen->xsettings_manager_window)
     result = gdk_xsettings_manager_window_filter (xevent, event, x11_screen);
 
-  cache = gdk_window_cache_get (display);
+  cache = gdk_surface_cache_get (display);
   if (cache)
     {
       if (result == GDK_FILTER_CONTINUE)
-        result = gdk_window_cache_shape_filter (xevent, event, cache);
+        result = gdk_surface_cache_shape_filter (xevent, event, cache);
 
       if (result == GDK_FILTER_CONTINUE &&
           xevent->xany.window == XRootWindow (dpy, 0))
-        result = gdk_window_cache_filter (xevent, event, cache);
+        result = gdk_surface_cache_filter (xevent, event, cache);
     }
 
   if (result == GDK_FILTER_CONTINUE)
diff --git a/gdk/x11/gdkeventtranslator.c b/gdk/x11/gdkeventtranslator.c
index 7bb4c6668e..96c2ed9957 100644
--- a/gdk/x11/gdkeventtranslator.c
+++ b/gdk/x11/gdkeventtranslator.c
@@ -86,7 +86,7 @@ _gdk_x11_event_translator_select_window_events (GdkEventTranslator *translator,
     iface->select_window_events (translator, window, event_mask);
 }
 
-GdkWindow *
+GdkSurface *
 _gdk_x11_event_translator_get_window (GdkEventTranslator *translator,
                                       GdkDisplay         *display,
                                       const XEvent       *xevent)
diff --git a/gdk/x11/gdkeventtranslator.h b/gdk/x11/gdkeventtranslator.h
index 1bd9d78d5f..7d7d0b7a9f 100644
--- a/gdk/x11/gdkeventtranslator.h
+++ b/gdk/x11/gdkeventtranslator.h
@@ -47,7 +47,7 @@ struct _GdkEventTranslatorIface
   void         (* select_window_events) (GdkEventTranslator *translator,
                                          Window              window,
                                          GdkEventMask        event_mask);
-  GdkWindow *  (* get_window)           (GdkEventTranslator *translator,
+  GdkSurface *  (* get_window)           (GdkEventTranslator *translator,
                                          const XEvent       *xevent);
 };
 
@@ -60,7 +60,7 @@ GdkEventMask _gdk_x11_event_translator_get_handled_events   (GdkEventTranslator
 void         _gdk_x11_event_translator_select_window_events (GdkEventTranslator *translator,
                                                              Window              window,
                                                              GdkEventMask        event_mask);
-GdkWindow *  _gdk_x11_event_translator_get_window           (GdkEventTranslator *translator,
+GdkSurface *  _gdk_x11_event_translator_get_window           (GdkEventTranslator *translator,
                                                              GdkDisplay         *display,
                                                              const XEvent       *xevent);
 
diff --git a/gdk/x11/gdkgeometry-x11.c b/gdk/x11/gdkgeometry-x11.c
index 6d299fe475..208704c360 100644
--- a/gdk/x11/gdkgeometry-x11.c
+++ b/gdk/x11/gdkgeometry-x11.c
@@ -25,12 +25,12 @@
 #include "gdkwindow-x11.h"
 
 
-typedef struct _GdkWindowQueueItem GdkWindowQueueItem;
-typedef struct _GdkWindowParentPos GdkWindowParentPos;
+typedef struct _GdkSurfaceQueueItem GdkSurfaceQueueItem;
+typedef struct _GdkSurfaceParentPos GdkSurfaceParentPos;
 
-struct _GdkWindowQueueItem
+struct _GdkSurfaceQueueItem
 {
-  GdkWindow *window;
+  GdkSurface *window;
   gulong serial;
   cairo_region_t *antiexpose_area;
 };
@@ -76,7 +76,7 @@ queue_delete_link (GQueue *queue,
 }
 
 static void
-queue_item_free (GdkWindowQueueItem *item)
+queue_item_free (GdkSurfaceQueueItem *item)
 {
   if (item->window)
     {
@@ -102,10 +102,10 @@ _gdk_x11_display_free_translate_queue (GdkDisplay *display)
 }
 
 static void
-gdk_window_queue (GdkWindow          *window,
-		  GdkWindowQueueItem *new_item)
+gdk_surface_queue (GdkSurface          *window,
+		  GdkSurfaceQueueItem *new_item)
 {
-  GdkX11Display *display_x11 = GDK_X11_DISPLAY (GDK_WINDOW_DISPLAY (window));
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (GDK_SURFACE_DISPLAY (window));
   
   if (!display_x11->translate_queue)
     display_x11->translate_queue = g_queue_new ();
@@ -116,12 +116,12 @@ gdk_window_queue (GdkWindow          *window,
    */
   if (display_x11->translate_queue->length >= 64)
     {
-      gulong serial = find_current_serial (GDK_WINDOW_XDISPLAY (window));
+      gulong serial = find_current_serial (GDK_SURFACE_XDISPLAY (window));
       GList *tmp_list = display_x11->translate_queue->head;
       
       while (tmp_list)
 	{
-	  GdkWindowQueueItem *item = tmp_list->data;
+	  GdkSurfaceQueueItem *item = tmp_list->data;
 	  GList *next = tmp_list->next;
 	  
 	  /* an overflow-safe (item->serial < serial) */
@@ -147,7 +147,7 @@ gdk_window_queue (GdkWindow          *window,
       
       while (tmp_list)
 	{
-	  GdkWindowQueueItem *item = tmp_list->data;
+	  GdkSurfaceQueueItem *item = tmp_list->data;
 	  GList *next = tmp_list->next;
 	  
 	  queue_delete_link (display_x11->translate_queue, tmp_list);
@@ -158,7 +158,7 @@ gdk_window_queue (GdkWindow          *window,
     }
 
   new_item->window = window;
-  new_item->serial = NextRequest (GDK_WINDOW_XDISPLAY (window));
+  new_item->serial = NextRequest (GDK_SURFACE_XDISPLAY (window));
   
   g_object_add_weak_pointer (G_OBJECT (window),
 			     (gpointer *)&(new_item->window));
@@ -167,22 +167,22 @@ gdk_window_queue (GdkWindow          *window,
 }
 
 void
-_gdk_x11_window_queue_antiexpose (GdkWindow *window,
+_gdk_x11_surface_queue_antiexpose (GdkSurface *window,
 				  cairo_region_t *area)
 {
-  GdkWindowQueueItem *item = g_new (GdkWindowQueueItem, 1);
+  GdkSurfaceQueueItem *item = g_new (GdkSurfaceQueueItem, 1);
   item->antiexpose_area = cairo_region_reference (area);
 
-  gdk_window_queue (window, item);
+  gdk_surface_queue (window, item);
 }
 
 void
-_gdk_x11_window_process_expose (GdkWindow    *window,
+_gdk_x11_surface_process_expose (GdkSurface    *window,
                                 gulong        serial,
                                 GdkRectangle *area)
 {
   cairo_region_t *invalidate_region = cairo_region_create_rectangle (area);
-  GdkX11Display *display_x11 = GDK_X11_DISPLAY (GDK_WINDOW_DISPLAY (window));
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (GDK_SURFACE_DISPLAY (window));
 
   if (display_x11->translate_queue)
     {
@@ -190,7 +190,7 @@ _gdk_x11_window_process_expose (GdkWindow    *window,
 
       while (tmp_list)
         {
-          GdkWindowQueueItem *item = tmp_list->data;
+          GdkSurfaceQueueItem *item = tmp_list->data;
           GList *next = tmp_list->next;
 
           /* an overflow-safe (serial < item->serial) */
@@ -209,7 +209,7 @@ _gdk_x11_window_process_expose (GdkWindow    *window,
     }
 
   if (!cairo_region_is_empty (invalidate_region))
-    _gdk_window_invalidate_for_expose (window, invalidate_region);
+    _gdk_surface_invalidate_for_expose (window, invalidate_region);
 
   cairo_region_destroy (invalidate_region);
 }
diff --git a/gdk/x11/gdkglcontext-x11.c b/gdk/x11/gdkglcontext-x11.c
index fdd9571b92..682df01b39 100644
--- a/gdk/x11/gdkglcontext-x11.c
+++ b/gdk/x11/gdkglcontext-x11.c
@@ -79,13 +79,13 @@ drawable_info_free (gpointer data_)
 }
 
 static DrawableInfo *
-get_glx_drawable_info (GdkWindow *window)
+get_glx_drawable_info (GdkSurface *window)
 {
   return g_object_get_data (G_OBJECT (window), "-gdk-x11-window-glx-info");
 }
 
 static void
-set_glx_drawable_info (GdkWindow    *window,
+set_glx_drawable_info (GdkSurface    *window,
                        DrawableInfo *info)
 {
   g_object_set_data_full (G_OBJECT (window), "-gdk-x11-window-glx-info",
@@ -125,7 +125,7 @@ gdk_x11_gl_context_end_frame (GdkDrawContext *draw_context,
 {
   GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
   GdkX11GLContext *context_x11 = GDK_X11_GL_CONTEXT (context);
-  GdkWindow *window = gdk_gl_context_get_window (context);
+  GdkSurface *window = gdk_gl_context_get_window (context);
   GdkDisplay *display = gdk_gl_context_get_display (context);
   Display *dpy = gdk_x11_display_get_xdisplay (display);
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
@@ -146,7 +146,7 @@ gdk_x11_gl_context_end_frame (GdkDrawContext *draw_context,
   GDK_DISPLAY_NOTE (display, OPENGL,
             g_message ("Flushing GLX buffers for drawable %lu (window: %lu), frame sync: %s",
                        (unsigned long) drawable,
-                       (unsigned long) gdk_x11_window_get_xid (window),
+                       (unsigned long) gdk_x11_surface_get_xid (window),
                        context_x11->do_frame_sync ? "yes" : "no"));
 
   /* if we are going to wait for the vertical refresh manually
@@ -194,7 +194,7 @@ gdk_x11_gl_context_get_damage (GdkGLContext *context)
   GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
   Display *dpy = gdk_x11_display_get_xdisplay (display);
-  GdkWindow *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
+  GdkSurface *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
   unsigned int buffer_age = 0;
 
   if (display_x11->has_glx_buffer_age)
@@ -370,7 +370,7 @@ gdk_x11_gl_context_texture_from_surface (GdkGLContext *paint_context,
   double device_x_offset, device_y_offset;
   cairo_rectangle_int_t rect;
   int n_rects, i;
-  GdkWindow *window;
+  GdkSurface *window;
   int unscaled_window_height;
   int window_scale;
   unsigned int texture_id;
@@ -401,8 +401,8 @@ gdk_x11_gl_context_texture_from_surface (GdkGLContext *paint_context,
   GDK_DISPLAY_NOTE (GDK_DISPLAY (display_x11), OPENGL, g_message ("Using GLX_EXT_texture_from_pixmap to draw surface"));
 
   window = gdk_gl_context_get_window (paint_context)->impl_window;
-  window_scale = gdk_window_get_scale_factor (window);
-  gdk_window_get_unscaled_size (window, NULL, &unscaled_window_height);
+  window_scale = gdk_surface_get_scale_factor (window);
+  gdk_surface_get_unscaled_size (window, NULL, &unscaled_window_height);
 
   sx = sy = 1;
   cairo_surface_get_device_scale (surface, &sx, &sy);
@@ -566,12 +566,12 @@ gdk_x11_gl_context_realize (GdkGLContext  *context,
   Display *dpy;
   DrawableInfo *info;
   GdkGLContext *share;
-  GdkWindow *window;
+  GdkSurface *window;
   gboolean debug_bit, compat_bit, legacy_bit, es_bit;
   int major, minor, flags;
 
   window = gdk_gl_context_get_window (context);
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   dpy = gdk_x11_display_get_xdisplay (display);
   context_x11 = GDK_X11_GL_CONTEXT (context);
   display_x11 = GDK_X11_DISPLAY (display);
@@ -698,7 +698,7 @@ gdk_x11_gl_context_realize (GdkGLContext  *context,
       if (GDK_X11_DISPLAY (display)->glx_version >= 13)
         {
           info->glx_drawable = glXCreateWindow (dpy, context_x11->glx_config,
-                                                gdk_x11_window_get_xid (window->impl_window),
+                                                gdk_x11_surface_get_xid (window->impl_window),
                                                 NULL);
           info->dummy_glx = glXCreateWindow (dpy, context_x11->glx_config, info->dummy_xwin, NULL);
         }
@@ -722,7 +722,7 @@ gdk_x11_gl_context_realize (GdkGLContext  *context,
 
   XFree (xvisinfo);
 
-  context_x11->attached_drawable = info->glx_drawable ? info->glx_drawable : gdk_x11_window_get_xid (window->impl_window);
+  context_x11->attached_drawable = info->glx_drawable ? info->glx_drawable : gdk_x11_surface_get_xid (window->impl_window);
   context_x11->unattached_drawable = info->dummy_glx ? info->dummy_glx : info->dummy_xwin;
 
   context_x11->is_direct = glXIsDirect (dpy, context_x11->glx_context);
@@ -1193,7 +1193,7 @@ _gdk_x11_screen_update_visuals_for_gl (GdkX11Screen *x11_screen)
 }
 
 GdkGLContext *
-gdk_x11_window_create_gl_context (GdkWindow    *window,
+gdk_x11_surface_create_gl_context (GdkSurface    *window,
                                   gboolean      attached,
                                   GdkGLContext *share,
                                   GError      **error)
@@ -1202,9 +1202,9 @@ gdk_x11_window_create_gl_context (GdkWindow    *window,
   GdkX11GLContext *context;
   GLXFBConfig config;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
-  if (!gdk_x11_screen_init_gl (GDK_WINDOW_SCREEN (window)))
+  if (!gdk_x11_screen_init_gl (GDK_SURFACE_SCREEN (window)))
     {
       g_set_error_literal (error, GDK_GL_ERROR,
                            GDK_GL_ERROR_NOT_AVAILABLE,
diff --git a/gdk/x11/gdkglcontext-x11.h b/gdk/x11/gdkglcontext-x11.h
index f5af2115df..61dbadef1f 100644
--- a/gdk/x11/gdkglcontext-x11.h
+++ b/gdk/x11/gdkglcontext-x11.h
@@ -55,7 +55,7 @@ struct _GdkX11GLContextClass
 };
 
 gboolean        gdk_x11_screen_init_gl                          (GdkX11Screen      *screen);
-GdkGLContext *  gdk_x11_window_create_gl_context                (GdkWindow         *window,
+GdkGLContext *  gdk_x11_surface_create_gl_context                (GdkSurface         *window,
 								 gboolean           attached,
                                                                  GdkGLContext      *share,
                                                                  GError           **error);
diff --git a/gdk/x11/gdkmain-x11.c b/gdk/x11/gdkmain-x11.c
index 72edfe1c09..c14c04e09d 100644
--- a/gdk/x11/gdkmain-x11.c
+++ b/gdk/x11/gdkmain-x11.c
@@ -102,7 +102,7 @@ static int	    gdk_x_error			 (Display     *display,
 static int	    gdk_x_io_error		 (Display     *display);
 
 void
-_gdk_x11_windowing_init (void)
+_gdk_x11_surfaceing_init (void)
 {
   XSetErrorHandler (gdk_x_error);
   XSetIOErrorHandler (gdk_x_io_error);
@@ -130,8 +130,8 @@ _gdk_x11_convert_grab_status (gint status)
 }
 
 /*
- * _gdk_x11_window_grab_check_unmap:
- * @window: a #GdkWindow
+ * _gdk_x11_surface_grab_check_unmap:
+ * @window: a #GdkSurface
  * @serial: serial from Unmap event (or from NextRequest(display)
  *   if the unmap is being done by this client.)
  *
@@ -140,10 +140,10 @@ _gdk_x11_convert_grab_status (gint status)
  * the pointer we keep to it.
  **/
 void
-_gdk_x11_window_grab_check_unmap (GdkWindow *window,
+_gdk_x11_surface_grab_check_unmap (GdkSurface *window,
                                   gulong     serial)
 {
-  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDisplay *display = gdk_surface_get_display (window);
   GdkSeat *seat;
   GList *devices, *d;
 
@@ -161,16 +161,16 @@ _gdk_x11_window_grab_check_unmap (GdkWindow *window,
 }
 
 /*
- * _gdk_x11_window_grab_check_destroy:
- * @window: a #GdkWindow
+ * _gdk_x11_surface_grab_check_destroy:
+ * @window: a #GdkSurface
  * 
  * Checks to see if window is the current grab window, and if
  * so, clear the current grab window.
  **/
 void
-_gdk_x11_window_grab_check_destroy (GdkWindow *window)
+_gdk_x11_surface_grab_check_destroy (GdkSurface *window)
 {
-  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDisplay *display = gdk_surface_get_display (window);
   GdkSeat *seat;
   GdkDeviceGrabInfo *grab;
   GList *devices, *d;
diff --git a/gdk/x11/gdkmonitor-x11.c b/gdk/x11/gdkmonitor-x11.c
index a10d41da6f..8a282b95cf 100644
--- a/gdk/x11/gdkmonitor-x11.c
+++ b/gdk/x11/gdkmonitor-x11.c
@@ -34,7 +34,7 @@ static gboolean
 gdk_monitor_has_fullscreen_window (GdkMonitor *monitor)
 {
   GList *toplevels, *l;
-  GdkWindow *window;
+  GdkSurface *window;
   gboolean has_fullscreen;
 
   toplevels = gdk_x11_display_get_toplevel_windows (monitor->display);
@@ -44,10 +44,10 @@ gdk_monitor_has_fullscreen_window (GdkMonitor *monitor)
     {
       window = l->data;
 
-      if ((gdk_window_get_state (window) & GDK_WINDOW_STATE_FULLSCREEN) == 0)
+      if ((gdk_surface_get_state (window) & GDK_SURFACE_STATE_FULLSCREEN) == 0)
         continue;
 
-      if (gdk_window_get_fullscreen_mode (window) == GDK_FULLSCREEN_ON_ALL_MONITORS ||
+      if (gdk_surface_get_fullscreen_mode (window) == GDK_FULLSCREEN_ON_ALL_MONITORS ||
           gdk_display_get_monitor_at_window (monitor->display, window) == monitor)
         {
           has_fullscreen = TRUE;
diff --git a/gdk/x11/gdkprivate-x11.h b/gdk/x11/gdkprivate-x11.h
index bcd6b265b3..90d6ecaafe 100644
--- a/gdk/x11/gdkprivate-x11.h
+++ b/gdk/x11/gdkprivate-x11.h
@@ -68,7 +68,7 @@ Colormap      gdk_x11_display_get_window_colormap        (GdkX11Display  *displa
 
 void _gdk_x11_display_add_window    (GdkDisplay *display,
                                      XID        *xid,
-                                     GdkWindow  *window);
+                                     GdkSurface  *window);
 void _gdk_x11_display_remove_window (GdkDisplay *display,
                                      XID         xid);
 
@@ -79,13 +79,13 @@ gint _gdk_x11_display_send_xevent (GdkDisplay *display,
                                    XEvent     *event_send);
 
 /* Routines from gdkgeometry-x11.c */
-void _gdk_x11_window_process_expose    (GdkWindow     *window,
+void _gdk_x11_surface_process_expose    (GdkSurface     *window,
                                         gulong         serial,
                                         GdkRectangle  *area);
 
-void     _gdk_x11_window_queue_antiexpose  (GdkWindow *window,
+void     _gdk_x11_surface_queue_antiexpose  (GdkSurface *window,
                                             cairo_region_t *area);
-void     _gdk_x11_window_translate         (GdkWindow *window,
+void     _gdk_x11_surface_translate         (GdkSurface *window,
                                             cairo_region_t *area,
                                             gint       dx,
                                             gint       dy);
@@ -106,7 +106,7 @@ void     _gdk_x11_region_get_xrectangles   (const cairo_region_t  *region,
 
 gboolean _gdk_x11_moveresize_handle_event   (const XEvent *event);
 gboolean _gdk_x11_moveresize_configure_done (GdkDisplay *display,
-                                             GdkWindow  *window);
+                                             GdkSurface  *window);
 
 void     _gdk_x11_keymap_state_changed   (GdkDisplay      *display,
                                           const XEvent    *event);
@@ -114,11 +114,11 @@ void     _gdk_x11_keymap_keys_changed    (GdkDisplay      *display);
 void     _gdk_x11_keymap_add_virt_mods   (GdkKeymap       *keymap,
                                           GdkModifierType *modifiers);
 
-void _gdk_x11_windowing_init    (void);
+void _gdk_x11_surfaceing_init    (void);
 
-void _gdk_x11_window_grab_check_unmap   (GdkWindow *window,
+void _gdk_x11_surface_grab_check_unmap   (GdkSurface *window,
                                          gulong     serial);
-void _gdk_x11_window_grab_check_destroy (GdkWindow *window);
+void _gdk_x11_surface_grab_check_destroy (GdkSurface *window);
 
 gboolean _gdk_x11_display_is_root_window (GdkDisplay *display,
                                           Window      xroot_window);
@@ -197,10 +197,10 @@ void       _gdk_x11_display_get_maximal_cursor_size (GdkDisplay *display,
                                                      guint      *width,
                                                      guint      *height);
 void       _gdk_x11_display_create_window_impl     (GdkDisplay    *display,
-                                                    GdkWindow     *window,
-                                                    GdkWindow     *real_parent,
+                                                    GdkSurface     *window,
+                                                    GdkSurface     *real_parent,
                                                     GdkEventMask   event_mask,
-                                                    GdkWindowAttr *attributes);
+                                                    GdkSurfaceAttr *attributes);
 GList *    gdk_x11_display_get_toplevel_windows    (GdkDisplay *display);
 
 void _gdk_x11_precache_atoms (GdkDisplay          *display,
@@ -221,25 +221,25 @@ xdnd_source_window_filter (const XEvent *xevent,
                            GdkEvent     *event,
                            gpointer      data);
 
-typedef struct _GdkWindowCache GdkWindowCache;
+typedef struct _GdkSurfaceCache GdkSurfaceCache;
 
-GdkWindowCache *
-gdk_window_cache_get (GdkDisplay *display);
+GdkSurfaceCache *
+gdk_surface_cache_get (GdkDisplay *display);
 
 GdkFilterReturn
-gdk_window_cache_filter (const XEvent *xevent,
+gdk_surface_cache_filter (const XEvent *xevent,
                          GdkEvent     *event,
                          gpointer      data);
 GdkFilterReturn
-gdk_window_cache_shape_filter (const XEvent *xevent,
+gdk_surface_cache_shape_filter (const XEvent *xevent,
                                GdkEvent     *event,
                                gpointer      data);
 
 void _gdk_x11_cursor_display_finalize (GdkDisplay *display);
 
-void _gdk_x11_window_register_dnd (GdkWindow *window);
+void _gdk_x11_surface_register_dnd (GdkSurface *window);
 
-GdkDragContext * _gdk_x11_window_drag_begin (GdkWindow          *window,
+GdkDragContext * _gdk_x11_surface_drag_begin (GdkSurface          *window,
                                              GdkDevice          *device,
                                              GdkContentProvider *content,
                                              GdkDragAction       actions,
@@ -258,20 +258,20 @@ extern const gint        _gdk_x11_event_mask_table_size;
 #define GDK_SCREEN_DISPLAY(screen)    (GDK_X11_SCREEN (screen)->display)
 #define GDK_SCREEN_XROOTWIN(screen)   (GDK_X11_SCREEN (screen)->xroot_window)
 #define GDK_DISPLAY_XROOTWIN(display) (GDK_SCREEN_XROOTWIN (GDK_X11_DISPLAY (display)->screen))
-#define GDK_WINDOW_SCREEN(win)        (GDK_X11_DISPLAY (gdk_window_get_display (win))->screen)
-#define GDK_WINDOW_DISPLAY(win)       (gdk_window_get_display (win))
-#define GDK_WINDOW_XROOTWIN(win)      (GDK_X11_SCREEN (GDK_WINDOW_SCREEN (win))->xroot_window)
-#define GDK_WINDOW_IS_X11(win)        (GDK_IS_WINDOW_IMPL_X11 ((win)->impl))
+#define GDK_SURFACE_SCREEN(win)        (GDK_X11_DISPLAY (gdk_surface_get_display (win))->screen)
+#define GDK_SURFACE_DISPLAY(win)       (gdk_surface_get_display (win))
+#define GDK_SURFACE_XROOTWIN(win)      (GDK_X11_SCREEN (GDK_SURFACE_SCREEN (win))->xroot_window)
+#define GDK_SURFACE_IS_X11(win)        (GDK_IS_SURFACE_IMPL_X11 ((win)->impl))
 
 /* override some macros from gdkx.h with direct-access variants */
 #undef GDK_DISPLAY_XDISPLAY
-#undef GDK_WINDOW_XDISPLAY
-#undef GDK_WINDOW_XID
+#undef GDK_SURFACE_XDISPLAY
+#undef GDK_SURFACE_XID
 #undef GDK_SCREEN_XDISPLAY
 
 #define GDK_DISPLAY_XDISPLAY(display) (GDK_X11_DISPLAY(display)->xdisplay)
-#define GDK_WINDOW_XDISPLAY(win)      (GDK_X11_SCREEN (GDK_WINDOW_SCREEN (win))->xdisplay)
-#define GDK_WINDOW_XID(win)           (GDK_WINDOW_IMPL_X11(GDK_WINDOW (win)->impl)->xid)
+#define GDK_SURFACE_XDISPLAY(win)      (GDK_X11_SCREEN (GDK_SURFACE_SCREEN (win))->xdisplay)
+#define GDK_SURFACE_XID(win)           (GDK_SURFACE_IMPL_X11(GDK_SURFACE (win)->impl)->xid)
 #define GDK_SCREEN_XDISPLAY(screen)   (GDK_X11_SCREEN (screen)->xdisplay)
 
 #endif /* __GDK_PRIVATE_X11_H__ */
diff --git a/gdk/x11/gdkscreen-x11.c b/gdk/x11/gdkscreen-x11.c
index 2ca0ac7886..bcabeb32de 100644
--- a/gdk/x11/gdkscreen-x11.c
+++ b/gdk/x11/gdkscreen-x11.c
@@ -805,9 +805,9 @@ _gdk_x11_screen_set_window_scale (GdkX11Screen *x11_screen,
 
   for (l = toplevels; l != NULL; l = l->next)
     {
-      GdkWindow *window = l->data;
+      GdkSurface *window = l->data;
 
-      _gdk_x11_window_set_window_scale (window, scale);
+      _gdk_x11_surface_set_window_scale (window, scale);
     }
 
   for (i = 0; i < x11_display->monitors->len; i++)
diff --git a/gdk/x11/gdkvulkancontext-x11.c b/gdk/x11/gdkvulkancontext-x11.c
index 608a2e22d7..0e88ec6d63 100644
--- a/gdk/x11/gdkvulkancontext-x11.c
+++ b/gdk/x11/gdkvulkancontext-x11.c
@@ -36,7 +36,7 @@ static VkResult
 gdk_x11_vulkan_context_create_surface (GdkVulkanContext *context,
                                        VkSurfaceKHR     *surface)
 {
-  GdkWindow *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
+  GdkSurface *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
   GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
 
   /* This is necessary so that Vulkan sees the Window.
@@ -52,7 +52,7 @@ gdk_x11_vulkan_context_create_surface (GdkVulkanContext *context,
                                                    NULL,
                                                    0,
                                                    gdk_x11_display_get_xdisplay (display),
-                                                   gdk_x11_window_get_xid (window)
+                                                   gdk_x11_surface_get_xid (window)
                                                },
                                                NULL,
                                                surface);
diff --git a/gdk/x11/gdkwindow-x11.c b/gdk/x11/gdkwindow-x11.c
index 3fcaae3591..c78c5c1840 100644
--- a/gdk/x11/gdkwindow-x11.c
+++ b/gdk/x11/gdkwindow-x11.c
@@ -101,23 +101,23 @@ const int _gdk_x11_event_mask_table[21] =
 const gint _gdk_x11_event_mask_table_size = G_N_ELEMENTS (_gdk_x11_event_mask_table);
 
 /* Forward declarations */
-static void     gdk_x11_window_apply_fullscreen_mode (GdkWindow  *window);
-static gboolean gdk_window_icon_name_set          (GdkWindow  *window);
+static void     gdk_x11_surface_apply_fullscreen_mode (GdkSurface  *window);
+static gboolean gdk_surface_icon_name_set          (GdkSurface  *window);
 static void     set_wm_name                       (GdkDisplay  *display,
 						   Window       xwindow,
 						   const gchar *name);
-static void     move_to_current_desktop           (GdkWindow *window);
+static void     move_to_current_desktop           (GdkSurface *window);
 
-static void        gdk_window_impl_x11_finalize   (GObject            *object);
+static void        gdk_surface_impl_x11_finalize   (GObject            *object);
 
 #define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window)           \
-  (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL ||   \
-   GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP ||       \
-   GDK_WINDOW_TYPE (window) == GDK_WINDOW_FOREIGN)
+  (GDK_SURFACE_TYPE (window) == GDK_SURFACE_TOPLEVEL ||   \
+   GDK_SURFACE_TYPE (window) == GDK_SURFACE_TEMP ||       \
+   GDK_SURFACE_TYPE (window) == GDK_SURFACE_FOREIGN)
 
 #define WINDOW_IS_TOPLEVEL(window)                      \
-  (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL ||   \
-   GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP)
+  (GDK_SURFACE_TYPE (window) == GDK_SURFACE_TOPLEVEL ||   \
+   GDK_SURFACE_TYPE (window) == GDK_SURFACE_TEMP)
 
 /* Return whether time1 is considered later than time2 as far as xserver
  * time is concerned.  Accounts for wraparound.
@@ -127,47 +127,47 @@ static void        gdk_window_impl_x11_finalize   (GObject            *object);
     (( time1 < time2 ) && ( time2 - time1 > ((guint32)-1)/2 ))     \
   )
 
-struct _GdkX11Window {
-  GdkWindow parent;
+struct _GdkX11Surface {
+  GdkSurface parent;
 };
 
-struct _GdkX11WindowClass {
-  GdkWindowClass parent_class;
+struct _GdkX11SurfaceClass {
+  GdkSurfaceClass parent_class;
 };
 
-G_DEFINE_TYPE (GdkX11Window, gdk_x11_window, GDK_TYPE_WINDOW)
+G_DEFINE_TYPE (GdkX11Surface, gdk_x11_surface, GDK_TYPE_SURFACE)
 
 static void
-gdk_x11_window_class_init (GdkX11WindowClass *x11_window_class)
+gdk_x11_surface_class_init (GdkX11SurfaceClass *x11_surface_class)
 {
 }
 
 static void
-gdk_x11_window_init (GdkX11Window *x11_window)
+gdk_x11_surface_init (GdkX11Surface *x11_surface)
 {
 }
 
 
-G_DEFINE_TYPE (GdkWindowImplX11, gdk_window_impl_x11, GDK_TYPE_WINDOW_IMPL)
+G_DEFINE_TYPE (GdkSurfaceImplX11, gdk_surface_impl_x11, GDK_TYPE_SURFACE_IMPL)
 
 static void
-gdk_window_impl_x11_init (GdkWindowImplX11 *impl)
+gdk_surface_impl_x11_init (GdkSurfaceImplX11 *impl)
 {  
   impl->window_scale = 1;
   impl->frame_sync_enabled = TRUE;
 }
 
 GdkToplevelX11 *
-_gdk_x11_window_get_toplevel (GdkWindow *window)
+_gdk_x11_surface_get_toplevel (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+  g_return_val_if_fail (GDK_IS_SURFACE (window), NULL);
 
   if (!WINDOW_IS_TOPLEVEL (window))
     return NULL;
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (!impl->toplevel)
     {
@@ -179,14 +179,14 @@ _gdk_x11_window_get_toplevel (GdkWindow *window)
 }
 
 /**
- * _gdk_x11_window_update_size:
- * @impl: a #GdkWindowImplX11.
+ * _gdk_x11_surface_update_size:
+ * @impl: a #GdkSurfaceImplX11.
  * 
  * Updates the state of the window (in particular the drawable's
  * cairo surface) when its size has changed.
  **/
 void
-_gdk_x11_window_update_size (GdkWindowImplX11 *impl)
+_gdk_x11_surface_update_size (GdkSurfaceImplX11 *impl)
 {
   if (impl->cairo_surface)
     {
@@ -196,11 +196,11 @@ _gdk_x11_window_update_size (GdkWindowImplX11 *impl)
 }
 
 static void
-gdk_x11_window_get_unscaled_size (GdkWindow *window,
+gdk_x11_surface_get_unscaled_size (GdkSurface *window,
                                   int *unscaled_width,
                                   int *unscaled_height)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (unscaled_width)
     *unscaled_width = impl->unscaled_width;
@@ -210,9 +210,9 @@ gdk_x11_window_get_unscaled_size (GdkWindow *window,
 }
 
 static gboolean
-gdk_x11_window_supports_edge_constraints (GdkWindow *window)
+gdk_x11_surface_supports_edge_constraints (GdkSurface *window)
 {
-  return gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+  return gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                               g_intern_static_string ("_GTK_EDGE_CONSTRAINTS"));
 }
 
@@ -230,21 +230,21 @@ set_sync_counter(Display     *display,
 }
 
 static void
-window_pre_damage (GdkWindow *window)
+window_pre_damage (GdkSurface *window)
 {
-  GdkWindow *toplevel_window = gdk_window_get_toplevel (window);
-  GdkWindowImplX11 *impl;
+  GdkSurface *toplevel_window = gdk_surface_get_toplevel (window);
+  GdkSurfaceImplX11 *impl;
 
   if (!toplevel_window || !WINDOW_IS_TOPLEVEL (toplevel_window))
     return;
 
-  impl = GDK_WINDOW_IMPL_X11 (toplevel_window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (toplevel_window->impl);
 
   if (impl->toplevel->in_frame &&
       impl->toplevel->current_counter_value % 2 == 0)
     {
       impl->toplevel->current_counter_value += 1;
-      set_sync_counter (GDK_WINDOW_XDISPLAY (impl->wrapper),
+      set_sync_counter (GDK_SURFACE_XDISPLAY (impl->wrapper),
 		        impl->toplevel->extended_update_counter,
                         impl->toplevel->current_counter_value);
     }
@@ -253,8 +253,8 @@ window_pre_damage (GdkWindow *window)
 static void
 on_surface_changed (void *data)
 {
-  GdkWindow *window = data;
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurface *window = data;
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (impl->tracking_damage)
     window_pre_damage (window);
@@ -270,9 +270,9 @@ on_surface_changed (void *data)
  */
 
 static void
-hook_surface_changed (GdkWindow *window)
+hook_surface_changed (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (impl->cairo_surface)
     {
@@ -287,9 +287,9 @@ hook_surface_changed (GdkWindow *window)
 }
 
 static void
-unhook_surface_changed (GdkWindow *window)
+unhook_surface_changed (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (impl->cairo_surface)
     {
@@ -302,9 +302,9 @@ unhook_surface_changed (GdkWindow *window)
 }
 
 static void
-gdk_x11_window_predict_presentation_time (GdkWindow *window)
+gdk_x11_surface_predict_presentation_time (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   GdkFrameClock *clock;
   GdkFrameTimings *timings;
   gint64 presentation_time;
@@ -313,7 +313,7 @@ gdk_x11_window_predict_presentation_time (GdkWindow *window)
   if (!WINDOW_IS_TOPLEVEL (window))
     return;
 
-  clock = gdk_window_get_frame_clock (window);
+  clock = gdk_surface_get_frame_clock (window);
 
   timings = gdk_frame_clock_get_current_timings (clock);
 
@@ -348,14 +348,14 @@ gdk_x11_window_predict_presentation_time (GdkWindow *window)
 }
 
 static void
-gdk_x11_window_begin_frame (GdkWindow *window,
+gdk_x11_surface_begin_frame (GdkSurface *window,
                             gboolean   force_frame)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (!WINDOW_IS_TOPLEVEL (window) ||
       impl->toplevel->extended_update_counter == None)
@@ -388,32 +388,32 @@ gdk_x11_window_begin_frame (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_end_frame (GdkWindow *window)
+gdk_x11_surface_end_frame (GdkSurface *window)
 {
   GdkFrameClock *clock;
   GdkFrameTimings *timings;
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (!WINDOW_IS_TOPLEVEL (window) ||
       impl->toplevel->extended_update_counter == None ||
       !impl->toplevel->in_frame)
     return;
 
-  clock = gdk_window_get_frame_clock (window);
+  clock = gdk_surface_get_frame_clock (window);
   timings = gdk_frame_clock_get_current_timings (clock);
 
   impl->toplevel->in_frame = FALSE;
 
   if (impl->toplevel->current_counter_value % 2 == 1)
     {
-      if (GDK_DISPLAY_DEBUG_CHECK (gdk_window_get_display (window), FRAMES))
+      if (GDK_DISPLAY_DEBUG_CHECK (gdk_surface_get_display (window), FRAMES))
         {
-          XImage *image = XGetImage (GDK_WINDOW_XDISPLAY (window),
-                                     GDK_WINDOW_XID (window),
+          XImage *image = XGetImage (GDK_SURFACE_XDISPLAY (window),
+                                     GDK_SURFACE_XID (window),
                                      0, 0, 1, 1,
                                      (1 << 24) - 1,
                                      ZPixmap);
@@ -429,16 +429,16 @@ gdk_x11_window_end_frame (GdkWindow *window)
       else
         impl->toplevel->current_counter_value += 1;
 
-      set_sync_counter(GDK_WINDOW_XDISPLAY (impl->wrapper),
+      set_sync_counter(GDK_SURFACE_XDISPLAY (impl->wrapper),
 		       impl->toplevel->extended_update_counter,
 		       impl->toplevel->current_counter_value);
 
       if (impl->frame_sync_enabled &&
-          gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+          gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
 					       g_intern_static_string ("_NET_WM_FRAME_DRAWN")))
         {
           impl->toplevel->frame_pending = TRUE;
-          _gdk_frame_clock_freeze (gdk_window_get_frame_clock (window));
+          _gdk_frame_clock_freeze (gdk_surface_get_frame_clock (window));
           timings->cookie = impl->toplevel->current_counter_value;
         }
     }
@@ -448,7 +448,7 @@ gdk_x11_window_end_frame (GdkWindow *window)
   if (impl->toplevel->configure_counter_value != 0 &&
       !impl->toplevel->configure_counter_value_is_extended)
     {
-      set_sync_counter (GDK_WINDOW_XDISPLAY (window),
+      set_sync_counter (GDK_SURFACE_XDISPLAY (window),
                         impl->toplevel->update_counter,
                         impl->toplevel->configure_counter_value);
 
@@ -464,32 +464,32 @@ gdk_x11_window_end_frame (GdkWindow *window)
  *****************************************************/
 
 static cairo_surface_t *
-gdk_x11_create_cairo_surface (GdkWindowImplX11 *impl,
+gdk_x11_create_cairo_surface (GdkSurfaceImplX11 *impl,
 			      int width,
 			      int height)
 {
   Visual *visual;
     
-  visual = gdk_x11_display_get_window_visual (GDK_X11_DISPLAY (gdk_window_get_display (impl->wrapper)));
-  return cairo_xlib_surface_create (GDK_WINDOW_XDISPLAY (impl->wrapper),
-                                    GDK_WINDOW_IMPL_X11 (impl)->xid,
+  visual = gdk_x11_display_get_window_visual (GDK_X11_DISPLAY (gdk_surface_get_display (impl->wrapper)));
+  return cairo_xlib_surface_create (GDK_SURFACE_XDISPLAY (impl->wrapper),
+                                    GDK_SURFACE_IMPL_X11 (impl)->xid,
                                     visual,
                                     width, height);
 }
 
 static cairo_surface_t *
-gdk_x11_ref_cairo_surface (GdkWindow *window)
+gdk_x11_ref_cairo_surface (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return NULL;
 
   if (!impl->cairo_surface)
     {
       impl->cairo_surface = gdk_x11_create_cairo_surface (impl,
-                                                          gdk_window_get_width (window) * impl->window_scale,
-                                                          gdk_window_get_height (window) * impl->window_scale);
+                                                          gdk_surface_get_width (window) * impl->window_scale,
+                                                          gdk_surface_get_height (window) * impl->window_scale);
       cairo_surface_set_device_scale (impl->cairo_surface, impl->window_scale, impl->window_scale);
 
       if (WINDOW_IS_TOPLEVEL (window) && impl->toplevel->in_frame)
@@ -502,25 +502,25 @@ gdk_x11_ref_cairo_surface (GdkWindow *window)
 }
 
 static void
-gdk_window_impl_x11_finalize (GObject *object)
+gdk_surface_impl_x11_finalize (GObject *object)
 {
-  GdkWindow *wrapper;
-  GdkWindowImplX11 *impl;
+  GdkSurface *wrapper;
+  GdkSurfaceImplX11 *impl;
 
-  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (object));
+  g_return_if_fail (GDK_IS_SURFACE_IMPL_X11 (object));
 
-  impl = GDK_WINDOW_IMPL_X11 (object);
+  impl = GDK_SURFACE_IMPL_X11 (object);
 
   wrapper = impl->wrapper;
 
   if (WINDOW_IS_TOPLEVEL (wrapper) && impl->toplevel->in_frame)
     unhook_surface_changed (wrapper);
 
-  _gdk_x11_window_grab_check_destroy (wrapper);
+  _gdk_x11_surface_grab_check_destroy (wrapper);
 
-  if (!GDK_WINDOW_DESTROYED (wrapper))
+  if (!GDK_SURFACE_DESTROYED (wrapper))
     {
-      GdkDisplay *display = GDK_WINDOW_DISPLAY (wrapper);
+      GdkDisplay *display = GDK_SURFACE_DISPLAY (wrapper);
 
       _gdk_x11_display_remove_window (display, impl->xid);
       if (impl->toplevel && impl->toplevel->focus_window)
@@ -532,7 +532,7 @@ gdk_window_impl_x11_finalize (GObject *object)
   if (impl->cursor)
     g_object_unref (impl->cursor);
 
-  G_OBJECT_CLASS (gdk_window_impl_x11_parent_class)->finalize (object);
+  G_OBJECT_CLASS (gdk_surface_impl_x11_parent_class)->finalize (object);
 }
 
 typedef struct {
@@ -597,7 +597,7 @@ _gdk_x11_display_create_bitmap_surface (GdkDisplay *display,
 
 /* Create a surface backed with a pixmap without alpha on the same screen as window */
 static cairo_surface_t *
-gdk_x11_window_create_pixmap_surface (GdkWindow *window,
+gdk_x11_surface_create_pixmap_surface (GdkSurface *window,
                                       int        width,
                                       int        height)
 {
@@ -606,11 +606,11 @@ gdk_x11_window_create_pixmap_surface (GdkWindow *window,
   cairo_surface_t *surface;
   Pixmap pixmap;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   dpy = GDK_DISPLAY_XDISPLAY (display);
 
   pixmap = XCreatePixmap (dpy,
-                          GDK_WINDOW_XID (window),
+                          GDK_SURFACE_XID (window),
                           width, height,
                           DefaultDepth (dpy, DefaultScreen (dpy)));
   surface = cairo_xlib_surface_create (dpy,
@@ -623,9 +623,9 @@ gdk_x11_window_create_pixmap_surface (GdkWindow *window,
 }
 
 static void
-set_wm_protocols (GdkWindow *window)
+set_wm_protocols (GdkSurface *window)
 {
-  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDisplay *display = gdk_surface_get_display (window);
   Atom protocols[4];
   int n = 0;
   
@@ -638,7 +638,7 @@ set_wm_protocols (GdkWindow *window)
     protocols[n++] = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_SYNC_REQUEST");
 #endif
   
-  XSetWMProtocols (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window), protocols, n);
+  XSetWMProtocols (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window), protocols, n);
 }
 
 static const gchar *
@@ -704,13 +704,13 @@ create_focus_window (GdkDisplay *display,
 }
 
 static void
-ensure_sync_counter (GdkWindow *window)
+ensure_sync_counter (GdkSurface *window)
 {
 #ifdef HAVE_XSYNC
-  if (!GDK_WINDOW_DESTROYED (window))
+  if (!GDK_SURFACE_DESTROYED (window))
     {
-      GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
-      GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
+      GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
+      GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
 
       if (toplevel &&
 	  toplevel->update_counter == None &&
@@ -731,7 +731,7 @@ ensure_sync_counter (GdkWindow *window)
 
 	  counters[0] = toplevel->update_counter;
 	  counters[1] = toplevel->extended_update_counter;
-	  XChangeProperty (xdisplay, GDK_WINDOW_XID (window),
+	  XChangeProperty (xdisplay, GDK_SURFACE_XID (window),
 			   atom, XA_CARDINAL,
 			   32, PropModeReplace,
 			   (guchar *)counters, 2);
@@ -743,14 +743,14 @@ ensure_sync_counter (GdkWindow *window)
 }
 
 static void
-setup_toplevel_window (GdkWindow    *window,
+setup_toplevel_window (GdkSurface    *window,
 		       GdkX11Screen *x11_screen)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
-  GdkDisplay *display = gdk_window_get_display (window);
-  Display *xdisplay = GDK_WINDOW_XDISPLAY (window);
-  XID xid = GDK_WINDOW_XID (window);
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
+  GdkDisplay *display = gdk_surface_get_display (window);
+  Display *xdisplay = GDK_SURFACE_XDISPLAY (window);
+  XID xid = GDK_SURFACE_XID (window);
   XSizeHints size_hints;
   long pid;
   Window leader_window;
@@ -805,41 +805,41 @@ setup_toplevel_window (GdkWindow    *window,
                      (guchar *) &toplevel->focus_window, 1);
 
   if (!window->focus_on_map)
-    gdk_x11_window_set_user_time (window, 0);
+    gdk_x11_surface_set_user_time (window, 0);
   else if (GDK_X11_DISPLAY (x11_screen->display)->user_time != 0)
-    gdk_x11_window_set_user_time (window, GDK_X11_DISPLAY (x11_screen->display)->user_time);
+    gdk_x11_surface_set_user_time (window, GDK_X11_DISPLAY (x11_screen->display)->user_time);
 
   ensure_sync_counter (window);
 
   /* Start off in a frozen state - we'll finish this when we first paint */
-  gdk_x11_window_begin_frame (window, TRUE);
+  gdk_x11_surface_begin_frame (window, TRUE);
 }
 
 static void
 on_frame_clock_before_paint (GdkFrameClock *clock,
-                             GdkWindow     *window)
+                             GdkSurface     *window)
 {
-  gdk_x11_window_predict_presentation_time (window);
-  gdk_x11_window_begin_frame (window, FALSE);
+  gdk_x11_surface_predict_presentation_time (window);
+  gdk_x11_surface_begin_frame (window, FALSE);
 }
 
 static void
 on_frame_clock_after_paint (GdkFrameClock *clock,
-                            GdkWindow     *window)
+                            GdkSurface     *window)
 {
-  gdk_x11_window_end_frame (window);
+  gdk_x11_surface_end_frame (window);
 
 }
 
 static void
-connect_frame_clock (GdkWindow *window)
+connect_frame_clock (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
   if (WINDOW_IS_TOPLEVEL (window) && !impl->frame_clock_connected)
     {
-      GdkFrameClock *frame_clock = gdk_window_get_frame_clock (window);
+      GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (window);
 
       g_signal_connect (frame_clock, "before-paint",
                         G_CALLBACK (on_frame_clock_before_paint), window);
@@ -852,12 +852,12 @@ connect_frame_clock (GdkWindow *window)
 
 void
 _gdk_x11_display_create_window_impl (GdkDisplay    *display,
-                                     GdkWindow     *window,
-                                     GdkWindow     *real_parent,
+                                     GdkSurface     *window,
+                                     GdkSurface     *real_parent,
                                      GdkEventMask   event_mask,
-                                     GdkWindowAttr *attributes)
+                                     GdkSurfaceAttr *attributes)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   GdkX11Screen *x11_screen;
   GdkX11Display *display_x11;
 
@@ -878,13 +878,13 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
   display_x11 = GDK_X11_DISPLAY (display);
   x11_screen = GDK_X11_SCREEN (display_x11->screen);
   if (real_parent)
-    xparent = GDK_WINDOW_XID (real_parent);
+    xparent = GDK_SURFACE_XID (real_parent);
   else
     xparent = GDK_SCREEN_XROOTWIN (x11_screen);
 
-  impl = g_object_new (GDK_TYPE_WINDOW_IMPL_X11, NULL);
-  window->impl = GDK_WINDOW_IMPL (impl);
-  impl->wrapper = GDK_WINDOW (window);
+  impl = g_object_new (GDK_TYPE_SURFACE_IMPL_X11, NULL);
+  window->impl = GDK_SURFACE_IMPL (impl);
+  impl->wrapper = GDK_SURFACE (window);
   impl->window_scale = x11_screen->window_scale;
 
   xdisplay = x11_screen->xdisplay;
@@ -898,8 +898,8 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
   /* Sanity checks */
   switch (window->window_type)
     {
-    case GDK_WINDOW_TOPLEVEL:
-    case GDK_WINDOW_TEMP:
+    case GDK_SURFACE_TOPLEVEL:
+    case GDK_SURFACE_TEMP:
       if (window->parent)
         {
           /* The common code warns for this case */
@@ -907,7 +907,7 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
         }
       break;
 
-    case GDK_WINDOW_CHILD:
+    case GDK_SURFACE_CHILD:
     default:
       g_assert_not_reached ();
       break;
@@ -928,7 +928,7 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
       xattributes.colormap = gdk_x11_display_get_window_colormap (display_x11);
       xattributes_mask |= CWColormap;
 
-      if (window->window_type == GDK_WINDOW_TEMP)
+      if (window->window_type == GDK_SURFACE_TEMP)
         {
           xattributes.save_under = True;
           xattributes.override_redirect = True;
@@ -944,7 +944,7 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
     {
       class = InputOnly;
 
-      if (window->window_type == GDK_WINDOW_TEMP)
+      if (window->window_type == GDK_SURFACE_TEMP)
         {
           xattributes.override_redirect = True;
           xattributes_mask |= CWOverrideRedirect;
@@ -990,11 +990,11 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
   g_object_ref (window);
   _gdk_x11_display_add_window (x11_screen->display, &impl->xid, window);
 
-  switch (GDK_WINDOW_TYPE (window))
+  switch (GDK_SURFACE_TYPE (window))
     {
-    case GDK_WINDOW_TOPLEVEL:
-    case GDK_WINDOW_TEMP:
-      gdk_window_set_title (window, get_default_title ());
+    case GDK_SURFACE_TOPLEVEL:
+    case GDK_SURFACE_TEMP:
+      gdk_surface_set_title (window, get_default_title ());
 
       class_hint = XAllocClassHint ();
       class_hint->res_name = (char *) g_get_prgname ();
@@ -1005,18 +1005,18 @@ _gdk_x11_display_create_window_impl (GdkDisplay    *display,
       setup_toplevel_window (window, x11_screen);
       break;
 
-    case GDK_WINDOW_CHILD:
+    case GDK_SURFACE_CHILD:
     default:
       break;
     }
 
   gdk_x11_event_source_select_events ((GdkEventSource *) display_x11->event_source,
-                                      GDK_WINDOW_XID (window), event_mask,
+                                      GDK_SURFACE_XID (window), event_mask,
                                       StructureNotifyMask | PropertyChangeMask);
 
   connect_frame_clock (window);
 
-  gdk_window_freeze_toplevel_updates (window);
+  gdk_surface_freeze_toplevel_updates (window);
 }
 
 static GdkEventMask
@@ -1035,29 +1035,29 @@ x_event_mask_to_gdk_event_mask (long mask)
 }
 
 /**
- * gdk_x11_window_foreign_new_for_display:
+ * gdk_x11_surface_foreign_new_for_display:
  * @display: (type GdkX11Display): the #GdkDisplay where the window handle comes from.
  * @window: an Xlib Window
  *
- * Wraps a native window in a #GdkWindow. The function will try to
- * look up the window using gdk_x11_window_lookup_for_display() first.
+ * Wraps a native window in a #GdkSurface. The function will try to
+ * look up the window using gdk_x11_surface_lookup_for_display() first.
  * If it does not find it there, it will create a new window.
  *
  * This may fail if the window has been destroyed. If the window
  * was already known to GDK, a new reference to the existing
- * #GdkWindow is returned.
+ * #GdkSurface is returned.
  *
- * Returns: (transfer full): a #GdkWindow wrapper for the native
+ * Returns: (transfer full): a #GdkSurface wrapper for the native
  *   window, or %NULL if the window has been destroyed. The wrapper
  *   will be newly created, if one doesn’t exist already.
  */
-GdkWindow *
-gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
+GdkSurface *
+gdk_x11_surface_foreign_new_for_display (GdkDisplay *display,
                                         Window      window)
 {
   GdkX11Screen *screen;
-  GdkWindow *win;
-  GdkWindowImplX11 *impl;
+  GdkSurface *win;
+  GdkSurfaceImplX11 *impl;
   GdkX11Display *display_x11;
   XWindowAttributes attrs;
   Window root, parent;
@@ -1069,7 +1069,7 @@ gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
 
   display_x11 = GDK_X11_DISPLAY (display);
 
-  if ((win = gdk_x11_window_lookup_for_display (display, window)) != NULL)
+  if ((win = gdk_x11_surface_lookup_for_display (display, window)) != NULL)
     return g_object_ref (win);
 
   gdk_x11_display_error_trap_push (display);
@@ -1093,10 +1093,10 @@ gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
     return NULL;
 
   win = _gdk_display_create_window (display);
-  win->impl = g_object_new (GDK_TYPE_WINDOW_IMPL_X11, NULL);
+  win->impl = g_object_new (GDK_TYPE_SURFACE_IMPL_X11, NULL);
   win->impl_window = win;
 
-  impl = GDK_WINDOW_IMPL_X11 (win->impl);
+  impl = GDK_SURFACE_IMPL_X11 (win->impl);
   impl->wrapper = win;
   impl->window_scale = GDK_X11_SCREEN (screen)->window_scale;
 
@@ -1111,22 +1111,22 @@ gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
   impl->unscaled_height = attrs.height;
   win->width = attrs.width / impl->window_scale;
   win->height = attrs.height  / impl->window_scale;
-  win->window_type = GDK_WINDOW_FOREIGN;
+  win->window_type = GDK_SURFACE_FOREIGN;
   win->destroyed = FALSE;
 
   win->event_mask = x_event_mask_to_gdk_event_mask (attrs.your_event_mask);
 
   if (attrs.map_state == IsUnmapped)
-    win->state = GDK_WINDOW_STATE_WITHDRAWN;
+    win->state = GDK_SURFACE_STATE_WITHDRAWN;
   else
     win->state = 0;
   win->viewable = TRUE;
 
   g_object_ref (win);
-  _gdk_x11_display_add_window (display, &GDK_WINDOW_XID (win), win);
+  _gdk_x11_display_add_window (display, &GDK_SURFACE_XID (win), win);
 
   /* Update the clip region, etc */
-  _gdk_window_update_size (win);
+  _gdk_surface_update_size (win);
 
   return win;
 }
@@ -1166,18 +1166,18 @@ gdk_toplevel_x11_free_contents (GdkDisplay *display,
 }
 
 static void
-gdk_x11_window_destroy (GdkWindow *window,
+gdk_x11_surface_destroy (GdkSurface *window,
                         gboolean   recursing,
                         gboolean   foreign_destroy)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   GdkToplevelX11 *toplevel;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
   if (toplevel)
-    gdk_toplevel_x11_free_contents (GDK_WINDOW_DISPLAY (window), toplevel);
+    gdk_toplevel_x11_free_contents (GDK_SURFACE_DISPLAY (window), toplevel);
 
   unhook_surface_changed (window);
 
@@ -1189,53 +1189,53 @@ gdk_x11_window_destroy (GdkWindow *window,
     }
 
   if (!recursing && !foreign_destroy)
-    XDestroyWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
+    XDestroyWindow (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XID (window));
 }
 
 /* This function is called when the XWindow is really gone.
  */
 static void
-gdk_x11_window_destroy_notify (GdkWindow *window)
+gdk_x11_surface_destroy_notify (GdkSurface *window)
 {
-  GdkWindowImplX11 *window_impl;
+  GdkSurfaceImplX11 *window_impl;
 
-  window_impl = GDK_WINDOW_IMPL_X11 ((window)->impl);
+  window_impl = GDK_SURFACE_IMPL_X11 ((window)->impl);
 
-  if (!GDK_WINDOW_DESTROYED (window))
+  if (!GDK_SURFACE_DESTROYED (window))
     {
-      if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
-	g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_WINDOW_XID (window));
+      if (GDK_SURFACE_TYPE(window) != GDK_SURFACE_FOREIGN)
+	g_warning ("GdkSurface %#lx unexpectedly destroyed", GDK_SURFACE_XID (window));
 
-      _gdk_window_destroy (window, TRUE);
+      _gdk_surface_destroy (window, TRUE);
     }
 
-  _gdk_x11_display_remove_window (GDK_WINDOW_DISPLAY (window), GDK_WINDOW_XID (window));
+  _gdk_x11_display_remove_window (GDK_SURFACE_DISPLAY (window), GDK_SURFACE_XID (window));
   if (window_impl->toplevel && window_impl->toplevel->focus_window)
-    _gdk_x11_display_remove_window (GDK_WINDOW_DISPLAY (window), window_impl->toplevel->focus_window);
+    _gdk_x11_display_remove_window (GDK_SURFACE_DISPLAY (window), window_impl->toplevel->focus_window);
 
-  _gdk_x11_window_grab_check_destroy (window);
+  _gdk_x11_surface_grab_check_destroy (window);
 
   g_object_unref (window);
 }
 
 static void
-update_wm_hints (GdkWindow *window,
+update_wm_hints (GdkSurface *window,
 		 gboolean   force)
 {
-  GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (window);
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkToplevelX11 *toplevel = _gdk_x11_surface_get_toplevel (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
   XWMHints wm_hints;
 
   if (!force &&
       !toplevel->is_leader &&
-      window->state & GDK_WINDOW_STATE_WITHDRAWN)
+      window->state & GDK_SURFACE_STATE_WITHDRAWN)
     return;
 
   wm_hints.flags = StateHint | InputHint;
   wm_hints.input = window->accept_focus ? True : False;
   wm_hints.initial_state = NormalState;
   
-  if (window->state & GDK_WINDOW_STATE_ICONIFIED)
+  if (window->state & GDK_SURFACE_STATE_ICONIFIED)
     {
       wm_hints.flags |= StateHint;
       wm_hints.initial_state = IconicState;
@@ -1254,10 +1254,10 @@ update_wm_hints (GdkWindow *window,
     }
   
   wm_hints.flags |= WindowGroupHint;
-  if (toplevel->group_leader && !GDK_WINDOW_DESTROYED (toplevel->group_leader))
+  if (toplevel->group_leader && !GDK_SURFACE_DESTROYED (toplevel->group_leader))
     {
       wm_hints.flags |= WindowGroupHint;
-      wm_hints.window_group = GDK_WINDOW_XID (toplevel->group_leader);
+      wm_hints.window_group = GDK_SURFACE_XID (toplevel->group_leader);
     }
   else
     wm_hints.window_group = GDK_X11_DISPLAY (display)->leader_window;
@@ -1265,22 +1265,22 @@ update_wm_hints (GdkWindow *window,
   if (toplevel->urgency_hint)
     wm_hints.flags |= XUrgencyHint;
   
-  XSetWMHints (GDK_WINDOW_XDISPLAY (window),
-	       GDK_WINDOW_XID (window),
+  XSetWMHints (GDK_SURFACE_XDISPLAY (window),
+	       GDK_SURFACE_XID (window),
 	       &wm_hints);
 }
 
 static void
-set_initial_hints (GdkWindow *window)
+set_initial_hints (GdkSurface *window)
 {
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
-  Window xwindow = GDK_WINDOW_XID (window);  
+  Window xwindow = GDK_SURFACE_XID (window);  
   GdkToplevelX11 *toplevel;
   Atom atoms[9];
   gint i;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (!toplevel)
     return;
@@ -1294,7 +1294,7 @@ set_initial_hints (GdkWindow *window)
   
   i = 0;
 
-  if (window->state & GDK_WINDOW_STATE_MAXIMIZED)
+  if (window->state & GDK_SURFACE_STATE_MAXIMIZED)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_MAXIMIZED_VERT");
@@ -1305,21 +1305,21 @@ set_initial_hints (GdkWindow *window)
       toplevel->have_maxhorz = toplevel->have_maxvert = TRUE;
     }
 
-  if (window->state & GDK_WINDOW_STATE_ABOVE)
+  if (window->state & GDK_SURFACE_STATE_ABOVE)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_ABOVE");
       ++i;
     }
   
-  if (window->state & GDK_WINDOW_STATE_BELOW)
+  if (window->state & GDK_SURFACE_STATE_BELOW)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_BELOW");
       ++i;
     }
   
-  if (window->state & GDK_WINDOW_STATE_STICKY)
+  if (window->state & GDK_SURFACE_STATE_STICKY)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_STICKY");
@@ -1327,7 +1327,7 @@ set_initial_hints (GdkWindow *window)
       toplevel->have_sticky = TRUE;
     }
 
-  if (window->state & GDK_WINDOW_STATE_FULLSCREEN)
+  if (window->state & GDK_SURFACE_STATE_FULLSCREEN)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_FULLSCREEN");
@@ -1356,7 +1356,7 @@ set_initial_hints (GdkWindow *window)
       ++i;
     }
 
-  if (window->state & GDK_WINDOW_STATE_ICONIFIED)
+  if (window->state & GDK_SURFACE_STATE_ICONIFIED)
     {
       atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
 							"_NET_WM_STATE_HIDDEN");
@@ -1379,7 +1379,7 @@ set_initial_hints (GdkWindow *window)
 		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"));
     }
 
-  if (window->state & GDK_WINDOW_STATE_STICKY)
+  if (window->state & GDK_SURFACE_STATE_STICKY)
     {
       atoms[0] = 0xFFFFFFFF;
       XChangeProperty (xdisplay,
@@ -1400,27 +1400,27 @@ set_initial_hints (GdkWindow *window)
 }
 
 static void
-gdk_window_x11_show (GdkWindow *window, gboolean already_mapped)
+gdk_surface_x11_show (GdkSurface *window, gboolean already_mapped)
 {
   GdkDisplay *display;
   GdkX11Display *display_x11;
   GdkToplevelX11 *toplevel;
-  Display *xdisplay = GDK_WINDOW_XDISPLAY (window);
-  Window xwindow = GDK_WINDOW_XID (window);
+  Display *xdisplay = GDK_SURFACE_XDISPLAY (window);
+  Window xwindow = GDK_SURFACE_XID (window);
 
   if (!already_mapped)
     set_initial_hints (window);
       
   if (WINDOW_IS_TOPLEVEL (window))
     {
-      display = gdk_window_get_display (window);
+      display = gdk_surface_get_display (window);
       display_x11 = GDK_X11_DISPLAY (display);
-      toplevel = _gdk_x11_window_get_toplevel (window);
+      toplevel = _gdk_x11_surface_get_toplevel (window);
       
       if (toplevel->user_time != 0 &&
 	      display_x11->user_time != 0 &&
 	  XSERVER_TIME_IS_LATER (display_x11->user_time, toplevel->user_time))
-	gdk_x11_window_set_user_time (window, display_x11->user_time);
+	gdk_x11_surface_set_user_time (window, display_x11->user_time);
     }
   
   XMapWindow (xdisplay, xwindow);
@@ -1430,65 +1430,65 @@ gdk_window_x11_show (GdkWindow *window, gboolean already_mapped)
    * consistent with pre-fullscreen mode implementation.
    */
   if (window->fullscreen_mode != GDK_FULLSCREEN_ON_CURRENT_MONITOR)
-    gdk_x11_window_apply_fullscreen_mode (window);
+    gdk_x11_surface_apply_fullscreen_mode (window);
 }
 
 static void
-gdk_window_x11_hide (GdkWindow *window)
+gdk_surface_x11_hide (GdkSurface *window)
 {
   /* We'll get the unmap notify eventually, and handle it then,
    * but checking here makes things more consistent if we are
    * just doing stuff ourself.
    */
-  _gdk_x11_window_grab_check_unmap (window,
-                                    NextRequest (GDK_WINDOW_XDISPLAY (window)));
+  _gdk_x11_surface_grab_check_unmap (window,
+                                    NextRequest (GDK_SURFACE_XDISPLAY (window)));
 
   /* You can't simply unmap toplevel windows. */
   switch (window->window_type)
     {
-    case GDK_WINDOW_TOPLEVEL:
-    case GDK_WINDOW_TEMP: /* ? */
-      gdk_window_withdraw (window);
+    case GDK_SURFACE_TOPLEVEL:
+    case GDK_SURFACE_TEMP: /* ? */
+      gdk_surface_withdraw (window);
       return;
       
-    case GDK_WINDOW_FOREIGN:
-    case GDK_WINDOW_CHILD:
+    case GDK_SURFACE_FOREIGN:
+    case GDK_SURFACE_CHILD:
     default:
       break;
     }
   
-  _gdk_window_clear_update_area (window);
+  _gdk_surface_clear_update_area (window);
   
-  XUnmapWindow (GDK_WINDOW_XDISPLAY (window),
-		GDK_WINDOW_XID (window));
+  XUnmapWindow (GDK_SURFACE_XDISPLAY (window),
+		GDK_SURFACE_XID (window));
 }
 
 static void
-gdk_window_x11_withdraw (GdkWindow *window)
+gdk_surface_x11_withdraw (GdkSurface *window)
 {
   if (!window->destroyed)
     {
-      if (GDK_WINDOW_IS_MAPPED (window))
+      if (GDK_SURFACE_IS_MAPPED (window))
         gdk_synthesize_window_state (window,
                                      0,
-                                     GDK_WINDOW_STATE_WITHDRAWN);
+                                     GDK_SURFACE_STATE_WITHDRAWN);
 
-      g_assert (!GDK_WINDOW_IS_MAPPED (window));
+      g_assert (!GDK_SURFACE_IS_MAPPED (window));
 
-      XWithdrawWindow (GDK_WINDOW_XDISPLAY (window),
-                       GDK_WINDOW_XID (window), 0);
+      XWithdrawWindow (GDK_SURFACE_XDISPLAY (window),
+                       GDK_SURFACE_XID (window), 0);
     }
 }
 
 static inline void
-window_x11_move (GdkWindow *window,
+window_x11_move (GdkSurface *window,
                  gint       x,
                  gint       y)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
-  XMoveWindow (GDK_WINDOW_XDISPLAY (window),
-               GDK_WINDOW_XID (window),
+  XMoveWindow (GDK_SURFACE_XDISPLAY (window),
+               GDK_SURFACE_XID (window),
                x * impl->window_scale, y * impl->window_scale);
 
   if (impl->override_redirect)
@@ -1499,11 +1499,11 @@ window_x11_move (GdkWindow *window,
 }
 
 static inline void
-window_x11_resize (GdkWindow *window,
+window_x11_resize (GdkSurface *window,
                    gint       width,
                    gint       height)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (width < 1)
     width = 1;
@@ -1513,8 +1513,8 @@ window_x11_resize (GdkWindow *window,
 
   window_pre_damage (window);
 
-  XResizeWindow (GDK_WINDOW_XDISPLAY (window),
-                 GDK_WINDOW_XID (window),
+  XResizeWindow (GDK_SURFACE_XDISPLAY (window),
+                 GDK_SURFACE_XID (window),
                  width * impl->window_scale, height * impl->window_scale);
 
   if (impl->override_redirect)
@@ -1523,7 +1523,7 @@ window_x11_resize (GdkWindow *window,
       impl->unscaled_height = height * impl->window_scale;
       window->width = width;
       window->height = height;
-      _gdk_x11_window_update_size (GDK_WINDOW_IMPL_X11 (window->impl));
+      _gdk_x11_surface_update_size (GDK_SURFACE_IMPL_X11 (window->impl));
     }
   else
     {
@@ -1533,13 +1533,13 @@ window_x11_resize (GdkWindow *window,
 }
 
 static inline void
-window_x11_move_resize (GdkWindow *window,
+window_x11_move_resize (GdkSurface *window,
                         gint       x,
                         gint       y,
                         gint       width,
                         gint       height)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   if (width < 1)
     width = 1;
@@ -1549,8 +1549,8 @@ window_x11_move_resize (GdkWindow *window,
 
   window_pre_damage (window);
 
-  XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
-                     GDK_WINDOW_XID (window),
+  XMoveResizeWindow (GDK_SURFACE_XDISPLAY (window),
+                     GDK_SURFACE_XID (window),
                      x * impl->window_scale, y * impl->window_scale,
                      width * impl->window_scale, height * impl->window_scale);
 
@@ -1564,7 +1564,7 @@ window_x11_move_resize (GdkWindow *window,
       window->width = width;
       window->height = height;
 
-      _gdk_x11_window_update_size (GDK_WINDOW_IMPL_X11 (window->impl));
+      _gdk_x11_surface_update_size (GDK_SURFACE_IMPL_X11 (window->impl));
     }
   else
     {
@@ -1574,7 +1574,7 @@ window_x11_move_resize (GdkWindow *window,
 }
 
 static void
-gdk_window_x11_move_resize (GdkWindow *window,
+gdk_surface_x11_move_resize (GdkSurface *window,
                             gboolean   with_move,
                             gint       x,
                             gint       y,
@@ -1593,35 +1593,35 @@ gdk_window_x11_move_resize (GdkWindow *window,
 }
 
 void
-_gdk_x11_window_set_window_scale (GdkWindow *window,
+_gdk_x11_surface_set_window_scale (GdkSurface *window,
 				  int scale)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   GdkToplevelX11 *toplevel;
-  GdkWindowHints geom_mask;
+  GdkSurfaceHints geom_mask;
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   impl->window_scale = scale;
   if (impl->cairo_surface)
     cairo_surface_set_device_scale (impl->cairo_surface, impl->window_scale, impl->window_scale);
-  _gdk_window_update_size (window);
+  _gdk_surface_update_size (window);
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
-  if (toplevel && window->window_type != GDK_WINDOW_FOREIGN)
+  toplevel = _gdk_x11_surface_get_toplevel (window);
+  if (toplevel && window->window_type != GDK_SURFACE_FOREIGN)
     {
       /* These are affected by window scale: */
       geom_mask = toplevel->last_geometry_hints_mask &
         (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC);
       if (geom_mask)
-        gdk_window_set_geometry_hints (window,
+        gdk_surface_set_geometry_hints (window,
                                        &toplevel->last_geometry_hints,
                                        geom_mask);
     }
 
-  if (window->window_type == GDK_WINDOW_FOREIGN)
-    XMoveWindow (GDK_WINDOW_XDISPLAY (window),
-                 GDK_WINDOW_XID (window),
+  if (window->window_type == GDK_SURFACE_FOREIGN)
+    XMoveWindow (GDK_SURFACE_XDISPLAY (window),
+                 GDK_SURFACE_XID (window),
                  window->x * impl->window_scale,
                  window->y * impl->window_scale);
   else
@@ -1632,45 +1632,45 @@ _gdk_x11_window_set_window_scale (GdkWindow *window,
           impl->unscaled_height = window->height * impl->window_scale;
         }
 
-      XResizeWindow (GDK_WINDOW_XDISPLAY (window),
-                     GDK_WINDOW_XID (window),
+      XResizeWindow (GDK_SURFACE_XDISPLAY (window),
+                     GDK_SURFACE_XID (window),
                      window->width * impl->window_scale,
                      window->height * impl->window_scale);
     }
 
-  gdk_window_invalidate_rect (window, NULL, TRUE);
+  gdk_surface_invalidate_rect (window, NULL, TRUE);
 }
 
 static void
-gdk_window_x11_raise (GdkWindow *window)
+gdk_surface_x11_raise (GdkSurface *window)
 {
-  XRaiseWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
+  XRaiseWindow (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XID (window));
 }
 
 static void
-gdk_window_x11_restack_toplevel (GdkWindow *window,
-				 GdkWindow *sibling,
+gdk_surface_x11_restack_toplevel (GdkSurface *window,
+				 GdkSurface *sibling,
 				 gboolean   above)
 {
   XWindowChanges changes;
 
-  changes.sibling = GDK_WINDOW_XID (sibling);
+  changes.sibling = GDK_SURFACE_XID (sibling);
   changes.stack_mode = above ? Above : Below;
-  XReconfigureWMWindow (GDK_WINDOW_XDISPLAY (window),
-			GDK_WINDOW_XID (window),
-			gdk_x11_screen_get_screen_number (GDK_WINDOW_SCREEN (window)),
+  XReconfigureWMWindow (GDK_SURFACE_XDISPLAY (window),
+			GDK_SURFACE_XID (window),
+			gdk_x11_screen_get_screen_number (GDK_SURFACE_SCREEN (window)),
 			CWStackMode | CWSibling, &changes);
 }
 
 static void
-gdk_window_x11_lower (GdkWindow *window)
+gdk_surface_x11_lower (GdkSurface *window)
 {
-  XLowerWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
+  XLowerWindow (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XID (window));
 }
 
 /**
- * gdk_x11_window_move_to_current_desktop:
- * @window: (type GdkX11Window): a #GdkWindow
+ * gdk_x11_surface_move_to_current_desktop:
+ * @window: (type GdkX11Surface): a #GdkSurface
  * 
  * Moves the window to the correct workspace when running under a 
  * window manager that supports multiple workspaces, as described
@@ -1678,14 +1678,14 @@ gdk_window_x11_lower (GdkWindow *window)
  * Will not do anything if the window is already on all workspaces.
  */
 void
-gdk_x11_window_move_to_current_desktop (GdkWindow *window)
+gdk_x11_surface_move_to_current_desktop (GdkSurface *window)
 {
   GdkToplevelX11 *toplevel;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
-  g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
+  g_return_if_fail (GDK_IS_SURFACE (window));
+  g_return_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD);
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (toplevel->on_all_desktops)
     return;
@@ -1694,19 +1694,19 @@ gdk_x11_window_move_to_current_desktop (GdkWindow *window)
 }
 
 static void
-move_to_current_desktop (GdkWindow *window)
+move_to_current_desktop (GdkSurface *window)
 {
   guint32 desktop;
 
-  desktop = gdk_x11_screen_get_current_desktop (GDK_WINDOW_SCREEN (window));
-  gdk_x11_window_move_to_desktop (window, desktop);
+  desktop = gdk_x11_screen_get_current_desktop (GDK_SURFACE_SCREEN (window));
+  gdk_x11_surface_move_to_desktop (window, desktop);
 }
 
 static guint32
-get_netwm_cardinal_property (GdkWindow   *window,
+get_netwm_cardinal_property (GdkSurface   *window,
                              const gchar *name)
 {
-  GdkX11Screen *x11_screen = GDK_WINDOW_SCREEN (window);
+  GdkX11Screen *x11_screen = GDK_SURFACE_SCREEN (window);
   GdkAtom atom;
   guint32 prop = 0;
   Atom type;
@@ -1721,8 +1721,8 @@ get_netwm_cardinal_property (GdkWindow   *window,
     return 0;
 
   XGetWindowProperty (x11_screen->xdisplay,
-                      GDK_WINDOW_XID (window),
-                      gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window), name),
+                      GDK_SURFACE_XID (window),
+                      gdk_x11_get_xatom_by_name_for_display (GDK_SURFACE_DISPLAY (window), name),
                       0, G_MAXLONG,
                       False, XA_CARDINAL, &type, &format, &nitems,
                       &bytes_after, &data);
@@ -1736,24 +1736,24 @@ get_netwm_cardinal_property (GdkWindow   *window,
 }
 
 /**
- * gdk_x11_window_get_desktop:
- * @window: (type GdkX11Window): a #GdkWindow
+ * gdk_x11_surface_get_desktop:
+ * @window: (type GdkX11Surface): a #GdkSurface
  *
  * Gets the number of the workspace @window is on.
  *
  * Returns: the current workspace of @window
  */
 guint32
-gdk_x11_window_get_desktop (GdkWindow *window)
+gdk_x11_surface_get_desktop (GdkSurface *window)
 {
-  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
+  g_return_val_if_fail (GDK_IS_SURFACE (window), 0);
 
   return get_netwm_cardinal_property (window, "_NET_WM_DESKTOP");
 }
 
 /**
- * gdk_x11_window_move_to_desktop:
- * @window: (type GdkX11Window): a #GdkWindow
+ * gdk_x11_surface_move_to_desktop:
+ * @window: (type GdkX11Surface): a #GdkSurface
  * @desktop: the number of the workspace to move the window to
  *
  * Moves the window to the given workspace when running unde a
@@ -1761,24 +1761,24 @@ gdk_x11_window_get_desktop (GdkWindow *window)
  * in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
  */
 void
-gdk_x11_window_move_to_desktop (GdkWindow *window,
+gdk_x11_surface_move_to_desktop (GdkSurface *window,
                                 guint32    desktop)
 {
   GdkAtom atom;
   XClientMessageEvent xclient;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
   atom = g_intern_static_string ("_NET_WM_DESKTOP");
-  if (!gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window), atom))
+  if (!gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window), atom))
     return;
 
   memset (&xclient, 0, sizeof (xclient));
   xclient.type = ClientMessage;
   xclient.serial = 0;
   xclient.send_event = True;
-  xclient.window = GDK_WINDOW_XID (window);
-  xclient.message_type = gdk_x11_atom_to_xatom_for_display (GDK_WINDOW_DISPLAY (window), atom);
+  xclient.window = GDK_SURFACE_XID (window);
+  xclient.message_type = gdk_x11_atom_to_xatom_for_display (GDK_SURFACE_DISPLAY (window), atom);
   xclient.format = 32;
 
   xclient.data.l[0] = desktop;
@@ -1787,35 +1787,35 @@ gdk_x11_window_move_to_desktop (GdkWindow *window,
   xclient.data.l[3] = 0;
   xclient.data.l[4] = 0;
 
-  XSendEvent (GDK_WINDOW_XDISPLAY (window),
-              GDK_WINDOW_XROOTWIN (window),
+  XSendEvent (GDK_SURFACE_XDISPLAY (window),
+              GDK_SURFACE_XROOTWIN (window),
               False,
               SubstructureRedirectMask | SubstructureNotifyMask,
               (XEvent *)&xclient);
 }
 
 static void
-gdk_x11_window_focus (GdkWindow *window,
+gdk_x11_surface_focus (GdkSurface *window,
 		      guint32    timestamp)
 {
   GdkDisplay *display;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  display = GDK_WINDOW_DISPLAY (window);
+  display = GDK_SURFACE_DISPLAY (window);
 
-  if (gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+  if (gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
 					   g_intern_static_string ("_NET_ACTIVE_WINDOW")))
     {
       XClientMessageEvent xclient;
 
       memset (&xclient, 0, sizeof (xclient));
       xclient.type = ClientMessage;
-      xclient.window = GDK_WINDOW_XID (window);
+      xclient.window = GDK_SURFACE_XID (window);
       xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display,
                                                                     "_NET_ACTIVE_WINDOW");
       xclient.format = 32;
@@ -1825,20 +1825,20 @@ gdk_x11_window_focus (GdkWindow *window,
       xclient.data.l[3] = 0;
       xclient.data.l[4] = 0;
       
-      XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XROOTWIN (window), False,
+      XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XROOTWIN (window), False,
                   SubstructureRedirectMask | SubstructureNotifyMask,
                   (XEvent *)&xclient);
     }
   else
     {
-      XRaiseWindow (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window));
+      XRaiseWindow (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window));
 
       /* There is no way of knowing reliably whether we are viewable;
        * so trap errors asynchronously around the XSetInputFocus call
        */
       gdk_x11_display_error_trap_push (display);
       XSetInputFocus (GDK_DISPLAY_XDISPLAY (display),
-                      GDK_WINDOW_XID (window),
+                      GDK_SURFACE_XID (window),
                       RevertToParent,
                       timestamp);
       gdk_x11_display_error_trap_pop_ignored (display);
@@ -1846,95 +1846,95 @@ gdk_x11_window_focus (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_set_type_hint (GdkWindow        *window,
-			      GdkWindowTypeHint hint)
+gdk_x11_surface_set_type_hint (GdkSurface        *window,
+			      GdkSurfaceTypeHint hint)
 {
   GdkDisplay *display;
   Atom atom;
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   switch (hint)
     {
-    case GDK_WINDOW_TYPE_HINT_DIALOG:
+    case GDK_SURFACE_TYPE_HINT_DIALOG:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DIALOG");
       break;
-    case GDK_WINDOW_TYPE_HINT_MENU:
+    case GDK_SURFACE_TYPE_HINT_MENU:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_MENU");
       break;
-    case GDK_WINDOW_TYPE_HINT_TOOLBAR:
+    case GDK_SURFACE_TYPE_HINT_TOOLBAR:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLBAR");
       break;
-    case GDK_WINDOW_TYPE_HINT_UTILITY:
+    case GDK_SURFACE_TYPE_HINT_UTILITY:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_UTILITY");
       break;
-    case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
+    case GDK_SURFACE_TYPE_HINT_SPLASHSCREEN:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_SPLASH");
       break;
-    case GDK_WINDOW_TYPE_HINT_DOCK:
+    case GDK_SURFACE_TYPE_HINT_DOCK:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DOCK");
       break;
-    case GDK_WINDOW_TYPE_HINT_DESKTOP:
+    case GDK_SURFACE_TYPE_HINT_DESKTOP:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DESKTOP");
       break;
-    case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
+    case GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU");
       break;
-    case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
+    case GDK_SURFACE_TYPE_HINT_POPUP_MENU:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_POPUP_MENU");
       break;
-    case GDK_WINDOW_TYPE_HINT_TOOLTIP:
+    case GDK_SURFACE_TYPE_HINT_TOOLTIP:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLTIP");
       break;
-    case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
+    case GDK_SURFACE_TYPE_HINT_NOTIFICATION:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NOTIFICATION");
       break;
-    case GDK_WINDOW_TYPE_HINT_COMBO:
+    case GDK_SURFACE_TYPE_HINT_COMBO:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_COMBO");
       break;
-    case GDK_WINDOW_TYPE_HINT_DND:
+    case GDK_SURFACE_TYPE_HINT_DND:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DND");
       break;
     default:
-      g_warning ("Unknown hint %d passed to gdk_window_set_type_hint", hint);
+      g_warning ("Unknown hint %d passed to gdk_surface_set_type_hint", hint);
       /* Fall thru */
-    case GDK_WINDOW_TYPE_HINT_NORMAL:
+    case GDK_SURFACE_TYPE_HINT_NORMAL:
       atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NORMAL");
       break;
     }
 
-  XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
 		   gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE"),
 		   XA_ATOM, 32, PropModeReplace,
 		   (guchar *)&atom, 1);
 }
 
-static GdkWindowTypeHint
-gdk_x11_window_get_type_hint (GdkWindow *window)
+static GdkSurfaceTypeHint
+gdk_x11_surface_get_type_hint (GdkSurface *window)
 {
   GdkDisplay *display;
-  GdkWindowTypeHint type;
+  GdkSurfaceTypeHint type;
   Atom type_return;
   gint format_return;
   gulong nitems_return;
   gulong bytes_after_return;
   guchar *data = NULL;
 
-  g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_WINDOW_TYPE_HINT_NORMAL);
+  g_return_val_if_fail (GDK_IS_SURFACE (window), GDK_SURFACE_TYPE_HINT_NORMAL);
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
-    return GDK_WINDOW_TYPE_HINT_NORMAL;
+    return GDK_SURFACE_TYPE_HINT_NORMAL;
 
-  type = GDK_WINDOW_TYPE_HINT_NORMAL;
+  type = GDK_SURFACE_TYPE_HINT_NORMAL;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
-  if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+  if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
                           gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE"),
                           0, G_MAXLONG, False, XA_ATOM, &type_return,
                           &format_return, &nitems_return, &bytes_after_return,
@@ -1946,31 +1946,31 @@ gdk_x11_window_get_type_hint (GdkWindow *window)
           Atom atom = *(Atom*)data;
 
           if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DIALOG"))
-            type = GDK_WINDOW_TYPE_HINT_DIALOG;
+            type = GDK_SURFACE_TYPE_HINT_DIALOG;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_MENU"))
-            type = GDK_WINDOW_TYPE_HINT_MENU;
+            type = GDK_SURFACE_TYPE_HINT_MENU;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLBAR"))
-            type = GDK_WINDOW_TYPE_HINT_TOOLBAR;
+            type = GDK_SURFACE_TYPE_HINT_TOOLBAR;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_UTILITY"))
-            type = GDK_WINDOW_TYPE_HINT_UTILITY;
+            type = GDK_SURFACE_TYPE_HINT_UTILITY;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_SPLASH"))
-            type = GDK_WINDOW_TYPE_HINT_SPLASHSCREEN;
+            type = GDK_SURFACE_TYPE_HINT_SPLASHSCREEN;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DOCK"))
-            type = GDK_WINDOW_TYPE_HINT_DOCK;
+            type = GDK_SURFACE_TYPE_HINT_DOCK;
           else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DESKTOP"))
-            type = GDK_WINDOW_TYPE_HINT_DESKTOP;
+            type = GDK_SURFACE_TYPE_HINT_DESKTOP;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"))
-	    type = GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU;
+	    type = GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_POPUP_MENU"))
-	    type = GDK_WINDOW_TYPE_HINT_POPUP_MENU;
+	    type = GDK_SURFACE_TYPE_HINT_POPUP_MENU;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLTIP"))
-	    type = GDK_WINDOW_TYPE_HINT_TOOLTIP;
+	    type = GDK_SURFACE_TYPE_HINT_TOOLTIP;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NOTIFICATION"))
-	    type = GDK_WINDOW_TYPE_HINT_NOTIFICATION;
+	    type = GDK_SURFACE_TYPE_HINT_NOTIFICATION;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_COMBO"))
-	    type = GDK_WINDOW_TYPE_HINT_COMBO;
+	    type = GDK_SURFACE_TYPE_HINT_COMBO;
 	  else if (atom == gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DND"))
-	    type = GDK_WINDOW_TYPE_HINT_DND;
+	    type = GDK_SURFACE_TYPE_HINT_DND;
         }
 
       if (type_return != None && data != NULL)
@@ -1982,11 +1982,11 @@ gdk_x11_window_get_type_hint (GdkWindow *window)
 
 static void
 gdk_wmspec_change_state (gboolean   add,
-			 GdkWindow *window,
+			 GdkSurface *window,
 			 GdkAtom    state1,
 			 GdkAtom    state2)
 {
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
   XClientMessageEvent xclient;
   
 #define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
@@ -1995,7 +1995,7 @@ gdk_wmspec_change_state (gboolean   add,
   
   memset (&xclient, 0, sizeof (xclient));
   xclient.type = ClientMessage;
-  xclient.window = GDK_WINDOW_XID (window);
+  xclient.window = GDK_SURFACE_XID (window);
   xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE");
   xclient.format = 32;
   xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
@@ -2004,101 +2004,101 @@ gdk_wmspec_change_state (gboolean   add,
   xclient.data.l[3] = 1; /* source indication */
   xclient.data.l[4] = 0;
   
-  XSendEvent (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XROOTWIN (window), False,
+  XSendEvent (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XROOTWIN (window), False,
 	      SubstructureRedirectMask | SubstructureNotifyMask,
 	      (XEvent *)&xclient);
 }
 
 static void
-gdk_x11_window_set_modal_hint (GdkWindow *window,
+gdk_x11_surface_set_modal_hint (GdkSurface *window,
 			       gboolean   modal)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
   window->modal_hint = modal;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (modal, window,
 			     g_intern_static_string ("_NET_WM_STATE_MODAL"), 
 			     NULL);
 }
 
 static void
-gdk_x11_window_set_skip_taskbar_hint (GdkWindow *window,
+gdk_x11_surface_set_skip_taskbar_hint (GdkSurface *window,
 				      gboolean   skips_taskbar)
 {
   GdkToplevelX11 *toplevel;
   
-  g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
+  g_return_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD);
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
   toplevel->skip_taskbar_hint = skips_taskbar;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (skips_taskbar, window,
 			     g_intern_static_string ("_NET_WM_STATE_SKIP_TASKBAR"),
 			     NULL);
 }
 
 static void
-gdk_x11_window_set_skip_pager_hint (GdkWindow *window,
+gdk_x11_surface_set_skip_pager_hint (GdkSurface *window,
 				    gboolean   skips_pager)
 {
   GdkToplevelX11 *toplevel;
     
-  g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
+  g_return_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD);
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
   toplevel->skip_pager_hint = skips_pager;
   
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (skips_pager, window,
 			     g_intern_static_string ("_NET_WM_STATE_SKIP_PAGER"), 
 			     NULL);
 }
 
 static void
-gdk_x11_window_set_urgency_hint (GdkWindow *window,
+gdk_x11_surface_set_urgency_hint (GdkSurface *window,
 			     gboolean   urgent)
 {
   GdkToplevelX11 *toplevel;
     
-  g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
+  g_return_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD);
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
   toplevel->urgency_hint = urgent;
   
   update_wm_hints (window, FALSE);
 }
 
 static void
-gdk_x11_window_set_geometry_hints (GdkWindow         *window,
+gdk_x11_surface_set_geometry_hints (GdkSurface         *window,
 				   const GdkGeometry *geometry,
-				   GdkWindowHints     geom_mask)
+				   GdkSurfaceHints     geom_mask)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   XSizeHints size_hints;
   GdkToplevelX11 *toplevel;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
   if (toplevel)
     {
       if (geometry)
@@ -2197,38 +2197,38 @@ gdk_x11_window_set_geometry_hints (GdkWindow         *window,
   /* FIXME: Would it be better to delete this property if
    *        geom_mask == 0? It would save space on the server
    */
-  XSetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
-		     GDK_WINDOW_XID (window),
+  XSetWMNormalHints (GDK_SURFACE_XDISPLAY (window),
+		     GDK_SURFACE_XID (window),
 		     &size_hints);
 }
 
 static void
-gdk_window_get_geometry_hints (GdkWindow      *window,
+gdk_surface_get_geometry_hints (GdkSurface      *window,
                                GdkGeometry    *geometry,
-                               GdkWindowHints *geom_mask)
+                               GdkSurfaceHints *geom_mask)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   XSizeHints *size_hints;  
   glong junk_supplied_mask = 0;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
   g_return_if_fail (geometry != NULL);
   g_return_if_fail (geom_mask != NULL);
 
   *geom_mask = 0;
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   size_hints = XAllocSizeHints ();
   if (!size_hints)
     return;
   
-  if (!XGetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
-                          GDK_WINDOW_XID (window),
+  if (!XGetWMNormalHints (GDK_SURFACE_XDISPLAY (window),
+                          GDK_SURFACE_XID (window),
                           size_hints,
                           &junk_supplied_mask))
     size_hints->flags = 0;
@@ -2357,7 +2357,7 @@ set_wm_name (GdkDisplay  *display,
 }
 
 static void
-gdk_x11_window_set_title (GdkWindow   *window,
+gdk_x11_surface_set_title (GdkSurface   *window,
 			  const gchar *title)
 {
   GdkDisplay *display;
@@ -2366,17 +2366,17 @@ gdk_x11_window_set_title (GdkWindow   *window,
   
   g_return_if_fail (title != NULL);
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
   
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   xdisplay = GDK_DISPLAY_XDISPLAY (display);
-  xwindow = GDK_WINDOW_XID (window);
+  xwindow = GDK_SURFACE_XID (window);
 
   set_wm_name (display, xwindow, title);
   
-  if (!gdk_window_icon_name_set (window))
+  if (!gdk_surface_icon_name_set (window))
     {
       XChangeProperty (xdisplay, xwindow,
 		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"),
@@ -2390,89 +2390,89 @@ gdk_x11_window_set_title (GdkWindow   *window,
 }
 
 static void
-gdk_x11_window_set_role (GdkWindow   *window,
+gdk_x11_surface_set_role (GdkSurface   *window,
 			 const gchar *role)
 {
   GdkDisplay *display;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
   if (role)
-    XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+    XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
                      gdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"),
                      XA_STRING, 8, PropModeReplace, (guchar *)role, strlen (role));
   else
-    XDeleteProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+    XDeleteProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
                      gdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"));
 }
 
 static void
-gdk_x11_window_set_startup_id (GdkWindow   *window,
+gdk_x11_surface_set_startup_id (GdkSurface   *window,
 			       const gchar *startup_id)
 {
   GdkDisplay *display;
 
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
   if (startup_id)
-    XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+    XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
                      gdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"), 
                      gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                      PropModeReplace, (unsigned char *)startup_id, strlen (startup_id));
   else
-    XDeleteProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+    XDeleteProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
                      gdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"));
 }
 
 static void
-gdk_x11_window_set_transient_for (GdkWindow *window,
-				  GdkWindow *parent)
+gdk_x11_surface_set_transient_for (GdkSurface *window,
+				  GdkSurface *parent)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
   /* XSetTransientForHint() doesn't allow unsetting, so do it manually */
-  if (parent && !GDK_WINDOW_DESTROYED (parent))
-    XSetTransientForHint (GDK_WINDOW_XDISPLAY (window), 
-			  GDK_WINDOW_XID (window),
-			  GDK_WINDOW_XID (parent));
+  if (parent && !GDK_SURFACE_DESTROYED (parent))
+    XSetTransientForHint (GDK_SURFACE_XDISPLAY (window), 
+			  GDK_SURFACE_XID (window),
+			  GDK_SURFACE_XID (parent));
   else
-    XDeleteProperty (GDK_WINDOW_XDISPLAY (window),
-                     GDK_WINDOW_XID (window),
-                     gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window), "WM_TRANSIENT_FOR"));
+    XDeleteProperty (GDK_SURFACE_XDISPLAY (window),
+                     GDK_SURFACE_XID (window),
+                     gdk_x11_get_xatom_by_name_for_display (GDK_SURFACE_DISPLAY (window), "WM_TRANSIENT_FOR"));
 }
 
 GdkCursor *
-_gdk_x11_window_get_cursor (GdkWindow *window)
+_gdk_x11_surface_get_cursor (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+  g_return_val_if_fail (GDK_IS_SURFACE (window), NULL);
     
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   return impl->cursor;
 }
 
 static void
-gdk_window_x11_get_geometry (GdkWindow *window,
+gdk_surface_x11_get_geometry (GdkSurface *window,
                              gint      *x,
                              gint      *y,
                              gint      *width,
                              gint      *height)
 {
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   Window root;
   gint tx;
   gint ty;
@@ -2481,12 +2481,12 @@ gdk_window_x11_get_geometry (GdkWindow *window,
   guint tborder_width;
   guint tdepth;
   
-  if (!GDK_WINDOW_DESTROYED (window))
+  if (!GDK_SURFACE_DESTROYED (window))
     {
-      impl = GDK_WINDOW_IMPL_X11 (window->impl);
+      impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
-      XGetGeometry (GDK_WINDOW_XDISPLAY (window),
-		    GDK_WINDOW_XID (window),
+      XGetGeometry (GDK_SURFACE_XDISPLAY (window),
+		    GDK_SURFACE_XID (window),
 		    &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth);
       
       if (x)
@@ -2501,20 +2501,20 @@ gdk_window_x11_get_geometry (GdkWindow *window,
 }
 
 static void
-gdk_window_x11_get_root_coords (GdkWindow *window,
+gdk_surface_x11_get_root_coords (GdkSurface *window,
 				gint       x,
 				gint       y,
 				gint      *root_x,
 				gint      *root_y)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   Window child;
   gint tx;
   gint ty;
   
-  XTranslateCoordinates (GDK_WINDOW_XDISPLAY (window),
-                         GDK_WINDOW_XID (window),
-                         GDK_WINDOW_XROOTWIN (window),
+  XTranslateCoordinates (GDK_SURFACE_XDISPLAY (window),
+                         GDK_SURFACE_XID (window),
+                         GDK_SURFACE_XROOTWIN (window),
                          x * impl->window_scale, y * impl->window_scale, &tx, &ty,
                          &child);
 
@@ -2525,11 +2525,11 @@ gdk_window_x11_get_root_coords (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_get_frame_extents (GdkWindow    *window,
+gdk_x11_surface_get_frame_extents (GdkSurface    *window,
                                   GdkRectangle *rect)
 {
   GdkDisplay *display;
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
   Window xwindow;
   Window xparent;
   Window root;
@@ -2558,7 +2558,7 @@ gdk_x11_window_get_frame_extents (GdkWindow    *window,
   while (window->parent && (window->parent)->parent)
     window = window->parent;
 
-  impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
   /* Refine our fallback answer a bit using local information */
   rect->x = window->x * impl->window_scale;
@@ -2566,20 +2566,20 @@ gdk_x11_window_get_frame_extents (GdkWindow    *window,
   rect->width = window->width * impl->window_scale;
   rect->height = window->height * impl->window_scale;
 
-  if (GDK_WINDOW_DESTROYED (window) || impl->override_redirect)
+  if (GDK_SURFACE_DESTROYED (window) || impl->override_redirect)
     return;
 
   nvroots = 0;
   vroots = NULL;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   gdk_x11_display_error_trap_push (display);
 
-  xwindow = GDK_WINDOW_XID (window);
+  xwindow = GDK_SURFACE_XID (window);
 
   /* first try: use _NET_FRAME_EXTENTS */
-  if (gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+  if (gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                            g_intern_static_string ("_NET_FRAME_EXTENTS")) &&
       XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), xwindow,
                           gdk_x11_get_xatom_by_name_for_display (display,
@@ -2626,9 +2626,9 @@ gdk_x11_window_get_frame_extents (GdkWindow    *window,
      tree to get our window's parent which hopefully is the window frame */
 
   /* use NETWM_VIRTUAL_ROOTS if available */
-  root = GDK_WINDOW_XROOTWIN (window);
+  root = GDK_SURFACE_XROOTWIN (window);
 
-  if (gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+  if (gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                            g_intern_static_string ("_NET_VIRTUAL_ROOTS")) &&
       XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), root,
 			  gdk_x11_get_xatom_by_name_for_display (display, 
@@ -2645,7 +2645,7 @@ gdk_x11_window_get_frame_extents (GdkWindow    *window,
 	}
     }
 
-  xparent = GDK_WINDOW_XID (window);
+  xparent = GDK_SURFACE_XID (window);
 
   do
     {
@@ -2696,15 +2696,15 @@ gdk_x11_window_get_frame_extents (GdkWindow    *window,
 }
 
 static gboolean
-gdk_window_x11_get_device_state (GdkWindow       *window,
+gdk_surface_x11_get_device_state (GdkSurface       *window,
                                  GdkDevice       *device,
                                  gdouble         *x,
                                  gdouble         *y,
                                  GdkModifierType *mask)
 {
-  GdkWindow *child;
+  GdkSurface *child;
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return FALSE;
 
   /*HIDPI: handle coords here?*/
@@ -2716,18 +2716,18 @@ gdk_window_x11_get_device_state (GdkWindow       *window,
 }
 
 static GdkEventMask
-gdk_window_x11_get_events (GdkWindow *window)
+gdk_surface_x11_get_events (GdkSurface *window)
 {
   XWindowAttributes attrs;
   GdkEventMask event_mask;
   GdkEventMask filtered;
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return 0;
   else
     {
-      XGetWindowAttributes (GDK_WINDOW_XDISPLAY (window),
-			    GDK_WINDOW_XID (window),
+      XGetWindowAttributes (GDK_SURFACE_XDISPLAY (window),
+			    GDK_SURFACE_XID (window),
 			    &attrs);
       event_mask = x_event_mask_to_gdk_event_mask (attrs.your_event_mask);
       /* if property change was filtered out before, keep it filtered out */
@@ -2738,46 +2738,46 @@ gdk_window_x11_get_events (GdkWindow *window)
     }
 }
 static void
-gdk_window_x11_set_events (GdkWindow    *window,
+gdk_surface_x11_set_events (GdkSurface    *window,
                            GdkEventMask  event_mask)
 {
   long xevent_mask = 0;
   
-  if (!GDK_WINDOW_DESTROYED (window))
+  if (!GDK_SURFACE_DESTROYED (window))
     {
       GdkX11Display *display_x11;
 
-      if (GDK_WINDOW_XID (window) != GDK_WINDOW_XROOTWIN (window))
+      if (GDK_SURFACE_XID (window) != GDK_SURFACE_XROOTWIN (window))
         xevent_mask = StructureNotifyMask | PropertyChangeMask;
 
-      display_x11 = GDK_X11_DISPLAY (gdk_window_get_display (window));
+      display_x11 = GDK_X11_DISPLAY (gdk_surface_get_display (window));
       gdk_x11_event_source_select_events ((GdkEventSource *) display_x11->event_source,
-                                          GDK_WINDOW_XID (window), event_mask,
+                                          GDK_SURFACE_XID (window), event_mask,
                                           xevent_mask);
     }
 }
 
 static inline void
-do_shape_combine_region (GdkWindow       *window,
+do_shape_combine_region (GdkSurface       *window,
 			 const cairo_region_t *shape_region,
 			 gint             offset_x,
 			 gint             offset_y,
 			 gint             shape)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return;
 
   if (shape_region == NULL)
     {
       /* Use NULL mask to unset the shape */
       if (shape == ShapeBounding
-	  ? gdk_display_supports_shapes (GDK_WINDOW_DISPLAY (window))
-	  : gdk_display_supports_input_shapes (GDK_WINDOW_DISPLAY (window)))
+	  ? gdk_display_supports_shapes (GDK_SURFACE_DISPLAY (window))
+	  : gdk_display_supports_input_shapes (GDK_SURFACE_DISPLAY (window)))
 	{
-	  XShapeCombineMask (GDK_WINDOW_XDISPLAY (window),
-			     GDK_WINDOW_XID (window),
+	  XShapeCombineMask (GDK_SURFACE_XDISPLAY (window),
+			     GDK_SURFACE_XID (window),
 			     shape,
 			     0, 0,
 			     None,
@@ -2787,8 +2787,8 @@ do_shape_combine_region (GdkWindow       *window,
     }
   
   if (shape == ShapeBounding
-      ? gdk_display_supports_shapes (GDK_WINDOW_DISPLAY (window))
-      : gdk_display_supports_input_shapes (GDK_WINDOW_DISPLAY (window)))
+      ? gdk_display_supports_shapes (GDK_SURFACE_DISPLAY (window))
+      : gdk_display_supports_input_shapes (GDK_SURFACE_DISPLAY (window)))
     {
       gint n_rects = 0;
       XRectangle *xrects = NULL;
@@ -2797,8 +2797,8 @@ do_shape_combine_region (GdkWindow       *window,
                                        0, 0, impl->window_scale,
                                        &xrects, &n_rects);
       
-      XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (window),
-                               GDK_WINDOW_XID (window),
+      XShapeCombineRectangles (GDK_SURFACE_XDISPLAY (window),
+                               GDK_SURFACE_XID (window),
                                shape,
                                offset_x * impl->window_scale,
                                offset_y * impl->window_scale,
@@ -2811,7 +2811,7 @@ do_shape_combine_region (GdkWindow       *window,
 }
 
 static void
-gdk_window_x11_shape_combine_region (GdkWindow       *window,
+gdk_surface_x11_shape_combine_region (GdkSurface       *window,
                                      const cairo_region_t *shape_region,
                                      gint             offset_x,
                                      gint             offset_y)
@@ -2820,7 +2820,7 @@ gdk_window_x11_shape_combine_region (GdkWindow       *window,
 }
 
 static void 
-gdk_window_x11_input_shape_combine_region (GdkWindow       *window,
+gdk_surface_x11_input_shape_combine_region (GdkSurface       *window,
 					   const cairo_region_t *shape_region,
 					   gint             offset_x,
 					   gint             offset_y)
@@ -2831,7 +2831,7 @@ gdk_window_x11_input_shape_combine_region (GdkWindow       *window,
 }
 
 static void
-gdk_x11_window_set_accept_focus (GdkWindow *window,
+gdk_x11_surface_set_accept_focus (GdkSurface *window,
 				 gboolean accept_focus)
 {
   accept_focus = accept_focus != FALSE;
@@ -2840,14 +2840,14 @@ gdk_x11_window_set_accept_focus (GdkWindow *window,
     {
       window->accept_focus = accept_focus;
 
-      if (!GDK_WINDOW_DESTROYED (window) &&
+      if (!GDK_SURFACE_DESTROYED (window) &&
 	  WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
 	update_wm_hints (window, FALSE);
     }
 }
 
 static void
-gdk_x11_window_set_focus_on_map (GdkWindow *window,
+gdk_x11_surface_set_focus_on_map (GdkSurface *window,
 				 gboolean focus_on_map)
 {
   focus_on_map = focus_on_map != FALSE;
@@ -2856,16 +2856,16 @@ gdk_x11_window_set_focus_on_map (GdkWindow *window,
     {
       window->focus_on_map = focus_on_map;
       
-      if ((!GDK_WINDOW_DESTROYED (window)) &&
+      if ((!GDK_SURFACE_DESTROYED (window)) &&
 	  (!window->focus_on_map) &&
 	  WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
-	gdk_x11_window_set_user_time (window, 0);
+	gdk_x11_surface_set_user_time (window, 0);
     }
 }
 
 /**
- * gdk_x11_window_set_user_time:
- * @window: (type GdkX11Window): A toplevel #GdkWindow
+ * gdk_x11_surface_set_user_time:
+ * @window: (type GdkX11Surface): A toplevel #GdkSurface
  * @timestamp: An XServer timestamp to which the property should be set
  *
  * The application can use this call to update the _NET_WM_USER_TIME
@@ -2882,7 +2882,7 @@ gdk_x11_window_set_focus_on_map (GdkWindow *window,
  * events bypassing GDK.
  **/
 void
-gdk_x11_window_set_user_time (GdkWindow *window,
+gdk_x11_surface_set_user_time (GdkSurface *window,
                               guint32    timestamp)
 {
   GdkDisplay *display;
@@ -2891,26 +2891,26 @@ gdk_x11_window_set_user_time (GdkWindow *window,
   glong timestamp_long = (glong)timestamp;
   Window xid;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   display_x11 = GDK_X11_DISPLAY (display);
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (!toplevel)
     {
-      g_warning ("gdk_window_set_user_time called on non-toplevel\n");
+      g_warning ("gdk_surface_set_user_time called on non-toplevel\n");
       return;
     }
 
   if (toplevel->focus_window != None &&
-      gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+      gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                            g_intern_static_string ("_NET_WM_USER_TIME_WINDOW")))
     xid = toplevel->focus_window;
   else
-    xid = GDK_WINDOW_XID (window);
+    xid = GDK_SURFACE_XID (window);
 
   XChangeProperty (GDK_DISPLAY_XDISPLAY (display), xid,
                    gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_USER_TIME"),
@@ -2927,8 +2927,8 @@ gdk_x11_window_set_user_time (GdkWindow *window,
 }
 
 /**
- * gdk_x11_window_set_utf8_property:
- * @window: (type GdkX11Window): a #GdkWindow
+ * gdk_x11_surface_set_utf8_property:
+ * @window: (type GdkX11Surface): a #GdkSurface
  * @name: Property name, will be interned as an X atom
  * @value: (allow-none): Property value, or %NULL to delete
  *
@@ -2937,7 +2937,7 @@ gdk_x11_window_set_user_time (GdkWindow *window,
  * not a toplevel window, it is ignored.
  */
 void
-gdk_x11_window_set_utf8_property  (GdkWindow *window,
+gdk_x11_surface_set_utf8_property  (GdkSurface *window,
 				   const gchar *name,
 				   const gchar *value)
 {
@@ -2946,12 +2946,12 @@ gdk_x11_window_set_utf8_property  (GdkWindow *window,
   if (!WINDOW_IS_TOPLEVEL (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   if (value != NULL)
     {
       XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        gdk_x11_get_xatom_by_name_for_display (display, name),
                        gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                        PropModeReplace, (guchar *)value, strlen (value));
@@ -2959,19 +2959,19 @@ gdk_x11_window_set_utf8_property  (GdkWindow *window,
   else
     {
       XDeleteProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        gdk_x11_get_xatom_by_name_for_display (display, name));
     }
 }
 
 static void
-gdk_x11_window_set_shadow_width (GdkWindow *window,
+gdk_x11_surface_set_shadow_width (GdkSurface *window,
                                  int        left,
                                  int        right,
                                  int        top,
                                  int        bottom)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   Atom frame_extents;
   gulong data[4] = {
     left * impl->window_scale,
@@ -2980,18 +2980,18 @@ gdk_x11_window_set_shadow_width (GdkWindow *window,
     bottom * impl->window_scale
   };
 
-  frame_extents = gdk_x11_get_xatom_by_name_for_display (gdk_window_get_display (window),
+  frame_extents = gdk_x11_get_xatom_by_name_for_display (gdk_surface_get_display (window),
                                                          "_GTK_FRAME_EXTENTS");
-  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
-                   GDK_WINDOW_XID (window),
+  XChangeProperty (GDK_SURFACE_XDISPLAY (window),
+                   GDK_SURFACE_XID (window),
                    frame_extents, XA_CARDINAL,
                    32, PropModeReplace,
                    (guchar *) &data, 4);
 }
 
 /**
- * gdk_x11_window_set_theme_variant:
- * @window: (type GdkX11Window): a #GdkWindow
+ * gdk_x11_surface_set_theme_variant:
+ * @window: (type GdkX11Surface): a #GdkSurface
  * @variant: the theme variant to export
  *
  * GTK+ applications can request a dark theme variant. In order to
@@ -3005,10 +3005,10 @@ gdk_x11_window_set_shadow_width (GdkWindow *window,
  * to create toplevel windows.
  */
 void
-gdk_x11_window_set_theme_variant (GdkWindow  *window,
+gdk_x11_surface_set_theme_variant (GdkSurface  *window,
                                   const char *variant)
 {
-  gdk_x11_window_set_utf8_property (window, "_GTK_THEME_VARIANT",
+  gdk_x11_surface_set_utf8_property (window, "_GTK_THEME_VARIANT",
                                     variant ? variant : "");
 }
 
@@ -3019,7 +3019,7 @@ gdk_x11_window_set_theme_variant (GdkWindow  *window,
        : XExtendedMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) - 100)
 
 static void
-gdk_window_update_icon (GdkWindow *window,
+gdk_surface_update_icon (GdkSurface *window,
                         GList     *icon_list)
 {
   GdkToplevelX11 *toplevel;
@@ -3027,7 +3027,7 @@ gdk_window_update_icon (GdkWindow *window,
   GList *tmp_list;
   int best_size;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (toplevel->icon_pixmap != NULL)
     {
@@ -3083,7 +3083,7 @@ gdk_window_update_icon (GdkWindow *window,
       cairo_surface_t *surface;
       cairo_t *cr;
 
-      toplevel->icon_pixmap = gdk_x11_window_create_pixmap_surface (window, width, height);
+      toplevel->icon_pixmap = gdk_x11_surface_create_pixmap_surface (window, width, height);
 
       surface = gdk_texture_download_surface (best_icon);
 
@@ -3104,7 +3104,7 @@ gdk_window_update_icon (GdkWindow *window,
 
       if (cairo_surface_get_content (surface) == CAIRO_CONTENT_COLOR_ALPHA)
         {
-          GdkDisplay *display = gdk_window_get_display (window);
+          GdkDisplay *display = gdk_surface_get_display (window);
 
           toplevel->icon_mask = _gdk_x11_display_create_bitmap_surface (display, width, height);
 
@@ -3122,7 +3122,7 @@ gdk_window_update_icon (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_set_icon_list (GdkWindow *window,
+gdk_x11_surface_set_icon_list (GdkSurface *window,
 			      GList     *textures)
 {
   gulong *data;
@@ -3134,11 +3134,11 @@ gdk_x11_window_set_icon_list (GdkWindow *window,
   GdkDisplay *display;
   gint i, n;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   size = 0;
   n = 0;
@@ -3185,7 +3185,7 @@ gdk_x11_window_set_icon_list (GdkWindow *window,
   if (size > 0)
     {
       XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
 		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON"),
                        XA_CARDINAL, 32,
                        PropModeReplace,
@@ -3194,33 +3194,33 @@ gdk_x11_window_set_icon_list (GdkWindow *window,
   else
     {
       XDeleteProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
 		       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON"));
     }
   
   g_free (data);
 
-  gdk_window_update_icon (window, textures);
+  gdk_surface_update_icon (window, textures);
 }
 
 static gboolean
-gdk_window_icon_name_set (GdkWindow *window)
+gdk_surface_icon_name_set (GdkSurface *window)
 {
   return GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (window),
 					       g_quark_from_static_string ("gdk-icon-name-set")));
 }
 
 static void
-gdk_x11_window_set_icon_name (GdkWindow   *window,
+gdk_x11_surface_set_icon_name (GdkSurface   *window,
 			      const gchar *name)
 {
   GdkDisplay *display;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   g_object_set_qdata (G_OBJECT (window), g_quark_from_static_string ("gdk-icon-name-set"),
                       GUINT_TO_POINTER (name != NULL));
@@ -3228,45 +3228,45 @@ gdk_x11_window_set_icon_name (GdkWindow   *window,
   if (name != NULL)
     {
       XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"),
                        gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                        PropModeReplace, (guchar *)name, strlen (name));
 
-      set_text_property (display, GDK_WINDOW_XID (window),
+      set_text_property (display, GDK_SURFACE_XID (window),
                          gdk_x11_get_xatom_by_name_for_display (display, "WM_ICON_NAME"),
                          name);
     }
   else
     {
       XDeleteProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"));
       XDeleteProperty (GDK_DISPLAY_XDISPLAY (display),
-                       GDK_WINDOW_XID (window),
+                       GDK_SURFACE_XID (window),
                        gdk_x11_get_xatom_by_name_for_display (display, "WM_ICON_NAME"));
     }
 }
 
 static void
-gdk_x11_window_iconify (GdkWindow *window)
+gdk_x11_surface_iconify (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {  
-      XIconifyWindow (GDK_WINDOW_XDISPLAY (window),
-		      GDK_WINDOW_XID (window),
-		      gdk_x11_screen_get_screen_number (GDK_WINDOW_SCREEN (window)));
+      XIconifyWindow (GDK_SURFACE_XDISPLAY (window),
+		      GDK_SURFACE_XID (window),
+		      gdk_x11_screen_get_screen_number (GDK_SURFACE_SCREEN (window)));
     }
   else
     {
       /* Flip our client side flag, the real work happens on map. */
       gdk_synthesize_window_state (window,
                                    0,
-                                   GDK_WINDOW_STATE_ICONIFIED);
+                                   GDK_SURFACE_STATE_ICONIFIED);
       gdk_wmspec_change_state (TRUE, window,
                                g_intern_static_string ("_NET_WM_STATE_HIDDEN"),
                                NULL);
@@ -3274,15 +3274,15 @@ gdk_x11_window_iconify (GdkWindow *window)
 }
 
 static void
-gdk_x11_window_deiconify (GdkWindow *window)
+gdk_x11_surface_deiconify (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {  
-      gdk_window_show (window);
+      gdk_surface_show (window);
       gdk_wmspec_change_state (FALSE, window,
                                g_intern_static_string ("_NET_WM_STATE_HIDDEN"),
                                NULL);
@@ -3291,7 +3291,7 @@ gdk_x11_window_deiconify (GdkWindow *window)
     {
       /* Flip our client side flag, the real work happens on map. */
       gdk_synthesize_window_state (window,
-                                   GDK_WINDOW_STATE_ICONIFIED,
+                                   GDK_SURFACE_STATE_ICONIFIED,
                                    0);
       gdk_wmspec_change_state (FALSE, window,
                                g_intern_static_string ("_NET_WM_STATE_HIDDEN"),
@@ -3300,13 +3300,13 @@ gdk_x11_window_deiconify (GdkWindow *window)
 }
 
 static void
-gdk_x11_window_stick (GdkWindow *window)
+gdk_x11_surface_stick (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       /* "stick" means stick to all desktops _and_ do not scroll with the
        * viewport. i.e. glue to the monitor glass in all cases.
@@ -3322,9 +3322,9 @@ gdk_x11_window_stick (GdkWindow *window)
       /* Request desktop 0xFFFFFFFF */
       memset (&xclient, 0, sizeof (xclient));
       xclient.type = ClientMessage;
-      xclient.window = GDK_WINDOW_XID (window);
-      xclient.display = GDK_WINDOW_XDISPLAY (window);
-      xclient.message_type = gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window), 
+      xclient.window = GDK_SURFACE_XID (window);
+      xclient.display = GDK_SURFACE_XDISPLAY (window);
+      xclient.message_type = gdk_x11_get_xatom_by_name_for_display (GDK_SURFACE_DISPLAY (window), 
 									"_NET_WM_DESKTOP");
       xclient.format = 32;
 
@@ -3334,7 +3334,7 @@ gdk_x11_window_stick (GdkWindow *window)
       xclient.data.l[3] = 0;
       xclient.data.l[4] = 0;
 
-      XSendEvent (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XROOTWIN (window), False,
+      XSendEvent (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XROOTWIN (window), False,
                   SubstructureRedirectMask | SubstructureNotifyMask,
                   (XEvent *)&xclient);
     }
@@ -3343,18 +3343,18 @@ gdk_x11_window_stick (GdkWindow *window)
       /* Flip our client side flag, the real work happens on map. */
       gdk_synthesize_window_state (window,
                                    0,
-                                   GDK_WINDOW_STATE_STICKY);
+                                   GDK_SURFACE_STATE_STICKY);
     }
 }
 
 static void
-gdk_x11_window_unstick (GdkWindow *window)
+gdk_x11_surface_unstick (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       /* Request unstick from viewport */
       gdk_wmspec_change_state (FALSE, window,
@@ -3367,50 +3367,50 @@ gdk_x11_window_unstick (GdkWindow *window)
     {
       /* Flip our client side flag, the real work happens on map. */
       gdk_synthesize_window_state (window,
-                                   GDK_WINDOW_STATE_STICKY,
+                                   GDK_SURFACE_STATE_STICKY,
                                    0);
 
     }
 }
 
 static void
-gdk_x11_window_maximize (GdkWindow *window)
+gdk_x11_surface_maximize (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (TRUE, window,
 			     g_intern_static_string ("_NET_WM_STATE_MAXIMIZED_VERT"),
 			     g_intern_static_string ("_NET_WM_STATE_MAXIMIZED_HORZ"));
   else
     gdk_synthesize_window_state (window,
 				 0,
-				 GDK_WINDOW_STATE_MAXIMIZED);
+				 GDK_SURFACE_STATE_MAXIMIZED);
 }
 
 static void
-gdk_x11_window_unmaximize (GdkWindow *window)
+gdk_x11_surface_unmaximize (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (FALSE, window,
 			     g_intern_static_string ("_NET_WM_STATE_MAXIMIZED_VERT"),
 			     g_intern_static_string ("_NET_WM_STATE_MAXIMIZED_HORZ"));
   else
     gdk_synthesize_window_state (window,
-				 GDK_WINDOW_STATE_MAXIMIZED,
+				 GDK_SURFACE_STATE_MAXIMIZED,
 				 0);
 }
 
 static void
-gdk_x11_window_apply_fullscreen_mode (GdkWindow *window)
+gdk_x11_surface_apply_fullscreen_mode (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
@@ -3420,7 +3420,7 @@ gdk_x11_window_apply_fullscreen_mode (GdkWindow *window)
    * mapped.
    */
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       XClientMessageEvent xclient;
       gint                monitors[4];
@@ -3428,8 +3428,8 @@ gdk_x11_window_apply_fullscreen_mode (GdkWindow *window)
 
       memset (&xclient, 0, sizeof (xclient));
       xclient.type = ClientMessage;
-      xclient.window = GDK_WINDOW_XID (window);
-      xclient.display = GDK_WINDOW_XDISPLAY (window);
+      xclient.window = GDK_SURFACE_XID (window);
+      xclient.display = GDK_SURFACE_XDISPLAY (window);
       xclient.format = 32;
 
       switch (window->fullscreen_mode)
@@ -3463,7 +3463,7 @@ gdk_x11_window_apply_fullscreen_mode (GdkWindow *window)
 
 	case GDK_FULLSCREEN_ON_ALL_MONITORS:
 
-	  _gdk_x11_screen_get_edge_monitors (GDK_WINDOW_SCREEN (window),
+	  _gdk_x11_screen_get_edge_monitors (GDK_SURFACE_SCREEN (window),
 					     &monitors[0],
 					     &monitors[1],
 					     &monitors[2],
@@ -3477,36 +3477,36 @@ gdk_x11_window_apply_fullscreen_mode (GdkWindow *window)
 	       */
 	      if (xclient.data.l[i] < 0)
 		{
-		  g_warning ("gdk_x11_window_apply_fullscreen_mode: Invalid XINERAMA monitor index");
+		  g_warning ("gdk_x11_surface_apply_fullscreen_mode: Invalid XINERAMA monitor index");
 		  return;
 		}
 	    }
 	  break;
 
 	default:
-	  g_warning ("gdk_x11_window_apply_fullscreen_mode: Unhandled fullscreen mode %d",
+	  g_warning ("gdk_x11_surface_apply_fullscreen_mode: Unhandled fullscreen mode %d",
 		     window->fullscreen_mode);
 	  return;
 	}
 
       /* Send fullscreen monitors client message */
       xclient.data.l[4] = 1; /* source indication */
-      xclient.message_type = gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window),
+      xclient.message_type = gdk_x11_get_xatom_by_name_for_display (GDK_SURFACE_DISPLAY (window),
 								    "_NET_WM_FULLSCREEN_MONITORS");
-      XSendEvent (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XROOTWIN (window), False,
+      XSendEvent (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XROOTWIN (window), False,
                   SubstructureRedirectMask | SubstructureNotifyMask,
                   (XEvent *)&xclient);
     }
 }
 
 static void
-gdk_x11_window_fullscreen (GdkWindow *window)
+gdk_x11_surface_fullscreen (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       gdk_wmspec_change_state (TRUE, window,
 			       g_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
@@ -3515,60 +3515,60 @@ gdk_x11_window_fullscreen (GdkWindow *window)
        * monitors in GDK_FULLSCREEN_ON_ALL_MONITORS mode.
        */
       if (window->fullscreen_mode == GDK_FULLSCREEN_ON_ALL_MONITORS)
-	gdk_x11_window_apply_fullscreen_mode (window);
+	gdk_x11_surface_apply_fullscreen_mode (window);
     }
   else
     gdk_synthesize_window_state (window,
                                  0,
-                                 GDK_WINDOW_STATE_FULLSCREEN);
+                                 GDK_SURFACE_STATE_FULLSCREEN);
 }
 
 static void
-gdk_x11_window_fullscreen_on_monitor (GdkWindow  *window,
+gdk_x11_surface_fullscreen_on_monitor (GdkSurface  *window,
                                       GdkMonitor *monitor)
 {
   GdkRectangle geom;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
   gdk_monitor_get_geometry (monitor, &geom);
-  gdk_window_move (window, geom.x, geom.y);
+  gdk_surface_move (window, geom.x, geom.y);
 
-  gdk_window_set_fullscreen_mode (window, GDK_FULLSCREEN_ON_CURRENT_MONITOR);
-  gdk_x11_window_fullscreen (window);
+  gdk_surface_set_fullscreen_mode (window, GDK_FULLSCREEN_ON_CURRENT_MONITOR);
+  gdk_x11_surface_fullscreen (window);
 }
 
 static void
-gdk_x11_window_unfullscreen (GdkWindow *window)
+gdk_x11_surface_unfullscreen (GdkSurface *window)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     gdk_wmspec_change_state (FALSE, window,
 			     g_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
                              NULL);
 
   else
     gdk_synthesize_window_state (window,
-				 GDK_WINDOW_STATE_FULLSCREEN,
+				 GDK_SURFACE_STATE_FULLSCREEN,
 				 0);
 }
 
 static void
-gdk_x11_window_set_keep_above (GdkWindow *window,
+gdk_x11_surface_set_keep_above (GdkSurface *window,
 			       gboolean   setting)
 {
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       if (setting)
 	gdk_wmspec_change_state (FALSE, window,
@@ -3580,20 +3580,20 @@ gdk_x11_window_set_keep_above (GdkWindow *window,
     }
   else
     gdk_synthesize_window_state (window,
-    				 setting ? GDK_WINDOW_STATE_BELOW : GDK_WINDOW_STATE_ABOVE,
-				 setting ? GDK_WINDOW_STATE_ABOVE : 0);
+    				 setting ? GDK_SURFACE_STATE_BELOW : GDK_SURFACE_STATE_ABOVE,
+				 setting ? GDK_SURFACE_STATE_ABOVE : 0);
 }
 
 static void
-gdk_x11_window_set_keep_below (GdkWindow *window, gboolean setting)
+gdk_x11_surface_set_keep_below (GdkSurface *window, gboolean setting)
 {
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
-  if (GDK_WINDOW_IS_MAPPED (window))
+  if (GDK_SURFACE_IS_MAPPED (window))
     {
       if (setting)
 	gdk_wmspec_change_state (FALSE, window,
@@ -3605,57 +3605,57 @@ gdk_x11_window_set_keep_below (GdkWindow *window, gboolean setting)
     }
   else
     gdk_synthesize_window_state (window,
-				 setting ? GDK_WINDOW_STATE_ABOVE : GDK_WINDOW_STATE_BELOW,
-				 setting ? GDK_WINDOW_STATE_BELOW : 0);
+				 setting ? GDK_SURFACE_STATE_ABOVE : GDK_SURFACE_STATE_BELOW,
+				 setting ? GDK_SURFACE_STATE_BELOW : 0);
 }
 
-static GdkWindow *
-gdk_x11_window_get_group (GdkWindow *window)
+static GdkSurface *
+gdk_x11_surface_get_group (GdkSurface *window)
 {
   GdkToplevelX11 *toplevel;
   
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
     return NULL;
   
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   return toplevel->group_leader;
 }
 
 static void
-gdk_x11_window_set_group (GdkWindow *window,
-			  GdkWindow *leader)
+gdk_x11_surface_set_group (GdkSurface *window,
+			  GdkSurface *leader)
 {
   GdkToplevelX11 *toplevel;
   
-  g_return_if_fail (GDK_IS_WINDOW (window));
-  g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
-  g_return_if_fail (leader == NULL || GDK_IS_WINDOW (leader));
+  g_return_if_fail (GDK_IS_SURFACE (window));
+  g_return_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD);
+  g_return_if_fail (leader == NULL || GDK_IS_SURFACE (leader));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
-      (leader != NULL && GDK_WINDOW_DESTROYED (leader)) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
+      (leader != NULL && GDK_SURFACE_DESTROYED (leader)) ||
       !WINDOW_IS_TOPLEVEL (window))
     return;
 
-  toplevel = _gdk_x11_window_get_toplevel (window);
+  toplevel = _gdk_x11_surface_get_toplevel (window);
 
   if (leader == NULL)
-    leader = gdk_display_get_default_group (gdk_window_get_display (window));
+    leader = gdk_display_get_default_group (gdk_surface_get_display (window));
   
   if (toplevel->group_leader != leader)
     {
       if (toplevel->group_leader)
 	g_object_unref (toplevel->group_leader);
       toplevel->group_leader = g_object_ref (leader);
-      (_gdk_x11_window_get_toplevel (leader))->is_leader = TRUE;      
+      (_gdk_x11_surface_get_toplevel (leader))->is_leader = TRUE;      
     }
 
   update_wm_hints (window, FALSE);
 }
 
 static MotifWmHints *
-gdk_window_get_mwm_hints (GdkWindow *window)
+gdk_surface_get_mwm_hints (GdkSurface *window)
 {
   GdkDisplay *display;
   Atom hints_atom = None;
@@ -3665,14 +3665,14 @@ gdk_window_get_mwm_hints (GdkWindow *window)
   gulong nitems;
   gulong bytes_after;
   
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return NULL;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   
   hints_atom = gdk_x11_get_xatom_by_name_for_display (display, _XA_MOTIF_WM_HINTS);
 
-  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (window),
 		      hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
 		      False, AnyPropertyType, &type, &format, &nitems,
 		      &bytes_after, &data);
@@ -3684,7 +3684,7 @@ gdk_window_get_mwm_hints (GdkWindow *window)
 }
 
 static void
-gdk_window_set_mwm_hints (GdkWindow *window,
+gdk_surface_set_mwm_hints (GdkSurface *window,
 			  MotifWmHints *new_hints)
 {
   GdkDisplay *display;
@@ -3696,14 +3696,14 @@ gdk_window_set_mwm_hints (GdkWindow *window,
   gulong nitems;
   gulong bytes_after;
   
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return;
   
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   
   hints_atom = gdk_x11_get_xatom_by_name_for_display (display, _XA_MOTIF_WM_HINTS);
 
-  XGetWindowProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
+  XGetWindowProperty (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XID (window),
 		      hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
 		      False, AnyPropertyType, &type, &format, &nitems,
 		      &bytes_after, &data);
@@ -3726,7 +3726,7 @@ gdk_window_set_mwm_hints (GdkWindow *window,
 	}
     }
   
-  XChangeProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
+  XChangeProperty (GDK_SURFACE_XDISPLAY (window), GDK_SURFACE_XID (window),
 		   hints_atom, hints_atom, 32, PropModeReplace,
 		   (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));
   
@@ -3735,12 +3735,12 @@ gdk_window_set_mwm_hints (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_set_decorations (GdkWindow      *window,
+gdk_x11_surface_set_decorations (GdkSurface      *window,
 				GdkWMDecoration decorations)
 {
   MotifWmHints hints;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
   
@@ -3749,21 +3749,21 @@ gdk_x11_window_set_decorations (GdkWindow      *window,
   hints.flags = MWM_HINTS_DECORATIONS;
   hints.decorations = decorations;
   
-  gdk_window_set_mwm_hints (window, &hints);
+  gdk_surface_set_mwm_hints (window, &hints);
 }
 
 static gboolean
-gdk_x11_window_get_decorations(GdkWindow       *window,
+gdk_x11_surface_get_decorations(GdkSurface       *window,
 			       GdkWMDecoration *decorations)
 {
   MotifWmHints *hints;
   gboolean result = FALSE;
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return FALSE;
   
-  hints = gdk_window_get_mwm_hints (window);
+  hints = gdk_surface_get_mwm_hints (window);
   
   if (hints)
     {
@@ -3781,14 +3781,14 @@ gdk_x11_window_get_decorations(GdkWindow       *window,
 }
 
 static void
-gdk_x11_window_set_functions (GdkWindow    *window,
+gdk_x11_surface_set_functions (GdkSurface    *window,
                               GdkWMFunction functions)
 {
   MotifWmHints hints;
   
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
   
@@ -3797,7 +3797,7 @@ gdk_x11_window_set_functions (GdkWindow    *window,
   hints.flags = MWM_HINTS_FUNCTIONS;
   hints.functions = functions;
   
-  gdk_window_set_mwm_hints (window, &hints);
+  gdk_surface_set_mwm_hints (window, &hints);
 }
 
 cairo_region_t *
@@ -3871,18 +3871,18 @@ _gdk_x11_xwindow_get_shape (Display *xdisplay,
 
 static void
 wmspec_send_message (GdkDisplay *display,
-                     GdkWindow  *window,
+                     GdkSurface  *window,
                      gint        root_x,
                      gint        root_y,
                      gint        action,
                      gint        button)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   XClientMessageEvent xclient;
 
   memset (&xclient, 0, sizeof (xclient));
   xclient.type = ClientMessage;
-  xclient.window = GDK_WINDOW_XID (window);
+  xclient.window = GDK_SURFACE_XID (window);
   xclient.message_type =
     gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_MOVERESIZE");
   xclient.format = 32;
@@ -3892,7 +3892,7 @@ wmspec_send_message (GdkDisplay *display,
   xclient.data.l[3] = button;
   xclient.data.l[4] = 1;  /* source indication */
 
-  XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XROOTWIN (window), False,
+  XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XROOTWIN (window), False,
               SubstructureRedirectMask | SubstructureNotifyMask,
               (XEvent *)&xclient);
 }
@@ -3902,17 +3902,17 @@ handle_wmspec_button_release (GdkDisplay   *display,
                               const XEvent *xevent)
 {
   GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
-  GdkWindow *window;
+  GdkSurface *window;
 
 #if defined (HAVE_XGENERICEVENTS) && defined (XINPUT_2)
   XIEvent *xiev = (XIEvent *) xevent->xcookie.data;
   XIDeviceEvent *xidev = (XIDeviceEvent *) xiev;
 
   if (xevent->xany.type == GenericEvent)
-    window = gdk_x11_window_lookup_for_display (display, xidev->event);
+    window = gdk_x11_surface_lookup_for_display (display, xidev->event);
   else
 #endif
-    window = gdk_x11_window_lookup_for_display (display, xevent->xany.window);
+    window = gdk_x11_surface_lookup_for_display (display, xevent->xany.window);
 
   if (display_x11->wm_moveresize_button != 0 && window != NULL)
     {
@@ -3933,7 +3933,7 @@ handle_wmspec_button_release (GdkDisplay   *display,
 }
 
 static void
-wmspec_moveresize (GdkWindow *window,
+wmspec_moveresize (GdkSurface *window,
                    gint       direction,
                    GdkDevice *device,
                    gint       button,
@@ -3941,7 +3941,7 @@ wmspec_moveresize (GdkWindow *window,
                    gint       root_y,
                    guint32    timestamp)
 {
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
 
   if (button != 0)
     gdk_seat_ungrab (gdk_device_get_seat (device)); /* Release passive grab */
@@ -3951,8 +3951,8 @@ wmspec_moveresize (GdkWindow *window,
 }
 
 static void
-wmspec_resize_drag (GdkWindow     *window,
-                    GdkWindowEdge  edge,
+wmspec_resize_drag (GdkSurface     *window,
+                    GdkSurfaceEdge  edge,
                     GdkDevice     *device,
                     gint           button,
                     gint           root_x,
@@ -3969,40 +3969,40 @@ wmspec_resize_drag (GdkWindow     *window,
       /* Let the compiler turn a switch into a table, instead
        * of doing the table manually, this way is easier to verify.
        */
-      case GDK_WINDOW_EDGE_NORTH_WEST:
+      case GDK_SURFACE_EDGE_NORTH_WEST:
         direction = _NET_WM_MOVERESIZE_SIZE_TOPLEFT;
         break;
 
-      case GDK_WINDOW_EDGE_NORTH:
+      case GDK_SURFACE_EDGE_NORTH:
         direction = _NET_WM_MOVERESIZE_SIZE_TOP;
         break;
 
-      case GDK_WINDOW_EDGE_NORTH_EAST:
+      case GDK_SURFACE_EDGE_NORTH_EAST:
         direction = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT;
         break;
 
-      case GDK_WINDOW_EDGE_WEST:
+      case GDK_SURFACE_EDGE_WEST:
         direction = _NET_WM_MOVERESIZE_SIZE_LEFT;
         break;
 
-      case GDK_WINDOW_EDGE_EAST:
+      case GDK_SURFACE_EDGE_EAST:
         direction = _NET_WM_MOVERESIZE_SIZE_RIGHT;
         break;
 
-      case GDK_WINDOW_EDGE_SOUTH_WEST:
+      case GDK_SURFACE_EDGE_SOUTH_WEST:
         direction = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT;
         break;
 
-      case GDK_WINDOW_EDGE_SOUTH:
+      case GDK_SURFACE_EDGE_SOUTH:
         direction = _NET_WM_MOVERESIZE_SIZE_BOTTOM;
         break;
 
-      case GDK_WINDOW_EDGE_SOUTH_EAST:
+      case GDK_SURFACE_EDGE_SOUTH_EAST:
         direction = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT;
         break;
 
       default:
-        g_warning ("gdk_window_begin_resize_drag: bad resize edge %d!",
+        g_warning ("gdk_surface_begin_resize_drag: bad resize edge %d!",
                    edge);
         return;
       }
@@ -4016,10 +4016,10 @@ struct _MoveResizeData
 {
   GdkDisplay *display;
 
-  GdkWindow *moveresize_window;
-  GdkWindow *moveresize_emulation_window;
+  GdkSurface *moveresize_window;
+  GdkSurface *moveresize_emulation_window;
   gboolean is_resize;
-  GdkWindowEdge resize_edge;
+  GdkSurfaceEdge resize_edge;
   GdkDevice *device;
   gint moveresize_button;
   gint moveresize_x;
@@ -4028,7 +4028,7 @@ struct _MoveResizeData
   gint moveresize_orig_y;
   gint moveresize_orig_width;
   gint moveresize_orig_height;
-  GdkWindowHints moveresize_geom_mask;
+  GdkSurfaceHints moveresize_geom_mask;
   GdkGeometry moveresize_geometry;
   Time moveresize_process_time;
   XEvent *moveresize_pending_event;
@@ -4062,21 +4062,21 @@ check_maximize (MoveResizeData *mv_resize,
                 gdouble         x_root,
                 gdouble         y_root)
 {
-  GdkWindowState state;
+  GdkSurfaceState state;
   gint y;
 
   if (mv_resize->is_resize)
     return;
 
-  state = gdk_window_get_state (mv_resize->moveresize_window);
+  state = gdk_surface_get_state (mv_resize->moveresize_window);
 
-  if (state & GDK_WINDOW_STATE_MAXIMIZED)
+  if (state & GDK_SURFACE_STATE_MAXIMIZED)
     return;
 
   y = mv_resize->moveresize_orig_y + (y_root - mv_resize->moveresize_y);
 
   if (y < 10)
-    gdk_window_maximize (mv_resize->moveresize_window);
+    gdk_surface_maximize (mv_resize->moveresize_window);
 }
 
 static void
@@ -4084,22 +4084,22 @@ check_unmaximize (MoveResizeData *mv_resize,
                   gdouble         x_root,
                   gdouble         y_root)
 {
-  GdkWindowState state;
+  GdkSurfaceState state;
   gint dx, dy;
 
   if (mv_resize->is_resize)
     return;
 
-  state = gdk_window_get_state (mv_resize->moveresize_window);
+  state = gdk_surface_get_state (mv_resize->moveresize_window);
 
-  if ((state & (GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_TILED)) == 0)
+  if ((state & (GDK_SURFACE_STATE_MAXIMIZED | GDK_SURFACE_STATE_TILED)) == 0)
     return;
 
   dx = x_root - mv_resize->moveresize_x;
   dy = y_root - mv_resize->moveresize_y;
 
   if (ABS (dx) > 20 || ABS (dy) > 20)
-    gdk_window_unmaximize (mv_resize->moveresize_window);
+    gdk_surface_unmaximize (mv_resize->moveresize_window);
 }
 
 static void
@@ -4125,37 +4125,37 @@ update_pos (MoveResizeData *mv_resize,
 
       switch (mv_resize->resize_edge)
 	{
-	case GDK_WINDOW_EDGE_NORTH_WEST:
+	case GDK_SURFACE_EDGE_NORTH_WEST:
 	  x += dx;
 	  y += dy;
 	  w -= dx;
 	  h -= dy;
 	  break;
-	case GDK_WINDOW_EDGE_NORTH:
+	case GDK_SURFACE_EDGE_NORTH:
 	  y += dy;
 	  h -= dy;
 	  break;
-	case GDK_WINDOW_EDGE_NORTH_EAST:
+	case GDK_SURFACE_EDGE_NORTH_EAST:
 	  y += dy;
 	  h -= dy;
 	  w += dx;
 	  break;
-	case GDK_WINDOW_EDGE_SOUTH_WEST:
+	case GDK_SURFACE_EDGE_SOUTH_WEST:
 	  h += dy;
 	  x += dx;
 	  w -= dx;
 	  break;
-	case GDK_WINDOW_EDGE_SOUTH_EAST:
+	case GDK_SURFACE_EDGE_SOUTH_EAST:
 	  w += dx;
 	  h += dy;
 	  break;
-	case GDK_WINDOW_EDGE_SOUTH:
+	case GDK_SURFACE_EDGE_SOUTH:
 	  h += dy;
 	  break;
-	case GDK_WINDOW_EDGE_EAST:
+	case GDK_SURFACE_EDGE_EAST:
 	  w += dx;
 	  break;
-	case GDK_WINDOW_EDGE_WEST:
+	case GDK_SURFACE_EDGE_WEST:
 	  x += dx;
 	  w -= dx;
 	  break;
@@ -4170,12 +4170,12 @@ update_pos (MoveResizeData *mv_resize,
 
       if (mv_resize->moveresize_geom_mask)
 	{
-	  gdk_window_constrain_size (&mv_resize->moveresize_geometry,
+	  gdk_surface_constrain_size (&mv_resize->moveresize_geometry,
 				     mv_resize->moveresize_geom_mask,
 				     w, h, &w, &h);
 	}
 
-      gdk_window_move_resize (mv_resize->moveresize_window, x, y, w, h);
+      gdk_surface_move_resize (mv_resize->moveresize_window, x, y, w, h);
     }
   else
     {
@@ -4184,14 +4184,14 @@ update_pos (MoveResizeData *mv_resize,
       x = mv_resize->moveresize_orig_x + dx;
       y = mv_resize->moveresize_orig_y + dy;
 
-      gdk_window_move (mv_resize->moveresize_window, x, y);
+      gdk_surface_move (mv_resize->moveresize_window, x, y);
     }
 }
 
 static void
 finish_drag (MoveResizeData *mv_resize)
 {
-  gdk_window_destroy (mv_resize->moveresize_emulation_window);
+  gdk_surface_destroy (mv_resize->moveresize_emulation_window);
   mv_resize->moveresize_emulation_window = NULL;
   g_clear_object (&mv_resize->moveresize_window);
   g_clear_pointer (&mv_resize->moveresize_pending_event, g_free);
@@ -4254,7 +4254,7 @@ _gdk_x11_moveresize_handle_event (const XEvent *event)
   guint button_mask = 0;
   GdkDisplay *display = gdk_x11_lookup_xdisplay (event->xany.display);
   MoveResizeData *mv_resize = get_move_resize_data (display, FALSE);
-  GdkWindowImplX11 *impl;
+  GdkSurfaceImplX11 *impl;
 
   if (!mv_resize || !mv_resize->moveresize_window)
     {
@@ -4262,7 +4262,7 @@ _gdk_x11_moveresize_handle_event (const XEvent *event)
       return FALSE;
     }
 
-  impl = GDK_WINDOW_IMPL_X11 (mv_resize->moveresize_window->impl);
+  impl = GDK_SURFACE_IMPL_X11 (mv_resize->moveresize_window->impl);
 
   if (mv_resize->moveresize_button != 0)
     button_mask = GDK_BUTTON1_MASK << (mv_resize->moveresize_button - 1);
@@ -4363,7 +4363,7 @@ _gdk_x11_moveresize_handle_event (const XEvent *event)
 
 gboolean
 _gdk_x11_moveresize_configure_done (GdkDisplay *display,
-                                    GdkWindow  *window)
+                                    GdkSurface  *window)
 {
   XEvent *tmp_event;
   MoveResizeData *mv_resize = get_move_resize_data (display, FALSE);
@@ -4390,8 +4390,8 @@ create_moveresize_window (MoveResizeData *mv_resize,
 
   g_assert (mv_resize->moveresize_emulation_window == NULL);
 
-  mv_resize->moveresize_emulation_window = gdk_window_new_temp (mv_resize->display);
-  gdk_window_show (mv_resize->moveresize_emulation_window);
+  mv_resize->moveresize_emulation_window = gdk_surface_new_temp (mv_resize->display);
+  gdk_surface_show (mv_resize->moveresize_emulation_window);
 
   status = gdk_seat_grab (gdk_device_get_seat (mv_resize->device),
                           mv_resize->moveresize_emulation_window,
@@ -4425,14 +4425,14 @@ calculate_unmoving_origin (MoveResizeData *mv_resize)
   if (mv_resize->moveresize_geom_mask & GDK_HINT_WIN_GRAVITY &&
       mv_resize->moveresize_geometry.win_gravity == GDK_GRAVITY_STATIC)
     {
-      gdk_window_get_origin (mv_resize->moveresize_window,
+      gdk_surface_get_origin (mv_resize->moveresize_window,
 			     &mv_resize->moveresize_orig_x,
 			     &mv_resize->moveresize_orig_y);
     }
   else
     {
-      gdk_window_get_frame_extents (mv_resize->moveresize_window, &rect);
-      gdk_window_get_geometry (mv_resize->moveresize_window, 
+      gdk_surface_get_frame_extents (mv_resize->moveresize_window, &rect);
+      gdk_surface_get_geometry (mv_resize->moveresize_window, 
 			       NULL, NULL, &width, &height);
       
       switch (mv_resize->moveresize_geometry.win_gravity) 
@@ -4483,15 +4483,15 @@ calculate_unmoving_origin (MoveResizeData *mv_resize)
 }
 
 static void
-emulate_resize_drag (GdkWindow     *window,
-                     GdkWindowEdge  edge,
+emulate_resize_drag (GdkSurface     *window,
+                     GdkSurfaceEdge  edge,
                      GdkDevice     *device,
                      gint           button,
                      gint           root_x,
                      gint           root_y,
                      guint32        timestamp)
 {
-  MoveResizeData *mv_resize = get_move_resize_data (GDK_WINDOW_DISPLAY (window), TRUE);
+  MoveResizeData *mv_resize = get_move_resize_data (GDK_SURFACE_DISPLAY (window), TRUE);
 
   if (mv_resize->moveresize_window != NULL)
     return; /* already a drag operation in progress */
@@ -4504,11 +4504,11 @@ emulate_resize_drag (GdkWindow     *window,
   mv_resize->moveresize_y = root_y;
   mv_resize->moveresize_window = g_object_ref (window);
 
-  mv_resize->moveresize_orig_width = gdk_window_get_width (window);
-  mv_resize->moveresize_orig_height = gdk_window_get_height (window);
+  mv_resize->moveresize_orig_width = gdk_surface_get_width (window);
+  mv_resize->moveresize_orig_height = gdk_surface_get_height (window);
 
   mv_resize->moveresize_geom_mask = 0;
-  gdk_window_get_geometry_hints (window,
+  gdk_surface_get_geometry_hints (window,
 				 &mv_resize->moveresize_geometry,
 				 &mv_resize->moveresize_geom_mask);
 
@@ -4518,14 +4518,14 @@ emulate_resize_drag (GdkWindow     *window,
 }
 
 static void
-emulate_move_drag (GdkWindow     *window,
+emulate_move_drag (GdkSurface     *window,
                    GdkDevice     *device,
                    gint           button,
                    gint           root_x,
                    gint           root_y,
                    guint32        timestamp)
 {
-  MoveResizeData *mv_resize = get_move_resize_data (GDK_WINDOW_DISPLAY (window), TRUE);
+  MoveResizeData *mv_resize = get_move_resize_data (GDK_SURFACE_DISPLAY (window), TRUE);
 
   if (mv_resize->moveresize_window != NULL)
     return; /* already a drag operation in progress */
@@ -4544,17 +4544,17 @@ emulate_move_drag (GdkWindow     *window,
 }
 
 static gboolean
-_should_perform_ewmh_drag (GdkWindow *window,
+_should_perform_ewmh_drag (GdkSurface *window,
                            GdkDevice *device)
 {
-  GdkPointerWindowInfo *info;
+  GdkPointerSurfaceInfo *info;
   GdkDisplay *display;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
   info = _gdk_display_get_pointer_info (display, device);
 
   if ((!info->last_slave || gdk_device_get_source (info->last_slave) != GDK_SOURCE_TOUCHSCREEN) &&
-      gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+      gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                            g_intern_static_string ("_NET_WM_MOVERESIZE")))
     return TRUE;
 
@@ -4562,15 +4562,15 @@ _should_perform_ewmh_drag (GdkWindow *window,
 }
 
 static void
-gdk_x11_window_begin_resize_drag (GdkWindow     *window,
-                                  GdkWindowEdge  edge,
+gdk_x11_surface_begin_resize_drag (GdkSurface     *window,
+                                  GdkSurfaceEdge  edge,
                                   GdkDevice     *device,
                                   gint           button,
                                   gint           root_x,
                                   gint           root_y,
                                   guint32        timestamp)
 {
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
     return;
 
@@ -4582,7 +4582,7 @@ gdk_x11_window_begin_resize_drag (GdkWindow     *window,
 }
 
 static void
-gdk_x11_window_begin_move_drag (GdkWindow *window,
+gdk_x11_surface_begin_move_drag (GdkSurface *window,
                                 GdkDevice *device,
 				gint       button,
 				gint       root_x,
@@ -4591,7 +4591,7 @@ gdk_x11_window_begin_move_drag (GdkWindow *window,
 {
   gint direction;
 
-  if (GDK_WINDOW_DESTROYED (window) || !WINDOW_IS_TOPLEVEL (window))
+  if (GDK_SURFACE_DESTROYED (window) || !WINDOW_IS_TOPLEVEL (window))
     return;
 
   if (button == 0)
@@ -4607,17 +4607,17 @@ gdk_x11_window_begin_move_drag (GdkWindow *window,
 }
 
 static gboolean
-gdk_x11_window_beep (GdkWindow *window)
+gdk_x11_surface_beep (GdkSurface *window)
 {
   GdkDisplay *display;
 
-  display = GDK_WINDOW_DISPLAY (window);
+  display = GDK_SURFACE_DISPLAY (window);
 
 #ifdef HAVE_XKB
   if (GDK_X11_DISPLAY (display)->use_xkb)
     {
       XkbBell (GDK_DISPLAY_XDISPLAY (display),
-               GDK_WINDOW_XID (window),
+               GDK_SURFACE_XID (window),
                0,
                None);
       return TRUE;
@@ -4628,19 +4628,19 @@ gdk_x11_window_beep (GdkWindow *window)
 }
 
 static void
-gdk_x11_window_set_opacity (GdkWindow *window,
+gdk_x11_surface_set_opacity (GdkSurface *window,
 			    gdouble    opacity)
 {
   GdkDisplay *display;
   gulong cardinal;
   
-  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_SURFACE (window));
 
-  if (GDK_WINDOW_DESTROYED (window) ||
+  if (GDK_SURFACE_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
     return;
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   if (opacity < 0)
     opacity = 0;
@@ -4651,11 +4651,11 @@ gdk_x11_window_set_opacity (GdkWindow *window,
 
   if (cardinal == 0xffffffff)
     XDeleteProperty (GDK_DISPLAY_XDISPLAY (display),
-		     GDK_WINDOW_XID (window),
+		     GDK_SURFACE_XID (window),
 		     gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_OPACITY"));
   else
     XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-		     GDK_WINDOW_XID (window),
+		     GDK_SURFACE_XID (window),
 		     gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_OPACITY"),
 		     XA_CARDINAL, 32,
 		     PropModeReplace,
@@ -4681,7 +4681,7 @@ timestamp_predicate (Display *display,
 
 /**
  * gdk_x11_get_server_time:
- * @window: (type GdkX11Window): a #GdkWindow, used for communication
+ * @window: (type GdkX11Surface): a #GdkSurface, used for communication
  *          with the server.  The window must have
  *          GDK_PROPERTY_CHANGE_MASK in its events mask or a hang will
  *          result.
@@ -4691,7 +4691,7 @@ timestamp_predicate (Display *display,
  * Returns: the time stamp.
  **/
 guint32
-gdk_x11_get_server_time (GdkWindow *window)
+gdk_x11_get_server_time (GdkSurface *window)
 {
   Display *xdisplay;
   Window   xwindow;
@@ -4699,13 +4699,13 @@ gdk_x11_get_server_time (GdkWindow *window)
   XEvent xevent;
   Atom timestamp_prop_atom;
 
-  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
-  g_return_val_if_fail (!GDK_WINDOW_DESTROYED (window), 0);
+  g_return_val_if_fail (GDK_IS_SURFACE (window), 0);
+  g_return_val_if_fail (!GDK_SURFACE_DESTROYED (window), 0);
 
-  xdisplay = GDK_WINDOW_XDISPLAY (window);
-  xwindow = GDK_WINDOW_XID (window);
+  xdisplay = GDK_SURFACE_XDISPLAY (window);
+  xwindow = GDK_SURFACE_XID (window);
   timestamp_prop_atom =
-    gdk_x11_get_xatom_by_name_for_display (GDK_WINDOW_DISPLAY (window),
+    gdk_x11_get_xatom_by_name_for_display (GDK_SURFACE_DISPLAY (window),
 					   "GDK_TIMESTAMP_PROP");
 
   XChangeProperty (xdisplay, xwindow, timestamp_prop_atom,
@@ -4719,40 +4719,40 @@ gdk_x11_get_server_time (GdkWindow *window)
 }
 
 /**
- * gdk_x11_window_get_xid:
- * @window: (type GdkX11Window): a native #GdkWindow.
+ * gdk_x11_surface_get_xid:
+ * @window: (type GdkX11Surface): a native #GdkSurface.
  * 
- * Returns the X resource (window) belonging to a #GdkWindow.
+ * Returns the X resource (window) belonging to a #GdkSurface.
  * 
  * Returns: the ID of @drawable’s X resource.
  **/
 XID
-gdk_x11_window_get_xid (GdkWindow *window)
+gdk_x11_surface_get_xid (GdkSurface *window)
 {
-  if (!GDK_WINDOW_IS_X11 (window) ||
-      !_gdk_window_has_impl (window))
+  if (!GDK_SURFACE_IS_X11 (window) ||
+      !_gdk_surface_has_impl (window))
     {
       g_warning (G_STRLOC " drawable is not a native X11 window");
       return None;
     }
   
-  return GDK_WINDOW_IMPL_X11 (window->impl)->xid;
+  return GDK_SURFACE_IMPL_X11 (window->impl)->xid;
 }
 
 static gint
-gdk_x11_window_get_scale_factor (GdkWindow *window)
+gdk_x11_surface_get_scale_factor (GdkSurface *window)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return 1;
 
   return impl->window_scale;
 }
 
 /**
- * gdk_x11_window_set_frame_sync_enabled:
- * @window: (type GdkX11Window): a native #GdkWindow
+ * gdk_x11_surface_set_frame_sync_enabled:
+ * @window: (type GdkX11Surface): a native #GdkSurface
  * @frame_sync_enabled: whether frame-synchronization should be enabled
  *
  * This function can be used to disable frame synchronization for a window.
@@ -4763,29 +4763,29 @@ gdk_x11_window_get_scale_factor (GdkWindow *window)
  * embedded via the XEMBED protocol.
  */
 void
-gdk_x11_window_set_frame_sync_enabled (GdkWindow *window,
+gdk_x11_surface_set_frame_sync_enabled (GdkSurface *window,
                                        gboolean   frame_sync_enabled)
 {
-  if (!GDK_WINDOW_IS_X11 (window) ||
-      !_gdk_window_has_impl (window))
+  if (!GDK_SURFACE_IS_X11 (window) ||
+      !_gdk_surface_has_impl (window))
     {
       g_warning (G_STRLOC " drawable is not a native X11 window");
       return;
     }
 
-  GDK_WINDOW_IMPL_X11 (window->impl)->frame_sync_enabled = FALSE;
+  GDK_SURFACE_IMPL_X11 (window->impl)->frame_sync_enabled = FALSE;
 }
 
 static void
-gdk_x11_window_set_opaque_region (GdkWindow      *window,
+gdk_x11_surface_set_opaque_region (GdkSurface      *window,
                                   cairo_region_t *region)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
   GdkDisplay *display;
   int nitems;
   gulong *data;
 
-  if (GDK_WINDOW_DESTROYED (window))
+  if (GDK_SURFACE_DESTROYED (window))
     return;
 
   if (region != NULL)
@@ -4812,10 +4812,10 @@ gdk_x11_window_set_opaque_region (GdkWindow      *window,
       data = NULL;
     }
 
-  display = gdk_window_get_display (window);
+  display = gdk_surface_get_display (window);
 
   XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (window),
+                   GDK_SURFACE_XID (window),
                    gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_OPAQUE_REGION"),
                    XA_CARDINAL, 32, PropModeReplace,
                    (guchar *) data, nitems);
@@ -4824,11 +4824,11 @@ gdk_x11_window_set_opaque_region (GdkWindow      *window,
 }
 
 static gboolean
-gdk_x11_window_show_window_menu (GdkWindow *window,
+gdk_x11_surface_show_window_menu (GdkSurface *window,
                                  GdkEvent  *event)
 {
-  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (window->impl);
-  GdkDisplay *display = GDK_WINDOW_DISPLAY (window);
+  GdkSurfaceImplX11 *impl = GDK_SURFACE_IMPL_X11 (window->impl);
+  GdkDisplay *display = GDK_SURFACE_DISPLAY (window);
   GdkDevice *device;
   int device_id;
   double x_root, y_root;
@@ -4843,7 +4843,7 @@ gdk_x11_window_show_window_menu (GdkWindow *window,
       return FALSE;
     }
 
-  if (!gdk_x11_screen_supports_net_wm_hint (GDK_WINDOW_SCREEN (window),
+  if (!gdk_x11_screen_supports_net_wm_hint (GDK_SURFACE_SCREEN (window),
                                             g_intern_static_string ("_GTK_SHOW_WINDOW_MENU")))
     return FALSE;
 
@@ -4857,14 +4857,14 @@ gdk_x11_window_show_window_menu (GdkWindow *window,
   gdk_seat_ungrab (gdk_device_get_seat (device));
 
   xclient.type = ClientMessage;
-  xclient.window = GDK_WINDOW_XID (window);
+  xclient.window = GDK_SURFACE_XID (window);
   xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_GTK_SHOW_WINDOW_MENU");
   xclient.data.l[0] = device_id;
   xclient.data.l[1] = x_root * impl->window_scale;
   xclient.data.l[2] = y_root * impl->window_scale;
   xclient.format = 32;
 
-  XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XROOTWIN (window), False,
+  XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XROOTWIN (window), False,
               SubstructureRedirectMask | SubstructureNotifyMask,
               (XEvent *)&xclient);
 
@@ -4872,77 +4872,77 @@ gdk_x11_window_show_window_menu (GdkWindow *window,
 }
 
 static void
-gdk_window_impl_x11_class_init (GdkWindowImplX11Class *klass)
+gdk_surface_impl_x11_class_init (GdkSurfaceImplX11Class *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_CLASS (klass);
+  GdkSurfaceImplClass *impl_class = GDK_SURFACE_IMPL_CLASS (klass);
   
-  object_class->finalize = gdk_window_impl_x11_finalize;
+  object_class->finalize = gdk_surface_impl_x11_finalize;
   
   impl_class->ref_cairo_surface = gdk_x11_ref_cairo_surface;
-  impl_class->show = gdk_window_x11_show;
-  impl_class->hide = gdk_window_x11_hide;
-  impl_class->withdraw = gdk_window_x11_withdraw;
-  impl_class->set_events = gdk_window_x11_set_events;
-  impl_class->get_events = gdk_window_x11_get_events;
-  impl_class->raise = gdk_window_x11_raise;
-  impl_class->lower = gdk_window_x11_lower;
-  impl_class->restack_toplevel = gdk_window_x11_restack_toplevel;
-  impl_class->move_resize = gdk_window_x11_move_resize;
-  impl_class->get_geometry = gdk_window_x11_get_geometry;
-  impl_class->get_root_coords = gdk_window_x11_get_root_coords;
-  impl_class->get_device_state = gdk_window_x11_get_device_state;
-  impl_class->shape_combine_region = gdk_window_x11_shape_combine_region;
-  impl_class->input_shape_combine_region = gdk_window_x11_input_shape_combine_region;
-  impl_class->queue_antiexpose = _gdk_x11_window_queue_antiexpose;
-  impl_class->destroy = gdk_x11_window_destroy;
-  impl_class->beep = gdk_x11_window_beep;
-
-  impl_class->focus = gdk_x11_window_focus;
-  impl_class->set_type_hint = gdk_x11_window_set_type_hint;
-  impl_class->get_type_hint = gdk_x11_window_get_type_hint;
-  impl_class->set_modal_hint = gdk_x11_window_set_modal_hint;
-  impl_class->set_skip_taskbar_hint = gdk_x11_window_set_skip_taskbar_hint;
-  impl_class->set_skip_pager_hint = gdk_x11_window_set_skip_pager_hint;
-  impl_class->set_urgency_hint = gdk_x11_window_set_urgency_hint;
-  impl_class->set_geometry_hints = gdk_x11_window_set_geometry_hints;
-  impl_class->set_title = gdk_x11_window_set_title;
-  impl_class->set_role = gdk_x11_window_set_role;
-  impl_class->set_startup_id = gdk_x11_window_set_startup_id;
-  impl_class->set_transient_for = gdk_x11_window_set_transient_for;
-  impl_class->get_frame_extents = gdk_x11_window_get_frame_extents;
-  impl_class->set_accept_focus = gdk_x11_window_set_accept_focus;
-  impl_class->set_focus_on_map = gdk_x11_window_set_focus_on_map;
-  impl_class->set_icon_list = gdk_x11_window_set_icon_list;
-  impl_class->set_icon_name = gdk_x11_window_set_icon_name;
-  impl_class->iconify = gdk_x11_window_iconify;
-  impl_class->deiconify = gdk_x11_window_deiconify;
-  impl_class->stick = gdk_x11_window_stick;
-  impl_class->unstick = gdk_x11_window_unstick;
-  impl_class->maximize = gdk_x11_window_maximize;
-  impl_class->unmaximize = gdk_x11_window_unmaximize;
-  impl_class->fullscreen = gdk_x11_window_fullscreen;
-  impl_class->fullscreen_on_monitor = gdk_x11_window_fullscreen_on_monitor;
-  impl_class->apply_fullscreen_mode = gdk_x11_window_apply_fullscreen_mode;
-  impl_class->unfullscreen = gdk_x11_window_unfullscreen;
-  impl_class->set_keep_above = gdk_x11_window_set_keep_above;
-  impl_class->set_keep_below = gdk_x11_window_set_keep_below;
-  impl_class->get_group = gdk_x11_window_get_group;
-  impl_class->set_group = gdk_x11_window_set_group;
-  impl_class->set_decorations = gdk_x11_window_set_decorations;
-  impl_class->get_decorations = gdk_x11_window_get_decorations;
-  impl_class->set_functions = gdk_x11_window_set_functions;
-  impl_class->begin_resize_drag = gdk_x11_window_begin_resize_drag;
-  impl_class->begin_move_drag = gdk_x11_window_begin_move_drag;
-  impl_class->set_opacity = gdk_x11_window_set_opacity;
-  impl_class->destroy_notify = gdk_x11_window_destroy_notify;
-  impl_class->register_dnd = _gdk_x11_window_register_dnd;
-  impl_class->drag_begin = _gdk_x11_window_drag_begin;
-  impl_class->get_scale_factor = gdk_x11_window_get_scale_factor;
-  impl_class->set_opaque_region = gdk_x11_window_set_opaque_region;
-  impl_class->set_shadow_width = gdk_x11_window_set_shadow_width;
-  impl_class->show_window_menu = gdk_x11_window_show_window_menu;
-  impl_class->create_gl_context = gdk_x11_window_create_gl_context;
-  impl_class->get_unscaled_size = gdk_x11_window_get_unscaled_size;
-  impl_class->supports_edge_constraints = gdk_x11_window_supports_edge_constraints;
+  impl_class->show = gdk_surface_x11_show;
+  impl_class->hide = gdk_surface_x11_hide;
+  impl_class->withdraw = gdk_surface_x11_withdraw;
+  impl_class->set_events = gdk_surface_x11_set_events;
+  impl_class->get_events = gdk_surface_x11_get_events;
+  impl_class->raise = gdk_surface_x11_raise;
+  impl_class->lower = gdk_surface_x11_lower;
+  impl_class->restack_toplevel = gdk_surface_x11_restack_toplevel;
+  impl_class->move_resize = gdk_surface_x11_move_resize;
+  impl_class->get_geometry = gdk_surface_x11_get_geometry;
+  impl_class->get_root_coords = gdk_surface_x11_get_root_coords;
+  impl_class->get_device_state = gdk_surface_x11_get_device_state;
+  impl_class->shape_combine_region = gdk_surface_x11_shape_combine_region;
+  impl_class->input_shape_combine_region = gdk_surface_x11_input_shape_combine_region;
+  impl_class->queue_antiexpose = _gdk_x11_surface_queue_antiexpose;
+  impl_class->destroy = gdk_x11_surface_destroy;
+  impl_class->beep = gdk_x11_surface_beep;
+
+  impl_class->focus = gdk_x11_surface_focus;
+  impl_class->set_type_hint = gdk_x11_surface_set_type_hint;
+  impl_class->get_type_hint = gdk_x11_surface_get_type_hint;
+  impl_class->set_modal_hint = gdk_x11_surface_set_modal_hint;
+  impl_class->set_skip_taskbar_hint = gdk_x11_surface_set_skip_taskbar_hint;
+  impl_class->set_skip_pager_hint = gdk_x11_surface_set_skip_pager_hint;
+  impl_class->set_urgency_hint = gdk_x11_surface_set_urgency_hint;
+  impl_class->set_geometry_hints = gdk_x11_surface_set_geometry_hints;
+  impl_class->set_title = gdk_x11_surface_set_title;
+  impl_class->set_role = gdk_x11_surface_set_role;
+  impl_class->set_startup_id = gdk_x11_surface_set_startup_id;
+  impl_class->set_transient_for = gdk_x11_surface_set_transient_for;
+  impl_class->get_frame_extents = gdk_x11_surface_get_frame_extents;
+  impl_class->set_accept_focus = gdk_x11_surface_set_accept_focus;
+  impl_class->set_focus_on_map = gdk_x11_surface_set_focus_on_map;
+  impl_class->set_icon_list = gdk_x11_surface_set_icon_list;
+  impl_class->set_icon_name = gdk_x11_surface_set_icon_name;
+  impl_class->iconify = gdk_x11_surface_iconify;
+  impl_class->deiconify = gdk_x11_surface_deiconify;
+  impl_class->stick = gdk_x11_surface_stick;
+  impl_class->unstick = gdk_x11_surface_unstick;
+  impl_class->maximize = gdk_x11_surface_maximize;
+  impl_class->unmaximize = gdk_x11_surface_unmaximize;
+  impl_class->fullscreen = gdk_x11_surface_fullscreen;
+  impl_class->fullscreen_on_monitor = gdk_x11_surface_fullscreen_on_monitor;
+  impl_class->apply_fullscreen_mode = gdk_x11_surface_apply_fullscreen_mode;
+  impl_class->unfullscreen = gdk_x11_surface_unfullscreen;
+  impl_class->set_keep_above = gdk_x11_surface_set_keep_above;
+  impl_class->set_keep_below = gdk_x11_surface_set_keep_below;
+  impl_class->get_group = gdk_x11_surface_get_group;
+  impl_class->set_group = gdk_x11_surface_set_group;
+  impl_class->set_decorations = gdk_x11_surface_set_decorations;
+  impl_class->get_decorations = gdk_x11_surface_get_decorations;
+  impl_class->set_functions = gdk_x11_surface_set_functions;
+  impl_class->begin_resize_drag = gdk_x11_surface_begin_resize_drag;
+  impl_class->begin_move_drag = gdk_x11_surface_begin_move_drag;
+  impl_class->set_opacity = gdk_x11_surface_set_opacity;
+  impl_class->destroy_notify = gdk_x11_surface_destroy_notify;
+  impl_class->register_dnd = _gdk_x11_surface_register_dnd;
+  impl_class->drag_begin = _gdk_x11_surface_drag_begin;
+  impl_class->get_scale_factor = gdk_x11_surface_get_scale_factor;
+  impl_class->set_opaque_region = gdk_x11_surface_set_opaque_region;
+  impl_class->set_shadow_width = gdk_x11_surface_set_shadow_width;
+  impl_class->show_window_menu = gdk_x11_surface_show_window_menu;
+  impl_class->create_gl_context = gdk_x11_surface_create_gl_context;
+  impl_class->get_unscaled_size = gdk_x11_surface_get_unscaled_size;
+  impl_class->supports_edge_constraints = gdk_x11_surface_supports_edge_constraints;
 }
diff --git a/gdk/x11/gdkwindow-x11.h b/gdk/x11/gdkwindow-x11.h
index 2199692327..b824240ffc 100644
--- a/gdk/x11/gdkwindow-x11.h
+++ b/gdk/x11/gdkwindow-x11.h
@@ -22,8 +22,8 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#ifndef __GDK_WINDOW_X11_H__
-#define __GDK_WINDOW_X11_H__
+#ifndef __GDK_SURFACE_X11_H__
+#define __GDK_SURFACE_X11_H__
 
 #include "gdk/x11/gdkprivate-x11.h"
 #include "gdk/gdkwindowimpl.h"
@@ -42,25 +42,25 @@
 G_BEGIN_DECLS
 
 typedef struct _GdkToplevelX11 GdkToplevelX11;
-typedef struct _GdkWindowImplX11 GdkWindowImplX11;
-typedef struct _GdkWindowImplX11Class GdkWindowImplX11Class;
+typedef struct _GdkSurfaceImplX11 GdkSurfaceImplX11;
+typedef struct _GdkSurfaceImplX11Class GdkSurfaceImplX11Class;
 typedef struct _GdkXPositionInfo GdkXPositionInfo;
 
 /* Window implementation for X11
  */
 
-#define GDK_TYPE_WINDOW_IMPL_X11              (gdk_window_impl_x11_get_type ())
-#define GDK_WINDOW_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11))
-#define GDK_WINDOW_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
-#define GDK_IS_WINDOW_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_X11))
-#define GDK_IS_WINDOW_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_X11))
-#define GDK_WINDOW_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
+#define GDK_TYPE_SURFACE_IMPL_X11              (gdk_surface_impl_x11_get_type ())
+#define GDK_SURFACE_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SURFACE_IMPL_X11, GdkSurfaceImplX11))
+#define GDK_SURFACE_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SURFACE_IMPL_X11, GdkSurfaceImplX11Class))
+#define GDK_IS_SURFACE_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SURFACE_IMPL_X11))
+#define GDK_IS_SURFACE_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SURFACE_IMPL_X11))
+#define GDK_SURFACE_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SURFACE_IMPL_X11, GdkSurfaceImplX11Class))
 
-struct _GdkWindowImplX11
+struct _GdkSurfaceImplX11
 {
-  GdkWindowImpl parent_instance;
+  GdkSurfaceImpl parent_instance;
 
-  GdkWindow *wrapper;
+  GdkSurface *wrapper;
 
   Window xid;
 
@@ -91,9 +91,9 @@ struct _GdkWindowImplX11
 #endif
 };
  
-struct _GdkWindowImplX11Class 
+struct _GdkSurfaceImplX11Class 
 {
-  GdkWindowImplClass parent_class;
+  GdkSurfaceImplClass parent_class;
 };
 
 struct _GdkToplevelX11
@@ -151,7 +151,7 @@ struct _GdkToplevelX11
   
   cairo_surface_t *icon_pixmap;
   cairo_surface_t *icon_mask;
-  GdkWindow *group_leader;
+  GdkSurface *group_leader;
 
   /* Time of most recent user interaction. */
   gulong user_time;
@@ -162,7 +162,7 @@ struct _GdkToplevelX11
    */
   Window focus_window;
 
-  GdkWindowHints last_geometry_hints_mask;
+  GdkSurfaceHints last_geometry_hints_mask;
   GdkGeometry last_geometry_hints;
   
   /* Constrained edge information */
@@ -184,16 +184,16 @@ struct _GdkToplevelX11
 #endif
 };
 
-GType gdk_window_impl_x11_get_type (void);
+GType gdk_surface_impl_x11_get_type (void);
 
-GdkToplevelX11 *_gdk_x11_window_get_toplevel        (GdkWindow *window);
+GdkToplevelX11 *_gdk_x11_surface_get_toplevel        (GdkSurface *window);
 
-GdkCursor      *_gdk_x11_window_get_cursor          (GdkWindow *window);
+GdkCursor      *_gdk_x11_surface_get_cursor          (GdkSurface *window);
 
-void            _gdk_x11_window_update_size         (GdkWindowImplX11 *impl);
-void            _gdk_x11_window_set_window_scale    (GdkWindow *window,
+void            _gdk_x11_surface_update_size         (GdkSurfaceImplX11 *impl);
+void            _gdk_x11_surface_set_window_scale    (GdkSurface *window,
 						     int        scale);
 
 G_END_DECLS
 
-#endif /* __GDK_WINDOW_X11_H__ */
+#endif /* __GDK_SURFACE_X11_H__ */
diff --git a/gdk/x11/gdkx-autocleanups.h b/gdk/x11/gdkx-autocleanups.h
index d18abfa48b..ff3d5a43a9 100644
--- a/gdk/x11/gdkx-autocleanups.h
+++ b/gdk/x11/gdkx-autocleanups.h
@@ -31,6 +31,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11DragContext, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11GLContext, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Keymap, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Screen, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Window, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Surface, g_object_unref)
 
 #endif
diff --git a/gdk/x11/gdkx11window.h b/gdk/x11/gdkx11window.h
index a9c13189fc..d2fc1e4a60 100644
--- a/gdk/x11/gdkx11window.h
+++ b/gdk/x11/gdkx11window.h
@@ -22,8 +22,8 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#ifndef __GDK_X11_WINDOW_H__
-#define __GDK_X11_WINDOW_H__
+#ifndef __GDK_X11_SURFACE_H__
+#define __GDK_X11_SURFACE_H__
 
 #if !defined (__GDKX_H_INSIDE__) && !defined (GDK_COMPILATION)
 #error "Only <gdk/gdkx.h> can be included directly."
@@ -36,78 +36,78 @@
 
 G_BEGIN_DECLS
 
-#define GDK_TYPE_X11_WINDOW              (gdk_x11_window_get_type ())
-#define GDK_X11_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_WINDOW, GdkX11Window))
-#define GDK_X11_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_WINDOW, GdkX11WindowClass))
-#define GDK_IS_X11_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_WINDOW))
-#define GDK_IS_X11_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_WINDOW))
-#define GDK_X11_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_WINDOW, GdkX11WindowClass))
+#define GDK_TYPE_X11_SURFACE              (gdk_x11_surface_get_type ())
+#define GDK_X11_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SURFACE, GdkX11Surface))
+#define GDK_X11_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
+#define GDK_IS_X11_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SURFACE))
+#define GDK_IS_X11_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SURFACE))
+#define GDK_X11_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
 
 #ifdef GDK_COMPILATION
-typedef struct _GdkX11Window GdkX11Window;
+typedef struct _GdkX11Surface GdkX11Surface;
 #else
-typedef GdkWindow GdkX11Window;
+typedef GdkSurface GdkX11Surface;
 #endif
-typedef struct _GdkX11WindowClass GdkX11WindowClass;
+typedef struct _GdkX11SurfaceClass GdkX11SurfaceClass;
 
 GDK_AVAILABLE_IN_ALL
-GType    gdk_x11_window_get_type          (void);
+GType    gdk_x11_surface_get_type          (void);
 
 GDK_AVAILABLE_IN_ALL
-Window   gdk_x11_window_get_xid           (GdkWindow   *window);
+Window   gdk_x11_surface_get_xid           (GdkSurface   *window);
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_set_user_time     (GdkWindow   *window,
+void     gdk_x11_surface_set_user_time     (GdkSurface   *window,
                                            guint32      timestamp);
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_set_utf8_property    (GdkWindow *window,
+void     gdk_x11_surface_set_utf8_property    (GdkSurface *window,
 					      const gchar *name,
 					      const gchar *value);
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_set_theme_variant (GdkWindow   *window,
+void     gdk_x11_surface_set_theme_variant (GdkSurface   *window,
                                            const char  *variant);
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_move_to_current_desktop (GdkWindow   *window);
+void     gdk_x11_surface_move_to_current_desktop (GdkSurface   *window);
 
 GDK_AVAILABLE_IN_ALL
-guint32  gdk_x11_window_get_desktop             (GdkWindow   *window);
+guint32  gdk_x11_surface_get_desktop             (GdkSurface   *window);
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_move_to_desktop         (GdkWindow   *window,
+void     gdk_x11_surface_move_to_desktop         (GdkSurface   *window,
                                                  guint32      desktop);
 
 GDK_AVAILABLE_IN_ALL
-void     gdk_x11_window_set_frame_sync_enabled (GdkWindow *window,
+void     gdk_x11_surface_set_frame_sync_enabled (GdkSurface *window,
                                                 gboolean   frame_sync_enabled);
 
 /**
- * GDK_WINDOW_XDISPLAY:
- * @win: a #GdkWindow.
+ * GDK_SURFACE_XDISPLAY:
+ * @win: a #GdkSurface.
  *
- * Returns the display of a #GdkWindow.
+ * Returns the display of a #GdkSurface.
  *
  * Returns: an Xlib Display*.
  */
-#define GDK_WINDOW_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_window_get_display (win)))
+#define GDK_SURFACE_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_surface_get_display (win)))
 
 /**
- * GDK_WINDOW_XID:
- * @win: a #GdkWindow.
+ * GDK_SURFACE_XID:
+ * @win: a #GdkSurface.
  *
- * Returns the X window belonging to a #GdkWindow.
+ * Returns the X window belonging to a #GdkSurface.
  *
  * Returns: the Xlib Window of @win.
  */
-#define GDK_WINDOW_XID(win)           (gdk_x11_window_get_xid (win))
+#define GDK_SURFACE_XID(win)           (gdk_x11_surface_get_xid (win))
 
 GDK_AVAILABLE_IN_ALL
-guint32       gdk_x11_get_server_time  (GdkWindow       *window);
+guint32       gdk_x11_get_server_time  (GdkSurface       *window);
 
 GDK_AVAILABLE_IN_ALL
-GdkWindow  *gdk_x11_window_foreign_new_for_display (GdkDisplay *display,
+GdkSurface  *gdk_x11_surface_foreign_new_for_display (GdkDisplay *display,
                                                     Window      window);
 GDK_AVAILABLE_IN_ALL
-GdkWindow  *gdk_x11_window_lookup_for_display      (GdkDisplay *display,
+GdkSurface  *gdk_x11_surface_lookup_for_display      (GdkDisplay *display,
                                                     Window      window);
 
 G_END_DECLS
 
-#endif /* __GDK_X11_WINDOW_H__ */
+#endif /* __GDK_X11_SURFACE_H__ */
diff --git a/gdk/x11/gdkxid.c b/gdk/x11/gdkxid.c
index d74b367b41..ec8bf6ab4e 100644
--- a/gdk/x11/gdkxid.c
+++ b/gdk/x11/gdkxid.c
@@ -44,7 +44,7 @@ gdk_xid_equal (XID *a, XID *b)
 void
 _gdk_x11_display_add_window (GdkDisplay *display,
                              XID        *xid,
-                             GdkWindow  *data)
+                             GdkSurface  *data)
 {
   GdkX11Display *display_x11;
 
@@ -62,7 +62,7 @@ _gdk_x11_display_add_window (GdkDisplay *display,
 
   g_hash_table_insert (display_x11->xid_ht, xid, data);
 
-  if (gdk_window_get_parent (GDK_WINDOW (data)) == NULL)
+  if (gdk_surface_get_parent (GDK_SURFACE (data)) == NULL)
     display_x11->toplevels = g_list_prepend (display_x11->toplevels, data);
 }
 
@@ -71,7 +71,7 @@ _gdk_x11_display_remove_window (GdkDisplay *display,
                                 XID         xid)
 {
   GdkX11Display *display_x11;
-  GdkWindow *window;
+  GdkSurface *window;
 
   g_return_if_fail (GDK_IS_DISPLAY (display));
 
@@ -81,29 +81,29 @@ _gdk_x11_display_remove_window (GdkDisplay *display,
     return;
 
   window = g_hash_table_lookup (display_x11->xid_ht, &xid);
-  if (window && gdk_window_get_parent (window) == NULL)
+  if (window && gdk_surface_get_parent (window) == NULL)
     display_x11->toplevels = g_list_remove (display_x11->toplevels, window);
 
   g_hash_table_remove (display_x11->xid_ht, &xid);
 }
 
 /**
- * gdk_x11_window_lookup_for_display:
+ * gdk_x11_surface_lookup_for_display:
  * @display: (type GdkX11Display): the #GdkDisplay corresponding to the
  *           window handle
  * @window: an Xlib Window
  *
- * Looks up the #GdkWindow that wraps the given native window handle.
+ * Looks up the #GdkSurface that wraps the given native window handle.
  *
- * Returns: (transfer none) (type GdkX11Window): the #GdkWindow wrapper for the native
+ * Returns: (transfer none) (type GdkX11Surface): the #GdkSurface wrapper for the native
  *    window, or %NULL if there is none.
  */
-GdkWindow *
-gdk_x11_window_lookup_for_display (GdkDisplay *display,
+GdkSurface *
+gdk_x11_surface_lookup_for_display (GdkDisplay *display,
                                    Window      window)
 {
   GdkX11Display *display_x11;
-  GdkWindow *data = NULL;
+  GdkSurface *data = NULL;
 
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);