Add Wayland backend

26 files changed, 5444 insertions, 7 deletions

diff --git a/Makefile.am b/Makefile.am
index 382837057f..2c6e77be6f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -55,11 +55,11 @@ MAINTAINERCLEANFILES = \
 
 
 ## Copy .pc files to target-specific names
-gtk+-x11-3.0.pc gtk+-win32-3.0.pc gtk+-quartz-3.0.pc: gtk+-3.0.pc
+gtk+-x11-3.0.pc gtk+-win32-3.0.pc gtk+-quartz-3.0.pc gtk+-wayland-3.0.pc: gtk+-3.0.pc
 	rm -f $@ && \
 	cp gtk+-3.0.pc $@
 
-gdk-x11-3.0.pc gdk-win32-3.0.pc gdk-quartz-3.0.pc: gdk-3.0.pc
+gdk-x11-3.0.pc gdk-win32-3.0.pc gdk-quartz-3.0.pc gdk-wayland-3.0.pc: gdk-3.0.pc
 	rm -f $@ && \
 	cp gdk-3.0.pc $@
 
diff --git a/configure.ac b/configure.ac
index 71589c1df2..d33aeec6c2 100644
--- a/configure.ac
+++ b/configure.ac
@@ -290,6 +290,10 @@ AC_ARG_ENABLE(quartz-backend,
               [AC_HELP_STRING([--enable-quartz-backend],
                               [enable the quartz gdk backend])],
 			      [backend_set=yes])
+AC_ARG_ENABLE(wayland-backend,
+              [AC_HELP_STRING([--enable-wayland-backend],
+                              [enable the wayland gdk backend])],
+			      [backend_set=yes])
 
 if test -z "$backend_set"; then
   if test "$platform_win32" = yes; then
@@ -345,6 +349,19 @@ else
   AM_CONDITIONAL(USE_QUARTZ, false)
 fi
 
+if test "x$enable_wayland_backend" == "xyes"; then
+  # Wayland uses cairo-gl
+  cairo_backends="$cairo_backends cairo-gl"
+  GDK_BACKENDS="$GDK_BACKENDS wayland"
+  GIO_PACKAGE=gio-unix-2.0
+  GDK_WINDOWING="$GDK_WINDOWING
+#define GDK_WINDOWING_WAYLAND"
+  WAYLAND_PACKAGES="wayland-client xkbcommon"
+  AM_CONDITIONAL(USE_WAYLAND, true)
+else
+  AM_CONDITIONAL(USE_WAYLAND, false)
+fi
+
 # strip leading space
 GDK_BACKENDS=${GDK_BACKENDS/# }
 
@@ -1244,7 +1261,7 @@ fi
 CFLAGS="$saved_cflags"
 LDFLAGS="$saved_ldflags"
 
-GDK_PACKAGES="$PANGO_PACKAGES $GIO_PACKAGE $X_PACKAGES gdk-pixbuf-2.0 $cairo_backends cairo-gobject"
+GDK_PACKAGES="$PANGO_PACKAGES $GIO_PACKAGE $X_PACKAGES $WAYLAND_PACKAGES gdk-pixbuf-2.0 $cairo_backends cairo-gobject"
 
 GDK_DEP_LIBS="$GDK_EXTRA_LIBS `$PKG_CONFIG --libs $GDK_PACKAGES`"
 GDK_DEP_CFLAGS="`$PKG_CONFIG --cflags  gthread-2.0 $GDK_PACKAGES` $GDK_EXTRA_CFLAGS"
@@ -1668,6 +1685,7 @@ gdk/win32/Makefile
 gdk/win32/rc/Makefile
 gdk/win32/rc/gdk.rc
 gdk/quartz/Makefile
+gdk/wayland/Makefile
 gdk/tests/Makefile
 gtk/Makefile
 gtk/makefile.msc
diff --git a/gdk/Makefile.am b/gdk/Makefile.am
index f81147e062..91fcbb0531 100644
--- a/gdk/Makefile.am
+++ b/gdk/Makefile.am
@@ -11,7 +11,7 @@ INTROSPECTION_COMPILER_ARGS = \
 
 SUBDIRS = $(GDK_BACKENDS) . tests
 
-DIST_SUBDIRS = win32 x11 quartz tests
+DIST_SUBDIRS = win32 x11 quartz wayland tests
 
 CLEANFILES =
 
@@ -176,6 +176,10 @@ libgdk_3_0_la_DEPENDENCIES = win32/libgdk-win32.la win32/rc/gdk-win32-res.o gdk.
 libgdk_3_0_la_LDFLAGS += -Wl,win32/rc/gdk-win32-res.o -export-symbols $(srcdir)/gdk.def
 endif # USE_WIN32
 
+if USE_WAYLAND
+libgdk_3_0_la_LIBADD += wayland/libgdk-wayland.la
+endif
+
 if HAVE_INTROSPECTION
 
 introspection_files = 		\
diff --git a/gdk/gdkdisplaymanager.c b/gdk/gdkdisplaymanager.c
index 160404d75c..f5bbc9508b 100644
--- a/gdk/gdkdisplaymanager.c
+++ b/gdk/gdkdisplaymanager.c
@@ -48,6 +48,10 @@
 #include "win32/gdkwin32.h"
 #endif
 
+#ifdef GDK_WINDOWING_WAYLAND
+#include "wayland/gdkwayland.h"
+#endif
+
 /**
  * SECTION:gdkdisplaymanager
  * @Short_description: Maintains a list of all open GdkDisplays
@@ -203,6 +207,11 @@ gdk_display_manager_get (void)
         manager = g_object_new (gdk_win32_display_manager_get_type (), NULL);
       else
 #endif
+#ifdef GDK_WINDOWING_WAYLAND
+      if (backend == NULL || strcmp (backend, "wayland") == 0)
+        manager = g_object_new (gdk_wayland_display_manager_get_type (), NULL);
+      else
+#endif
       if (backend != NULL)
         g_error ("Unsupported GDK backend: %s", backend);
       else
diff --git a/gdk/wayland/Makefile.am b/gdk/wayland/Makefile.am
new file mode 100644
index 0000000000..0696483b52
--- /dev/null
+++ b/gdk/wayland/Makefile.am
@@ -0,0 +1,45 @@
+## Process this file with automake to produce Makefile.in
+include $(top_srcdir)/Makefile.decl
+
+libgdkincludedir = $(includedir)/gtk-3.0/gdk
+
+INCLUDES =					\
+	-DG_LOG_DOMAIN=\"Gdk\"			\
+	-DGDK_COMPILATION			\
+	-I$(top_srcdir)				\
+	-I$(top_srcdir)/gdk			\
+	-I$(top_builddir)/gdk			\
+	$(GTK_DEBUG_FLAGS)			\
+	$(GDK_DEP_CFLAGS)
+
+LDADDS = $(GDK_DEP_LIBS)
+
+noinst_LTLIBRARIES =				\
+	libgdk-wayland.la
+
+libgdk_wayland_la_SOURCES =			\
+	gdkapplaunchcontext-wayland.c		\
+	gdkcursor-wayland.c			\
+	gdkdevice-wayland.h			\
+	gdkdevice-wayland.c			\
+	gdkdevicemanager-wayland.h		\
+	gdkdevicemanager-wayland.c		\
+	gdkdisplay-wayland.c			\
+	gdkdisplay-wayland.h			\
+	gdkdisplaymanager-wayland.c		\
+	gdkdnd-wayland.c			\
+	gdkeventsource.c			\
+	gdkeventsource.h			\
+	gdkkeys-wayland.c			\
+	gdkscreen-wayland.c			\
+	gdkscreen-wayland.h			\
+	gdkselection-wayland.c			\
+	gdkwindow-wayland.c			\
+	gdkwindow-wayland.h			\
+	gdkwayland.h				\
+	gdkprivate-wayland.h
+
+libgdkinclude_HEADERS =				\
+	gdkwayland.h
+
+-include $(top_srcdir)/git.mk
diff --git a/gdk/wayland/gdkapplaunchcontext-wayland.c b/gdk/wayland/gdkapplaunchcontext-wayland.c
new file mode 100644
index 0000000000..1ff2549c79
--- /dev/null
+++ b/gdk/wayland/gdkapplaunchcontext-wayland.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <gio/gdesktopappinfo.h>
+
+#include "gdkwayland.h"
+#include "gdkprivate-wayland.h"
+#include "gdkapplaunchcontextprivate.h"
+#include "gdkscreen.h"
+#include "gdkinternals.h"
+#include "gdkintl.h"
+
+static char *
+gdk_wayland_app_launch_context_get_startup_notify_id (GAppLaunchContext *context,
+						      GAppInfo          *info, 
+						      GList             *files)
+{
+  return NULL;
+}
+
+static void
+gdk_wayland_app_launch_context_launch_failed (GAppLaunchContext *context, 
+					      const char        *startup_notify_id)
+{
+}
+
+typedef struct _GdkWaylandAppLaunchContext GdkWaylandAppLaunchContext;
+typedef struct _GdkWaylandAppLaunchContextClass GdkWaylandAppLaunchContextClass;
+
+struct _GdkWaylandAppLaunchContext
+{
+  GdkAppLaunchContext base;
+  gchar *name;
+  guint serial;
+};
+
+struct _GdkWaylandAppLaunchContextClass
+{
+  GdkAppLaunchContextClass base_class;
+};
+
+G_DEFINE_TYPE (GdkWaylandAppLaunchContext, gdk_wayland_app_launch_context, GDK_TYPE_APP_LAUNCH_CONTEXT)
+
+static void
+gdk_wayland_app_launch_context_class_init (GdkWaylandAppLaunchContextClass *klass)
+{
+  GAppLaunchContextClass *ctx_class = G_APP_LAUNCH_CONTEXT_CLASS (klass);
+
+  ctx_class->get_startup_notify_id = gdk_wayland_app_launch_context_get_startup_notify_id;
+  ctx_class->launch_failed = gdk_wayland_app_launch_context_launch_failed;
+}
+
+static void
+gdk_wayland_app_launch_context_init (GdkWaylandAppLaunchContext *ctx)
+{
+}
+
+GdkAppLaunchContext *
+_gdk_wayland_display_get_app_launch_context (GdkDisplay *display)
+{
+  GdkAppLaunchContext *ctx;
+
+  ctx = g_object_new (gdk_wayland_app_launch_context_get_type (),
+                      "display", display,
+                      NULL);
+
+  return ctx;
+}
diff --git a/gdk/wayland/gdkcursor-wayland.c b/gdk/wayland/gdkcursor-wayland.c
new file mode 100644
index 0000000000..468be5296b
--- /dev/null
+++ b/gdk/wayland/gdkcursor-wayland.c
@@ -0,0 +1,184 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "config.h"
+
+#define GDK_PIXBUF_ENABLE_BACKEND
+
+#include <string.h>
+
+#include "gdkprivate-wayland.h"
+#include "gdkcursorprivate.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkwayland.h"
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#define GDK_TYPE_WAYLAND_CURSOR              (_gdk_wayland_cursor_get_type ())
+#define GDK_WAYLAND_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_CURSOR, GdkWaylandCursor))
+#define GDK_WAYLAND_CURSOR_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_CURSOR, GdkWaylandCursorClass))
+#define GDK_IS_WAYLAND_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_CURSOR))
+#define GDK_IS_WAYLAND_CURSOR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_CURSOR))
+#define GDK_WAYLAND_CURSOR_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_CURSOR, GdkWaylandCursorClass))
+
+typedef struct _GdkWaylandCursor GdkWaylandCursor;
+typedef struct _GdkWaylandCursorClass GdkWaylandCursorClass;
+
+struct _GdkWaylandCursor
+{
+  GdkCursor cursor;
+  gchar *name;
+  guint serial;
+};
+
+struct _GdkWaylandCursorClass
+{
+  GdkCursorClass cursor_class;
+};
+
+G_DEFINE_TYPE (GdkWaylandCursor, _gdk_wayland_cursor, GDK_TYPE_CURSOR)
+
+static guint theme_serial = 0;
+
+static void
+gdk_wayland_cursor_finalize (GObject *object)
+{
+  GdkWaylandCursor *cursor = GDK_WAYLAND_CURSOR (object);
+
+  g_free (cursor->name);
+
+  G_OBJECT_CLASS (_gdk_wayland_cursor_parent_class)->finalize (object);
+}
+
+static GdkPixbuf*
+gdk_wayland_cursor_get_image (GdkCursor *cursor)
+{
+  return NULL;
+}
+
+static void
+_gdk_wayland_cursor_class_init (GdkWaylandCursorClass *wayland_cursor_class)
+{
+  GdkCursorClass *cursor_class = GDK_CURSOR_CLASS (wayland_cursor_class);
+  GObjectClass *object_class = G_OBJECT_CLASS (wayland_cursor_class);
+
+  object_class->finalize = gdk_wayland_cursor_finalize;
+
+  cursor_class->get_image = gdk_wayland_cursor_get_image;
+}
+
+static void
+_gdk_wayland_cursor_init (GdkWaylandCursor *cursor)
+{
+}
+
+GdkCursor*
+_gdk_wayland_display_get_cursor_for_type (GdkDisplay    *display,
+					  GdkCursorType  cursor_type)
+{
+  GdkWaylandCursor *private;
+
+  private = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
+                          "cursor-type", GDK_CURSOR_IS_PIXMAP,
+                          "display", display,
+                          NULL);
+  private->name = NULL;
+  private->serial = theme_serial;
+
+  return GDK_CURSOR (private);
+}
+
+GdkCursor*
+_gdk_wayland_display_get_cursor_for_name (GdkDisplay  *display,
+					  const gchar *name)
+{
+  GdkWaylandCursor *private;
+
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+  private = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
+                          "cursor-type", GDK_CURSOR_IS_PIXMAP,
+                          "display", display,
+                          NULL);
+  private->name = g_strdup (name);
+  private->serial = theme_serial;
+
+  return GDK_CURSOR (private);
+}
+
+GdkCursor *
+_gdk_wayland_display_get_cursor_for_pixbuf (GdkDisplay *display,
+					    GdkPixbuf  *pixbuf,
+					    gint        x,
+					    gint        y)
+{
+  GdkWaylandCursor *private;
+
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+  g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
+  g_return_val_if_fail (0 <= x && x < gdk_pixbuf_get_width (pixbuf), NULL);
+  g_return_val_if_fail (0 <= y && y < gdk_pixbuf_get_height (pixbuf), NULL);
+
+  private = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
+                          "cursor-type", GDK_CURSOR_IS_PIXMAP,
+                          "display", display,
+                          NULL);
+
+  private->name = NULL;
+  private->serial = theme_serial;
+
+  return GDK_CURSOR (private);
+}
+
+void
+_gdk_wayland_display_get_default_cursor_size (GdkDisplay *display,
+					      guint       *width,
+					      guint       *height)
+{
+  /* FIXME: wayland settings? */
+  *width = 64;
+  *height = 64;
+}
+
+void
+_gdk_wayland_display_get_maximal_cursor_size (GdkDisplay *display,
+					      guint       *width,
+					      guint       *height)
+{
+  *width = 256;
+  *height = 256;
+}
+
+gboolean
+_gdk_wayland_display_supports_cursor_alpha (GdkDisplay *display)
+{
+  return TRUE;
+}
+
+gboolean
+_gdk_wayland_display_supports_cursor_color (GdkDisplay *display)
+{
+  return TRUE;
+}
diff --git a/gdk/wayland/gdkdevice-wayland.c b/gdk/wayland/gdkdevice-wayland.c
new file mode 100644
index 0000000000..fcdc54bf74
--- /dev/null
+++ b/gdk/wayland/gdkdevice-wayland.c
@@ -0,0 +1,216 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <gdk/gdkwindow.h>
+#include "gdkdevice-wayland.h"
+#include "gdkprivate-wayland.h"
+#include "gdkwayland.h"
+
+static gboolean gdk_device_core_get_history (GdkDevice      *device,
+                                             GdkWindow      *window,
+                                             guint32         start,
+                                             guint32         stop,
+                                             GdkTimeCoord ***events,
+                                             gint           *n_events);
+static void gdk_device_core_get_state (GdkDevice       *device,
+                                       GdkWindow       *window,
+                                       gdouble         *axes,
+                                       GdkModifierType *mask);
+static void gdk_device_core_set_window_cursor (GdkDevice *device,
+                                               GdkWindow *window,
+                                               GdkCursor *cursor);
+static void gdk_device_core_warp (GdkDevice *device,
+                                  GdkScreen *screen,
+                                  gint       x,
+                                  gint       y);
+static gboolean gdk_device_core_query_state (GdkDevice        *device,
+                                             GdkWindow        *window,
+                                             GdkWindow       **root_window,
+                                             GdkWindow       **child_window,
+                                             gint             *root_x,
+                                             gint             *root_y,
+                                             gint             *win_x,
+                                             gint             *win_y,
+                                             GdkModifierType  *mask);
+static GdkGrabStatus gdk_device_core_grab   (GdkDevice     *device,
+                                             GdkWindow     *window,
+                                             gboolean       owner_events,
+                                             GdkEventMask   event_mask,
+                                             GdkWindow     *confine_to,
+                                             GdkCursor     *cursor,
+                                             guint32        time_);
+static void          gdk_device_core_ungrab (GdkDevice     *device,
+                                             guint32        time_);
+static GdkWindow * gdk_device_core_window_at_position (GdkDevice       *device,
+                                                       gint            *win_x,
+                                                       gint            *win_y,
+                                                       GdkModifierType *mask,
+                                                       gboolean         get_toplevel);
+static void      gdk_device_core_select_window_events (GdkDevice       *device,
+                                                       GdkWindow       *window,
+                                                       GdkEventMask     event_mask);
+
+
+G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
+
+static void
+gdk_device_core_class_init (GdkDeviceCoreClass *klass)
+{
+  GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
+
+  device_class->get_history = gdk_device_core_get_history;
+  device_class->get_state = gdk_device_core_get_state;
+  device_class->set_window_cursor = gdk_device_core_set_window_cursor;
+  device_class->warp = gdk_device_core_warp;
+  device_class->query_state = gdk_device_core_query_state;
+  device_class->grab = gdk_device_core_grab;
+  device_class->ungrab = gdk_device_core_ungrab;
+  device_class->window_at_position = gdk_device_core_window_at_position;
+  device_class->select_window_events = gdk_device_core_select_window_events;
+}
+
+static void
+gdk_device_core_init (GdkDeviceCore *device_core)
+{
+  GdkDevice *device;
+
+  device = GDK_DEVICE (device_core);
+
+  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
+  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+}
+
+static gboolean
+gdk_device_core_get_history (GdkDevice      *device,
+                             GdkWindow      *window,
+                             guint32         start,
+                             guint32         stop,
+                             GdkTimeCoord ***events,
+                             gint           *n_events)
+{
+  return FALSE;
+}
+
+static void
+gdk_device_core_get_state (GdkDevice       *device,
+                           GdkWindow       *window,
+                           gdouble         *axes,
+                           GdkModifierType *mask)
+{
+  gint x_int, y_int;
+
+  gdk_window_get_pointer (window, &x_int, &y_int, mask);
+
+  if (axes)
+    {
+      axes[0] = x_int;
+      axes[1] = y_int;
+    }
+}
+
+static void
+gdk_device_core_set_window_cursor (GdkDevice *device,
+                                   GdkWindow *window,
+                                   GdkCursor *cursor)
+{
+}
+
+static void
+gdk_device_core_warp (GdkDevice *device,
+                      GdkScreen *screen,
+                      gint       x,
+                      gint       y)
+{
+}
+
+static gboolean
+gdk_device_core_query_state (GdkDevice        *device,
+                             GdkWindow        *window,
+                             GdkWindow       **root_window,
+                             GdkWindow       **child_window,
+                             gint             *root_x,
+                             gint             *root_y,
+                             gint             *win_x,
+                             gint             *win_y,
+                             GdkModifierType  *mask)
+{
+  GdkWaylandDevice *wd;
+  GdkScreen *default_screen;
+
+  wd = GDK_DEVICE_CORE(device)->device;
+  default_screen = gdk_display_get_default_screen (wd->display);
+
+  if (root_window)
+    *root_window = gdk_screen_get_root_window (default_screen);
+  if (child_window)
+    *child_window = wd->pointer_focus;
+  if (root_x)
+    *root_x = wd->x;
+  if (root_y)
+    *root_y = wd->y;
+  if (win_x)
+    *win_x = wd->surface_x;
+  if (win_y)
+    *win_y = wd->surface_y;
+  if (mask)
+    *mask = wd->modifiers;
+
+  return TRUE;
+}
+
+static GdkGrabStatus
+gdk_device_core_grab (GdkDevice    *device,
+                      GdkWindow    *window,
+                      gboolean      owner_events,
+                      GdkEventMask  event_mask,
+                      GdkWindow    *confine_to,
+                      GdkCursor    *cursor,
+                      guint32       time_)
+{
+  return GDK_GRAB_SUCCESS;
+}
+
+static void
+gdk_device_core_ungrab (GdkDevice *device,
+                        guint32    time_)
+{
+}
+
+static GdkWindow *
+gdk_device_core_window_at_position (GdkDevice       *device,
+                                    gint            *win_x,
+                                    gint            *win_y,
+                                    GdkModifierType *mask,
+                                    gboolean         get_toplevel)
+{
+  GdkWaylandDevice *wd;
+
+  wd = GDK_DEVICE_CORE(device)->device;
+
+  return wd->pointer_focus;
+}
+
+static void
+gdk_device_core_select_window_events (GdkDevice    *device,
+                                      GdkWindow    *window,
+                                      GdkEventMask  event_mask)
+{
+}
diff --git a/gdk/wayland/gdkdevice-wayland.h b/gdk/wayland/gdkdevice-wayland.h
new file mode 100644
index 0000000000..88fac43a6e
--- /dev/null
+++ b/gdk/wayland/gdkdevice-wayland.h
@@ -0,0 +1,68 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GDK_DEVICE_CORE_H__
+#define __GDK_DEVICE_CORE_H__
+
+#include <gdk/gdkdeviceprivate.h>
+#include <X11/extensions/XKBcommon.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
+#define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
+#define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
+#define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
+#define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
+#define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
+
+typedef struct _GdkDeviceCore GdkDeviceCore;
+typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
+typedef struct _GdkWaylandDevice GdkWaylandDevice;
+
+struct _GdkWaylandDevice
+{
+  GdkDisplay *display;
+  GdkDevice *pointer;
+  GdkDevice *keyboard;
+  GdkModifierType modifiers;
+  GdkWindow *pointer_focus;
+  GdkWindow *keyboard_focus;
+  struct wl_input_device *device;
+  struct xkb_desc *xkb;
+  int32_t x, y, surface_x, surface_y;
+};
+
+struct _GdkDeviceCore
+{
+  GdkDevice parent_instance;
+  GdkWaylandDevice *device;
+};
+
+struct _GdkDeviceCoreClass
+{
+  GdkDeviceClass parent_class;
+};
+
+G_GNUC_INTERNAL
+GType gdk_device_core_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __GDK_DEVICE_CORE_H__ */
diff --git a/gdk/wayland/gdkdevicemanager-wayland.c b/gdk/wayland/gdkdevicemanager-wayland.c
new file mode 100644
index 0000000000..c432ec7ea8
--- /dev/null
+++ b/gdk/wayland/gdkdevicemanager-wayland.c
@@ -0,0 +1,443 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <gdk/gdktypes.h>
+#include <gdk/gdkdevicemanager.h>
+#include "gdkdevicemanager-wayland.h"
+#include "gdkdevice-wayland.h"
+#include "gdkkeysyms.h"
+#include "gdkprivate-wayland.h"
+#include "gdkeventsource.h"
+
+
+static void    gdk_device_manager_core_finalize    (GObject *object);
+
+static GList * gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                                     GdkDeviceType     type);
+static GdkDevice * gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager);
+
+G_DEFINE_TYPE (GdkDeviceManagerCore, gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
+
+static void
+gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
+{
+  GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = gdk_device_manager_core_finalize;
+  device_manager_class->list_devices = gdk_device_manager_core_list_devices;
+  device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
+}
+
+static void
+input_handle_motion(void *data, struct wl_input_device *input_device,
+		    uint32_t time,
+		    int32_t x, int32_t y, int32_t sx, int32_t sy)
+{
+  GdkWaylandDevice *device = data;
+  GdkEvent *event;
+
+  event = gdk_event_new (GDK_NOTHING);
+
+  device->x = x;
+  device->y = y;
+  device->surface_x = sx;
+  device->surface_y = sy;
+
+  event->motion.type = GDK_MOTION_NOTIFY;
+  event->motion.window = g_object_ref (device->pointer_focus);
+  gdk_event_set_device (event, device->pointer);
+  event->motion.time = time;
+  event->motion.x = (gdouble) sx;
+  event->motion.y = (gdouble) sy;
+  event->motion.x_root = (gdouble) x;
+  event->motion.y_root = (gdouble) y;
+  event->motion.axes = NULL;
+  event->motion.state = device->modifiers;
+  event->motion.is_hint = 0;
+
+  _gdk_wayland_display_deliver_event (device->display, event);
+}
+
+static void
+input_handle_button(void *data, struct wl_input_device *input_device,
+		     uint32_t time, uint32_t button, uint32_t state)
+{
+  GdkWaylandDevice *device = data;
+  GdkEvent *event;
+  uint32_t modifier;
+
+  fprintf (stderr, "button event %d, state %d\n", button, state);
+
+  event = gdk_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
+  event->button.window = g_object_ref (device->pointer_focus);
+  gdk_event_set_device (event, device->pointer);
+  event->button.time = time;
+  event->button.x = (gdouble) device->surface_x;
+  event->button.y = (gdouble) device->surface_y;
+  event->button.x_root = (gdouble) device->x;
+  event->button.y_root = (gdouble) device->y;
+  event->button.axes = NULL;
+  event->button.state = device->modifiers;
+  event->button.button = button - 271;
+
+  modifier = 1 << (8 + button - 272);
+  if (state)
+    device->modifiers |= modifier;
+  else
+    device->modifiers &= ~modifier;
+
+  _gdk_wayland_display_deliver_event (device->display, event);
+}
+
+static void
+input_handle_key(void *data, struct wl_input_device *input_device,
+		 uint32_t time, uint32_t key, uint32_t state)
+{
+  GdkWaylandDevice *device = data;
+  GdkEvent *event;
+  uint32_t code, modifier, level;
+
+  event = gdk_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
+  event->key.window = g_object_ref (device->keyboard_focus);
+  gdk_event_set_device (event, device->keyboard);
+  event->button.time = time;
+  event->key.state = device->modifiers;
+  event->key.group = 0;
+  event->key.hardware_keycode = key;
+
+  code = key + device->xkb->min_key_code;
+
+  level = 0;
+  if (device->modifiers & ShiftMask &&
+      XkbKeyGroupWidth(device->xkb, code, 0) > 1)
+    level = 1;
+
+  event->key.keyval = XkbKeySymEntry(device->xkb, code, level, 0);
+
+  modifier = device->xkb->map->modmap[code];
+  if (state)
+    device->modifiers |= modifier;
+  else
+    device->modifiers &= ~modifier;
+
+  event->key.is_modifier = modifier > 0;
+
+  if (event->key.keyval == GDK_KEY_Escape)
+    {
+      event->key.length = 1;
+      event->key.string = g_strdup ("\033");
+    }
+  else if (event->key.keyval == GDK_KEY_Return ||
+	   event->key.keyval == GDK_KEY_KP_Enter)
+    {
+      event->key.length = 1;
+      event->key.string = g_strdup ("\r");
+    }
+  else if (event->key.state & GDK_CONTROL_MASK)
+    {
+      gsize bytes_written;
+      gint len;
+      gchar buf[7];
+      int c = event->key.keyval;
+
+      /* Apply the control key - Taken from Xlib */
+      if ((c >= XK_at && c < '\177') || c == ' ')
+	c &= 0x1F;
+      else if (c == XK_2)
+	{
+	  event->key.string = g_memdup ("\0\0", 2);
+	  event->key.length = 1;
+	  buf[0] = '\0';
+	  goto out;
+	}
+      else if (c >= XK_3 && c <= XK_7)
+	c -= (XK_3 - '\033');
+      else if (c == XK_8)
+	c = '\177';
+      else if (c == XK_slash)
+	c = '_' & 0x1F;
+
+      len = g_unichar_to_utf8 (c, buf);
+      buf[len] = '\0';
+
+      event->key.string = g_locale_from_utf8 (buf, len,
+					      NULL, &bytes_written,
+					      NULL);
+      if (event->key.string)
+	event->key.length = bytes_written;
+    }
+  else
+    {
+      char buffer[128];
+      xkb_keysym_to_string(event->key.keyval, buffer, sizeof buffer);
+      event->key.string = g_strdup (buffer);
+      event->key.length = strlen(event->key.string);
+    }
+
+ out:
+  _gdk_wayland_display_deliver_event (device->display, event);
+
+  fprintf (stderr, "keyboard event, code %d, sym %d, string %s, mods 0x%x\n",
+	   code, event->key.keyval, event->key.string, event->key.state);
+}
+
+static void
+input_handle_pointer_focus(void *data,
+			   struct wl_input_device *input_device,
+			   uint32_t time, struct wl_surface *surface,
+			   int32_t x, int32_t y, int32_t sx, int32_t sy)
+{
+  GdkWaylandDevice *device = data;
+  GdkEvent *event;
+
+  if (device->pointer_focus)
+    {
+      event = gdk_event_new (GDK_LEAVE_NOTIFY);
+      event->crossing.window = g_object_ref (device->pointer_focus);
+      gdk_event_set_device (event, device->pointer);
+      event->crossing.subwindow = NULL;
+      event->crossing.time = time;
+      event->crossing.x = (gdouble) device->surface_x;
+      event->crossing.y = (gdouble) device->surface_y;
+      event->crossing.x_root = (gdouble) device->x;
+      event->crossing.y_root = (gdouble) device->y;
+
+      event->crossing.mode = GDK_CROSSING_NORMAL;
+      event->crossing.detail = GDK_NOTIFY_ANCESTOR;
+      event->crossing.focus = TRUE;
+      event->crossing.state = 0;
+
+      _gdk_wayland_display_deliver_event (device->display, event);
+
+      g_object_unref(device->pointer_focus);
+      device->pointer_focus = NULL;
+    }
+
+  if (surface)
+    {
+      device->pointer_focus = wl_surface_get_user_data(surface);
+      g_object_ref(device->pointer_focus);
+
+      event = gdk_event_new (GDK_ENTER_NOTIFY);
+      event->crossing.window = g_object_ref (device->pointer_focus);
+      gdk_event_set_device (event, device->pointer);
+      event->crossing.subwindow = NULL;
+      event->crossing.time = time;
+      event->crossing.x = (gdouble) sx;
+      event->crossing.y = (gdouble) sy;
+      event->crossing.x_root = (gdouble) x;
+      event->crossing.y_root = (gdouble) y;
+
+      event->crossing.mode = GDK_CROSSING_NORMAL;
+      event->crossing.detail = GDK_NOTIFY_ANCESTOR;
+      event->crossing.focus = TRUE;
+      event->crossing.state = 0;
+
+      device->surface_x = sx;
+      device->surface_y = sy;
+      device->x = x;
+      device->y = y;
+
+      _gdk_wayland_display_deliver_event (device->display, event);
+    }
+
+  fprintf (stderr, "pointer focus surface %p, window %p\n",
+	   surface, device->pointer_focus);
+}
+
+static void
+update_modifiers(GdkWaylandDevice *device, struct wl_array *keys)
+{
+  uint32_t *k, *end;
+
+  end = keys->data + keys->size;
+  for (k = keys->data; k < end; k++)
+    device->modifiers |= device->xkb->map->modmap[*k];
+
+  fprintf (stderr, "modifiers: 0x%x\n", device->modifiers);
+}
+
+static void
+input_handle_keyboard_focus(void *data,
+			    struct wl_input_device *input_device,
+			    uint32_t time,
+			    struct wl_surface *surface,
+			    struct wl_array *keys)
+{
+  GdkWaylandDevice *device = data;
+  GdkEvent *event;
+
+  fprintf (stderr, "keyboard focus surface %p\n", surface);
+
+  if (device->keyboard_focus)
+    {
+      event = gdk_event_new (GDK_FOCUS_CHANGE);
+      event->focus_change.window = g_object_ref (device->keyboard_focus);
+      event->focus_change.send_event = FALSE;
+      event->focus_change.in = FALSE;
+      gdk_event_set_device (event, device->keyboard);
+
+      g_object_unref(device->pointer_focus);
+      device->keyboard_focus = NULL;
+
+      _gdk_wayland_display_deliver_event (device->display, event);
+    }
+
+  if (surface)
+    {
+      device->keyboard_focus = wl_surface_get_user_data(surface);
+      g_object_ref(device->keyboard_focus);
+
+      event = gdk_event_new (GDK_FOCUS_CHANGE);
+      event->focus_change.window = g_object_ref (device->keyboard_focus);
+      event->focus_change.send_event = FALSE;
+      event->focus_change.in = TRUE;
+      gdk_event_set_device (event, device->keyboard);
+
+      update_modifiers (device, keys);
+
+      _gdk_wayland_display_deliver_event (device->display, event);
+    }
+}
+
+static const struct wl_input_device_listener input_device_listener = {
+	input_handle_motion,
+	input_handle_button,
+	input_handle_key,
+	input_handle_pointer_focus,
+	input_handle_keyboard_focus,
+};
+
+void
+gdk_device_manager_core_add_device (GdkDeviceManager *device_manager,
+				    struct wl_input_device *wl_device)
+{
+  GdkDisplay *display;
+  GdkDeviceManagerCore *device_manager_core =
+    GDK_DEVICE_MANAGER_CORE(device_manager);
+  struct xkb_rule_names names;
+  GdkWaylandDevice *device;
+
+  device = g_new0 (GdkWaylandDevice, 1);
+  display = gdk_device_manager_get_display (device_manager);
+
+  device->display = display;
+  device->pointer = g_object_new (GDK_TYPE_DEVICE_CORE,
+				  "name", "Core Pointer",
+				  "type", GDK_DEVICE_TYPE_MASTER,
+				  "input-source", GDK_SOURCE_MOUSE,
+				  "input-mode", GDK_MODE_SCREEN,
+				  "has-cursor", TRUE,
+				  "display", display,
+				  "device-manager", device_manager,
+				  NULL);
+
+  device->keyboard = g_object_new (GDK_TYPE_DEVICE_CORE,
+				   "name", "Core Keyboard",
+				   "type", GDK_DEVICE_TYPE_MASTER,
+				   "input-source", GDK_SOURCE_KEYBOARD,
+				   "input-mode", GDK_MODE_SCREEN,
+				   "has-cursor", FALSE,
+				   "display", display,
+				   "device-manager", device_manager,
+				   NULL);
+
+  GDK_DEVICE_CORE (device->pointer)->device = device;
+  GDK_DEVICE_CORE (device->keyboard)->device = device;
+  device->device = wl_device;
+
+  names.rules = "evdev";
+  names.model = "pc105";
+  names.layout = "us";
+  names.variant = "";
+  names.options = "";
+  device->xkb = xkb_compile_keymap_from_rules(&names);
+
+  wl_input_device_add_listener(device->device,
+			       &input_device_listener, device);
+
+  device_manager_core->devices =
+    g_list_prepend (device_manager_core->devices, device->keyboard);
+  device_manager_core->devices =
+    g_list_prepend (device_manager_core->devices, device->pointer);
+
+  _gdk_device_set_associated_device (device->pointer, device->keyboard);
+  _gdk_device_set_associated_device (device->keyboard, device->pointer);
+}
+
+static void
+gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
+{
+}
+
+static void
+free_device (void *data, void *user_data)
+{
+  g_object_unref (data);
+}
+
+static void
+gdk_device_manager_core_finalize (GObject *object)
+{
+  GdkDeviceManagerCore *device_manager_core;
+
+  device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
+
+  g_list_foreach (device_manager_core->devices, free_device, NULL);
+  g_list_free (device_manager_core->devices);
+
+  G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
+}
+
+static GList *
+gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                      GdkDeviceType     type)
+{
+  GdkDeviceManagerCore *device_manager_core;
+  GList *devices = NULL;
+
+  if (type == GDK_DEVICE_TYPE_MASTER)
+    {
+      device_manager_core = (GdkDeviceManagerCore *) device_manager;
+      devices = g_list_copy(device_manager_core->devices);
+    }
+
+  return devices;
+}
+
+static GdkDevice *
+gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
+{
+  GdkDeviceManagerCore *device_manager_core;
+
+  device_manager_core = (GdkDeviceManagerCore *) device_manager;
+  return device_manager_core->devices->data;
+}
+
+GdkDeviceManager *
+_gdk_device_manager_new (GdkDisplay *display)
+{
+  return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
+                       "display", display,
+                       NULL);
+}
diff --git a/gdk/wayland/gdkdevicemanager-wayland.h b/gdk/wayland/gdkdevicemanager-wayland.h
new file mode 100644
index 0000000000..83c76e9983
--- /dev/null
+++ b/gdk/wayland/gdkdevicemanager-wayland.h
@@ -0,0 +1,59 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GDK_DEVICE_MANAGER_CORE_H__
+#define __GDK_DEVICE_MANAGER_CORE_H__
+
+#include <gdk/gdkdevicemanagerprivate.h>
+#include <wayland-client.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
+#define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
+#define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
+#define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
+#define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
+#define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
+
+typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
+typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
+
+struct _GdkDeviceManagerCore
+{
+  GdkDeviceManager parent_object;
+  GdkDevice *core_pointer;
+  GdkDevice *core_keyboard;
+  GList *devices;
+};
+
+struct _GdkDeviceManagerCoreClass
+{
+  GdkDeviceManagerClass parent_class;
+};
+
+GType gdk_device_manager_core_get_type (void) G_GNUC_CONST;
+
+void
+gdk_device_manager_core_add_device (GdkDeviceManager *device_manager,
+				    struct wl_input_device *device);
+
+G_END_DECLS
+
+#endif /* __GDK_DEVICE_MANAGER_CORE_H__ */
diff --git a/gdk/wayland/gdkdisplay-wayland.c b/gdk/wayland/gdkdisplay-wayland.c
new file mode 100644
index 0000000000..378fbea135
--- /dev/null
+++ b/gdk/wayland/gdkdisplay-wayland.c
@@ -0,0 +1,795 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#define EGL_EGLEXT_PROTOTYPES 1
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <glib.h>
+#include "gdkwayland.h"
+#include "gdkdisplay.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkeventsource.h"
+#include "gdkscreen.h"
+#include "gdkscreen-wayland.h"
+#include "gdkinternals.h"
+#include "gdkdeviceprivate.h"
+#include "gdkdevicemanager.h"
+#include "gdkdevicemanager-wayland.h"
+#include "gdkkeysprivate.h"
+
+#include <xf86drm.h>
+
+typedef struct _GdkEventTypeWayland GdkEventTypeWayland;
+
+struct _GdkEventTypeWayland
+{
+  gint base;
+  gint n_events;
+};
+
+G_DEFINE_TYPE (GdkDisplayWayland, _gdk_display_wayland, GDK_TYPE_DISPLAY)
+
+/* GDK_VISIBILITY,
+ * GDK_MAP,
+ * GDK_UNMAP,
+ * GDK_PROPERTY_NOTIFY
+ * GDK_SELECTION_CLEAR
+ * GDK_SELECTION_ REQUEST
+ * GDK_SELECTION_NOTIFY
+ * GDK_CLIENT_EVENT,
+ *
+ * new keyboard mapping: _gdk_keymap_keys_changed (display);
+ *
+ * Selection owner change: GDK_OWNER_CHANGE;
+ *
+ * Screen size changes: _gdk_wayland_screen_size_changed (screen, xevent);
+ *
+ * XkbStateNotify: _gdk_keymap_state_changed (display, xevent);
+ */
+
+static void
+gdk_input_init (GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland;
+  GdkDeviceManager *device_manager;
+  GdkDevice *device;
+  GList *list, *l;
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+  device_manager = gdk_display_get_device_manager (display);
+
+  /* For backwards compatibility, just add
+   * floating devices that are not keyboards.
+   */
+  list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
+
+  for (l = list; l; l = l->next)
+    {
+      device = l->data;
+
+      if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
+	continue;
+
+      display_wayland->input_devices = g_list_prepend (display_wayland->input_devices, l->data);
+    }
+
+  g_list_free (list);
+
+  /* Now set "core" pointer to the first
+   * master device that is a pointer.
+   */
+  list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+
+  for (l = list; l; l = l->next)
+    {
+      device = list->data;
+
+      if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
+	continue;
+
+      display->core_pointer = device;
+      break;
+    }
+
+  /* Add the core pointer to the devices list */
+  display_wayland->input_devices = g_list_prepend (display_wayland->input_devices, display->core_pointer);
+
+  g_list_free (list);
+}
+
+static void
+drm_handle_device(void *data, struct wl_drm *compositor, const char *device)
+{
+  GdkDisplayWayland *display_wayland = data;
+
+  fprintf(stderr, "display name: %s\n", device);
+
+  display_wayland->device_name = g_strdup (device);
+}
+
+static void drm_handle_authenticated(void *data, struct wl_drm *drm)
+{
+  GdkDisplayWayland *display_wayland = data;
+
+  display_wayland->authenticated = TRUE;
+}
+
+static const struct wl_drm_listener drm_listener = {
+	drm_handle_device,
+	drm_handle_authenticated
+};
+
+static void
+shell_handle_configure(void *data, struct wl_shell *shell,
+		       uint32_t time, uint32_t edges,
+		       struct wl_surface *surface,
+		       int32_t width, int32_t height)
+{
+  GdkWindow *window;
+  GdkDisplay *display;
+  GdkEvent *event;
+
+  window = wl_surface_get_user_data(surface);
+
+  printf("got configure: window %p, %dx%d, edges %d\n",
+	 window, width, height, edges);
+
+  display = gdk_window_get_display (window);
+
+  event = gdk_event_new (GDK_CONFIGURE);
+  event->configure.window = window;
+  event->configure.send_event = FALSE;
+  event->configure.width = width;
+  event->configure.height = height;
+
+  window->width = width;
+  window->height = height;
+
+  _gdk_window_update_size (window);
+  _gdk_wayland_window_update_size (GDK_WINDOW_IMPL_WAYLAND (window->impl));
+
+  g_object_ref(window);
+
+  _gdk_wayland_display_deliver_event (display, event);
+}
+
+static const struct wl_shell_listener shell_listener = {
+  shell_handle_configure,
+};
+
+static void
+output_handle_geometry(void *data,
+		       struct wl_output *output,
+		       int32_t x, int32_t y, int32_t width, int32_t height)
+{
+  /*
+    g_signal_emit_by_name (screen, "monitors-changed");
+    g_signal_emit_by_name (screen, "size-changed");
+  */
+}
+
+static const struct wl_output_listener output_listener = {
+	output_handle_geometry,
+};
+
+static void
+gdk_display_handle_global(struct wl_display *display, uint32_t id,
+			  const char *interface, uint32_t version, void *data)
+{
+  GdkDisplayWayland *display_wayland = data;
+  GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (data);
+  struct wl_input_device *input;
+
+  if (strcmp(interface, "compositor") == 0) {
+    display_wayland->compositor = wl_compositor_create(display, id);
+  } else if (strcmp(interface, "drm") == 0) {
+    display_wayland->drm = wl_drm_create(display, id);
+    wl_drm_add_listener(display_wayland->drm,
+			&drm_listener, display_wayland);
+  } else if (strcmp(interface, "shell") == 0) {
+    display_wayland->shell = wl_shell_create(display, id);
+    wl_shell_add_listener(display_wayland->shell,
+			  &shell_listener, display_wayland);
+  } else if (strcmp(interface, "output") == 0) {
+    display_wayland->output = wl_output_create(display, id);
+    wl_output_add_listener(display_wayland->output,
+			   &output_listener, display_wayland);
+  } else if (strcmp(interface, "input_device") == 0) {
+    input = wl_input_device_create(display, id);
+    gdk_device_manager_core_add_device (gdk_display->device_manager, input);
+  }
+}
+
+static gboolean
+gdk_display_init_egl(GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland = GDK_DISPLAY_WAYLAND (display);
+  EGLint major, minor, i;
+  drm_magic_t magic;
+  void *p;
+
+  static const struct { const char *f; unsigned int offset; }
+  extension_functions[] = {
+    { "eglCreateDRMImageMESA", offsetof(GdkDisplayWayland, create_drm_image) },
+    { "glEGLImageTargetTexture2DOES", offsetof(GdkDisplayWayland, image_target_texture_2d) },
+    { "eglExportDRMImageMESA", offsetof(GdkDisplayWayland, export_drm_image) },
+    { "eglDestroyImageKHR", offsetof(GdkDisplayWayland, destroy_image) }
+  };
+
+  display_wayland->fd = open(display_wayland->device_name, O_RDWR);
+  if (display_wayland->fd < 0) {
+    fprintf(stderr, "drm open failed: %m\n");
+    return FALSE;
+  }
+
+  if (drmGetMagic(display_wayland->fd, &magic))
+    {
+      fprintf(stderr, "DRI2: failed to get drm magic");
+      return FALSE;
+    }
+
+  /* Authenticate and wait for authenticated event */
+  wl_drm_authenticate(display_wayland->drm, magic);
+  wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_WRITABLE);
+  while (!display_wayland->authenticated)
+    wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_READABLE);
+
+  display_wayland->egl_display = eglGetDRMDisplayMESA(display_wayland->fd);
+  if (!eglInitialize(display_wayland->egl_display, &major, &minor)) {
+    fprintf(stderr, "failed to initialize display\n");
+    return FALSE;
+  }
+
+  eglBindAPI(EGL_OPENGL_API);
+
+  display_wayland->egl_context =
+    eglCreateContext(display_wayland->egl_display, NULL, EGL_NO_CONTEXT, NULL);
+  if (display_wayland->egl_context == NULL) {
+    fprintf(stderr, "failed to create context\n");
+    return FALSE;
+  }
+
+  if (!eglMakeCurrent(display_wayland->egl_display,
+		      NULL, NULL, display_wayland->egl_context)) {
+    fprintf(stderr, "faile to make context current\n");
+    return FALSE;
+  }
+
+  display_wayland->cairo_device =
+    cairo_egl_device_create(display_wayland->egl_display,
+			    display_wayland->egl_context);
+  if (cairo_device_status (display_wayland->cairo_device) != CAIRO_STATUS_SUCCESS) {
+    fprintf(stderr, "failed to get cairo drm device\n");
+    return FALSE;
+  }
+
+  for (i = 0; i < G_N_ELEMENTS(extension_functions); i++) {
+    p = eglGetProcAddress(extension_functions[i].f);
+    *(void **) ((char *) display_wayland + extension_functions[i].offset) = p;
+    if (p == NULL) {
+      fprintf(stderr, "failed to look up %s\n", extension_functions[i].f);
+      return FALSE;
+    }
+  }
+
+  fprintf(stderr, "egl initialized\n");
+
+  return TRUE;
+}
+
+GdkDisplay *
+_gdk_wayland_display_open (const gchar *display_name)
+{
+  struct wl_display *wl_display;
+  GdkDisplay *display;
+  GdkDisplayWayland *display_wayland;
+  GdkWindowAttr attr;
+
+  gint i;
+
+  wl_display = wl_display_connect(display_name);
+  if (!wl_display)
+    return NULL;
+
+  display = g_object_new (GDK_TYPE_DISPLAY_WAYLAND, NULL);
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  display_wayland->wl_display = wl_display;
+
+  /* initialize the display's screens */
+  display_wayland->screens = g_new (GdkScreen *, 1);
+  for (i = 0; i < 1; i++)
+    display_wayland->screens[i] = _gdk_wayland_screen_new (display);
+
+  /*set the default screen */
+  display_wayland->default_screen = display_wayland->screens[0];
+
+  display->device_manager = _gdk_device_manager_new (display);
+
+  /* Set up listener so we'll catch all events. */
+  wl_display_add_global_listener(display_wayland->wl_display,
+				 gdk_display_handle_global, display_wayland);
+
+  /* Process connection events. */
+  wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_READABLE);
+
+  gdk_display_init_egl(display);
+
+  display_wayland->event_source = _gdk_wayland_display_event_source_new (display);
+
+  attr.window_type = GDK_WINDOW_TOPLEVEL;
+  attr.wclass = GDK_INPUT_OUTPUT;
+  attr.x = 10;
+  attr.y = 10;
+  attr.width = 10;
+  attr.height = 10;
+  attr.event_mask = 0;
+
+  gdk_input_init (display);
+
+  g_signal_emit_by_name (display, "opened");
+  g_signal_emit_by_name (gdk_display_manager_get(),
+			 "display_opened", display);
+
+  return display;
+}
+
+static void
+gdk_wayland_display_dispose (GObject *object)
+{
+  GdkDisplayWayland *display_wayland = GDK_DISPLAY_WAYLAND (object);
+  gint           i;
+
+  _gdk_wayland_display_manager_remove_display (gdk_display_manager_get (),
+					       GDK_DISPLAY (display_wayland));
+  g_list_foreach (display_wayland->input_devices,
+		  (GFunc) g_object_run_dispose, NULL);
+
+  for (i = 0; i < 1; i++)
+    _gdk_screen_close (display_wayland->screens[i]);
+
+  if (display_wayland->event_source)
+    {
+      g_source_destroy (display_wayland->event_source);
+      g_source_unref (display_wayland->event_source);
+      display_wayland->event_source = NULL;
+    }
+
+  G_OBJECT_CLASS (_gdk_display_wayland_parent_class)->dispose (object);
+}
+
+static void
+gdk_wayland_display_finalize (GObject *object)
+{
+  GdkDisplayWayland *display_wayland = GDK_DISPLAY_WAYLAND (object);
+  gint           i;
+
+  /* Keymap */
+  if (display_wayland->keymap)
+    g_object_unref (display_wayland->keymap);
+
+  /* Atom Hashtable */
+  g_hash_table_destroy (display_wayland->atom_from_virtual);
+  g_hash_table_destroy (display_wayland->atom_to_virtual);
+
+  /* list of filters for client messages */
+  g_list_foreach (display_wayland->client_filters, (GFunc) g_free, NULL);
+  g_list_free (display_wayland->client_filters);
+
+  /* List of event window extraction functions */
+  g_slist_foreach (display_wayland->event_types, (GFunc)g_free, NULL);
+  g_slist_free (display_wayland->event_types);
+
+  /* input GdkDevice list */
+  g_list_foreach (display_wayland->input_devices, (GFunc) g_object_unref, NULL);
+  g_list_free (display_wayland->input_devices);
+
+  /* input GdkWindow list */
+  g_list_foreach (display_wayland->input_windows, (GFunc) g_free, NULL);
+  g_list_free (display_wayland->input_windows);
+
+  /* Free all GdkScreens */
+  for (i = 0; i < 1; i++)
+    g_object_unref (display_wayland->screens[i]);
+  g_free (display_wayland->screens);
+
+  g_free (display_wayland->startup_notification_id);
+
+  /* X ID hashtable */
+  g_hash_table_destroy (display_wayland->xid_ht);
+
+  G_OBJECT_CLASS (_gdk_display_wayland_parent_class)->finalize (object);
+}
+
+static G_CONST_RETURN gchar *
+gdk_wayland_display_get_name (GdkDisplay *display)
+{
+  return "Wayland";
+}
+
+static gint
+gdk_wayland_display_get_n_screens (GdkDisplay *display)
+{
+  return 1;
+}
+
+static GdkScreen *
+gdk_wayland_display_get_screen (GdkDisplay *display, 
+				gint        screen_num)
+{
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+  g_return_val_if_fail (screen_num == 0, NULL);
+
+  return GDK_DISPLAY_WAYLAND (display)->screens[0];
+}
+
+static GdkScreen *
+gdk_wayland_display_get_default_screen (GdkDisplay *display)
+{
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+  return GDK_DISPLAY_WAYLAND (display)->default_screen;
+}
+
+static void
+gdk_wayland_display_beep (GdkDisplay *display)
+{
+  g_return_if_fail (GDK_IS_DISPLAY (display));
+}
+
+static void
+sync_callback(void *data)
+{
+  gboolean *done = data;
+
+  *done = TRUE;
+}
+
+static void
+gdk_wayland_display_sync (GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland;
+  gboolean done;
+
+  g_return_if_fail (GDK_IS_DISPLAY (display));
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  wl_display_sync_callback(display_wayland->wl_display, sync_callback, &done);
+  wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_WRITABLE);
+  while (!done)
+    wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_READABLE);
+}
+
+static void
+gdk_wayland_display_flush (GdkDisplay *display)
+{
+  g_return_if_fail (GDK_IS_DISPLAY (display));
+
+  if (!display->closed)
+    wl_display_iterate(GDK_DISPLAY_WAYLAND (display)->wl_display,
+		       WL_DISPLAY_WRITABLE);
+}
+
+static gboolean
+gdk_wayland_display_has_pending (GdkDisplay *display)
+{
+  return FALSE;
+}
+
+static GdkWindow *
+gdk_wayland_display_get_default_group (GdkDisplay *display)
+{
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+  return NULL;
+}
+
+
+static gboolean
+gdk_wayland_display_supports_selection_notification (GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  return display_wayland->have_xfixes;
+}
+
+static gboolean
+gdk_wayland_display_request_selection_notification (GdkDisplay *display,
+						    GdkAtom     selection)
+
+{
+    return FALSE;
+}
+
+static gboolean
+gdk_wayland_display_supports_clipboard_persistence (GdkDisplay *display)
+{
+  return FALSE;
+}
+
+static void
+gdk_wayland_display_store_clipboard (GdkDisplay    *display,
+				     GdkWindow     *clipboard_window,
+				     guint32        time_,
+				     const GdkAtom *targets,
+				     gint           n_targets)
+{
+}
+
+static gboolean
+gdk_wayland_display_supports_shapes (GdkDisplay *display)
+{
+  return GDK_DISPLAY_WAYLAND (display)->have_shapes;
+}
+
+static gboolean
+gdk_wayland_display_supports_input_shapes (GdkDisplay *display)
+{
+  return GDK_DISPLAY_WAYLAND (display)->have_input_shapes;
+}
+
+static gboolean
+gdk_wayland_display_supports_composite (GdkDisplay *display)
+{
+  return TRUE;
+}
+
+static GList *
+gdk_wayland_display_list_devices (GdkDisplay *display)
+{
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+  return GDK_DISPLAY_WAYLAND (display)->input_devices;
+}
+
+static gboolean
+gdk_wayland_display_send_client_message (GdkDisplay     *display,
+					 GdkEvent       *event,
+					 GdkNativeWindow winid)
+{
+  return 0;
+}
+
+static void
+gdk_wayland_display_add_client_message_filter (GdkDisplay   *display,
+					       GdkAtom       message_type,
+					       GdkFilterFunc func,
+					       gpointer      data)
+{
+  GdkClientFilter *filter;
+  g_return_if_fail (GDK_IS_DISPLAY (display));
+  filter = g_new (GdkClientFilter, 1);
+
+  filter->type = message_type;
+  filter->function = func;
+  filter->data = data;
+
+  GDK_DISPLAY_WAYLAND(display)->client_filters =
+    g_list_append (GDK_DISPLAY_WAYLAND (display)->client_filters,
+		   filter);
+}
+
+static void
+gdk_wayland_display_before_process_all_updates (GdkDisplay *display)
+{
+}
+
+static void
+gdk_wayland_display_after_process_all_updates (GdkDisplay *display)
+{
+  /* Post the damage here instead? */
+}
+
+static gulong
+gdk_wayland_display_get_next_serial (GdkDisplay *display)
+{
+  return 0;
+}
+
+void
+_gdk_wayland_display_make_default (GdkDisplay *display)
+{
+}
+
+/**
+ * gdk_wayland_display_broadcast_startup_message:
+ * @display: a #GdkDisplay
+ * @message_type: startup notification message type ("new", "change",
+ * or "remove")
+ * @...: a list of key/value pairs (as strings), terminated by a
+ * %NULL key. (A %NULL value for a key will cause that key to be
+ * skipped in the output.)
+ *
+ * Sends a startup notification message of type @message_type to
+ * @display. 
+ *
+ * This is a convenience function for use by code that implements the
+ * freedesktop startup notification specification. Applications should
+ * not normally need to call it directly. See the <ulink
+ * url="http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt">Startup
+ * Notification Protocol specification</ulink> for
+ * definitions of the message types and keys that can be used.
+ *
+ * Since: 2.12
+ **/
+void
+gdk_wayland_display_broadcast_startup_message (GdkDisplay *display,
+					       const char *message_type,
+					       ...)
+{
+  GString *message;
+  va_list ap;
+  const char *key, *value, *p;
+
+  message = g_string_new (message_type);
+  g_string_append_c (message, ':');
+
+  va_start (ap, message_type);
+  while ((key = va_arg (ap, const char *)))
+    {
+      value = va_arg (ap, const char *);
+      if (!value)
+	continue;
+
+      g_string_append_printf (message, " %s=\"", key);
+      for (p = value; *p; p++)
+	{
+	  switch (*p)
+	    {
+	    case ' ':
+	    case '"':
+	    case '\\':
+	      g_string_append_c (message, '\\');
+	      break;
+	    }
+
+	  g_string_append_c (message, *p);
+	}
+      g_string_append_c (message, '\"');
+    }
+  va_end (ap);
+
+  printf ("startup message: %s\n", message->str);
+
+  g_string_free (message, TRUE);
+}
+
+static void
+gdk_wayland_display_notify_startup_complete (GdkDisplay  *display,
+					     const gchar *startup_id)
+{
+  gdk_wayland_display_broadcast_startup_message (display, "remove",
+						 "ID", startup_id,
+						 NULL);
+}
+
+static void
+gdk_wayland_display_event_data_copy (GdkDisplay     *display,
+				     const GdkEvent *src,
+				     GdkEvent       *dst)
+{
+}
+
+static void
+gdk_wayland_display_event_data_free (GdkDisplay *display,
+				     GdkEvent   *event)
+{
+}
+
+static GdkKeymap *
+gdk_wayland_display_get_keymap (GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland;
+
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  if (!display_wayland->keymap)
+    display_wayland->keymap =
+      g_object_new (_gdk_wayland_keymap_get_type(), NULL);
+
+  display_wayland->keymap->display = display;
+
+  return display_wayland->keymap;
+}
+
+static void
+gdk_wayland_display_push_error_trap (GdkDisplay *display)
+{
+}
+
+static gint
+gdk_wayland_display_pop_error_trap (GdkDisplay *display,
+				    gboolean    ignored)
+{
+  return 0;
+}
+
+static void
+_gdk_display_wayland_class_init (GdkDisplayWaylandClass * class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (class);
+
+  object_class->dispose = gdk_wayland_display_dispose;
+  object_class->finalize = gdk_wayland_display_finalize;
+
+  display_class->window_type = _gdk_wayland_window_get_type ();
+  display_class->get_name = gdk_wayland_display_get_name;
+  display_class->get_n_screens = gdk_wayland_display_get_n_screens;
+  display_class->get_screen = gdk_wayland_display_get_screen;
+  display_class->get_default_screen = gdk_wayland_display_get_default_screen;
+  display_class->beep = gdk_wayland_display_beep;
+  display_class->sync = gdk_wayland_display_sync;
+  display_class->flush = gdk_wayland_display_flush;
+  display_class->has_pending = gdk_wayland_display_has_pending;
+  display_class->queue_events = _gdk_wayland_display_queue_events;
+  display_class->get_default_group = gdk_wayland_display_get_default_group;
+  display_class->supports_selection_notification = gdk_wayland_display_supports_selection_notification;
+  display_class->request_selection_notification = gdk_wayland_display_request_selection_notification;
+  display_class->supports_clipboard_persistence = gdk_wayland_display_supports_clipboard_persistence;
+  display_class->store_clipboard = gdk_wayland_display_store_clipboard;
+  display_class->supports_shapes = gdk_wayland_display_supports_shapes;
+  display_class->supports_input_shapes = gdk_wayland_display_supports_input_shapes;
+  display_class->supports_composite = gdk_wayland_display_supports_composite;
+  display_class->list_devices = gdk_wayland_display_list_devices;
+  display_class->send_client_message = gdk_wayland_display_send_client_message;
+  display_class->add_client_message_filter = gdk_wayland_display_add_client_message_filter;
+  display_class->get_app_launch_context = _gdk_wayland_display_get_app_launch_context;
+  display_class->get_drag_protocol = _gdk_wayland_display_get_drag_protocol;
+  display_class->get_cursor_for_type = _gdk_wayland_display_get_cursor_for_type;
+  display_class->get_cursor_for_name = _gdk_wayland_display_get_cursor_for_name;
+  display_class->get_cursor_for_pixbuf = _gdk_wayland_display_get_cursor_for_pixbuf;
+  display_class->get_default_cursor_size = _gdk_wayland_display_get_default_cursor_size;
+  display_class->get_maximal_cursor_size = _gdk_wayland_display_get_maximal_cursor_size;
+  display_class->supports_cursor_alpha = _gdk_wayland_display_supports_cursor_alpha;
+  display_class->supports_cursor_color = _gdk_wayland_display_supports_cursor_color;
+  display_class->before_process_all_updates = gdk_wayland_display_before_process_all_updates;
+  display_class->after_process_all_updates = gdk_wayland_display_after_process_all_updates;
+  display_class->get_next_serial = gdk_wayland_display_get_next_serial;
+  display_class->notify_startup_complete = gdk_wayland_display_notify_startup_complete;
+  display_class->event_data_copy = gdk_wayland_display_event_data_copy;
+  display_class->event_data_free = gdk_wayland_display_event_data_free;
+  display_class->create_window_impl = _gdk_wayland_display_create_window_impl;
+  display_class->get_keymap = gdk_wayland_display_get_keymap;
+  display_class->push_error_trap = gdk_wayland_display_push_error_trap;
+  display_class->pop_error_trap = gdk_wayland_display_pop_error_trap;
+  display_class->get_selection_owner = _gdk_wayland_display_get_selection_owner;
+  display_class->set_selection_owner = _gdk_wayland_display_set_selection_owner;
+  display_class->send_selection_notify = _gdk_wayland_display_send_selection_notify;
+  display_class->get_selection_property = _gdk_wayland_display_get_selection_property;
+  display_class->convert_selection = _gdk_wayland_display_convert_selection;
+  display_class->text_property_to_utf8_list = _gdk_wayland_display_text_property_to_utf8_list;
+  display_class->utf8_to_string_target = _gdk_wayland_display_utf8_to_string_target;
+}
+
+static void
+_gdk_display_wayland_init (GdkDisplayWayland *display)
+{
+  _gdk_wayland_display_manager_add_display (gdk_display_manager_get (),
+					    GDK_DISPLAY (display));
+}
diff --git a/gdk/wayland/gdkdisplay-wayland.h b/gdk/wayland/gdkdisplay-wayland.h
new file mode 100644
index 0000000000..d9dceaa195
--- /dev/null
+++ b/gdk/wayland/gdkdisplay-wayland.h
@@ -0,0 +1,173 @@
+/*
+ * gdkdisplay-wayland.h
+ * 
+ * Copyright 2001 Sun Microsystems Inc. 
+ *
+ * Erwann Chenede <erwann.chenede@sun.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GDK_DISPLAY_WAYLAND__
+#define __GDK_DISPLAY_WAYLAND__
+
+#include <stdint.h>
+#include <wayland-client.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <cairo-gl.h>
+#include <glib.h>
+#include <gdk/gdkkeys.h>
+#include <gdk/gdkwindow.h>
+#include <gdk/gdkinternals.h>
+#include <gdk/gdk.h>		/* For gdk_get_program_class() */
+
+#include "gdkdisplayprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GdkDisplayWayland GdkDisplayWayland;
+typedef struct _GdkDisplayWaylandClass GdkDisplayWaylandClass;
+
+#define GDK_TYPE_DISPLAY_WAYLAND              (_gdk_display_wayland_get_type())
+#define GDK_DISPLAY_WAYLAND(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_WAYLAND, GdkDisplayWayland))
+#define GDK_DISPLAY_WAYLAND_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_WAYLAND, GdkDisplayWaylandClass))
+#define GDK_IS_DISPLAY_WAYLAND(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_WAYLAND))
+#define GDK_IS_DISPLAY_WAYLAND_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY_WAYLAND))
+#define GDK_DISPLAY_WAYLAND_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY_WAYLAND, GdkDisplayWaylandClass))
+
+struct _GdkDisplayWayland
+{
+  GdkDisplay parent_instance;
+  GdkScreen *default_screen;
+  GdkScreen **screens;
+
+  gint grab_count;
+
+  /* Keyboard related information */
+
+  gint xkb_event_type;
+  gboolean use_xkb;
+  
+  /* Whether we were able to turn on detectable-autorepeat using
+   * XkbSetDetectableAutorepeat. If FALSE, we'll fall back
+   * to checking the next event with XPending(). */
+  gboolean have_xkb_autorepeat;
+
+  GdkKeymap *keymap;
+  guint	    keymap_serial;
+
+  gboolean have_xfixes;
+  gint xfixes_event_base;
+
+  gboolean have_xcomposite;
+  gboolean have_xdamage;
+  gint xdamage_event_base;
+
+  gboolean have_randr13;
+  gint xrandr_event_base;
+
+  /* If the SECURITY extension is in place, whether this client holds 
+   * a trusted authorization and so is allowed to make various requests 
+   * (grabs, properties etc.) Otherwise always TRUE. */
+  gboolean trusted_client;
+
+  /* drag and drop information */
+  GdkDragContext *current_dest_drag;
+
+  /* data needed for MOTIF DnD */
+
+  Window motif_drag_window;
+  GdkWindow *motif_drag_gdk_window;
+  GList **motif_target_lists;
+  gint motif_n_target_lists;
+
+  /* Mapping to/from virtual atoms */
+
+  GHashTable *atom_from_virtual;
+  GHashTable *atom_to_virtual;
+
+  /* list of filters for client messages */
+  GList *client_filters;
+
+  /* List of functions to go from extension event => X window */
+  GSList *event_types;
+  
+  /* X ID hashtable */
+  GHashTable *xid_ht;
+
+  /* translation queue */
+  GQueue *translate_queue;
+
+  /* Input device */
+  /* input GdkDevice list */
+  GList *input_devices;
+
+  /* input GdkWindow list */
+  GList *input_windows;
+
+  /* Startup notification */
+  gchar *startup_notification_id;
+
+  /* Time of most recent user interaction. */
+  gulong user_time;
+
+  /* Sets of atoms for DND */
+  guint base_dnd_atoms_precached : 1;
+  guint xdnd_atoms_precached : 1;
+  guint motif_atoms_precached : 1;
+  guint use_sync : 1;
+
+  guint have_shapes : 1;
+  guint have_input_shapes : 1;
+  gint shape_event_base;
+
+  /* The offscreen window that has the pointer in it (if any) */
+  GdkWindow *active_offscreen_window;
+
+  /* Wayland fields below */
+  char *device_name;
+  struct wl_display *wl_display;
+  struct wl_drm *drm;
+  struct wl_compositor *compositor;
+  struct wl_shell *shell;
+  struct wl_output *output;
+  struct wl_input_device *input_device;
+  GSource *event_source;
+  int fd;
+  EGLDisplay egl_display;
+  EGLContext egl_context;
+  cairo_device_t *cairo_device;
+  int authenticated;
+
+  PFNEGLCREATEDRMIMAGEMESA create_drm_image;
+  PFNEGLEXPORTDRMIMAGEMESA export_drm_image;
+  PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_target_texture_2d;
+  PFNEGLDESTROYIMAGEKHRPROC destroy_image;
+};
+
+struct _GdkDisplayWaylandClass
+{
+  GdkDisplayClass parent_class;
+};
+
+GType      _gdk_display_wayland_get_type            (void);
+GdkScreen *_gdk_wayland_display_screen_for_xrootwin (GdkDisplay *display,
+						     Window      xrootwin);
+
+G_END_DECLS
+
+#endif				/* __GDK_DISPLAY_WAYLAND__ */
diff --git a/gdk/wayland/gdkdisplaymanager-wayland.c b/gdk/wayland/gdkdisplaymanager-wayland.c
new file mode 100644
index 0000000000..1b48014cdf
--- /dev/null
+++ b/gdk/wayland/gdkdisplaymanager-wayland.c
@@ -0,0 +1,298 @@
+/* GDK - The GIMP Drawing Kit
+ * gdkdisplaymanager-wayland.c
+ *
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * Author: Matthias clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gdkdisplaymanagerprivate.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkprivate-wayland.h"
+
+#include "gdkinternals.h"
+
+typedef struct _GdkWaylandDisplayManager GdkWaylandDisplayManager;
+typedef struct _GdkWaylandDisplayManagerClass GdkWaylandDisplayManagerClass;
+
+#define GDK_TYPE_WAYLAND_DISPLAY_MANAGER              (gdk_wayland_display_manager_get_type())
+#define GDK_WAYLAND_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DISPLAY_MANAGER, GdkWaylandDisplayManager))
+#define GDK_WAYLAND_DISPLAY_MANAGER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DISPLAY_MANAGER, GdkWaylandDisplayManagerClass))
+#define GDK_IS_WAYLAND_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DISPLAY_MANAGER))
+#define GDK_IS_WAYLAND_DISPLAY_MANAGER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DISPLAY_MANAGER))
+#define GDK_WAYLAND_DISPLAY_MANAGER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DISPLAY_MANAGER, GdkWaylandDisplayManagerClass))
+
+struct _GdkWaylandDisplayManager
+{
+  GdkDisplayManager parent;
+
+  GdkDisplay *default_display;
+  GSList *displays;
+};
+
+struct _GdkWaylandDisplayManagerClass
+{
+  GdkDisplayManagerClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkWaylandDisplayManager, gdk_wayland_display_manager, GDK_TYPE_DISPLAY_MANAGER)
+
+static void
+gdk_wayland_display_manager_finalize (GObject *object)
+{
+  g_error ("A GdkWaylandDisplayManager object was finalized. This should not happen");
+  G_OBJECT_CLASS (gdk_wayland_display_manager_parent_class)->finalize (object);
+}
+
+static GdkDisplay *
+gdk_wayland_display_manager_open_display (GdkDisplayManager *manager,
+					  const gchar       *name)
+{
+  return _gdk_wayland_display_open (name);
+}
+
+static GSList *
+gdk_wayland_display_manager_list_displays (GdkDisplayManager *manager)
+{
+  return g_slist_copy (GDK_WAYLAND_DISPLAY_MANAGER (manager)->displays);
+}
+
+static void
+gdk_wayland_display_manager_set_default_display (GdkDisplayManager *manager,
+						 GdkDisplay        *display)
+{
+  GDK_WAYLAND_DISPLAY_MANAGER (manager)->default_display = display;
+
+  _gdk_wayland_display_make_default (display);
+}
+
+static GdkDisplay *
+gdk_wayland_display_manager_get_default_display (GdkDisplayManager *manager)
+{
+  return GDK_WAYLAND_DISPLAY_MANAGER (manager)->default_display;
+}
+
+static GdkAtom
+gdk_wayland_display_manager_atom_intern (GdkDisplayManager *manager,
+					 const gchar       *atom_name,
+					 gboolean           dup)
+{
+  return 0;
+}
+
+static gchar *
+gdk_wayland_display_manager_get_atom_name (GdkDisplayManager *manager,
+					   GdkAtom            atom)
+{
+  return 0;
+}
+
+static guint
+gdk_wayland_display_manager_lookup_keyval (GdkDisplayManager *manager,
+					   const gchar       *keyval_name)
+{
+  return /* XStringToKeysym (keyval_name); */ 0;
+}
+
+static gchar *
+gdk_wayland_display_manager_get_keyval_name (GdkDisplayManager *manager,
+					     guint              keyval)
+{
+  return NULL;
+}
+
+static void
+gdk_wayland_display_manager_keyval_convert_case (GdkDisplayManager *manager,
+						 guint              symbol,
+						 guint             *lower,
+						 guint             *upper)
+{
+  guint xlower = symbol;
+  guint xupper = symbol;
+
+  /* Check for directly encoded 24-bit UCS characters: */
+  if ((symbol & 0xff000000) == 0x01000000)
+    {
+      if (lower)
+	*lower = gdk_unicode_to_keyval (g_unichar_tolower (symbol & 0x00ffffff));
+      if (upper)
+	*upper = gdk_unicode_to_keyval (g_unichar_toupper (symbol & 0x00ffffff));
+      return;
+    }
+
+  switch (symbol >> 8)
+    {
+    case 0: /* Latin 1 */
+      if ((symbol >= GDK_KEY_A) && (symbol <= GDK_KEY_Z))
+	xlower += (GDK_KEY_a - GDK_KEY_A);
+      else if ((symbol >= GDK_KEY_a) && (symbol <= GDK_KEY_z))
+	xupper -= (GDK_KEY_a - GDK_KEY_A);
+      else if ((symbol >= GDK_KEY_Agrave) && (symbol <= GDK_KEY_Odiaeresis))
+	xlower += (GDK_KEY_agrave - GDK_KEY_Agrave);
+      else if ((symbol >= GDK_KEY_agrave) && (symbol <= GDK_KEY_odiaeresis))
+	xupper -= (GDK_KEY_agrave - GDK_KEY_Agrave);
+      else if ((symbol >= GDK_KEY_Ooblique) && (symbol <= GDK_KEY_Thorn))
+	xlower += (GDK_KEY_oslash - GDK_KEY_Ooblique);
+      else if ((symbol >= GDK_KEY_oslash) && (symbol <= GDK_KEY_thorn))
+	xupper -= (GDK_KEY_oslash - GDK_KEY_Ooblique);
+      break;
+
+    case 1: /* Latin 2 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (symbol == GDK_KEY_Aogonek)
+	xlower = GDK_KEY_aogonek;
+      else if (symbol >= GDK_KEY_Lstroke && symbol <= GDK_KEY_Sacute)
+	xlower += (GDK_KEY_lstroke - GDK_KEY_Lstroke);
+      else if (symbol >= GDK_KEY_Scaron && symbol <= GDK_KEY_Zacute)
+	xlower += (GDK_KEY_scaron - GDK_KEY_Scaron);
+      else if (symbol >= GDK_KEY_Zcaron && symbol <= GDK_KEY_Zabovedot)
+	xlower += (GDK_KEY_zcaron - GDK_KEY_Zcaron);
+      else if (symbol == GDK_KEY_aogonek)
+	xupper = GDK_KEY_Aogonek;
+      else if (symbol >= GDK_KEY_lstroke && symbol <= GDK_KEY_sacute)
+	xupper -= (GDK_KEY_lstroke - GDK_KEY_Lstroke);
+      else if (symbol >= GDK_KEY_scaron && symbol <= GDK_KEY_zacute)
+	xupper -= (GDK_KEY_scaron - GDK_KEY_Scaron);
+      else if (symbol >= GDK_KEY_zcaron && symbol <= GDK_KEY_zabovedot)
+	xupper -= (GDK_KEY_zcaron - GDK_KEY_Zcaron);
+      else if (symbol >= GDK_KEY_Racute && symbol <= GDK_KEY_Tcedilla)
+	xlower += (GDK_KEY_racute - GDK_KEY_Racute);
+      else if (symbol >= GDK_KEY_racute && symbol <= GDK_KEY_tcedilla)
+	xupper -= (GDK_KEY_racute - GDK_KEY_Racute);
+      break;
+
+    case 2: /* Latin 3 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (symbol >= GDK_KEY_Hstroke && symbol <= GDK_KEY_Hcircumflex)
+	xlower += (GDK_KEY_hstroke - GDK_KEY_Hstroke);
+      else if (symbol >= GDK_KEY_Gbreve && symbol <= GDK_KEY_Jcircumflex)
+	xlower += (GDK_KEY_gbreve - GDK_KEY_Gbreve);
+      else if (symbol >= GDK_KEY_hstroke && symbol <= GDK_KEY_hcircumflex)
+	xupper -= (GDK_KEY_hstroke - GDK_KEY_Hstroke);
+      else if (symbol >= GDK_KEY_gbreve && symbol <= GDK_KEY_jcircumflex)
+	xupper -= (GDK_KEY_gbreve - GDK_KEY_Gbreve);
+      else if (symbol >= GDK_KEY_Cabovedot && symbol <= GDK_KEY_Scircumflex)
+	xlower += (GDK_KEY_cabovedot - GDK_KEY_Cabovedot);
+      else if (symbol >= GDK_KEY_cabovedot && symbol <= GDK_KEY_scircumflex)
+	xupper -= (GDK_KEY_cabovedot - GDK_KEY_Cabovedot);
+      break;
+
+    case 3: /* Latin 4 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (symbol >= GDK_KEY_Rcedilla && symbol <= GDK_KEY_Tslash)
+	xlower += (GDK_KEY_rcedilla - GDK_KEY_Rcedilla);
+      else if (symbol >= GDK_KEY_rcedilla && symbol <= GDK_KEY_tslash)
+	xupper -= (GDK_KEY_rcedilla - GDK_KEY_Rcedilla);
+      else if (symbol == GDK_KEY_ENG)
+	xlower = GDK_KEY_eng;
+      else if (symbol == GDK_KEY_eng)
+	xupper = GDK_KEY_ENG;
+      else if (symbol >= GDK_KEY_Amacron && symbol <= GDK_KEY_Umacron)
+	xlower += (GDK_KEY_amacron - GDK_KEY_Amacron);
+      else if (symbol >= GDK_KEY_amacron && symbol <= GDK_KEY_umacron)
+	xupper -= (GDK_KEY_amacron - GDK_KEY_Amacron);
+      break;
+
+    case 6: /* Cyrillic */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (symbol >= GDK_KEY_Serbian_DJE && symbol <= GDK_KEY_Serbian_DZE)
+	xlower -= (GDK_KEY_Serbian_DJE - GDK_KEY_Serbian_dje);
+      else if (symbol >= GDK_KEY_Serbian_dje && symbol <= GDK_KEY_Serbian_dze)
+	xupper += (GDK_KEY_Serbian_DJE - GDK_KEY_Serbian_dje);
+      else if (symbol >= GDK_KEY_Cyrillic_YU && symbol <= GDK_KEY_Cyrillic_HARDSIGN)
+	xlower -= (GDK_KEY_Cyrillic_YU - GDK_KEY_Cyrillic_yu);
+      else if (symbol >= GDK_KEY_Cyrillic_yu && symbol <= GDK_KEY_Cyrillic_hardsign)
+	xupper += (GDK_KEY_Cyrillic_YU - GDK_KEY_Cyrillic_yu);
+      break;
+
+    case 7: /* Greek */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (symbol >= GDK_KEY_Greek_ALPHAaccent && symbol <= GDK_KEY_Greek_OMEGAaccent)
+	xlower += (GDK_KEY_Greek_alphaaccent - GDK_KEY_Greek_ALPHAaccent);
+      else if (symbol >= GDK_KEY_Greek_alphaaccent && symbol <= GDK_KEY_Greek_omegaaccent &&
+	       symbol != GDK_KEY_Greek_iotaaccentdieresis &&
+	       symbol != GDK_KEY_Greek_upsilonaccentdieresis)
+	xupper -= (GDK_KEY_Greek_alphaaccent - GDK_KEY_Greek_ALPHAaccent);
+      else if (symbol >= GDK_KEY_Greek_ALPHA && symbol <= GDK_KEY_Greek_OMEGA)
+	xlower += (GDK_KEY_Greek_alpha - GDK_KEY_Greek_ALPHA);
+      else if (symbol >= GDK_KEY_Greek_alpha && symbol <= GDK_KEY_Greek_omega &&
+	       symbol != GDK_KEY_Greek_finalsmallsigma)
+	xupper -= (GDK_KEY_Greek_alpha - GDK_KEY_Greek_ALPHA);
+      break;
+    }
+
+  if (lower)
+    *lower = xlower;
+  if (upper)
+    *upper = xupper;
+}
+
+static void
+gdk_wayland_display_manager_class_init (GdkWaylandDisplayManagerClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GdkDisplayManagerClass *manager_class = GDK_DISPLAY_MANAGER_CLASS (class);
+
+  object_class->finalize = gdk_wayland_display_manager_finalize;
+
+  manager_class->open_display = gdk_wayland_display_manager_open_display;
+  manager_class->list_displays = gdk_wayland_display_manager_list_displays;
+  manager_class->set_default_display = gdk_wayland_display_manager_set_default_display;
+  manager_class->get_default_display = gdk_wayland_display_manager_get_default_display;
+  manager_class->atom_intern = gdk_wayland_display_manager_atom_intern;
+  manager_class->get_atom_name = gdk_wayland_display_manager_get_atom_name;
+  manager_class->lookup_keyval = gdk_wayland_display_manager_lookup_keyval;
+  manager_class->get_keyval_name = gdk_wayland_display_manager_get_keyval_name;
+  manager_class->keyval_convert_case = gdk_wayland_display_manager_keyval_convert_case;
+}
+
+static void
+gdk_wayland_display_manager_init (GdkWaylandDisplayManager *manager)
+{
+}
+
+void
+_gdk_wayland_display_manager_add_display (GdkDisplayManager *manager,
+					  GdkDisplay        *display)
+{
+  GdkWaylandDisplayManager *manager_wayland = GDK_WAYLAND_DISPLAY_MANAGER (manager);
+
+  if (manager_wayland->displays == NULL)
+    gdk_display_manager_set_default_display (manager, display);
+
+  manager_wayland->displays = g_slist_prepend (manager_wayland->displays, display);
+}
+
+void
+_gdk_wayland_display_manager_remove_display (GdkDisplayManager *manager,
+					     GdkDisplay        *display)
+{
+  GdkWaylandDisplayManager *manager_wayland = GDK_WAYLAND_DISPLAY_MANAGER (manager);
+
+  manager_wayland->displays = g_slist_remove (manager_wayland->displays, display);
+
+  if (manager_wayland->default_display == display)
+    {
+      if (manager_wayland->displays)
+        gdk_display_manager_set_default_display (manager, manager_wayland->displays->data);
+      else
+        gdk_display_manager_set_default_display (manager, NULL);
+    }
+}
diff --git a/gdk/wayland/gdkdnd-wayland.c b/gdk/wayland/gdkdnd-wayland.c
new file mode 100644
index 0000000000..1d36e95732
--- /dev/null
+++ b/gdk/wayland/gdkdnd-wayland.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gdkdndprivate.h"
+
+#include "gdkmain.h"
+#include "gdkinternals.h"
+#include "gdkproperty.h"
+#include "gdkprivate-wayland.h"
+#include "gdkscreen-wayland.h"
+#include "gdkdisplay-wayland.h"
+
+#include <string.h>
+
+#define GDK_TYPE_WAYLAND_DRAG_CONTEXT              (gdk_wayland_drag_context_get_type ())
+#define GDK_WAYLAND_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContext))
+#define GDK_WAYLAND_DRAG_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContextClass))
+#define GDK_IS_WAYLAND_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DRAG_CONTEXT))
+#define GDK_IS_WAYLAND_DRAG_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DRAG_CONTEXT))
+#define GDK_WAYLAND_DRAG_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContextClass))
+
+typedef struct _GdkWaylandDragContext GdkWaylandDragContext;
+typedef struct _GdkWaylandDragContextClass GdkWaylandDragContextClass;
+
+struct _GdkWaylandDragContext
+{
+  GdkDragContext context;
+};
+
+struct _GdkWaylandDragContextClass
+{
+  GdkDragContextClass parent_class;
+};
+
+static GList *contexts;
+
+G_DEFINE_TYPE (GdkWaylandDragContext, gdk_wayland_drag_context, GDK_TYPE_DRAG_CONTEXT)
+
+static void
+gdk_wayland_drag_context_finalize (GObject *object)
+{
+  GdkDragContext *context = GDK_DRAG_CONTEXT (object);
+
+  contexts = g_list_remove (contexts, context);
+
+  G_OBJECT_CLASS (gdk_wayland_drag_context_parent_class)->finalize (object);
+}
+
+static GdkWindow *
+gdk_wayland_drag_context_find_window (GdkDragContext  *context,
+				      GdkWindow       *drag_window,
+				      GdkScreen       *screen,
+				      gint             x_root,
+				      gint             y_root,
+				      GdkDragProtocol *protocol)
+{
+  return NULL;
+}
+
+static gboolean
+gdk_wayland_drag_context_drag_motion (GdkDragContext *context,
+				      GdkWindow      *dest_window,
+				      GdkDragProtocol protocol,
+				      gint            x_root,
+				      gint            y_root,
+				      GdkDragAction   suggested_action,
+				      GdkDragAction   possible_actions,
+				      guint32         time)
+{
+  return FALSE;
+}
+
+static void
+gdk_wayland_drag_context_drag_abort (GdkDragContext *context,
+				     guint32         time)
+{
+}
+
+static void
+gdk_wayland_drag_context_drag_drop (GdkDragContext *context,
+				    guint32         time)
+{
+}
+
+/* Destination side */
+
+static void
+gdk_wayland_drag_context_drag_status (GdkDragContext *context,
+				      GdkDragAction   action,
+				      guint32         time_)
+{
+}
+
+static void
+gdk_wayland_drag_context_drop_reply (GdkDragContext *context,
+				     gboolean        accepted,
+				     guint32         time_)
+{
+}
+
+static void
+gdk_wayland_drag_context_drop_finish (GdkDragContext *context,
+				      gboolean        success,
+				      guint32         time)
+{
+}
+
+static gboolean
+gdk_wayland_drag_context_drop_status (GdkDragContext *context)
+{
+  return FALSE;
+}
+
+static GdkAtom
+gdk_wayland_drag_context_get_selection (GdkDragContext *context)
+{
+    return GDK_NONE;
+}
+
+static void
+gdk_wayland_drag_context_init (GdkWaylandDragContext *context)
+{
+  contexts = g_list_prepend (contexts, context);
+}
+
+static void
+gdk_wayland_drag_context_class_init (GdkWaylandDragContextClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
+
+  object_class->finalize = gdk_wayland_drag_context_finalize;
+
+  context_class->find_window = gdk_wayland_drag_context_find_window;
+  context_class->drag_status = gdk_wayland_drag_context_drag_status;
+  context_class->drag_motion = gdk_wayland_drag_context_drag_motion;
+  context_class->drag_abort = gdk_wayland_drag_context_drag_abort;
+  context_class->drag_drop = gdk_wayland_drag_context_drag_drop;
+  context_class->drop_reply = gdk_wayland_drag_context_drop_reply;
+  context_class->drop_finish = gdk_wayland_drag_context_drop_finish;
+  context_class->drop_status = gdk_wayland_drag_context_drop_status;
+  context_class->get_selection = gdk_wayland_drag_context_get_selection;
+}
+
+GdkNativeWindow
+_gdk_wayland_display_get_drag_protocol (GdkDisplay      *display,
+					GdkNativeWindow  xid,
+					GdkDragProtocol *protocol,
+					guint           *version)
+
+{
+  return 0;
+}
+
+void
+_gdk_wayland_window_register_dnd (GdkWindow *window)
+{
+}
+
+GdkDragContext *
+_gdk_wayland_window_drag_begin (GdkWindow *window,
+				GdkDevice *device,
+				GList     *targets)
+{
+  GdkDragContext *context;
+
+  context = (GdkDragContext *) g_object_new (GDK_TYPE_WAYLAND_DRAG_CONTEXT, NULL);
+
+  gdk_drag_context_set_device (context, device);
+
+  return context;
+}
diff --git a/gdk/wayland/gdkeventsource.c b/gdk/wayland/gdkeventsource.c
new file mode 100644
index 0000000000..12c9118201
--- /dev/null
+++ b/gdk/wayland/gdkeventsource.c
@@ -0,0 +1,167 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gdkeventsource.h"
+#include "gdkinternals.h"
+
+typedef struct _GdkWaylandEventSource {
+  GSource source;
+  GPollFD pfd;
+  uint32_t mask;
+  GdkDisplay *display;
+} GdkWaylandEventSource;
+
+static GList *event_sources = NULL;
+
+static gboolean
+gdk_event_source_prepare(GSource *base, gint *timeout)
+{
+  GdkWaylandEventSource *source = (GdkWaylandEventSource *) base;
+  GdkDisplayWayland *display = (GdkDisplayWayland *) source->display;
+
+  *timeout = -1;
+
+  /* We have to add/remove the GPollFD if we want to update our
+   * poll event mask dynamically.  Instead, let's just flush all
+   * write on idle instead, which is what this amounts to. */
+
+  if (_gdk_event_queue_find_first (source->display) != NULL)
+    return TRUE;
+
+  while (source->mask & WL_DISPLAY_WRITABLE)
+    wl_display_iterate(display->wl_display, WL_DISPLAY_WRITABLE);
+
+  return FALSE;
+}
+
+static gboolean
+gdk_event_source_check(GSource *base)
+{
+  GdkWaylandEventSource *source = (GdkWaylandEventSource *) base;
+
+  return _gdk_event_queue_find_first (source->display) != NULL ||
+    source->pfd.revents;
+}
+
+static gboolean
+gdk_event_source_dispatch(GSource *base,
+			  GSourceFunc callback,
+			  gpointer data)
+{
+  GdkWaylandEventSource *source = (GdkWaylandEventSource *) base;
+  GdkDisplay *display = source->display;
+  GdkEvent *event;
+
+  GDK_THREADS_ENTER ();
+
+  event = gdk_display_get_event (display);
+
+  if (event)
+    {
+      _gdk_event_emit (event);
+
+      gdk_event_free (event);
+    }
+
+  GDK_THREADS_LEAVE ();
+
+  return TRUE;
+}
+
+static void
+gdk_event_source_finalize (GSource *source)
+{
+  event_sources = g_list_remove (event_sources, source);
+}
+
+static GSourceFuncs wl_glib_source_funcs = {
+  gdk_event_source_prepare,
+  gdk_event_source_check,
+  gdk_event_source_dispatch,
+  gdk_event_source_finalize
+};
+
+static int
+gdk_event_source_update(uint32_t mask, void *data)
+{
+  GdkWaylandEventSource *source = data;
+
+  source->mask = mask;
+
+  return 0;
+}
+
+void
+_gdk_wayland_display_deliver_event (GdkDisplay *display, GdkEvent *event)
+{
+  GList *node;
+  static int serial;
+
+  node = _gdk_event_queue_append (display, event);
+  _gdk_windowing_got_event (display, node, event, serial++);
+}
+
+GSource *
+_gdk_wayland_display_event_source_new (GdkDisplay *display)
+{
+  GSource *source;
+  GdkWaylandEventSource *wl_source;
+  GdkDisplayWayland *display_wayland;
+  char *name;
+
+  source = g_source_new (&wl_glib_source_funcs,
+			 sizeof (GdkWaylandEventSource));
+  name = g_strdup_printf ("GDK Wayland Event source (%s)", "display name");
+  g_source_set_name (source, name);
+  g_free (name);
+  wl_source = (GdkWaylandEventSource *) source;
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+  wl_source->display = display;
+  wl_source->pfd.fd = wl_display_get_fd(display_wayland->wl_display,
+					gdk_event_source_update, source);
+  wl_source->pfd.events = G_IO_IN | G_IO_ERR;
+  g_source_add_poll(source, &wl_source->pfd);
+
+  g_source_set_priority (source, GDK_PRIORITY_EVENTS);
+  g_source_set_can_recurse (source, TRUE);
+  g_source_attach (source, NULL);
+
+  event_sources = g_list_prepend (event_sources, source);
+
+  return source;
+}
+
+void
+_gdk_wayland_display_queue_events (GdkDisplay *display)
+{
+  GdkDisplayWayland *display_wayland;
+  GdkWaylandEventSource *source;
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+  source = (GdkWaylandEventSource *) display_wayland->event_source;
+
+  if (source->pfd.revents)
+    {
+      wl_display_iterate(display_wayland->wl_display, WL_DISPLAY_READABLE);
+      source->pfd.revents = 0;
+    }
+}
diff --git a/gdk/wayland/gdkeventsource.h b/gdk/wayland/gdkeventsource.h
new file mode 100644
index 0000000000..65a7ca3e78
--- /dev/null
+++ b/gdk/wayland/gdkeventsource.h
@@ -0,0 +1,44 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GDK_EVENT_SOURCE_H__
+#define __GDK_EVENT_SOURCE_H__
+
+#include "gdkprivate-wayland.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GdkEventSource GdkEventSource;
+
+G_GNUC_INTERNAL
+GSource * gdk_event_source_new            (GdkDisplay *display);
+
+G_GNUC_INTERNAL
+void      gdk_event_source_select_events  (GdkEventSource *source,
+                                           Window          window,
+                                           GdkEventMask    event_mask,
+                                           unsigned int    extra_x_mask);
+
+G_GNUC_INTERNAL
+void      _gdk_deliver_event (GdkDisplay *display, GdkEvent *event);
+
+
+G_END_DECLS
+
+#endif /* __GDK_EVENT_SOURCE_H__ */
diff --git a/gdk/wayland/gdkkeys-wayland.c b/gdk/wayland/gdkkeys-wayland.c
new file mode 100644
index 0000000000..87b139814a
--- /dev/null
+++ b/gdk/wayland/gdkkeys-wayland.c
@@ -0,0 +1,171 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+
+#include "gdk.h"
+#include "gdkwayland.h"
+
+#include "gdkprivate-wayland.h"
+#include "gdkinternals.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkkeysprivate.h"
+
+#include <X11/extensions/XKBcommon.h>
+
+typedef struct _GdkWaylandKeymap          GdkWaylandKeymap;
+typedef struct _GdkWaylandKeymapClass     GdkWaylandKeymapClass;
+
+struct _GdkWaylandKeymap
+{
+  GdkKeymap parent_instance;
+};
+
+struct _GdkWaylandKeymapClass
+{
+  GdkKeymapClass parent_class;
+};
+
+#define GDK_TYPE_WAYLAND_KEYMAP          (_gdk_wayland_keymap_get_type ())
+#define GDK_WAYLAND_KEYMAP(object)       (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_KEYMAP, GdkWaylandKeyMap))
+#define GDK_IS_WAYLAND_KEYMAP(object)    (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_KEYMAP))
+
+G_DEFINE_TYPE (GdkWaylandKeymap, _gdk_wayland_keymap, GDK_TYPE_KEYMAP)
+
+static void
+gdk_wayland_keymap_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (_gdk_wayland_keymap_parent_class)->finalize (object);
+}
+
+static PangoDirection
+gdk_wayland_keymap_get_direction (GdkKeymap *keymap)
+{
+    return PANGO_DIRECTION_NEUTRAL;
+}
+
+static gboolean
+gdk_wayland_keymap_have_bidi_layouts (GdkKeymap *keymap)
+{
+    return FALSE;
+}
+
+static gboolean
+gdk_wayland_keymap_get_caps_lock_state (GdkKeymap *keymap)
+{
+  return FALSE;
+}
+
+static gboolean
+gdk_wayland_keymap_get_num_lock_state (GdkKeymap *keymap)
+{
+  return FALSE;
+}
+
+static gboolean
+gdk_wayland_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
+				       guint          keyval,
+				       GdkKeymapKey **keys,
+				       gint          *n_keys)
+{
+  return FALSE;
+}
+
+static gboolean
+gdk_wayland_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
+					guint          hardware_keycode,
+					GdkKeymapKey **keys,
+					guint        **keyvals,
+					gint          *n_entries)
+{
+  return FALSE;
+}
+
+static guint
+gdk_wayland_keymap_lookup_key (GdkKeymap          *keymap,
+			   const GdkKeymapKey *key)
+{
+  return 0;
+}
+
+static gboolean
+gdk_wayland_keymap_translate_keyboard_state (GdkKeymap       *keymap,
+					 guint            hardware_keycode,
+					 GdkModifierType  state,
+					 gint             group,
+					 guint           *keyval,
+					 gint            *effective_group,
+					 gint            *level,
+					 GdkModifierType *consumed_modifiers)
+{
+  return FALSE;
+}
+
+
+static void
+gdk_wayland_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
+				      GdkModifierType *state)
+{
+}
+
+static gboolean
+gdk_wayland_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
+				      GdkModifierType *state)
+{
+  return FALSE;
+}
+
+static void
+_gdk_wayland_keymap_class_init (GdkWaylandKeymapClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
+
+  object_class->finalize = gdk_wayland_keymap_finalize;
+
+  keymap_class->get_direction = gdk_wayland_keymap_get_direction;
+  keymap_class->have_bidi_layouts = gdk_wayland_keymap_have_bidi_layouts;
+  keymap_class->get_caps_lock_state = gdk_wayland_keymap_get_caps_lock_state;
+  keymap_class->get_num_lock_state = gdk_wayland_keymap_get_num_lock_state;
+  keymap_class->get_entries_for_keyval = gdk_wayland_keymap_get_entries_for_keyval;
+  keymap_class->get_entries_for_keycode = gdk_wayland_keymap_get_entries_for_keycode;
+  keymap_class->lookup_key = gdk_wayland_keymap_lookup_key;
+  keymap_class->translate_keyboard_state = gdk_wayland_keymap_translate_keyboard_state;
+  keymap_class->add_virtual_modifiers = gdk_wayland_keymap_add_virtual_modifiers;
+  keymap_class->map_virtual_modifiers = gdk_wayland_keymap_map_virtual_modifiers;
+}
+
+static void
+_gdk_wayland_keymap_init (GdkWaylandKeymap *keymap)
+{
+}
diff --git a/gdk/wayland/gdkprivate-wayland.h b/gdk/wayland/gdkprivate-wayland.h
new file mode 100644
index 0000000000..fa3b27861e
--- /dev/null
+++ b/gdk/wayland/gdkprivate-wayland.h
@@ -0,0 +1,141 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+/*
+ * Private uninstalled header defining things local to X windowing code
+ */
+
+#ifndef __GDK_PRIVATE_WAYLAND_H__
+#define __GDK_PRIVATE_WAYLAND_H__
+
+#include <gdk/gdkcursor.h>
+#include <gdk/gdkprivate.h>
+#include <gdk/wayland/gdkwindow-wayland.h>
+#include <gdk/wayland/gdkdisplay-wayland.h>
+
+#include "gdkinternals.h"
+
+#include "config.h"
+
+#define GDK_SCREEN_DISPLAY(screen)    (GDK_SCREEN_WAYLAND (screen)->display)
+#define GDK_WINDOW_SCREEN(win)	      (gdk_window_get_screen (win))
+#define GDK_WINDOW_DISPLAY(win)       (GDK_SCREEN_WAYLAND (GDK_WINDOW_SCREEN (win))->display)
+#define GDK_WINDOW_IS_WAYLAND(win)    (GDK_IS_WINDOW_IMPL_WAYLAND (((GdkWindow *)win)->impl))
+
+GType      _gdk_wayland_window_get_type            (void);
+GType      _gdk_wayland_keymap_get_type            (void);
+
+GdkCursor *_gdk_wayland_display_get_cursor_for_type (GdkDisplay    *display,
+						     GdkCursorType  cursor_type);
+GdkCursor *_gdk_wayland_display_get_cursor_for_name (GdkDisplay  *display,
+						     const gchar *name);
+GdkCursor *_gdk_wayland_display_get_cursor_for_pixbuf (GdkDisplay *display,
+						       GdkPixbuf  *pixbuf,
+						       gint        x,
+						       gint        y);
+void       _gdk_wayland_display_get_default_cursor_size (GdkDisplay *display,
+							 guint       *width,
+							 guint       *height);
+void       _gdk_wayland_display_get_maximal_cursor_size (GdkDisplay *display,
+							 guint       *width,
+							 guint       *height);
+gboolean   _gdk_wayland_display_supports_cursor_alpha (GdkDisplay *display);
+gboolean   _gdk_wayland_display_supports_cursor_color (GdkDisplay *display);
+
+GdkNativeWindow _gdk_wayland_display_get_drag_protocol (GdkDisplay      *display,
+							GdkNativeWindow  xid,
+							GdkDragProtocol *protocol,
+							guint           *version);
+void            _gdk_wayland_window_register_dnd (GdkWindow *window);
+GdkDragContext *_gdk_wayland_window_drag_begin (GdkWindow *window,
+						GdkDevice *device,
+						GList     *targets);
+
+void _gdk_wayland_display_create_window_impl (GdkDisplay    *display,
+					      GdkWindow     *window,
+					      GdkWindow     *real_parent,
+					      GdkScreen     *screen,
+					      GdkEventMask   event_mask,
+					      GdkWindowAttr *attributes,
+					      gint           attributes_mask);
+
+GdkKeymap *_gdk_wayland_display_get_keymap (GdkDisplay *display);
+
+GdkWindow *_gdk_wayland_display_get_selection_owner (GdkDisplay *display,
+						 GdkAtom     selection);
+gboolean   _gdk_wayland_display_set_selection_owner (GdkDisplay *display,
+						     GdkWindow  *owner,
+						     GdkAtom     selection,
+						     guint32     time,
+						     gboolean    send_event);
+void       _gdk_wayland_display_send_selection_notify (GdkDisplay       *display,
+						       GdkNativeWindow  requestor,
+						       GdkAtom          selection,
+						       GdkAtom          target,
+						       GdkAtom          property,
+						       guint32          time);
+gint       _gdk_wayland_display_get_selection_property (GdkDisplay  *display,
+							GdkWindow   *requestor,
+							guchar     **data,
+							GdkAtom     *ret_type,
+							gint        *ret_format);
+void       _gdk_wayland_display_convert_selection (GdkDisplay *display,
+						   GdkWindow  *requestor,
+						   GdkAtom     selection,
+						   GdkAtom     target,
+						   guint32     time);
+gint        _gdk_wayland_display_text_property_to_utf8_list (GdkDisplay    *display,
+							     GdkAtom        encoding,
+							     gint           format,
+							     const guchar  *text,
+							     gint           length,
+							     gchar       ***list);
+gchar *     _gdk_wayland_display_utf8_to_string_target (GdkDisplay  *display,
+							const gchar *str);
+
+GdkDeviceManager *_gdk_device_manager_new (GdkDisplay *display);
+
+void     _gdk_wayland_display_deliver_event (GdkDisplay *display, GdkEvent *event);
+GSource *_gdk_wayland_display_event_source_new (GdkDisplay *display);
+void     _gdk_wayland_display_queue_events (GdkDisplay *display);
+
+GdkAppLaunchContext *_gdk_wayland_display_get_app_launch_context (GdkDisplay *display);
+
+GdkDisplay *_gdk_wayland_display_open (const gchar *display_name);
+void        _gdk_wayland_display_make_default (GdkDisplay *display);
+
+GdkWindow *_gdk_wayland_screen_create_root_window (GdkScreen *screen,
+						   int width,
+						   int height);
+
+GdkScreen *_gdk_wayland_screen_new (GdkDisplay *display);
+
+void _gdk_wayland_display_manager_add_display (GdkDisplayManager *manager,
+					       GdkDisplay        *display);
+void _gdk_wayland_display_manager_remove_display (GdkDisplayManager *manager,
+						  GdkDisplay        *display);
+
+#endif /* __GDK_PRIVATE_WAYLAND_H__ */
diff --git a/gdk/wayland/gdkscreen-wayland.c b/gdk/wayland/gdkscreen-wayland.c
new file mode 100644
index 0000000000..09adafbb63
--- /dev/null
+++ b/gdk/wayland/gdkscreen-wayland.c
@@ -0,0 +1,586 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+#include "gdkscreenprivate.h"
+#include "gdkvisualprivate.h"
+#include "gdkdisplay.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkwayland.h"
+#include "gdkprivate-wayland.h"
+
+typedef struct _GdkScreenWayland      GdkScreenWayland;
+typedef struct _GdkScreenWaylandClass GdkScreenWaylandClass;
+
+#define GDK_TYPE_SCREEN_WAYLAND              (_gdk_screen_wayland_get_type ())
+#define GDK_SCREEN_WAYLAND(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWayland))
+#define GDK_SCREEN_WAYLAND_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWaylandClass))
+#define GDK_IS_SCREEN_WAYLAND(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SCREEN_WAYLAND))
+#define GDK_IS_SCREEN_WAYLAND_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN_WAYLAND))
+#define GDK_SCREEN_WAYLAND_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWaylandClass))
+
+typedef struct _GdkWaylandMonitor GdkWaylandMonitor;
+
+struct _GdkScreenWayland
+{
+  GdkScreen parent_instance;
+
+  GdkDisplay *display;
+  GdkWindow *root_window;
+
+  int width, height;
+  int width_mm, height_mm;
+
+  /* Window manager */
+  long last_wmspec_check_time;
+  Window wmspec_check_window;
+  char *window_manager_name;
+  /* TRUE if wmspec_check_window has changed since last
+   * fetch of _NET_SUPPORTED
+   */
+  guint need_refetch_net_supported : 1;
+  /* TRUE if wmspec_check_window has changed since last
+   * fetch of window manager name
+   */
+  guint need_refetch_wm_name : 1;
+
+  /* Visual Part */
+  GdkVisual *argb_visual;
+  GdkVisual *premultiplied_argb_visual;
+  GdkVisual *rgb_visual;
+
+  /* Xinerama/RandR 1.2 */
+  gint		     n_monitors;
+  GdkWaylandMonitor *monitors;
+  gint               primary_monitor;
+
+  /* Xft resources for the display, used for default values for
+   * the Xft/ XSETTINGS
+   */
+  gboolean xft_init;		/* Whether we've intialized these values yet */
+  gboolean xft_antialias;
+  gboolean xft_hinting;
+  gint xft_hintstyle;
+  gint xft_rgba;
+  gint xft_dpi;
+
+  GdkAtom cm_selection_atom;
+  gboolean is_composited;
+};
+  
+struct _GdkScreenWaylandClass
+{
+  GdkScreenClass parent_class;
+
+  void (* window_manager_changed) (GdkScreenWayland *screen_wayland);
+};
+
+struct _GdkWaylandMonitor
+{
+  GdkRectangle  geometry;
+  XID		output;
+  int		width_mm;
+  int		height_mm;
+  char *	output_name;
+  char *	manufacturer;
+};
+
+G_DEFINE_TYPE (GdkScreenWayland, _gdk_screen_wayland, GDK_TYPE_SCREEN)
+
+static void
+init_monitor_geometry (GdkWaylandMonitor *monitor,
+		       int x, int y, int width, int height)
+{
+  monitor->geometry.x = x;
+  monitor->geometry.y = y;
+  monitor->geometry.width = width;
+  monitor->geometry.height = height;
+
+  monitor->output = None;
+  monitor->width_mm = -1;
+  monitor->height_mm = -1;
+  monitor->output_name = NULL;
+  monitor->manufacturer = NULL;
+}
+
+static void
+free_monitors (GdkWaylandMonitor *monitors,
+               gint           n_monitors)
+{
+  int i;
+
+  for (i = 0; i < n_monitors; ++i)
+    {
+      g_free (monitors[i].output_name);
+      g_free (monitors[i].manufacturer);
+    }
+
+  g_free (monitors);
+}
+
+static void
+deinit_multihead (GdkScreen *screen)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  free_monitors (screen_wayland->monitors, screen_wayland->n_monitors);
+
+  screen_wayland->n_monitors = 0;
+  screen_wayland->monitors = NULL;
+}
+
+static void
+init_multihead (GdkScreen *screen)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  /* No multihead support of any kind for this screen */
+  screen_wayland->n_monitors = 1;
+  screen_wayland->monitors = g_new0 (GdkWaylandMonitor, 1);
+  screen_wayland->primary_monitor = 0;
+
+  init_monitor_geometry (screen_wayland->monitors, 0, 0,
+			 screen_wayland->width, screen_wayland->height);
+}
+
+static void
+gdk_wayland_screen_dispose (GObject *object)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (object);
+
+  if (screen_wayland->root_window)
+    _gdk_window_destroy (screen_wayland->root_window, TRUE);
+
+  G_OBJECT_CLASS (_gdk_screen_wayland_parent_class)->dispose (object);
+
+  screen_wayland->wmspec_check_window = None;
+}
+
+static void
+gdk_wayland_screen_finalize (GObject *object)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (object);
+
+  if (screen_wayland->root_window)
+    g_object_unref (screen_wayland->root_window);
+
+  /* Visual Part */
+  g_object_unref (screen_wayland->argb_visual);
+  g_object_unref (screen_wayland->premultiplied_argb_visual);
+  g_object_unref (screen_wayland->rgb_visual);
+
+  g_free (screen_wayland->window_manager_name);
+
+  deinit_multihead (GDK_SCREEN (object));
+
+  G_OBJECT_CLASS (_gdk_screen_wayland_parent_class)->finalize (object);
+}
+
+static GdkDisplay *
+gdk_wayland_screen_get_display (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+  return GDK_SCREEN_WAYLAND (screen)->display;
+}
+
+static gint
+gdk_wayland_screen_get_width (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->width;
+}
+
+static gint
+gdk_wayland_screen_get_height (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->height;
+}
+
+static gint
+gdk_wayland_screen_get_width_mm (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->width_mm;
+}
+
+static gint
+gdk_wayland_screen_get_height_mm (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->height_mm;
+}
+
+static gint
+gdk_wayland_screen_get_number (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return 0;
+}
+
+static GdkWindow *
+gdk_wayland_screen_get_root_window (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+  return GDK_SCREEN_WAYLAND (screen)->root_window;
+}
+
+static gint
+gdk_wayland_screen_get_n_monitors (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->n_monitors;
+}
+
+static gint
+gdk_wayland_screen_get_primary_monitor (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
+
+  return GDK_SCREEN_WAYLAND (screen)->primary_monitor;
+}
+
+static gint
+gdk_wayland_screen_get_monitor_width_mm	(GdkScreen *screen,
+					 gint       monitor_num)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
+  g_return_val_if_fail (monitor_num >= 0, -1);
+  g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, -1);
+
+  return screen_wayland->monitors[monitor_num].width_mm;
+}
+
+static gint
+gdk_wayland_screen_get_monitor_height_mm (GdkScreen *screen,
+					  gint       monitor_num)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
+  g_return_val_if_fail (monitor_num >= 0, -1);
+  g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, -1);
+
+  return screen_wayland->monitors[monitor_num].height_mm;
+}
+
+static gchar *
+gdk_wayland_screen_get_monitor_plug_name (GdkScreen *screen,
+					  gint       monitor_num)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+  g_return_val_if_fail (monitor_num >= 0, NULL);
+  g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, NULL);
+
+  return g_strdup (screen_wayland->monitors[monitor_num].output_name);
+}
+
+static void
+gdk_wayland_screen_get_monitor_geometry (GdkScreen    *screen,
+					 gint          monitor_num,
+					 GdkRectangle *dest)
+{
+  GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  g_return_if_fail (GDK_IS_SCREEN (screen));
+  g_return_if_fail (monitor_num >= 0);
+  g_return_if_fail (monitor_num < screen_wayland->n_monitors);
+
+  if (dest)
+    *dest = screen_wayland->monitors[monitor_num].geometry;
+}
+
+static GdkVisual *
+gdk_wayland_screen_get_system_visual (GdkScreen * screen)
+{
+  return (GdkVisual *) GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static GdkVisual *
+gdk_wayland_screen_get_rgba_visual (GdkScreen *screen)
+{
+  return (GdkVisual *) GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static gboolean
+gdk_wayland_screen_is_composited (GdkScreen *screen)
+{
+  return TRUE;
+}
+
+static gchar *
+gdk_wayland_screen_make_display_name (GdkScreen *screen)
+{
+  return NULL;
+}
+
+static GdkWindow *
+gdk_wayland_screen_get_active_window (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+  return NULL;
+}
+
+static GList *
+gdk_wayland_screen_get_window_stack (GdkScreen *screen)
+{
+  return NULL;
+}
+
+static void
+gdk_wayland_screen_broadcast_client_message (GdkScreen *screen,
+					     GdkEvent  *event)
+{
+}
+
+static gboolean
+gdk_wayland_screen_get_setting (GdkScreen   *screen,
+				const gchar *name,
+				GValue      *value)
+{
+  return FALSE;
+}
+
+typedef struct _GdkWaylandVisual	GdkWaylandVisual;
+typedef struct _GdkWaylandVisualClass	GdkWaylandVisualClass;
+
+struct _GdkWaylandVisual
+{
+  GdkVisual visual;
+  struct wl_visual *wl_visual;
+};
+
+struct _GdkWaylandVisualClass
+{
+  GdkVisualClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkWaylandVisual, _gdk_wayland_visual, GDK_TYPE_VISUAL)
+
+static void
+_gdk_wayland_visual_class_init (GdkWaylandVisualClass *klass)
+{
+}
+
+static void
+_gdk_wayland_visual_init (GdkWaylandVisual *visual)
+{
+}
+
+static gint
+gdk_wayland_screen_visual_get_best_depth (GdkScreen *screen)
+{
+  return 32;
+}
+
+static GdkVisualType
+gdk_wayland_screen_visual_get_best_type (GdkScreen *screen)
+{
+  return GDK_VISUAL_TRUE_COLOR;
+}
+
+static GdkVisual*
+gdk_wayland_screen_visual_get_best (GdkScreen *screen)
+{
+  return GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static GdkVisual*
+gdk_wayland_screen_visual_get_best_with_depth (GdkScreen *screen,
+					       gint       depth)
+{
+  return GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static GdkVisual*
+gdk_wayland_screen_visual_get_best_with_type (GdkScreen     *screen,
+					      GdkVisualType  visual_type)
+{
+  return GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static GdkVisual*
+gdk_wayland_screen_visual_get_best_with_both (GdkScreen     *screen,
+					      gint           depth,
+					      GdkVisualType  visual_type)
+{
+  return GDK_SCREEN_WAYLAND (screen)->argb_visual;
+}
+
+static void
+gdk_wayland_screen_query_depths  (GdkScreen  *screen,
+				  gint      **depths,
+				  gint       *count)
+{
+  static gint static_depths[] = { 32 };
+
+  *count = G_N_ELEMENTS(static_depths);
+  *depths = static_depths;
+}
+
+static void
+gdk_wayland_screen_query_visual_types (GdkScreen      *screen,
+				       GdkVisualType **visual_types,
+				       gint           *count)
+{
+  static GdkVisualType static_visual_types[] = { GDK_VISUAL_TRUE_COLOR };
+
+  *count = G_N_ELEMENTS(static_visual_types);
+  *visual_types = static_visual_types;
+}
+
+static GList *
+gdk_wayland_screen_list_visuals (GdkScreen *screen)
+{
+  GList *list;
+  GdkScreenWayland *screen_wayland;
+
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+  screen_wayland = GDK_SCREEN_WAYLAND (screen);
+
+  list = g_list_append (NULL, screen_wayland->argb_visual);
+  list = g_list_append (NULL, screen_wayland->premultiplied_argb_visual);
+  list = g_list_append (NULL, screen_wayland->rgb_visual);
+
+  return list;
+}
+
+#define GDK_TYPE_WAYLAND_VISUAL              (_gdk_wayland_visual_get_type ())
+#define GDK_WAYLAND_VISUAL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_VISUAL, GdkWaylandVisual))
+
+static GdkVisual *
+gdk_wayland_visual_new (GdkScreen *screen, struct wl_visual *wl_visual)
+{
+  GdkVisual *visual;
+
+  visual = g_object_new (GDK_TYPE_WAYLAND_VISUAL, NULL);
+  visual->screen = GDK_SCREEN (screen);
+  visual->type = GDK_VISUAL_TRUE_COLOR;
+  visual->depth = 32;
+
+  GDK_WAYLAND_VISUAL (visual)->wl_visual = wl_visual;
+
+  return visual;
+}
+
+GdkScreen *
+_gdk_wayland_screen_new (GdkDisplay *display)
+{
+  GdkScreen *screen;
+  GdkScreenWayland *screen_wayland;
+  GdkDisplayWayland *display_wayland;
+  struct wl_visual *visual;
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  screen = g_object_new (GDK_TYPE_SCREEN_WAYLAND, NULL);
+
+  screen_wayland = GDK_SCREEN_WAYLAND (screen);
+  screen_wayland->display = display;
+  screen_wayland->wmspec_check_window = None;
+  /* we want this to be always non-null */
+  screen_wayland->window_manager_name = g_strdup ("unknown");
+
+  screen_wayland->width = 8192;
+  screen_wayland->height = 8192;
+
+  visual = wl_display_get_argb_visual(display_wayland->wl_display);
+  screen_wayland->argb_visual = gdk_wayland_visual_new (screen, visual);
+
+  visual =
+    wl_display_get_premultiplied_argb_visual(display_wayland->wl_display);
+  screen_wayland->premultiplied_argb_visual =
+    gdk_wayland_visual_new (screen, visual);
+
+  visual = wl_display_get_rgb_visual(display_wayland->wl_display);
+  screen_wayland->rgb_visual = gdk_wayland_visual_new (screen, visual);
+
+  screen_wayland->root_window =
+    _gdk_wayland_screen_create_root_window (screen,
+					    screen_wayland->width,
+					    screen_wayland->height);
+
+  init_multihead (screen);
+
+  return screen;
+}
+
+static void
+_gdk_screen_wayland_class_init (GdkScreenWaylandClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
+
+  object_class->dispose = gdk_wayland_screen_dispose;
+  object_class->finalize = gdk_wayland_screen_finalize;
+
+  screen_class->get_display = gdk_wayland_screen_get_display;
+  screen_class->get_width = gdk_wayland_screen_get_width;
+  screen_class->get_height = gdk_wayland_screen_get_height;
+  screen_class->get_width_mm = gdk_wayland_screen_get_width_mm;
+  screen_class->get_height_mm = gdk_wayland_screen_get_height_mm;
+  screen_class->get_number = gdk_wayland_screen_get_number;
+  screen_class->get_root_window = gdk_wayland_screen_get_root_window;
+  screen_class->get_n_monitors = gdk_wayland_screen_get_n_monitors;
+  screen_class->get_primary_monitor = gdk_wayland_screen_get_primary_monitor;
+  screen_class->get_monitor_width_mm = gdk_wayland_screen_get_monitor_width_mm;
+  screen_class->get_monitor_height_mm = gdk_wayland_screen_get_monitor_height_mm;
+  screen_class->get_monitor_plug_name = gdk_wayland_screen_get_monitor_plug_name;
+  screen_class->get_monitor_geometry = gdk_wayland_screen_get_monitor_geometry;
+  screen_class->get_system_visual = gdk_wayland_screen_get_system_visual;
+  screen_class->get_rgba_visual = gdk_wayland_screen_get_rgba_visual;
+  screen_class->is_composited = gdk_wayland_screen_is_composited;
+  screen_class->make_display_name = gdk_wayland_screen_make_display_name;
+  screen_class->get_active_window = gdk_wayland_screen_get_active_window;
+  screen_class->get_window_stack = gdk_wayland_screen_get_window_stack;
+  screen_class->broadcast_client_message = gdk_wayland_screen_broadcast_client_message;
+  screen_class->get_setting = gdk_wayland_screen_get_setting;
+  screen_class->visual_get_best_depth = gdk_wayland_screen_visual_get_best_depth;
+  screen_class->visual_get_best_type = gdk_wayland_screen_visual_get_best_type;
+  screen_class->visual_get_best = gdk_wayland_screen_visual_get_best;
+  screen_class->visual_get_best_with_depth = gdk_wayland_screen_visual_get_best_with_depth;
+  screen_class->visual_get_best_with_type = gdk_wayland_screen_visual_get_best_with_type;
+  screen_class->visual_get_best_with_both = gdk_wayland_screen_visual_get_best_with_both;
+  screen_class->query_depths = gdk_wayland_screen_query_depths;
+  screen_class->query_visual_types = gdk_wayland_screen_query_visual_types;
+  screen_class->list_visuals = gdk_wayland_screen_list_visuals;
+}
+
+static void
+_gdk_screen_wayland_init (GdkScreenWayland *screen_wayland)
+{
+}
diff --git a/gdk/wayland/gdkscreen-wayland.h b/gdk/wayland/gdkscreen-wayland.h
new file mode 100644
index 0000000000..9fa4baab81
--- /dev/null
+++ b/gdk/wayland/gdkscreen-wayland.h
@@ -0,0 +1,36 @@
+/*
+ * gdkscreen-wayland.h
+ * 
+ * Copyright 2001 Sun Microsystems Inc. 
+ *
+ * Erwann Chenede <erwann.chenede@sun.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GDK_SCREEN_WAYLAND_H__
+#define __GDK_SCREEN_WAYLAND_H__
+
+#include "gdkprivate-wayland.h"
+#include <gdk/gdkscreenprivate.h>
+#include <gdk/gdkvisual.h>
+
+G_BEGIN_DECLS
+  
+
+G_END_DECLS
+
+#endif /* __GDK_SCREEN_WAYLAND_H__ */
diff --git a/gdk/wayland/gdkselection-wayland.c b/gdk/wayland/gdkselection-wayland.c
new file mode 100644
index 0000000000..f2f4b2f1a6
--- /dev/null
+++ b/gdk/wayland/gdkselection-wayland.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gdkselection.h"
+#include "gdkproperty.h"
+#include "gdkprivate.h"
+
+#include <string.h>
+
+GdkWindow *
+_gdk_wayland_display_get_selection_owner (GdkDisplay *display,
+					  GdkAtom     selection)
+{
+  return NULL;
+}
+
+gboolean
+_gdk_wayland_display_set_selection_owner (GdkDisplay *display,
+					  GdkWindow  *owner,
+					  GdkAtom     selection,
+					  guint32     time,
+					  gboolean    send_event)
+{
+  return FALSE;
+}
+
+void
+_gdk_wayland_display_send_selection_notify (GdkDisplay       *display,
+					    GdkNativeWindow  requestor,
+					    GdkAtom          selection,
+					    GdkAtom          target,
+					    GdkAtom          property,
+					    guint32          time)
+{
+}
+
+gint
+_gdk_wayland_display_get_selection_property (GdkDisplay  *display,
+					     GdkWindow   *requestor,
+					     guchar     **data,
+					     GdkAtom     *ret_type,
+					     gint        *ret_format)
+{
+  return 0;
+}
+
+void
+_gdk_wayland_display_convert_selection (GdkDisplay *display,
+					GdkWindow  *requestor,
+					GdkAtom     selection,
+					GdkAtom     target,
+					guint32     time)
+{
+}
+
+gint
+_gdk_wayland_display_text_property_to_utf8_list (GdkDisplay    *display,
+						 GdkAtom        encoding,
+						 gint           format,
+						 const guchar  *text,
+						 gint           length,
+						 gchar       ***list)
+{
+  return 0;
+}
+
+gchar *
+_gdk_wayland_display_utf8_to_string_target (GdkDisplay  *display,
+					    const gchar *str)
+{
+  return NULL;
+}
diff --git a/gdk/wayland/gdkwayland.h b/gdk/wayland/gdkwayland.h
new file mode 100644
index 0000000000..c9e9f6e14d
--- /dev/null
+++ b/gdk/wayland/gdkwayland.h
@@ -0,0 +1,38 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifndef __GDK_WAYLAND_H__
+#define __GDK_WAYLAND_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+GType      gdk_wayland_display_manager_get_type   (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WAYLAND_H__ */
diff --git a/gdk/wayland/gdkwindow-wayland.c b/gdk/wayland/gdkwindow-wayland.c
new file mode 100644
index 0000000000..15a2e4c5f8
--- /dev/null
+++ b/gdk/wayland/gdkwindow-wayland.c
@@ -0,0 +1,1419 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <netinet/in.h>
+#include <unistd.h>
+
+#include "gdk.h"
+#include "gdkwayland.h"
+
+#include "gdkwindow.h"
+#include "gdkwindowimpl.h"
+#include "gdkdisplay-wayland.h"
+#include "gdkscreen-wayland.h"
+#include "gdkprivate-wayland.h"
+#include "gdkinternals.h"
+#include "gdkwindow-wayland.h"
+#include "gdkdeviceprivate.h"
+#include "gdkdevice-wayland.h"
+#include "gdkeventsource.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window) \
+  (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
+   GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
+
+#define WINDOW_IS_TOPLEVEL(window)		     \
+  (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
+   GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
+   GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
+
+/* Return whether time1 is considered later than time2 as far as xserver
+ * time is concerned.  Accounts for wraparound.
+ */
+#define XSERVER_TIME_IS_LATER(time1, time2)                        \
+  ( (( time1 > time2 ) && ( time1 - time2 < ((guint32)-1)/2 )) ||  \
+    (( time1 < time2 ) && ( time2 - time1 > ((guint32)-1)/2 ))     \
+  )
+
+typedef struct _GdkWaylandWindow GdkWaylandWindow;
+typedef struct _GdkWaylandWindowClass GdkWaylandWindowClass;
+
+struct _GdkWaylandWindow {
+  GdkWindow parent;
+};
+
+struct _GdkWaylandWindowClass {
+  GdkWindowClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkWaylandWindow, _gdk_wayland_window, GDK_TYPE_WINDOW)
+
+static void
+_gdk_wayland_window_class_init (GdkWaylandWindowClass *wayland_window_class)
+{
+}
+
+static void
+_gdk_wayland_window_init (GdkWaylandWindow *wayland_window)
+{
+}
+
+G_DEFINE_TYPE (GdkWindowImplWayland, _gdk_window_impl_wayland, GDK_TYPE_WINDOW_IMPL)
+
+static void
+_gdk_window_impl_wayland_init (GdkWindowImplWayland *impl)
+{  
+  impl->toplevel_window_type = -1;
+  impl->device_cursor = g_hash_table_new_full (NULL, NULL, NULL,
+                                               (GDestroyNotify) gdk_cursor_unref);
+}
+
+GdkToplevelWayland *
+_gdk_wayland_window_get_toplevel (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl;
+  
+  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+  if (!WINDOW_IS_TOPLEVEL (window))
+    return NULL;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (!impl->toplevel)
+    impl->toplevel = g_new0 (GdkToplevelWayland, 1);
+
+  return impl->toplevel;
+}
+
+/**
+ * _gdk_wayland_window_update_size:
+ * @drawable: a #GdkDrawableImplWayland.
+ * 
+ * Updates the state of the drawable (in particular the drawable's
+ * cairo surface) when its size has changed.
+ **/
+void
+_gdk_wayland_window_update_size (GdkWindowImplWayland *impl)
+{
+  GdkDisplayWayland *display_wayland =
+    GDK_DISPLAY_WAYLAND (gdk_window_get_display (impl->wrapper));
+
+  fprintf(stderr, "update size, window %p\n", impl->wrapper);
+
+  if (impl->cairo_surface)
+    {
+      cairo_surface_destroy (impl->cairo_surface);
+      impl->cairo_surface = NULL;
+    }
+
+  if (impl->image)
+    {
+      if (impl->image == impl->next_image)
+	impl->next_image = NULL;
+
+      if (impl->image != impl->pending_image)
+	display_wayland->destroy_image(display_wayland->egl_display,
+				       impl->image);
+
+      impl->image = NULL;
+
+      fprintf(stderr, " - cleared image\n");
+    }
+}
+
+GdkWindow *
+_gdk_wayland_screen_create_root_window (GdkScreen *screen,
+					int width, int height)
+{
+  GdkWindow *window;
+  GdkWindowImplWayland *impl;
+
+  window = _gdk_display_create_window (gdk_screen_get_display (screen));
+  window->impl = g_object_new (GDK_TYPE_WINDOW_IMPL_WAYLAND, NULL);
+  window->impl_window = window;
+  window->visual = gdk_screen_get_system_visual (screen);
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  impl->wrapper = GDK_WINDOW (window);
+
+  window->window_type = GDK_WINDOW_ROOT;
+  window->depth = 32;
+
+  window->x = 0;
+  window->y = 0;
+  window->abs_x = 0;
+  window->abs_y = 0;
+  window->width = width;
+  window->height = height;
+  window->viewable = TRUE;
+
+  /* see init_randr_support() in gdkscreen-wayland.c */
+  window->event_mask = GDK_STRUCTURE_MASK;
+
+  return window;
+}
+
+static const gchar *
+get_default_title (void)
+{
+  const char *title;
+
+  title = g_get_application_name ();
+  if (!title)
+    title = g_get_prgname ();
+  if (!title)
+    title = "";
+
+  return title;
+}
+
+void
+_gdk_wayland_display_create_window_impl (GdkDisplay    *display,
+					 GdkWindow     *window,
+					 GdkWindow     *real_parent,
+					 GdkScreen     *screen,
+					 GdkEventMask   event_mask,
+					 GdkWindowAttr *attributes,
+					 gint           attributes_mask)
+{
+  GdkWindowImplWayland *impl;
+  GdkDisplayWayland *display_wayland;
+  const char *title;
+
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  impl = g_object_new (GDK_TYPE_WINDOW_IMPL_WAYLAND, NULL);
+  window->impl = GDK_WINDOW_IMPL (impl);
+  impl->wrapper = GDK_WINDOW (window);
+
+  printf("impl_new for window %p: %p\n", window, impl);
+
+  if (window->width > 65535 ||
+      window->height > 65535)
+    {
+      g_warning ("Native Windows wider or taller than 65535 pixels are not supported");
+      
+      if (window->width > 65535)
+	window->width = 65535;
+      if (window->height > 65535)
+	window->height = 65535;
+    }
+  
+  g_object_ref (window);
+
+  switch (GDK_WINDOW_TYPE (window))
+    {
+    case GDK_WINDOW_TOPLEVEL:
+    case GDK_WINDOW_TEMP:
+      if (attributes_mask & GDK_WA_TITLE)
+	title = attributes->title;
+      else
+	title = get_default_title ();
+
+      gdk_window_set_title (window, title);
+      break;
+
+    case GDK_WINDOW_CHILD:
+    default:
+      break;
+    }
+
+  if (attributes_mask & GDK_WA_TYPE_HINT)
+    gdk_window_set_type_hint (window, attributes->type_hint);
+}
+
+static void
+gdk_toplevel_wayland_free_contents (GdkDisplay *display,
+				GdkToplevelWayland *toplevel)
+{
+  if (toplevel->icon_pixmap)
+    {
+      cairo_surface_destroy (toplevel->icon_pixmap);
+      toplevel->icon_pixmap = NULL;
+    }
+  if (toplevel->icon_mask)
+    {
+      cairo_surface_destroy (toplevel->icon_mask);
+      toplevel->icon_mask = NULL;
+    }
+}
+
+void
+_gdk_wayland_window_attach_image (GdkWindow *window, EGLImageKHR image)
+{
+  GdkDisplayWayland *display_wayland =
+    GDK_DISPLAY_WAYLAND (gdk_window_get_display (window));
+  GdkWindowImplWayland *impl;
+  EGLint name, stride;
+  struct wl_visual *wl_visual;
+  struct wl_buffer *buffer;
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (impl->pending_image)
+    {
+      if (impl->next_image && impl->next_image != impl->image)
+	display_wayland->destroy_image(display_wayland->egl_display,
+				       impl->next_image);
+
+      impl->next_image = image;
+
+      return;
+    }
+
+  impl->pending_image = image;
+
+  wl_visual =
+    wl_display_get_premultiplied_argb_visual(display_wayland->wl_display);
+
+  display_wayland->export_drm_image (display_wayland->egl_display,
+				     image, &name, NULL, &stride);
+
+  buffer = wl_drm_create_buffer(display_wayland->drm,
+				name, window->width, window->height,
+				stride, wl_visual);
+  wl_surface_attach (impl->surface, buffer, 0, 0);
+  wl_surface_map_toplevel (impl->surface);
+  wl_buffer_destroy(buffer);
+
+  g_object_ref(impl);
+
+  fprintf(stderr, "attach %p %dx%d (image %p, name %d)\n",
+	  window, window->width, window->height,
+	  impl->pending_image, name);
+}
+
+static void
+gdk_window_impl_wayland_finalize (GObject *object)
+{
+  GdkWindow *wrapper;
+  GdkWindowImplWayland *impl;
+
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_WAYLAND (object));
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (object);
+
+  wrapper = impl->wrapper;
+
+  g_free (impl->toplevel);
+
+  if (impl->cursor)
+    gdk_cursor_unref (impl->cursor);
+
+  g_hash_table_destroy (impl->device_cursor);
+
+  G_OBJECT_CLASS (_gdk_window_impl_wayland_parent_class)->finalize (object);
+}
+
+static const cairo_user_data_key_t gdk_wayland_cairo_key;
+
+static void
+gdk_wayland_cairo_surface_destroy (void *data)
+{
+  GdkWindowImplWayland *impl = data;
+
+  impl->cairo_surface = NULL;
+}
+
+gboolean
+_gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
+				       int width,
+				       int height)
+{
+  fprintf (stderr, "_gdk_windowing_set_cairo_surface_size\n");
+
+  return FALSE;
+}
+
+static cairo_surface_t *
+gdk_wayland_create_cairo_surface (GdkWindowImplWayland *impl,
+			      int width,
+			      int height)
+{
+  GdkDisplayWayland *display_wayland =
+    GDK_DISPLAY_WAYLAND (gdk_window_get_display (impl->wrapper));
+  cairo_surface_t *surface;
+
+  EGLint image_attribs[] = {
+    EGL_WIDTH,			0,
+    EGL_HEIGHT,			0,
+    EGL_DRM_BUFFER_FORMAT_MESA,	EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
+    EGL_DRM_BUFFER_USE_MESA,	EGL_DRM_BUFFER_USE_SCANOUT_MESA,
+    EGL_NONE
+  };
+
+  if (impl->image == NULL)
+    {
+      image_attribs[1] = width;
+      image_attribs[3] = height;
+      impl->image =
+	display_wayland->create_drm_image(display_wayland->egl_display,
+					  image_attribs);
+      if (impl->texture == 0)
+	glGenTextures(1, &impl->texture);
+
+      glBindTexture(GL_TEXTURE_2D, impl->texture);
+      display_wayland->image_target_texture_2d(GL_TEXTURE_2D, impl->image);
+
+      printf("allocate image %dx%d (image %p, window %p)\n",
+	     width, height, impl->image, impl->wrapper);
+    }
+
+  surface = cairo_gl_surface_create_for_texture(display_wayland->cairo_device,
+						CAIRO_CONTENT_COLOR_ALPHA,
+						impl->texture, width, height);
+
+  if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS)
+    fprintf (stderr, "create gl surface failed\n");
+
+  return surface;
+}
+
+static cairo_surface_t *
+gdk_wayland_window_ref_cairo_surface (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (GDK_WINDOW_DESTROYED (impl->wrapper))
+    return NULL;
+
+  if (!impl->cairo_surface)
+    {
+      impl->cairo_surface =
+	gdk_wayland_create_cairo_surface (impl,
+				      impl->wrapper->width,
+				      impl->wrapper->height);
+
+      cairo_surface_set_user_data (impl->cairo_surface, &gdk_wayland_cairo_key,
+				   impl, gdk_wayland_cairo_surface_destroy);
+    }
+  else
+    cairo_surface_reference (impl->cairo_surface);
+
+  return impl->cairo_surface;
+}
+
+static void
+gdk_wayland_window_set_user_time (GdkWindow *window, guint32 user_time)
+{
+}
+
+static void
+gdk_wayland_window_show (GdkWindow *window, gboolean already_mapped)
+{
+  GdkDisplay *display;
+  GdkDisplayWayland *display_wayland;
+  GdkToplevelWayland *toplevel;
+  GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (WINDOW_IS_TOPLEVEL (window))
+    {
+      display = gdk_window_get_display (window);
+      display_wayland = GDK_DISPLAY_WAYLAND (display);
+      toplevel = _gdk_wayland_window_get_toplevel (window);
+
+      if (toplevel->user_time != 0 &&
+	      display_wayland->user_time != 0 &&
+	  XSERVER_TIME_IS_LATER (display_wayland->user_time, toplevel->user_time))
+	gdk_wayland_window_set_user_time (window, display_wayland->user_time);
+    }
+
+  display = gdk_window_get_display (window);
+  display_wayland = GDK_DISPLAY_WAYLAND (display);
+
+  impl->surface = wl_compositor_create_surface(display_wayland->compositor);
+  wl_surface_set_user_data(impl->surface, window);
+
+  _gdk_make_event (window, GDK_MAP, NULL, FALSE);
+}
+
+static void
+gdk_wayland_window_hide (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (impl->surface)
+    {
+      fprintf (stderr, "hide surface %p\n", impl->surface);
+
+      wl_surface_destroy(impl->surface);
+      impl->surface = NULL;
+    }
+
+  _gdk_window_clear_update_area (window);
+}
+
+static void
+gdk_window_wayland_withdraw (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl;
+
+  if (!window->destroyed)
+    {
+      if (GDK_WINDOW_IS_MAPPED (window))
+	gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_WITHDRAWN);
+
+      g_assert (!GDK_WINDOW_IS_MAPPED (window));
+
+      impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+      if (impl->surface)
+	{
+	  fprintf (stderr, "hide surface %p\n", impl->surface);
+
+	  wl_surface_destroy(impl->surface);
+	  impl->surface = NULL;
+	  cairo_surface_destroy(GDK_WINDOW_IMPL_WAYLAND(impl)->cairo_surface);
+	}
+    }
+}
+
+static void
+gdk_window_wayland_set_events (GdkWindow    *window,
+			       GdkEventMask  event_mask)
+{
+  GDK_WINDOW (window)->event_mask = event_mask;
+}
+
+static GdkEventMask
+gdk_window_wayland_get_events (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return 0;
+  else
+    return GDK_WINDOW (window)->event_mask;
+}
+
+static void
+gdk_window_wayland_raise (GdkWindow *window)
+{
+  /* FIXME: wl_shell_raise() */
+}
+
+static void
+gdk_window_wayland_lower (GdkWindow *window)
+{
+  /* FIXME: wl_shell_lower() */
+}
+
+static void
+gdk_window_wayland_restack_under (GdkWindow *window,
+			      GList *native_siblings)
+{
+}
+
+static void
+gdk_window_wayland_restack_toplevel (GdkWindow *window,
+				 GdkWindow *sibling,
+				 gboolean   above)
+{
+}
+
+static void
+gdk_window_wayland_move_resize (GdkWindow *window,
+				gboolean   with_move,
+				gint       x,
+				gint       y,
+				gint       width,
+				gint       height)
+{
+  GdkWindowImplWayland *impl;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  window->x = x;
+  window->y = y;
+  if (width > 0)
+    window->width = width;
+  if (height > 0)
+    window->height = height;
+
+  _gdk_wayland_window_update_size (GDK_WINDOW_IMPL_WAYLAND (window->impl));
+}
+
+static void
+gdk_window_wayland_set_background (GdkWindow      *window,
+			       cairo_pattern_t *pattern)
+{
+}
+
+static gboolean
+gdk_window_wayland_reparent (GdkWindow *window,
+			     GdkWindow *new_parent,
+			     gint       x,
+			     gint       y)
+{
+  return FALSE;
+}
+
+static void
+gdk_window_wayland_set_device_cursor (GdkWindow *window,
+				      GdkDevice *device,
+				      GdkCursor *cursor)
+{
+  GdkWindowImplWayland *impl;
+
+  g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (GDK_IS_DEVICE (device));
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (!cursor)
+    g_hash_table_remove (impl->device_cursor, device);
+  else
+    {
+      g_hash_table_replace (impl->device_cursor,
+			    device, gdk_cursor_ref (cursor));
+    }
+
+  if (!GDK_WINDOW_DESTROYED (window))
+    GDK_DEVICE_GET_CLASS (device)->set_window_cursor (device, window, cursor);
+}
+
+static void
+gdk_window_wayland_get_geometry (GdkWindow *window,
+				 gint      *x,
+				 gint      *y,
+				 gint      *width,
+				 gint      *height)
+{
+  if (!GDK_WINDOW_DESTROYED (window))
+    {
+      if (x)
+	*x = window->x;
+      if (y)
+	*y = window->y;
+      if (width)
+	*width = window->width;
+      if (height)
+	*height = window->height;
+    }
+}
+
+static gint
+gdk_window_wayland_get_root_coords (GdkWindow *window,
+				gint       x,
+				gint       y,
+				gint      *root_x,
+				gint      *root_y)
+{
+  /* We can't do this. */
+  if (root_x)
+    *root_x = 0;
+  if (root_y)
+    *root_y = 0;
+
+  return 1;
+}
+
+static gboolean
+gdk_window_wayland_get_device_state (GdkWindow       *window,
+				     GdkDevice       *device,
+				     gint            *x,
+				     gint            *y,
+				     GdkModifierType *mask)
+{
+  gboolean return_val;
+
+  g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), FALSE);
+
+  return_val = TRUE;
+
+  if (!GDK_WINDOW_DESTROYED (window))
+    {
+      GdkWindow *child;
+
+      GDK_DEVICE_GET_CLASS (device)->query_state (device, window,
+						  NULL, &child,
+						  NULL, NULL,
+						  x, y, mask);
+      return_val = (child != NULL);
+    }
+
+  return return_val;
+}
+
+static void
+gdk_window_wayland_shape_combine_region (GdkWindow       *window,
+					 const cairo_region_t *shape_region,
+					 gint             offset_x,
+					 gint             offset_y)
+{
+}
+
+static void 
+gdk_window_wayland_input_shape_combine_region (GdkWindow       *window,
+					       const cairo_region_t *shape_region,
+					       gint             offset_x,
+					       gint             offset_y)
+{
+}
+
+static gboolean
+gdk_window_wayland_set_static_gravities (GdkWindow *window,
+					 gboolean   use_static)
+{
+  return TRUE;
+}
+
+static gboolean
+gdk_wayland_window_queue_antiexpose (GdkWindow *window,
+				     cairo_region_t *area)
+{
+  return FALSE;
+}
+
+static void
+gdk_wayland_window_translate (GdkWindow      *window,
+			      cairo_region_t *area,
+			      gint            dx,
+			      gint            dy)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  surface = gdk_wayland_window_ref_cairo_surface (window->impl_window);
+  cr = cairo_create (surface);
+  cairo_surface_destroy (surface);
+
+  gdk_cairo_region (cr, area);
+  cairo_clip (cr);
+  cairo_set_source_surface (cr, cairo_get_target (cr), dx, dy);
+  cairo_push_group (cr);
+  cairo_paint (cr);
+  cairo_pop_group_to_source (cr);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+}
+
+static void
+gdk_wayland_window_destroy (GdkWindow *window,
+			    gboolean   recursing,
+			    gboolean   foreign_destroy)
+{
+  GdkToplevelWayland *toplevel;
+  GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
+  toplevel = _gdk_wayland_window_get_toplevel (window);
+  if (toplevel)
+    gdk_toplevel_wayland_free_contents (gdk_window_get_display (window),
+					toplevel);
+
+  if (impl->cairo_surface)
+    {
+      cairo_surface_finish (impl->cairo_surface);
+      cairo_surface_set_user_data (impl->cairo_surface, &gdk_wayland_cairo_key,
+				   NULL, NULL);
+    }
+
+  if (impl->texture)
+    glDeleteTextures(1, &impl->texture);
+
+  if (!recursing && !foreign_destroy)
+    {
+      fprintf (stderr, "destroy window, surface %p\n",
+	       GDK_WINDOW_IMPL_WAYLAND (window->impl)->surface);
+
+      if (GDK_WINDOW_IMPL_WAYLAND (window->impl)->surface)
+	wl_surface_destroy(GDK_WINDOW_IMPL_WAYLAND (window->impl)->surface);
+    }
+}
+
+static void
+gdk_window_wayland_destroy_foreign (GdkWindow *window)
+{
+}
+
+static cairo_surface_t *
+gdk_window_wayland_resize_cairo_surface (GdkWindow       *window,
+					 cairo_surface_t *surface,
+					 gint             width,
+					 gint             height)
+{
+  return surface;
+}
+
+static cairo_region_t *
+gdk_wayland_window_get_shape (GdkWindow *window)
+{
+  return NULL;
+}
+
+static cairo_region_t *
+gdk_wayland_window_get_input_shape (GdkWindow *window)
+{
+  return NULL;
+}
+
+static void
+gdk_wayland_window_focus (GdkWindow *window,
+			  guint32    timestamp)
+{
+  /* FIXME: wl_shell_focus() */
+}
+
+static void
+gdk_wayland_window_set_type_hint (GdkWindow        *window,
+				  GdkWindowTypeHint hint)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+
+  switch (hint)
+    {
+    case GDK_WINDOW_TYPE_HINT_DIALOG:
+    case GDK_WINDOW_TYPE_HINT_MENU:
+    case GDK_WINDOW_TYPE_HINT_TOOLBAR:
+    case GDK_WINDOW_TYPE_HINT_UTILITY:
+    case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
+    case GDK_WINDOW_TYPE_HINT_DOCK:
+    case GDK_WINDOW_TYPE_HINT_DESKTOP:
+    case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
+    case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
+    case GDK_WINDOW_TYPE_HINT_TOOLTIP:
+    case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
+    case GDK_WINDOW_TYPE_HINT_COMBO:
+    case GDK_WINDOW_TYPE_HINT_DND:
+      break;
+    default:
+      g_warning ("Unknown hint %d passed to gdk_window_set_type_hint", hint);
+      /* Fall thru */
+    case GDK_WINDOW_TYPE_HINT_NORMAL:
+      break;
+    }
+}
+
+static GdkWindowTypeHint
+gdk_wayland_window_get_type_hint (GdkWindow *window)
+{
+  return GDK_WINDOW_TYPE_HINT_NORMAL;
+}
+
+void
+gdk_wayland_window_set_modal_hint (GdkWindow *window,
+				   gboolean   modal)
+{
+}
+
+static void
+gdk_wayland_window_set_skip_taskbar_hint (GdkWindow *window,
+					  gboolean   skips_taskbar)
+{
+}
+
+static void
+gdk_wayland_window_set_skip_pager_hint (GdkWindow *window,
+					gboolean   skips_pager)
+{
+}
+
+static void
+gdk_wayland_window_set_urgency_hint (GdkWindow *window,
+				     gboolean   urgent)
+{
+}
+
+static void
+gdk_wayland_window_set_geometry_hints (GdkWindow         *window,
+				       const GdkGeometry *geometry,
+				       GdkWindowHints     geom_mask)
+{
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
+    return;
+
+  /*
+   * GDK_HINT_POS
+   * GDK_HINT_USER_POS
+   * GDK_HINT_USER_SIZE
+   * GDK_HINT_MIN_SIZE
+   * GDK_HINT_MAX_SIZE
+   * GDK_HINT_BASE_SIZE
+   * GDK_HINT_RESIZE_INC
+   * GDK_HINT_ASPECT
+   * GDK_HINT_WIN_GRAVITY
+   */
+}
+
+static void
+gdk_wayland_window_set_title (GdkWindow   *window,
+			      const gchar *title)
+{
+  g_return_if_fail (title != NULL);
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_set_role (GdkWindow   *window,
+			     const gchar *role)
+{
+}
+
+static void
+gdk_wayland_window_set_startup_id (GdkWindow   *window,
+				   const gchar *startup_id)
+{
+}
+
+static void
+gdk_wayland_window_set_transient_for (GdkWindow *window,
+				      GdkWindow *parent)
+{
+}
+
+static void
+gdk_wayland_window_get_root_origin (GdkWindow *window,
+				   gint      *x,
+				   gint      *y)
+{
+  if (x)
+    *x = 0;
+
+  if (y)
+    *y = 0;
+}
+
+static void
+gdk_wayland_window_get_frame_extents (GdkWindow    *window,
+				      GdkRectangle *rect)
+{
+  rect->x = window->x;
+  rect->y = window->y;
+  rect->width = window->width;
+  rect->height = window->height;
+}
+
+static void
+gdk_wayland_window_set_override_redirect (GdkWindow *window,
+					  gboolean override_redirect)
+{
+}
+
+static void
+gdk_wayland_window_set_accept_focus (GdkWindow *window,
+				     gboolean accept_focus)
+{
+}
+
+static void
+gdk_wayland_window_set_focus_on_map (GdkWindow *window,
+				     gboolean focus_on_map)
+{
+  focus_on_map = focus_on_map != FALSE;
+
+  if (window->focus_on_map != focus_on_map)
+    {
+      window->focus_on_map = focus_on_map;
+
+      if ((!GDK_WINDOW_DESTROYED (window)) &&
+	  (!window->focus_on_map) &&
+	  WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
+	gdk_wayland_window_set_user_time (window, 0);
+    }
+}
+
+static void
+gdk_wayland_window_set_icon_list (GdkWindow *window,
+				  GList     *pixbufs)
+{
+}
+
+static void
+gdk_wayland_window_set_icon_name (GdkWindow   *window,
+				  const gchar *name)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_iconify (GdkWindow *window)
+{
+}
+
+static void
+gdk_wayland_window_deiconify (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
+    return;
+
+  if (GDK_WINDOW_IS_MAPPED (window))
+    {  
+      gdk_window_show (window);
+    }
+  else
+    {
+      /* Flip our client side flag, the real work happens on map. */
+      gdk_synthesize_window_state (window, GDK_WINDOW_STATE_ICONIFIED, 0);
+    }
+}
+
+static void
+gdk_wayland_window_stick (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_unstick (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_maximize (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_unmaximize (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_fullscreen (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_unfullscreen (GdkWindow *window)
+{
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_set_keep_above (GdkWindow *window,
+				   gboolean   setting)
+{
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static void
+gdk_wayland_window_set_keep_below (GdkWindow *window, gboolean setting)
+{
+  g_return_if_fail (GDK_IS_WINDOW (window));
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+}
+
+static GdkWindow *
+gdk_wayland_window_get_group (GdkWindow *window)
+{
+  GdkToplevelWayland *toplevel;
+
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL (window))
+    return NULL;
+
+  return NULL;
+}
+
+static void
+gdk_wayland_window_set_group (GdkWindow *window,
+			      GdkWindow *leader)
+{
+  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));
+}
+
+static void
+gdk_wayland_window_set_decorations (GdkWindow      *window,
+				    GdkWMDecoration decorations)
+{
+}
+
+static gboolean
+gdk_wayland_window_get_decorations (GdkWindow       *window,
+				    GdkWMDecoration *decorations)
+{
+  return FALSE;
+}
+
+static void
+gdk_wayland_window_set_functions (GdkWindow    *window,
+				  GdkWMFunction functions)
+{
+}
+
+enum wl_grab_type {
+	WL_DEVICE_GRAB_NONE = 0,
+	WL_DEVICE_GRAB_RESIZE_TOP = 1,
+	WL_DEVICE_GRAB_RESIZE_BOTTOM = 2,
+	WL_DEVICE_GRAB_RESIZE_LEFT = 4,
+	WL_DEVICE_GRAB_RESIZE_TOP_LEFT = 5,
+	WL_DEVICE_GRAB_RESIZE_BOTTOM_LEFT = 6,
+	WL_DEVICE_GRAB_RESIZE_RIGHT = 8,
+	WL_DEVICE_GRAB_RESIZE_TOP_RIGHT = 9,
+	WL_DEVICE_GRAB_RESIZE_BOTTOM_RIGHT = 10,
+	WL_DEVICE_GRAB_RESIZE_MASK = 15,
+	WL_DEVICE_GRAB_MOVE = 16,
+	WL_DEVICE_GRAB_MOTION = 17
+};
+
+static void
+gdk_wayland_window_begin_resize_drag (GdkWindow     *window,
+				      GdkWindowEdge  edge,
+				      gint           button,
+				      gint           root_x,
+				      gint           root_y,
+				      guint32        timestamp)
+{
+  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDeviceManager *dm;
+  GdkWindowImplWayland *impl;
+  GdkDevice *device;
+  uint32_t grab_type;
+
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
+    return;
+
+  switch (edge)
+    {
+    case GDK_WINDOW_EDGE_NORTH_WEST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_TOP_LEFT;
+      break;
+
+    case GDK_WINDOW_EDGE_NORTH:
+      grab_type = WL_DEVICE_GRAB_RESIZE_TOP;
+      break;
+
+    case GDK_WINDOW_EDGE_NORTH_EAST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_RIGHT;
+      break;
+
+    case GDK_WINDOW_EDGE_WEST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_LEFT;
+      break;
+
+    case GDK_WINDOW_EDGE_EAST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_RIGHT;
+      break;
+
+    case GDK_WINDOW_EDGE_SOUTH_WEST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_BOTTOM_LEFT;
+      break;
+
+    case GDK_WINDOW_EDGE_SOUTH:
+      grab_type = WL_DEVICE_GRAB_RESIZE_BOTTOM;
+      break;
+
+    case GDK_WINDOW_EDGE_SOUTH_EAST:
+      grab_type = WL_DEVICE_GRAB_RESIZE_BOTTOM_RIGHT;
+      break;
+
+    default:
+      g_warning ("gdk_window_begin_resize_drag: bad resize edge %d!",
+                 edge);
+      return;
+    }
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+  dm = gdk_display_get_device_manager (display);
+  device = gdk_device_manager_get_client_pointer (dm);
+
+  wl_shell_resize(GDK_DISPLAY_WAYLAND (display)->shell, impl->surface,
+		  GDK_DEVICE_CORE (device)->device->device,
+		  timestamp, grab_type);
+}
+
+static void
+gdk_wayland_window_begin_move_drag (GdkWindow *window,
+				    gint       button,
+				    gint       root_x,
+				    gint       root_y,
+				    guint32    timestamp)
+{
+  GdkDisplay *display = gdk_window_get_display (window);
+  GdkDeviceManager *dm;
+  GdkWindowImplWayland *impl;
+  GdkDevice *device;
+
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL (window))
+    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  dm = gdk_display_get_device_manager (display);
+  device = gdk_device_manager_get_client_pointer (dm);
+
+  wl_shell_move(GDK_DISPLAY_WAYLAND (display)->shell, impl->surface,
+		GDK_DEVICE_CORE (device)->device->device, timestamp);
+}
+
+static void
+gdk_wayland_window_enable_synchronized_configure (GdkWindow *window)
+{
+}
+
+static void
+gdk_wayland_window_configure_finished (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl;
+
+  if (!WINDOW_IS_TOPLEVEL (window))
+    return;
+
+  if (!GDK_IS_WINDOW_IMPL_WAYLAND (window->impl))
+    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  fprintf(stderr, "configure %p finished\n", window);
+
+  gdk_wayland_window_ref_cairo_surface (GDK_WINDOW (impl));
+
+  _gdk_wayland_window_attach_image (window, impl->image);
+
+  cairo_surface_destroy (impl->cairo_surface);
+}
+
+static void
+gdk_wayland_window_set_opacity (GdkWindow *window,
+				gdouble    opacity)
+{
+}
+
+static void
+gdk_wayland_window_set_composited (GdkWindow *window,
+				   gboolean   composited)
+{
+}
+
+static void
+gdk_wayland_window_destroy_notify (GdkWindow *window)
+{
+  GdkWindowImplWayland *window_impl;
+
+  window_impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (!GDK_WINDOW_DESTROYED (window))
+    {
+      if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
+	g_warning ("GdkWindow %p unexpectedly destroyed", window);
+
+      _gdk_window_destroy (window, TRUE);
+    }
+
+  g_object_unref (window);
+}
+
+static void
+gdk_wayland_window_process_updates_recurse (GdkWindow *window,
+					    cairo_region_t *region)
+{
+  GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+  cairo_rectangle_int_t rect;
+  int i, n;
+
+#if 0
+  gdk_wayland_window_ref_cairo_surface (window);
+
+  _gdk_wayland_window_attach_image (window, impl->image);
+  cairo_surface_destroy (impl->cairo_surface);
+#endif
+
+  n = cairo_region_num_rectangles(region);
+  for (i = 0; i < n; i++)
+    {
+      cairo_region_get_rectangle (region, i, &rect);
+      wl_surface_damage (impl->surface,
+			 rect.x, rect.y, rect.width, rect.height);
+    }
+
+  _gdk_window_process_updates_recurse (window, region);
+}
+
+static void
+gdk_wayland_window_sync_rendering (GdkWindow *window)
+{
+}
+
+static gboolean
+gdk_wayland_window_simulate_key (GdkWindow      *window,
+				 gint            x,
+				 gint            y,
+				 guint           keyval,
+				 GdkModifierType modifiers,
+				 GdkEventType    key_pressrelease)
+{
+  return FALSE;
+}
+
+static gboolean
+gdk_wayland_window_simulate_button (GdkWindow      *window,
+				    gint            x,
+				    gint            y,
+				    guint           button, /*1..3*/
+				    GdkModifierType modifiers,
+				    GdkEventType    button_pressrelease)
+{
+  return FALSE;
+}
+
+static gboolean
+gdk_wayland_window_get_property (GdkWindow   *window,
+				 GdkAtom      property,
+				 GdkAtom      type,
+				 gulong       offset,
+				 gulong       length,
+				 gint         pdelete,
+				 GdkAtom     *actual_property_type,
+				 gint        *actual_format_type,
+				 gint        *actual_length,
+				 guchar     **data)
+{
+  return FALSE;
+}
+
+static void
+gdk_wayland_window_change_property (GdkWindow    *window,
+				    GdkAtom       property,
+				    GdkAtom       type,
+				    gint          format,
+				    GdkPropMode   mode,
+				    const guchar *data,
+				    gint          nelements)
+{
+}
+
+static void
+gdk_wayland_window_delete_property (GdkWindow *window,
+				    GdkAtom    property)
+{
+}
+
+static void
+_gdk_window_impl_wayland_class_init (GdkWindowImplWaylandClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_CLASS (klass);
+
+  object_class->finalize = gdk_window_impl_wayland_finalize;
+
+  impl_class->ref_cairo_surface = gdk_wayland_window_ref_cairo_surface;
+  impl_class->show = gdk_wayland_window_show;
+  impl_class->hide = gdk_wayland_window_hide;
+  impl_class->withdraw = gdk_window_wayland_withdraw;
+  impl_class->set_events = gdk_window_wayland_set_events;
+  impl_class->get_events = gdk_window_wayland_get_events;
+  impl_class->raise = gdk_window_wayland_raise;
+  impl_class->lower = gdk_window_wayland_lower;
+  impl_class->restack_under = gdk_window_wayland_restack_under;
+  impl_class->restack_toplevel = gdk_window_wayland_restack_toplevel;
+  impl_class->move_resize = gdk_window_wayland_move_resize;
+  impl_class->set_background = gdk_window_wayland_set_background;
+  impl_class->reparent = gdk_window_wayland_reparent;
+  impl_class->set_device_cursor = gdk_window_wayland_set_device_cursor;
+  impl_class->get_geometry = gdk_window_wayland_get_geometry;
+  impl_class->get_root_coords = gdk_window_wayland_get_root_coords;
+  impl_class->get_device_state = gdk_window_wayland_get_device_state;
+  impl_class->shape_combine_region = gdk_window_wayland_shape_combine_region;
+  impl_class->input_shape_combine_region = gdk_window_wayland_input_shape_combine_region;
+  impl_class->set_static_gravities = gdk_window_wayland_set_static_gravities;
+  impl_class->queue_antiexpose = gdk_wayland_window_queue_antiexpose;
+  impl_class->translate = gdk_wayland_window_translate;
+  impl_class->destroy = gdk_wayland_window_destroy;
+  impl_class->destroy_foreign = gdk_window_wayland_destroy_foreign;
+  impl_class->resize_cairo_surface = gdk_window_wayland_resize_cairo_surface;
+  impl_class->get_shape = gdk_wayland_window_get_shape;
+  impl_class->get_input_shape = gdk_wayland_window_get_input_shape;
+  /* impl_class->beep */
+
+  impl_class->focus = gdk_wayland_window_focus;
+  impl_class->set_type_hint = gdk_wayland_window_set_type_hint;
+  impl_class->get_type_hint = gdk_wayland_window_get_type_hint;
+  impl_class->set_modal_hint = gdk_wayland_window_set_modal_hint;
+  impl_class->set_skip_taskbar_hint = gdk_wayland_window_set_skip_taskbar_hint;
+  impl_class->set_skip_pager_hint = gdk_wayland_window_set_skip_pager_hint;
+  impl_class->set_urgency_hint = gdk_wayland_window_set_urgency_hint;
+  impl_class->set_geometry_hints = gdk_wayland_window_set_geometry_hints;
+  impl_class->set_title = gdk_wayland_window_set_title;
+  impl_class->set_role = gdk_wayland_window_set_role;
+  impl_class->set_startup_id = gdk_wayland_window_set_startup_id;
+  impl_class->set_transient_for = gdk_wayland_window_set_transient_for;
+  impl_class->get_root_origin = gdk_wayland_window_get_root_origin;
+  impl_class->get_frame_extents = gdk_wayland_window_get_frame_extents;
+  impl_class->set_override_redirect = gdk_wayland_window_set_override_redirect;
+  impl_class->set_accept_focus = gdk_wayland_window_set_accept_focus;
+  impl_class->set_focus_on_map = gdk_wayland_window_set_focus_on_map;
+  impl_class->set_icon_list = gdk_wayland_window_set_icon_list;
+  impl_class->set_icon_name = gdk_wayland_window_set_icon_name;
+  impl_class->iconify = gdk_wayland_window_iconify;
+  impl_class->deiconify = gdk_wayland_window_deiconify;
+  impl_class->stick = gdk_wayland_window_stick;
+  impl_class->unstick = gdk_wayland_window_unstick;
+  impl_class->maximize = gdk_wayland_window_maximize;
+  impl_class->unmaximize = gdk_wayland_window_unmaximize;
+  impl_class->fullscreen = gdk_wayland_window_fullscreen;
+  impl_class->unfullscreen = gdk_wayland_window_unfullscreen;
+  impl_class->set_keep_above = gdk_wayland_window_set_keep_above;
+  impl_class->set_keep_below = gdk_wayland_window_set_keep_below;
+  impl_class->get_group = gdk_wayland_window_get_group;
+  impl_class->set_group = gdk_wayland_window_set_group;
+  impl_class->set_decorations = gdk_wayland_window_set_decorations;
+  impl_class->get_decorations = gdk_wayland_window_get_decorations;
+  impl_class->set_functions = gdk_wayland_window_set_functions;
+  impl_class->begin_resize_drag = gdk_wayland_window_begin_resize_drag;
+  impl_class->begin_move_drag = gdk_wayland_window_begin_move_drag;
+  impl_class->enable_synchronized_configure = gdk_wayland_window_enable_synchronized_configure;
+  impl_class->configure_finished = gdk_wayland_window_configure_finished;
+  impl_class->set_opacity = gdk_wayland_window_set_opacity;
+  impl_class->set_composited = gdk_wayland_window_set_composited;
+  impl_class->destroy_notify = gdk_wayland_window_destroy_notify;
+  impl_class->register_dnd = _gdk_wayland_window_register_dnd;
+  impl_class->drag_begin = _gdk_wayland_window_drag_begin;
+  impl_class->process_updates_recurse = gdk_wayland_window_process_updates_recurse;
+  impl_class->sync_rendering = gdk_wayland_window_sync_rendering;
+  impl_class->simulate_key = gdk_wayland_window_simulate_key;
+  impl_class->simulate_button = gdk_wayland_window_simulate_button;
+  impl_class->get_property = gdk_wayland_window_get_property;
+  impl_class->change_property = gdk_wayland_window_change_property;
+  impl_class->delete_property = gdk_wayland_window_delete_property;
+}
diff --git a/gdk/wayland/gdkwindow-wayland.h b/gdk/wayland/gdkwindow-wayland.h
new file mode 100644
index 0000000000..f33afdf504
--- /dev/null
+++ b/gdk/wayland/gdkwindow-wayland.h
@@ -0,0 +1,150 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifndef __GDK_WINDOW_WAYLAND_H__
+#define __GDK_WINDOW_WAYLAND_H__
+
+#include <gdk/wayland/gdkprivate-wayland.h>
+#include <gdk/gdkwindowimpl.h>
+
+#include <stdint.h>
+#include <wayland-client.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GL/gl.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GdkToplevelWayland GdkToplevelWayland;
+typedef struct _GdkWindowImplWayland GdkWindowImplWayland;
+typedef struct _GdkWindowImplWaylandClass GdkWindowImplWaylandClass;
+typedef struct _GdkXPositionInfo GdkXPositionInfo;
+
+/* Window implementation for Wayland
+ */
+
+#define GDK_TYPE_WINDOW_IMPL_WAYLAND              (_gdk_window_impl_wayland_get_type ())
+#define GDK_WINDOW_IMPL_WAYLAND(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWayland))
+#define GDK_WINDOW_IMPL_WAYLAND_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWaylandClass))
+#define GDK_IS_WINDOW_IMPL_WAYLAND(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_WAYLAND))
+#define GDK_IS_WINDOW_IMPL_WAYLAND_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_WAYLAND))
+#define GDK_WINDOW_IMPL_WAYLAND_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWaylandClass))
+
+struct _GdkWindowImplWayland
+{
+  GdkWindowImpl parent_instance;
+
+  GdkWindow *wrapper;
+
+  GdkToplevelWayland *toplevel;	/* Toplevel-specific information */
+  GdkCursor *cursor;
+  GHashTable *device_cursor;
+
+  gint8 toplevel_window_type;
+  guint no_bg : 1;		/* Set when the window background is temporarily
+				 * unset during resizing and scaling */
+  guint override_redirect : 1;
+
+  struct wl_surface *surface;
+  EGLImageKHR *pending_image;
+  EGLImageKHR *next_image;
+
+  cairo_surface_t *cairo_surface;
+  GLuint texture;
+  EGLImageKHR image;
+
+};
+
+struct _GdkWindowImplWaylandClass
+{
+  GdkWindowImplClass parent_class;
+};
+
+struct _GdkToplevelWayland
+{
+
+  /* Set if the window, or any descendent of it, is the server's focus window
+   */
+  guint has_focus_window : 1;
+
+  /* Set if window->has_focus_window and the focus isn't grabbed elsewhere.
+   */
+  guint has_focus : 1;
+
+  /* Set if the pointer is inside this window. (This is needed for
+   * for focus tracking)
+   */
+  guint has_pointer : 1;
+  
+  /* Set if the window is a descendent of the focus window and the pointer is
+   * inside it. (This is the case where the window will receive keystroke
+   * events even window->has_focus_window is FALSE)
+   */
+  guint has_pointer_focus : 1;
+
+  /* Set if we are requesting these hints */
+  guint skip_taskbar_hint : 1;
+  guint skip_pager_hint : 1;
+  guint urgency_hint : 1;
+
+  guint on_all_desktops : 1;   /* _NET_WM_STICKY == 0xFFFFFFFF */
+
+  guint have_sticky : 1;	/* _NET_WM_STATE_STICKY */
+  guint have_maxvert : 1;       /* _NET_WM_STATE_MAXIMIZED_VERT */
+  guint have_maxhorz : 1;       /* _NET_WM_STATE_MAXIMIZED_HORZ */
+  guint have_fullscreen : 1;    /* _NET_WM_STATE_FULLSCREEN */
+
+  gulong map_serial;	/* Serial of last transition from unmapped */
+
+  cairo_surface_t *icon_pixmap;
+  cairo_surface_t *icon_mask;
+
+  /* Time of most recent user interaction. */
+  gulong user_time;
+
+  /* We use an extra X window for toplevel windows that we XSetInputFocus()
+   * to in order to avoid getting keyboard events redirected to subwindows
+   * that might not even be part of this app
+   */
+  Window focus_window;
+};
+
+GType               _gdk_window_impl_wayland_get_type  (void);
+
+GdkToplevelWayland *_gdk_wayland_window_get_toplevel  (GdkWindow   *window);
+void                _gdk_wayland_window_attach_image  (GdkWindow   *window,
+						       EGLImageKHR  image);
+
+GdkCursor          *_gdk_wayland_window_get_cursor    (GdkWindow   *window);
+void                _gdk_wayland_window_get_offsets   (GdkWindow   *window,
+						       gint        *x_offset,
+						       gint        *y_offset);
+
+void                _gdk_wayland_window_update_size   (GdkWindowImplWayland  *drawable);
+
+G_END_DECLS
+
+#endif /* __GDK_WINDOW_WAYLAND_H__ */
diff --git a/gtk/gtksettings.c b/gtk/gtksettings.c
index 44fe5c68ca..771f6e0fde 100644
--- a/gtk/gtksettings.c
+++ b/gtk/gtksettings.c
@@ -1466,9 +1466,12 @@ gtk_settings_get_for_screen (GdkScreen *screen)
       settings_init_style (settings);
       settings_update_double_click (settings);
 #ifdef GDK_WINDOWING_X11
-      settings_update_cursor_theme (settings);
-      settings_update_resolution (settings);
-      settings_update_font_options (settings);
+      if (GDK_IS_X11_SCREEN (screen))
+	{
+	  settings_update_cursor_theme (settings);
+	  settings_update_resolution (settings);
+	  settings_update_font_options (settings);
+	}
 #endif
       settings_update_color_scheme (settings);
     }