Handle non-baseline supporting subclasses overriding baseline supporting classes

If a subclass (say a child of GtkButton) overrides the non-baseline size request methods we need to call these, rather than the new get_height_and_baseline_for_width method. In order to handle this we make the default for this method to be NULL, and instead check at runtime which method to call. If any non-baseline vfunc has changed in a class but the baseline one hasn't, then we can't use the baseline one.
Add baseline functions to docs
2013-03-27 10:22:14 +01:00 · 2013-03-27 09:48:58 +01:00 · 2013-03-27 09:45:08 +01:00 · 2013-03-27 09:44:02 +01:00 · 2013-03-27 09:43:40 +01:00 · 2013-03-27 09:42:43 +01:00
161 changed files with 27029 additions and 16659 deletions
@@ -111,6 +111,7 @@ echo --no-libtool --library=gtk-3-vs%VSVER% ^^>> gtk_gir.bat
 echo --reparse-validate --add-include-path=%BASEDIR%\share\gir-1.0 --add-include-path=. ^^>> gtk_gir.bat
 echo --pkg-export gtk+-3.0 --warn-all --c-include="gtk/gtkx.h" ^^>> gtk_gir.bat
 echo -I..\.. -DG_LOG_DOMAIN=\"Gtk\" -DGTK_LIBDIR=\"/dummy/lib\" ^^>> gtk_gir.bat
+echo -Dtime_t=long ^^>> gtk_gir.bat
 echo -DGTK_DATADIR=\"/dummy/share\" -DGTK_DATA_PREFIX=\"/dummy\" ^^>> gtk_gir.bat
 echo -DGTK_SYSCONFDIR=\"/dummy/etc\" -DGTK_VERSION=\"3.6.2\" ^^>> gtk_gir.bat
 echo -DGTK_BINARY_VERSION=\"3.0.0\" -DGTK_HOST=\"i686-pc-vs%VSVER%\" ^^>> gtk_gir.bat
@@ -75,7 +75,7 @@
      <PreprocessorDefinitions>_DEBUG;G_ENABLE_DEBUG;$(GdkDefines);INSIDE_GDK_WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>true</MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
@@ -79,7 +79,7 @@
      <PreprocessorDefinitions>_DEBUG;G_ENABLE_DEBUG;$(GdkDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>true</MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
@@ -23,23 +23,6 @@ copy $(Configuration)\$(Platform)\bin\*.dll $(CopyDir)\bin
 copy $(Configuration)\$(Platform)\bin\*.exe $(CopyDir)\bin


-mkdir $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.c $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.css $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.h $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.ui $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.jpg $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.png $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-copy ..\..\..\demos\gtk-demo\*.gif $(CopyDir)\share\gtk-$(ApiVersion)\demo
-
-
 mkdir $(CopyDir)\lib

 copy $(Configuration)\$(Platform)\bin\*-$(ApiVersion).lib $(CopyDir)\lib
@@ -593,7 +576,7 @@ copy ..\..\..\gtk\deprecated\gtkvseparator.h $(CopyDir)\include\gtk-$(ApiVersion
 copy ..\..\..\gtk\deprecated\gtkvpaned.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\deprecated


-mkdir $(CopyDir)\include\gtk-$(ApiVersion)\a11y
+mkdir $(CopyDir)\include\gtk-$(ApiVersion)\gtk\a11y


 copy ..\..\..\gtk\a11y\gtkarrowaccessible.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\a11y
@@ -79,7 +79,7 @@
      <PreprocessorDefinitions>_DEBUG;G_ENABLE_DEBUG;$(GtkDefines);%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>true</MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
@@ -79,7 +79,7 @@
      <PreprocessorDefinitions>_DEBUG;$(GtkPrefixDefine);%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>true</MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
@@ -35,7 +35,7 @@
 				PreprocessorDefinitions="_DEBUG;G_ENABLE_DEBUG;$(GdkDefines);INSIDE_GDK_WIN32"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="2"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				DebugInformationFormat="4"
@@ -35,7 +35,7 @@
 				PreprocessorDefinitions="_DEBUG;G_ENABLE_DEBUG;$(GdkDefines)"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="2"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				DebugInformationFormat="4"
@@ -79,16 +79,6 @@ mkdir $(CopyDir)\bin&#x0D;&#x0A;
 copy $(ConfigurationName)\$(PlatformName)\bin\*.dll $(CopyDir)\bin&#x0D;&#x0A;
 copy $(ConfigurationName)\$(PlatformName)\bin\*.exe $(CopyDir)\bin&#x0D;&#x0A;

-mkdir $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-
-copy ..\..\..\demos\gtk-demo\*.c $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.css $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.h $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.ui $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.jpg $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.png $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-copy ..\..\..\demos\gtk-demo\*.gif $(CopyDir)\share\gtk-$(ApiVersion)\demo&#x0D;&#x0A;
-
 mkdir $(CopyDir)\lib&#x0D;&#x0A;
 copy $(ConfigurationName)\$(PlatformName)\bin\*-$(ApiVersion).lib $(CopyDir)\lib&#x0D;&#x0A;

@@ -369,7 +359,7 @@ copy ..\..\..\gtk\deprecated\gtkvscrollbar.h $(CopyDir)\include\gtk-$(ApiVersion
 copy ..\..\..\gtk\deprecated\gtkvseparator.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\deprecated&#x0D;&#x0A;
 copy ..\..\..\gtk\deprecated\gtkvpaned.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\deprecated&#x0D;&#x0A;

-mkdir $(CopyDir)\include\gtk-$(ApiVersion)\a11y&#x0D;&#x0A;
+mkdir $(CopyDir)\include\gtk-$(ApiVersion)\gtk\a11y&#x0D;&#x0A;

 copy ..\..\..\gtk\a11y\gtkarrowaccessible.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\a11y&#x0D;&#x0A;
 copy ..\..\..\gtk\a11y\gtkbooleancellaccessible.h $(CopyDir)\include\gtk-$(ApiVersion)\gtk\a11y&#x0D;&#x0A;
@@ -35,7 +35,7 @@
 				PreprocessorDefinitions="_DEBUG;G_ENABLE_DEBUG;$(GtkDefines)"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="2"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				DebugInformationFormat="4"
@@ -35,7 +35,7 @@
 				PreprocessorDefinitions="_DEBUG;$(GtkPrefixDefine)"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="2"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				DebugInformationFormat="4"
@@ -9,8 +9,8 @@
 # set GTK_BINARY_AGE and GTK_INTERFACE_AGE to 0.

 m4_define([gtk_major_version], [3])
-m4_define([gtk_minor_version], [7])
-m4_define([gtk_micro_version], [13])
+m4_define([gtk_minor_version], [9])
+m4_define([gtk_micro_version], [0])
 m4_define([gtk_interface_age], [0])
 m4_define([gtk_binary_age],
          [m4_eval(100 * gtk_minor_version + gtk_micro_version)])
@@ -350,7 +350,7 @@ if test "$enable_win32_backend" = "yes"; then
  backend_immodules="$backend_immodules,ime"
  GDK_WINDOWING="$GDK_WINDOWING
 #define GDK_WINDOWING_WIN32"
-  GDK_EXTRA_LIBS="$GDK_EXTRA_LIBS -lgdi32 -limm32 -lshell32 -lole32 -Wl,-luuid"
+  GDK_EXTRA_LIBS="$GDK_EXTRA_LIBS -lgdi32 -limm32 -lshell32 -lole32 -Wl,-luuid -lwinmm"
  AM_CONDITIONAL(USE_WIN32, true)
  PANGO_PACKAGES="pangowin32 pangocairo"
 else
@@ -1455,45 +1455,6 @@ else
  fi
 fi

-# Check for Avahi flags
-AC_ARG_ENABLE(avahi-browsing,
-              [AS_HELP_STRING([--disable-avahi-browsing],
-                              [disable avahi browsing of printers])],,
-              [enable_avahi_browsing=auto])
-
-have_avahi_browsing=no
-if test "x$enable_avahi_browsing" != "xno" -a \
-        "x$have_cups_api_1_6" = "xyes"; then
-  AC_MSG_CHECKING([avahi-gobject])
-
-  if $PKG_CONFIG --exists avahi-gobject ; then
-    AVAHI_CFLAGS=`$PKG_CONFIG --cflags avahi-gobject`
-    AC_SUBST(AVAHI_CFLAGS)
-    AVAHI_LIBS=`$PKG_CONFIG --libs avahi-gobject`
-    AC_SUBST(AVAHI_LIBS)
-    have_avahi_gobject=yes
-    AC_MSG_RESULT([yes])
-  else
-    AC_MSG_RESULT([no])
-  fi
-
-  if test "x$have_avahi_gobject" = "xyes" ; then
-    AC_DEFINE([HAVE_AVAHI_BROWSING], [1], [Define to 1 if avahi-gobject available])
-    have_avahi_browsing=yes
-  else
-    AC_MSG_ERROR([
-*** avahi-gobject not found. avahi-gobject is required to build GTK+ with support
-*** for avahi browsed printers when using CUPS 1.6.
-])
-  fi
-else
-  if test "x$enable_avahi_browsing" = "xyes"; then
-    AC_MSG_ERROR([
-*** Avahi browsing support requested but CUPS 1.6 not found.
-])
-  fi
-fi
-
 # Checks to see if we should compile with PAPI backend for GTK+
 #

@@ -1870,7 +1831,6 @@ echo "        Dynamic modules:      $build_dynamic_modules"
 echo "        Included immodules:   $included_immodules"
 echo "        PackageKit support:   $build_packagekit"
 echo "        colord support:       $have_colord"
-echo "        Avahi browsing:       $have_avahi_browsing"
 echo "        Introspection:        $found_introspection"
 echo "        Debugging:            $enable_debug"
 echo "        Documentation:        $enable_gtk_doc"
@@ -403,7 +403,7 @@ static GtkWidget *create_text (GtkWidget **text_view, gboolean is_source);
 static void
 add_data_tab (const gchar *demoname)
 {
-  gchar *resource_dir, *resource_name, *content_type;
+  gchar *resource_dir, *resource_name, *content_type, *content_mime;
  gchar **resources;
  GBytes *bytes;
  GtkWidget *widget, *label;
@@ -427,17 +427,20 @@ add_data_tab (const gchar *demoname)
                                           g_bytes_get_data (bytes, NULL),
                                           g_bytes_get_size (bytes),
                                           NULL);
+      content_mime = g_content_type_get_mime_type (content_type);

      /* In theory we should look at all the mime types gdk-pixbuf supports
       * and go from there, but we know what file types we've added.
       */
-      if (g_content_type_is_a (content_type, "image/png") ||
-          g_content_type_is_a (content_type, "image/gif") ||
-          g_content_type_is_a (content_type, "image/jpeg"))
+      if (g_content_type_is_a (content_mime, "image/png") ||
+          g_content_type_is_a (content_mime, "image/gif") ||
+          g_content_type_is_a (content_mime, "image/jpeg"))
        {
          widget = gtk_image_new_from_resource (resource_name);
        }
-      else if (g_content_type_is_a (content_type, "text/plain"))
+      else if (g_content_type_is_a (content_mime, "text/plain") ||
+               g_content_type_is_a (content_mime, "application/x-ext-ui") ||
+               g_content_type_is_a (content_mime, "text/css"))
        {
          GtkTextBuffer *buffer;
          GtkWidget *textview;
@@ -449,7 +452,8 @@ add_data_tab (const gchar *demoname)
        }
      else
        {
-          g_warning ("Don't know how to display resource '%s' of type '%s'\n", resource_name, content_type);
+
+          g_warning ("Don't know how to display resource '%s' of type '%s'\n", resource_name, content_mime);
          widget = NULL;
        }

@@ -458,6 +462,7 @@ add_data_tab (const gchar *demoname)
      gtk_widget_show (label);
      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, label);

+      g_free (content_mime);
      g_free (content_type);
      g_free (resource_name);
      g_bytes_unref (bytes);
@@ -10,6 +10,7 @@ gdk_parse_args
 gdk_get_display_arg_name
 gdk_notify_startup_complete
 gdk_notify_startup_complete_with_id
+gdk_set_allowed_backends

 <SUBSECTION>
 gdk_get_program_class
@@ -170,6 +171,7 @@ GdkDisplayClass
 <TITLE>GdkDisplayManager</TITLE>
 GdkDisplayManager
 gdk_display_manager_get
+gdk_display_manager_peek
 gdk_display_manager_get_default_display
 gdk_display_manager_set_default_display
 gdk_display_manager_list_displays
@@ -235,6 +235,7 @@
      <xi:include href="xml/gtknotebook.xml" />
      <xi:include href="xml/gtkexpander.xml" />
      <xi:include href="xml/gtkoverlay.xml" />
+      <xi:include href="xml/gtkheaderbar.xml" />
      <xi:include href="xml/gtkorientable.xml" />
    </chapter>

@@ -416,6 +417,10 @@
    <title>Index of new symbols in 3.8</title>
    <xi:include href="xml/api-index-3.8.xml"><xi:fallback /></xi:include>
  </index>
+  <index id="api-index-3-10" role="3.10">
+    <title>Index of new symbols in 3.10</title>
+    <xi:include href="xml/api-index-3.10.xml"><xi:fallback /></xi:include>
+  </index>

  <xi:include href="xml/annotation-glossary.xml"><xi:fallback /></xi:include>

@@ -486,6 +486,8 @@ gtk_box_set_spacing
 gtk_box_reorder_child
 gtk_box_query_child_packing
 gtk_box_set_child_packing
+gtk_box_get_baseline_position
+gtk_box_set_baseline_position
 <SUBSECTION Standard>
 GTK_BOX
 GTK_IS_BOX
@@ -5159,6 +5161,7 @@ gtk_widget_remove_tick_callback
 gtk_widget_size_request
 gtk_widget_get_child_requisition
 gtk_widget_size_allocate
+gtk_widget_size_allocate_with_baseline
 gtk_widget_add_accelerator
 gtk_widget_remove_accelerator
 gtk_widget_set_accel_path
@@ -5291,6 +5294,7 @@ gtk_widget_get_allocated_width
 gtk_widget_get_allocated_height
 gtk_widget_get_allocation
 gtk_widget_set_allocation
+gtk_widget_get_allocated_baseline
 gtk_widget_get_app_paintable
 gtk_widget_get_can_default
 gtk_widget_set_can_default
@@ -5351,8 +5355,10 @@ gtk_widget_get_preferred_height
 gtk_widget_get_preferred_width
 gtk_widget_get_preferred_height_for_width
 gtk_widget_get_preferred_width_for_height
+gtk_widget_get_preferred_height_and_baseline_for_width
 gtk_widget_get_request_mode
 gtk_widget_get_preferred_size
+gtk_widget_get_preferred_size_and_baseline
 gtk_distribute_natural_allocation

 <SUBSECTION Alignment and Margins>
@@ -5360,6 +5366,7 @@ GtkAlign
 gtk_widget_get_halign
 gtk_widget_set_halign
 gtk_widget_get_valign
+gtk_widget_get_valign_with_baseline
 gtk_widget_set_valign
 gtk_widget_get_margin_left
 gtk_widget_set_margin_left
@@ -5513,6 +5520,7 @@ gtk_window_get_resize_grip_area
 gtk_window_get_application
 gtk_window_set_application
 gtk_window_set_has_user_ref_count
+gtk_window_set_titlebar

 <SUBSECTION Standard>
 GTK_WINDOW
@@ -7237,6 +7245,8 @@ gtk_grid_attach_next_to
 gtk_grid_get_child_at
 gtk_grid_insert_row
 gtk_grid_insert_column
+gtk_grid_remove_row
+gtk_grid_remove_column
 gtk_grid_insert_next_to
 gtk_grid_set_row_homogeneous
 gtk_grid_get_row_homogeneous
@@ -7246,6 +7256,10 @@ gtk_grid_set_column_homogeneous
 gtk_grid_get_column_homogeneous
 gtk_grid_set_column_spacing
 gtk_grid_get_column_spacing
+gtk_grid_get_baseline_row
+gtk_grid_set_baseline_row
+gtk_grid_get_row_baseline_position
+gtk_grid_set_row_baseline_position

 <SUBSECTION Standard>
 GtkGridClass
@@ -7494,3 +7508,29 @@ GTK_COLOR_CHOOSER_DIALOG_GET_CLASS
 GtkColorChooserDialogPrivate
 gtk_color_chooser_dialog_get_type
 </SECTION>
+
+<SECTION>
+<FILE>gtkheaderbar</FILE>
+<TITLE>GtkHeaderBar</TITLE>
+GtkHeaderBar
+gtk_header_bar_new
+gtk_header_bar_set_title
+gtk_header_bar_get_title
+gtk_header_bar_set_subtitle
+gtk_header_bar_get_subtitle
+gtk_header_bar_set_custom_title
+gtk_header_bar_get_custom_title
+gtk_header_bar_pack_start
+gtk_header_bar_pack_end
+
+<SUBSECTION Standard>
+GTK_TYPE_HEADER_BAR
+GTK_HEADER_BAR
+GTK_HEADER_BAR_CLASS
+GTK_IS_HEADER_BAR
+GTK_IS_HEADER_BAR_CLASS
+GTK_HEADER_BAR_GET_CLASS
+
+<SUBSECTION Private>
+gtk_header_bar_get_type
+</SECTION>
@@ -461,6 +461,9 @@ nevertheless.
      </varlistentry>

    </variablelist>
+    Since 3.10, this environment variable can contain a comma-separated list
+    of backend names, which are tried in order. The list may also contain
+    a *, which means: try all remaining backends.
    For more information about selecting backends, see the gdk_display_manager_get() function.
  </para>
 </formalpara>
@@ -160,7 +160,7 @@ typedef struct {
 typedef struct {
  BroadwayRequestBase base;
  guint32 id;
-  char name[34];
+  char name[36];
  guint32 width;
  guint32 height;
 } BroadwayRequestUpdate;
@@ -409,7 +409,6 @@ client_fill_cb (GObject *source_object,
      guint32 size;
      gsize count, remaining;
      guint8 *buffer;
-      BroadwayRequest request;

      buffer = (guint8 *)g_buffered_input_stream_peek_buffer (client->in, &count);

@@ -417,14 +416,10 @@ client_fill_cb (GObject *source_object,
      while (remaining >= sizeof (guint32))
 	{
 	  memcpy (&size, buffer, sizeof (guint32));
-	  
+
 	  if (size <= remaining)
 	    {
-	      g_assert (size >= sizeof (BroadwayRequestBase));
-	      g_assert (size <= sizeof (BroadwayRequest));
-
-	      memcpy (&request, buffer, size);
-	      client_handle_request (client, &request);
+	      client_handle_request (client, (BroadwayRequest *)buffer);

 	      remaining -= size;
 	      buffer += size;
@@ -550,7 +550,7 @@ create_random_shm (char *name)
 static const cairo_user_data_key_t gdk_broadway_shm_cairo_key;

 typedef struct {
-  char name[34];
+  char name[36];
  void *data;
  gsize data_size;
 } BroadwayShmSurfaceData;
@@ -610,7 +610,7 @@ _gdk_broadway_server_window_update (GdkBroadwayServer *server,
  g_assert (data != NULL);

  msg.id = id;
-  memcpy (msg.name, data->name, 34);
+  memcpy (msg.name, data->name, 36);
  msg.width = cairo_image_surface_get_width (surface);
  msg.height = cairo_image_surface_get_height (surface);

@@ -22,6 +22,7 @@

 #include "config.h"

+#include <stdlib.h>
 #include "gdkdisplay-broadway.h"
 #include "gdkbroadwaydisplaymanager.h"
 #include "gdkprivate-broadway.h"
@@ -35,9 +36,53 @@ struct _GdkBroadwayDisplayManager

  GdkDisplay *default_display;
  GSList *displays;
+
+  gboolean init_failed;
 };

-G_DEFINE_TYPE (GdkBroadwayDisplayManager, gdk_broadway_display_manager, GDK_TYPE_DISPLAY_MANAGER)
+static void g_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GdkBroadwayDisplayManager, gdk_broadway_display_manager, GDK_TYPE_DISPLAY_MANAGER,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, g_initable_iface_init))
+
+static gboolean
+gdk_broadway_display_manager_initable_init (GInitable     *initable,
+                                            GCancellable  *cancellable,
+                                            GError       **error)
+{
+  const gchar *display_name;
+  gint port;
+  GdkBroadwayServer *server;
+
+  display_name = g_getenv ("BROADWAY_DISPLAY");
+
+  port = 0;
+  if (display_name != NULL)
+    {
+      if (*display_name == ':')
+        display_name++;
+      port = strtol(display_name, NULL, 10);
+    }
+  if (port == 0)
+    port = 1;
+
+  server = _gdk_broadway_server_new (port, NULL);
+  if (server == NULL)
+    {
+      GDK_BROADWAY_DISPLAY_MANAGER (initable)->init_failed = TRUE;
+      return FALSE;
+    }
+
+  g_object_unref (server);
+
+  return TRUE;
+}
+
+void
+g_initable_iface_init (GInitableIface *iface)
+{
+  iface->init = gdk_broadway_display_manager_initable_init;
+}

 static GdkDisplay *
 gdk_broadway_display_manager_open_display (GdkDisplayManager *manager,
@@ -94,7 +139,8 @@ gdk_broadway_display_manager_init (GdkBroadwayDisplayManager *manager)
 static void
 gdk_broadway_display_manager_finalize (GObject *object)
 {
-  g_error ("A GdkBroadwayDisplayManager object was finalized. This should not happen");
+  if (!GDK_BROADWAY_DISPLAY_MANAGER (object)->init_failed)
+    g_error ("A GdkBroadwayDisplayManager object was finalized. This should not happen");
  G_OBJECT_CLASS (gdk_broadway_display_manager_parent_class)->finalize (object);
 }

@@ -610,7 +610,7 @@ gdk_window_broadway_set_device_cursor (GdkWindow *window,
    {
      _gdk_broadway_cursor_update_theme (cursor);
      g_hash_table_replace (impl->device_cursor,
-                            device, gdk_cursor_ref (cursor));
+                            device, g_object_ref (cursor));
    }

  if (!GDK_WINDOW_DESTROYED (window))
@@ -42,3 +42,15 @@ isinf (double x)
  return (!_finite (x) && !_isnan (x));
 }
 #endif
+
+/* Workaround for round() for non-GCC/non-C99 compilers */
+#ifndef HAVE_ROUND
+static inline double
+round (double x)
+{
+  if (x >= 0)
+    return floor (x + 0.5);
+  else
+    return ceil (x - 0.5);
+}
+#endif
@@ -275,9 +275,6 @@ gdk_pre_parse_libgtk_only (void)
      else if (g_str_equal (rendering_mode, "recording"))
        _gdk_rendering_mode = GDK_RENDERING_MODE_RECORDING;
    }
-
-  /* Do any setup particular to the windowing system */
-  gdk_display_manager_get ();
 }

  
@@ -353,7 +350,7 @@ gdk_get_display_arg_name (void)
 *
 * Opens the default display specified by command line arguments or
 * environment variables, sets it as the default display, and returns
- * it.  gdk_parse_args must have been called first. If the default
+ * it. gdk_parse_args() must have been called first. If the default
 * display has previously been set, simply returns that. An internal
 * function that should not be used by applications.
 *
@@ -367,6 +364,9 @@ gdk_display_open_default_libgtk_only (void)

  g_return_val_if_fail (gdk_initialized, NULL);

+  if (gdk_display_manager_peek () == NULL)
+    return NULL;
+
  display = gdk_display_get_default ();
  if (display)
    return display;
@@ -101,6 +101,7 @@ gdk_display_is_closed
 gdk_display_keyboard_ungrab
 gdk_display_list_devices
 gdk_display_manager_get
+gdk_display_manager_peek
 gdk_display_manager_get_default_display
 gdk_display_manager_get_type
 gdk_display_manager_list_displays
@@ -335,6 +336,7 @@ gdk_set_program_class
 gdk_set_show_events
 gdk_setting_action_get_type
 gdk_setting_get
+gdk_set_allowed_backends
 gdk_status_get_type
 gdk_synthesize_window_state
 gdk_test_render_sync
@@ -125,7 +125,24 @@ static void gdk_display_manager_get_property (GObject                *object,

 static guint signals[LAST_SIGNAL] = { 0 };

-G_DEFINE_TYPE (GdkDisplayManager, gdk_display_manager, G_TYPE_OBJECT)
+static void g_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GdkDisplayManager, gdk_display_manager, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, g_initable_iface_init))
+
+static gboolean
+gdk_display_manager_initable_init (GInitable     *initable,
+                                   GCancellable  *cancellable,
+                                   GError       **error)
+{
+  return TRUE;
+}
+
+static void
+g_initable_iface_init (GInitableIface *iface)
+{
+  iface->init = gdk_display_manager_initable_init;
+}

 static void
 gdk_display_manager_class_init (GdkDisplayManagerClass *klass)
@@ -208,6 +225,50 @@ gdk_display_manager_get_property (GObject      *object,
    }
 }

+static const gchar *allowed_backends;
+
+/**
+ * gdk_set_allowed_backends:
+ * @backends: a comma-separated list of backends
+ *
+ * Sets a list of backends that GDK should try to use.
+ *
+ * This can be be useful if your application does not
+ * work with certain GDK backends.
+ *
+ * By default, GDK tries all included backends.
+ *
+ * For example,
+ * <programlisting>
+ * gdk_set_allowed_backends ("wayland,quartz,*");
+ * </programlisting>
+ * instructs GDK to try the Wayland backend first,
+ * followed by the Quartz backend, and then all
+ * others.
+ *
+ * If the <envvar>GDK_BACKEND</envvar> environment variable
+ * is set, it determines what backends are tried in what
+ * order, while still respecting the set of allowed backends
+ * that are specified by this function.
+ *
+ * The possible backend names are x11, win32, quartz,
+ * broadway, wayland. You can also include a * in the
+ * list to try all remaining backends.
+ *
+ * This call must happen prior to gdk_display_open(),
+ * gtk_init(), gtk_init_with_args() or gtk_init_check()
+ * in order to take effect.
+ *
+ * Since: 3.10
+ */
+void
+gdk_set_allowed_backends (const gchar *backends)
+{
+  allowed_backends = g_strdup (backends);
+}
+
+static GdkDisplayManager *manager = NULL;
+
 /**
 * gdk_display_manager_get:
 *
@@ -216,7 +277,8 @@ gdk_display_manager_get_property (GObject      *object,
 * When called for the first time, this function consults the
 * <envar>GDK_BACKEND</envar> environment variable to find out which
 * of the supported GDK backends to use (in case GDK has been compiled
- * with multiple backends).
+ * with multiple backends). Applications can use gdk_set_allowed_backends()
+ * to limit what backends can be used.
 *
 * Returns: (transfer none): The global #GdkDisplayManager singleton;
 *     gdk_parse_args(), gdk_init(), or gdk_init_check() must have
@@ -227,47 +289,124 @@ gdk_display_manager_get_property (GObject      *object,
 GdkDisplayManager*
 gdk_display_manager_get (void)
 {
-  static GdkDisplayManager *manager = NULL;
+  gdk_display_manager_peek ();

-  if (!manager)
+  if (manager == NULL)
+    g_error ("No GDK backend found (%s)", allowed_backends);
+
+  return manager;
+}
+
+/**
+ * gdk_display_manager_peek:
+ *
+ * Gets the singleton #GdkDisplayManager object. If GDK could
+ * not be initialized, %NULL is returned.
+ *
+ * Returns: (transfer none): The global #GdkDisplayManager singleton,
+ *     or %NULL if GDK could not be initialized. gdk_parse_args(),
+ *     gdk_init(), or gdk_init_check() must have been called first
+ *
+ * Since: 3.10
+ */
+GdkDisplayManager *
+gdk_display_manager_peek (void)
+{
+  if (manager == NULL)
    {
-      const gchar *backend;
+      const gchar *backend_list;
+      gchar **backends;
+      gint i;
+      gboolean allow_any;
+
+      if (allowed_backends == NULL)
+        allowed_backends = "*";
+      allow_any = strstr (allowed_backends, "*") != NULL;
+
+      backend_list = g_getenv ("GDK_BACKEND");
+      if (backend_list == NULL)
+        backend_list = allowed_backends;
+      backends = g_strsplit (backend_list, ",", 0);
+
+      for (i = 0; manager == NULL && backends[i] != NULL; i++)
+        {
+          const gchar *backend = backends[i];
+          gboolean any = g_str_equal (backend, "*");
+
+          if (!allow_any && !any && !strstr (allowed_backends, backend))
+            continue;

-      backend = g_getenv ("GDK_BACKEND");
 #ifdef GDK_WINDOWING_QUARTZ
-      if (backend == NULL || strcmp (backend, "quartz") == 0)
-        manager = g_object_new (gdk_quartz_display_manager_get_type (), NULL);
-      else
+          if ((any && allow_any) ||
+              (any && strstr (allowed_backends, "quartz")) ||
+              g_str_equal (backend, "quartz"))
+            {
+              GDK_NOTE (MISC, g_message ("Trying quartz backend"));
+              manager = g_initable_new (gdk_quartz_display_manager_get_type (), NULL, NULL, NULL);
+              if (manager)
+                break;
+            }
 #endif
 #ifdef GDK_WINDOWING_WIN32
-      if (backend == NULL || strcmp (backend, "win32") == 0)
-        manager = g_object_new (gdk_win32_display_manager_get_type (), NULL);
-      else
+          if ((any && allow_any) ||
+              (any && strstr (allowed_backends, "win32")) ||
+              g_str_equal (backend, "win32"))
+            {
+              GDK_NOTE (MISC, g_message ("Trying win32 backend"));
+              manager = g_initable_new (gdk_win32_display_manager_get_type (), NULL, NULL, NULL);
+              if (manager)
+                break;
+            }
 #endif
 #ifdef GDK_WINDOWING_X11
-      if (backend == NULL || strcmp (backend, "x11") == 0)
-        manager = g_object_new (gdk_x11_display_manager_get_type (), NULL);
-      else
+          if ((any && allow_any) ||
+              (any && strstr (allowed_backends, "x11")) ||
+              g_str_equal (backend, "x11"))
+            {
+              GDK_NOTE (MISC, g_message ("Trying x11 backend"));
+              manager = g_initable_new (gdk_x11_display_manager_get_type (), NULL, NULL, NULL);
+              if (manager)
+                break;
+            }
 #endif
 #ifdef GDK_WINDOWING_WAYLAND
-      if (backend == NULL || strcmp (backend, "wayland") == 0)
-        manager = g_object_new (gdk_wayland_display_manager_get_type (), NULL);
-      else
+          if ((any && allow_any) ||
+              (any && strstr (allowed_backends, "wayland")) ||
+              g_str_equal (backend, "wayland"))
+            {
+              GDK_NOTE (MISC, g_message ("Trying wayland backend"));
+              manager = g_initable_new (gdk_wayland_display_manager_get_type (), NULL, NULL, NULL);
+              if (manager)
+                break;
+            }
 #endif
 #ifdef GDK_WINDOWING_BROADWAY
-      if (backend == NULL || strcmp (backend, "broadway") == 0)
-        manager = g_object_new (gdk_broadway_display_manager_get_type (), NULL);
-      else
+          if ((any && allow_any) ||
+              (any && strstr (allowed_backends, "broadway")) ||
+              g_str_equal (backend, "broadway"))
+            {
+              GDK_NOTE (MISC, g_message ("Trying broadway backend"));
+              manager = g_initable_new (gdk_broadway_display_manager_get_type (), NULL, NULL, NULL);
+              if (manager)
+                break;
+            }
 #endif
-      if (backend != NULL)
-        g_error ("Unsupported GDK backend: %s", backend);
-      else
-        g_error ("No GDK backend found");
+        }
+      g_strfreev (backends);
    }

  return manager;
 }

+/* Used for cases where we don't actually want to instantiate a
+ * display manager if none exists.  Internal only.
+ */
+GdkDisplayManager *
+_gdk_display_manager_get_nocreate (void)
+{
+  return manager;
+}
+
 /**
 * gdk_display_manager_get_default_display:
 * @manager: a #GdkDisplayManager
@@ -43,6 +43,8 @@ G_BEGIN_DECLS
 GType              gdk_display_manager_get_type            (void) G_GNUC_CONST;

 GdkDisplayManager *gdk_display_manager_get                 (void);
+GDK_AVAILABLE_IN_3_10
+GdkDisplayManager *gdk_display_manager_peek                (void);
 GdkDisplay *       gdk_display_manager_get_default_display (GdkDisplayManager *manager);
 void               gdk_display_manager_set_default_display (GdkDisplayManager *manager,
                                                            GdkDisplay        *display);
@@ -64,6 +64,9 @@ struct _GdkDisplayManagerClass
                                       GdkDisplay        *display);
 };

+GdkDisplayManager *
+_gdk_display_manager_get_nocreate (void);
+
 G_END_DECLS

 #endif
@@ -66,7 +66,7 @@ typedef enum
 /**
 * GdkDragProtocol:
 * @GDK_DRAG_PROTO_NONE: no protocol.
- * @GDK_DRAG_PROTO_MOTIF: The Motif DND protocol.
+ * @GDK_DRAG_PROTO_MOTIF: The Motif DND protocol. No longer supported
 * @GDK_DRAG_PROTO_XDND: The Xdnd protocol.
 * @GDK_DRAG_PROTO_ROOTWIN: An extension to the Xdnd protocol for
 *  unclaimed root window drops.
@@ -1,5 +1,5 @@
 /*** BEGIN file-header ***/
-#define GDK_ENABLE_BROKEN
+#include "config.h"
 #include "gdk.h"

 /*** END file-header ***/
@@ -203,9 +203,12 @@ gdk_keyval_convert_case (guint symbol,
                         guint *lower,
                         guint *upper)
 {
-  GdkDisplayManager *manager = gdk_display_manager_get ();
+  GdkDisplayManager *manager = _gdk_display_manager_get_nocreate ();

-  GDK_DISPLAY_MANAGER_GET_CLASS (manager)->keyval_convert_case (manager, symbol, lower, upper);
+  if (manager)
+    GDK_DISPLAY_MANAGER_GET_CLASS (manager)->keyval_convert_case (manager, symbol, lower, upper);
+  else
+    _gdk_display_manager_real_keyval_convert_case (NULL, symbol, lower, upper);
 }

 /**
@@ -117,6 +117,9 @@ void gdk_flush (void);

 void gdk_disable_multidevice (void);

+GDK_AVAILABLE_IN_3_10
+void gdk_set_allowed_backends (const gchar *backends);
+
 G_END_DECLS

 #endif /* __GDK_MAIN_H__ */
@@ -297,8 +297,8 @@ typedef enum
 *  viewable.
 * @GDK_GRAB_FROZEN: the resource is frozen by an active grab of another client.
 *
- * Returned by gdk_pointer_grab() and gdk_keyboard_grab() to indicate
- * success or the reason for the failure of the grab attempt.
+ * Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to
+ * indicate success or the reason for the failure of the grab attempt.
 */
 typedef enum
 {
@@ -100,6 +100,16 @@
 */
 #define GDK_VERSION_3_8         (G_ENCODE_VERSION (3, 8))

+/**
+ * GDK_VERSION_3_10:
+ *
+ * A macro that evaluates to the 3.10 version of GDK, in a format
+ * that can be used by the C pre-processor.
+ *
+ * Since: 3.10
+ */
+#define GDK_VERSION_3_10        (G_ENCODE_VERSION (3, 10))
+

 /* evaluates to the current stable version; for development cycles,
 * this means the next stable target
@@ -241,4 +251,18 @@
 # define GDK_AVAILABLE_IN_3_8
 #endif

+#if GDK_VERSION_MIN_REQUIRED >= GDK_VERSION_3_10
+# define GDK_DEPRECATED_IN_3_10               GDK_DEPRECATED
+# define GDK_DEPRECATED_IN_3_10_FOR(f)        GDK_DEPRECATED_FOR(f)
+#else
+# define GDK_DEPRECATED_IN_3_10
+# define GDK_DEPRECATED_IN_3_10_FOR(f)
+#endif
+
+#if GDK_VERSION_MAX_ALLOWED < GDK_VERSION_3_10
+# define GDK_AVAILABLE_IN_3_10                GDK_UNAVAILABLE(3, 10)
+#else
+# define GDK_AVAILABLE_IN_3_10
+#endif
+
 #endif  /* __GDK_VERSION_MACROS_H__ */
@@ -42,6 +42,9 @@

 #include <math.h>

+/* for the use of round() */
+#include "fallback-c89.c"
+
 #undef DEBUG_WINDOW_PRINTING


@@ -54,6 +54,7 @@ struct _GdkWaylandCursor
  int hotspot_x, hotspot_y;
  int width, height;
  struct wl_buffer *buffer;
+  gboolean free_buffer;
 };

 struct _GdkWaylandCursorClass
@@ -65,12 +66,111 @@ G_DEFINE_TYPE (GdkWaylandCursor, _gdk_wayland_cursor, GDK_TYPE_CURSOR)

 static guint theme_serial = 0;

+struct cursor_cache_key
+{
+  GdkCursorType type;
+  const char *name;
+};
+
+static void
+add_to_cache (GdkWaylandDisplay *display, GdkWaylandCursor *cursor)
+{
+  display->cursor_cache = g_slist_prepend (display->cursor_cache, cursor);
+
+  g_object_ref (cursor);
+}
+
+static gint
+cache_compare_func (gconstpointer listelem,
+                    gconstpointer target)
+{
+  GdkWaylandCursor *cursor = (GdkWaylandCursor *) listelem;
+  struct cursor_cache_key* key = (struct cursor_cache_key *) target;
+
+  if (cursor->cursor.type != key->type)
+    return 1; /* No match */
+
+  /* Elements marked as pixmap must be named cursors
+   * (since we don't store normal pixmap cursors
+   */
+  if (key->type == GDK_CURSOR_IS_PIXMAP)
+    return strcmp (key->name, cursor->name);
+
+  return 0; /* Match */
+}
+
+static GdkWaylandCursor*
+find_in_cache (GdkWaylandDisplay *display,
+               GdkCursorType      type,
+               const char        *name)
+{
+  GSList* res;
+  struct cursor_cache_key key;
+
+  key.type = type;
+  key.name = name;
+
+  res = g_slist_find_custom (display->cursor_cache, &key, cache_compare_func);
+
+  if (res)
+    return (GdkWaylandCursor *) res->data;
+
+  return NULL;
+}
+
+/* Called by gdk_wayland_display_finalize to flush any cached cursors
+ * for a dead display.
+ */
+void
+_gdk_wayland_display_finalize_cursors (GdkWaylandDisplay *display)
+{
+  g_slist_foreach (display->cursor_cache, (GFunc) g_object_unref, NULL);
+  g_slist_free (display->cursor_cache);
+}
+
+static gboolean
+set_cursor_from_theme (GdkWaylandCursor *cursor, struct wl_cursor_theme *theme)
+{
+  struct wl_cursor *c;
+
+  c = wl_cursor_theme_get_cursor (theme, cursor->name);
+  if (!c)
+    {
+      g_warning (G_STRLOC ": Unable to load %s from the cursor theme", cursor->name);
+
+      /* return the left_ptr cursor as a fallback */
+      c = wl_cursor_theme_get_cursor (theme, "left_ptr");
+
+      if (!c)
+        return FALSE;
+    }
+
+  cursor->hotspot_x = c->images[0]->hotspot_x;
+  cursor->hotspot_y = c->images[0]->hotspot_y;
+  cursor->width = c->images[0]->width;
+  cursor->height = c->images[0]->height;
+
+  cursor->buffer = wl_cursor_image_get_buffer(c->images[0]);
+  cursor->free_buffer = FALSE;
+
+  return TRUE;
+}
+
+void
+_gdk_wayland_display_update_cursors (GdkWaylandDisplay      *display,
+                                     struct wl_cursor_theme *theme)
+{
+  g_slist_foreach (display->cursor_cache, (GFunc) set_cursor_from_theme, theme);
+}
+
 static void
 gdk_wayland_cursor_finalize (GObject *object)
 {
  GdkWaylandCursor *cursor = GDK_WAYLAND_CURSOR (object);

  g_free (cursor->name);
+  if (cursor->free_buffer)
+    wl_buffer_destroy (cursor->buffer);

  G_OBJECT_CLASS (_gdk_wayland_cursor_parent_class)->finalize (object);
 }
@@ -115,29 +215,27 @@ _gdk_wayland_cursor_init (GdkWaylandCursor *cursor)
 {
 }

-/* Use to implement from_pixbuf below */
-#if 0
+/* Used to implement from_pixbuf below */
 static void
-set_pixbuf (GdkWaylandCursor *cursor, GdkPixbuf *pixbuf)
+set_pixbuf (gpointer argb_pixels, int width, int height, GdkPixbuf *pixbuf)
 {
  int stride, i, n_channels;
-  unsigned char *pixels, *end, *argb_pixels, *s, *d;
+  unsigned char *pixels, *end, *s, *d;

  stride = gdk_pixbuf_get_rowstride(pixbuf);
  pixels = gdk_pixbuf_get_pixels(pixbuf);
  n_channels = gdk_pixbuf_get_n_channels(pixbuf);
-  argb_pixels = cursor->map;

 #define MULT(_d,c,a,t) \
 	do { t = c * a + 0x7f; _d = ((t >> 8) + t) >> 8; } while (0)

  if (n_channels == 4)
    {
-      for (i = 0; i < cursor->height; i++)
+      for (i = 0; i < height; i++)
 	{
 	  s = pixels + i * stride;
-	  end = s + cursor->width * 4;
-	  d = argb_pixels + i * cursor->width * 4;
+          end = s + width * 4;
+          d = argb_pixels + i * width * 4;
 	  while (s < end)
 	    {
 	      unsigned int t;
@@ -153,11 +251,11 @@ set_pixbuf (GdkWaylandCursor *cursor, GdkPixbuf *pixbuf)
    }
  else if (n_channels == 3)
    {
-      for (i = 0; i < cursor->height; i++)
+      for (i = 0; i < height; i++)
 	{
 	  s = pixels + i * stride;
-	  end = s + cursor->width * 3;
-	  d = argb_pixels + i * cursor->width * 4;
+          end = s + width * 3;
+          d = argb_pixels + i * width * 4;
 	  while (s < end)
 	    {
 	      d[0] = s[2];
@@ -171,84 +269,6 @@ set_pixbuf (GdkWaylandCursor *cursor, GdkPixbuf *pixbuf)
    }
 }

-static GdkCursor *
-create_cursor(GdkWaylandDisplay *display, GdkPixbuf *pixbuf, int x, int y)
-{
-  GdkWaylandCursor *cursor;
-  int stride, fd;
-  char *filename;
-  GError *error = NULL;
-  struct wl_shm_pool *pool;
-
-  cursor = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
-			 "cursor-type", GDK_CURSOR_IS_PIXMAP,
-			 "display", display,
-			 NULL);
-  cursor->name = NULL;
-  cursor->serial = theme_serial;
-  cursor->x = x;
-  cursor->y = y;
-  if (pixbuf)
-    {
-      cursor->width = gdk_pixbuf_get_width (pixbuf);
-      cursor->height = gdk_pixbuf_get_height (pixbuf);
-    }
-  else
-    {
-      cursor->width = 1;
-      cursor->height = 1;
-    }
-
-  stride = cursor->width * 4;
-  cursor->size = stride * cursor->height;
-
-  fd = g_file_open_tmp("wayland-shm-XXXXXX", &filename, &error);
-  if (fd < 0)
-    {
-      g_critical (G_STRLOC ": Error opening temporary file for buffer: %s",
-                  error->message);
-      g_error_free (error);
-      return NULL;
-  }
-
-  unlink (filename);
-  g_free (filename);
-
-  if (ftruncate(fd, cursor->size) < 0)
-    {
-      g_critical (G_STRLOC ": Error truncating file for buffer: %s",
-                  g_strerror (errno));
-      close(fd);
-      return NULL;
-    }
-
-  cursor->map = mmap(NULL, cursor->size,
-                     PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-  if (cursor->map == MAP_FAILED)
-    {
-      g_critical (G_STRLOC ": Error mmap'ing file for buffer: %s",
-                  g_strerror (errno));
-      close(fd);
-      return NULL;
-    }
-
-  if (pixbuf)
-    set_pixbuf (cursor, pixbuf);
-  else
-    memset (cursor->map, 0, 4);
-
-  cursor->buffer = wl_shm_create_buffer(display->shm,
-					fd,
-					cursor->width,
-					cursor->height,
-					stride, WL_SHM_FORMAT_ARGB8888);
-
-  close(fd);
-
- return GDK_CURSOR (cursor);
-}
-#endif
-
 GdkCursor *
 _gdk_wayland_display_get_cursor_for_type (GdkDisplay    *display,
 					  GdkCursorType  cursor_type)
@@ -277,10 +297,18 @@ _gdk_wayland_display_get_cursor_for_name (GdkDisplay  *display,
 {
  GdkWaylandCursor *private;
  GdkWaylandDisplay *wayland_display = GDK_WAYLAND_DISPLAY (display);
-  struct wl_cursor *cursor;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

+  private = find_in_cache (wayland_display, GDK_CURSOR_IS_PIXMAP, name);
+  if (private)
+    {
+      /* Cache had it, add a ref for this user */
+      g_object_ref (private);
+
+      return (GdkCursor*) private;
+    }
+
  private = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
                          "cursor-type", GDK_CURSOR_IS_PIXMAP,
                          "display", display,
@@ -292,59 +320,79 @@ _gdk_wayland_display_get_cursor_for_name (GdkDisplay  *display,
  if (!name || g_str_equal (name, "blank_cursor"))
    return GDK_CURSOR (private);

-  cursor = wl_cursor_theme_get_cursor (wayland_display->cursor_theme,
-                                       name);
-
-  if (!cursor)
-    {
-      g_warning (G_STRLOC ": Unable to load %s from the cursor theme", name);
-
-      /* return the left_ptr cursor as a fallback */
-      cursor = wl_cursor_theme_get_cursor (wayland_display->cursor_theme,
-                                           "left_ptr");
-
-      /* if the fallback failed to load, return a blank pointer */
-      if (!cursor)
-        return GDK_CURSOR (private);
-    }
+  if (!set_cursor_from_theme (private, wayland_display->cursor_theme))
+    return GDK_CURSOR (private);

  /* TODO: Do something clever so we can do animated cursors - move the
   * wl_pointer_set_cursor to a function here so that we can do the magic to
   * iterate through
   */
-  private->hotspot_x = cursor->images[0]->hotspot_x;
-  private->hotspot_y = cursor->images[0]->hotspot_y;
-  private->width = cursor->images[0]->width;
-  private->height = cursor->images[0]->height;

-  private->buffer = wl_cursor_image_get_buffer(cursor->images[0]);
+  add_to_cache (wayland_display, private);

  return GDK_CURSOR (private);
 }

-/* TODO: Needs implementing */
 GdkCursor *
 _gdk_wayland_display_get_cursor_for_pixbuf (GdkDisplay *display,
 					    GdkPixbuf  *pixbuf,
 					    gint        x,
 					    gint        y)
 {
-  GdkWaylandCursor *private;
+  GdkWaylandCursor *cursor;
+  GdkWaylandDisplay *wayland_display = GDK_WAYLAND_DISPLAY (display);
+  int stride;
+  size_t size;
+  gpointer data;
+  struct wl_shm_pool *pool;

  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);
+  cursor = g_object_new (GDK_TYPE_WAYLAND_CURSOR,
+			 "cursor-type", GDK_CURSOR_IS_PIXMAP,
+			 "display", wayland_display,
+			 NULL);
+  cursor->name = NULL;
+  cursor->serial = theme_serial;
+  cursor->hotspot_x = x;
+  cursor->hotspot_y = y;

-  private->name = NULL;
-  private->serial = theme_serial;
+  if (pixbuf)
+    {
+      cursor->width = gdk_pixbuf_get_width (pixbuf);
+      cursor->height = gdk_pixbuf_get_height (pixbuf);
+    }
+  else
+    {
+      cursor->width = 1;
+      cursor->height = 1;
+    }

-  return GDK_CURSOR (private);
+  pool = _create_shm_pool (wayland_display->shm,
+                           cursor->width,
+                           cursor->height,
+                           &size,
+                           &data);
+
+  if (pixbuf)
+    set_pixbuf (data, cursor->width, cursor->height, pixbuf);
+  else
+    memset (data, 0, 4);
+
+  stride = cursor->width * 4;
+  cursor->buffer = wl_shm_pool_create_buffer (pool, 0,
+					cursor->width,
+					cursor->height,
+					stride,
+					WL_SHM_FORMAT_ARGB8888);
+  cursor->free_buffer = FALSE;
+
+  wl_shm_pool_destroy (pool);
+
+  return GDK_CURSOR (cursor);
 }

 void
@@ -55,7 +55,7 @@ struct _GdkWaylandDeviceData

  GdkDevice *pointer;
  GdkDevice *keyboard;
-
+  GdkCursor *cursor;
  GdkKeymap *keymap;

  GdkModifierType modifiers;
@@ -64,11 +64,13 @@ struct _GdkWaylandDeviceData
  struct wl_data_device *data_device;
  double surface_x, surface_y;
  uint32_t time;
+  uint32_t enter_serial;
  GdkWindow *pointer_grab_window;
  uint32_t pointer_grab_time;
  guint32 repeat_timer;
  guint32 repeat_key;
  guint32 repeat_count;
+  GSettings *keyboard_settings;

  DataOffer *drag_offer;
  DataOffer *selection_offer;
@@ -91,31 +93,29 @@ struct _GdkWaylandDeviceClass

 G_DEFINE_TYPE (GdkWaylandDevice, gdk_wayland_device, GDK_TYPE_DEVICE)

-#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))
+#define GDK_TYPE_WAYLAND_DEVICE_MANAGER        (gdk_wayland_device_manager_get_type ())
+#define GDK_WAYLAND_DEVICE_MANAGER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_DEVICE_MANAGER, GdkWaylandDeviceManager))
+#define GDK_WAYLAND_DEVICE_MANAGER_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_DEVICE_MANAGER, GdkWaylandDeviceManagerClass))
+#define GDK_IS_WAYLAND_DEVICE_MANAGER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_DEVICE_MANAGER))
+#define GDK_IS_WAYLAND_DEVICE_MANAGER_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_DEVICE_MANAGER))
+#define GDK_WAYLAND_DEVICE_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_DEVICE_MANAGER, GdkWaylandDeviceManagerClass))

-typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
-typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
+typedef struct _GdkWaylandDeviceManager GdkWaylandDeviceManager;
+typedef struct _GdkWaylandDeviceManagerClass GdkWaylandDeviceManagerClass;

-struct _GdkDeviceManagerCore
+struct _GdkWaylandDeviceManager
 {
  GdkDeviceManager parent_object;
-  GdkDevice *core_pointer;
-  GdkDevice *core_keyboard;
  GList *devices;
 };

-struct _GdkDeviceManagerCoreClass
+struct _GdkWaylandDeviceManagerClass
 {
  GdkDeviceManagerClass parent_class;
 };

-G_DEFINE_TYPE (GdkDeviceManagerCore,
-	       gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
+G_DEFINE_TYPE (GdkWaylandDeviceManager,
+	       gdk_wayland_device_manager, GDK_TYPE_DEVICE_MANAGER)

 static gboolean
 gdk_wayland_device_get_history (GdkDevice      *device,
@@ -151,32 +151,33 @@ gdk_wayland_device_set_window_cursor (GdkDevice *device,
                                      GdkCursor *cursor)
 {
  GdkWaylandDeviceData *wd = GDK_WAYLAND_DEVICE(device)->device;
-  GdkWaylandDisplay *wayland_display =
-    GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
  struct wl_buffer *buffer;
  int x, y, w, h;

-  if (cursor)
-    g_object_ref (cursor);
-
  /* Setting the cursor to NULL means that we should use the default cursor */
  if (!cursor)
    {
      /* FIXME: Is this the best sensible default ? */
      cursor = _gdk_wayland_display_get_cursor_for_type (device->display,
-                                                         GDK_LEFT_PTR);
+                                                             GDK_LEFT_PTR);
    }

-  buffer = _gdk_wayland_cursor_get_buffer (cursor, &x, &y, &w, &h);
+  if (cursor == wd->cursor)
+    return;
+
+  if (wd->cursor)
+    g_object_unref (wd->cursor);
+
+  wd->cursor = g_object_ref (cursor);
+
+  buffer = _gdk_wayland_cursor_get_buffer (wd->cursor, &x, &y, &w, &h);
  wl_pointer_set_cursor (wd->wl_pointer,
-                         _gdk_wayland_display_get_serial (wayland_display),
+                         wd->enter_serial,
                         wd->pointer_surface,
                         x, y);
  wl_surface_attach (wd->pointer_surface, buffer, 0, 0);
  wl_surface_damage (wd->pointer_surface,  0, 0, w, h);
-  wl_surface_commit(wd->pointer_surface);
-
-  g_object_unref (cursor);
+  wl_surface_commit (wd->pointer_surface);
 }

 static void
@@ -575,6 +576,7 @@ pointer_handle_enter (void              *data,

  device->surface_x = wl_fixed_to_double (sx);
  device->surface_y = wl_fixed_to_double (sy);
+  device->enter_serial = serial;

  _gdk_wayland_display_deliver_event (device->display, event);

@@ -619,6 +621,12 @@ pointer_handle_leave (void              *data,
                       device, device->pointer_focus));

  g_object_unref(device->pointer_focus);
+  if (device->cursor)
+    {
+      g_object_unref (device->cursor);
+      device->cursor = NULL;
+    }
+
  device->pointer_focus = NULL;
 }

@@ -767,10 +775,11 @@ keyboard_handle_keymap (void               *data,
                       uint32_t            size)
 {
  GdkWaylandDeviceData *device = data;
-  if (device->keymap)
-    g_object_unref (device->keymap);

-  device->keymap = _gdk_wayland_keymap_new_from_fd (format, fd, size);
+  _gdk_wayland_keymap_update_from_fd (device->keymap, format, fd, size);
+
+  g_signal_emit_by_name (device->keymap, "keys-changed");
+  g_signal_emit_by_name (device->keymap, "state-changed");
 }

 static void
@@ -924,17 +933,43 @@ translate_keyboard_string (GdkEventKey *event)
    }
 }

+static gboolean
+get_key_repeat (GdkWaylandDeviceData *device,
+                guint                *delay,
+                guint                *interval)
+{
+  gboolean repeat;
+
+  if (device->keyboard_settings)
+    {
+      repeat = g_settings_get_boolean (device->keyboard_settings, "repeat");
+      *delay = g_settings_get_uint (device->keyboard_settings, "delay");
+      *interval = g_settings_get_uint (device->keyboard_settings, "repeat-interval");
+    }
+  else
+    {
+      repeat = TRUE;
+      *delay = 400;
+      *interval = 80;
+    }
+
+  return repeat;
+}
+
 static gboolean
 deliver_key_event(GdkWaylandDeviceData *device,
                  uint32_t time, uint32_t key, uint32_t state)
 {
  GdkEvent *event;
  struct xkb_state *xkb_state;
+  struct xkb_keymap *xkb_keymap;
  GdkKeymap *keymap;
  xkb_keysym_t sym;
+  guint delay, interval;

  keymap = device->keymap;
  xkb_state = _gdk_wayland_keymap_get_xkb_state (keymap);
+  xkb_keymap = _gdk_wayland_keymap_get_xkb_keymap (keymap);

  sym = xkb_state_key_get_one_sym (xkb_state, key);

@@ -962,6 +997,12 @@ deliver_key_event(GdkWaylandDeviceData *device,
                       event->key.hardware_keycode, event->key.keyval,
                       event->key.string, event->key.state));

+  if (!xkb_keymap_key_repeats (xkb_keymap, key))
+    return FALSE;
+
+  if (!get_key_repeat (device, &delay, &interval))
+    return FALSE;
+
  device->repeat_count++;
  device->repeat_key = key;

@@ -974,10 +1015,6 @@ deliver_key_event(GdkWaylandDeviceData *device,
        }
      return FALSE;
    }
-  else if (device->modifiers)
-    {
-      return FALSE;
-    }
  else switch (device->repeat_count)
    {
    case 1:
@@ -988,11 +1025,11 @@ deliver_key_event(GdkWaylandDeviceData *device,
        }

      device->repeat_timer =
-        gdk_threads_add_timeout (400, keyboard_repeat, device);
+        gdk_threads_add_timeout (delay, keyboard_repeat, device);
      return TRUE;
    case 2:
      device->repeat_timer =
-        gdk_threads_add_timeout (80, keyboard_repeat, device);
+        gdk_threads_add_timeout (interval, keyboard_repeat, device);
      return FALSE;
    default:
      return TRUE;
@@ -1042,6 +1079,8 @@ keyboard_handle_modifiers (void               *data,
  device->modifiers = mods_depressed | mods_latched | mods_locked;

  xkb_state_update_mask (xkb_state, mods_depressed, mods_latched, mods_locked, group, 0, 0);
+
+  g_signal_emit_by_name (keymap, "state-changed");
 }

 static const struct wl_pointer_listener pointer_listener = {
@@ -1065,8 +1104,8 @@ seat_handle_capabilities(void *data, struct wl_seat *seat,
                         enum wl_seat_capability caps)
 {
  GdkWaylandDeviceData *device = data;
-  GdkDeviceManagerCore *device_manager_core =
-    GDK_DEVICE_MANAGER_CORE(device->device_manager);
+  GdkWaylandDeviceManager *device_manager =
+    GDK_WAYLAND_DEVICE_MANAGER(device->device_manager);

  if ((caps & WL_SEAT_CAPABILITY_POINTER) && !device->wl_pointer)
    {
@@ -1086,16 +1125,16 @@ seat_handle_capabilities(void *data, struct wl_seat *seat,
                                      NULL);
      GDK_WAYLAND_DEVICE (device->pointer)->device = device;

-      device_manager_core->devices =
-        g_list_prepend (device_manager_core->devices, device->pointer);
+      device_manager->devices =
+        g_list_prepend (device_manager->devices, device->pointer);
    }
  else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && device->wl_pointer)
    {
      wl_pointer_destroy(device->wl_pointer);
      device->wl_pointer = NULL;

-      device_manager_core->devices =
-        g_list_remove (device_manager_core->devices, device->pointer);
+      device_manager->devices =
+        g_list_remove (device_manager->devices, device->pointer);

      g_object_unref (device->pointer);
      device->pointer = NULL;
@@ -1119,16 +1158,16 @@ seat_handle_capabilities(void *data, struct wl_seat *seat,
                                       NULL);
      GDK_WAYLAND_DEVICE (device->keyboard)->device = device;

-      device_manager_core->devices =
-        g_list_prepend (device_manager_core->devices, device->keyboard);
+      device_manager->devices =
+        g_list_prepend (device_manager->devices, device->keyboard);
    }
  else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && device->wl_keyboard) 
    {
      wl_keyboard_destroy(device->wl_keyboard);
      device->wl_keyboard = NULL;

-      device_manager_core->devices =
-        g_list_remove (device_manager_core->devices, device->keyboard);
+      device_manager->devices =
+        g_list_remove (device_manager->devices, device->keyboard);

      g_object_unref (device->keyboard);
      device->keyboard = NULL;
@@ -1145,6 +1184,21 @@ static const struct wl_seat_listener seat_listener = {
    seat_handle_capabilities,
 };

+static void
+init_settings (GdkWaylandDeviceData *device)
+{
+  GSettingsSchemaSource *source;
+  GSettingsSchema *schema;
+
+  source = g_settings_schema_source_get_default ();
+  schema = g_settings_schema_source_lookup (source, "org.gnome.settings-daemon.peripherals.keyboard", FALSE);
+  if (schema != NULL)
+    {
+      device->keyboard_settings = g_settings_new_full (schema, NULL, NULL);
+      g_settings_schema_unref (schema);
+    }
+}
+
 void
 _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,
 					struct wl_seat *wl_seat)
@@ -1174,6 +1228,8 @@ _gdk_wayland_device_manager_add_device (GdkDeviceManager *device_manager,

  device->pointer_surface =
    wl_compositor_create_surface (display_wayland->compositor);
+
+  init_settings (device);
 }

 static void
@@ -1183,43 +1239,43 @@ free_device (gpointer data)
 }

 static void
-gdk_device_manager_core_finalize (GObject *object)
+gdk_wayland_device_manager_finalize (GObject *object)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkWaylandDeviceManager *device_manager;

-  device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
+  device_manager = GDK_WAYLAND_DEVICE_MANAGER (object);

-  g_list_free_full (device_manager_core->devices, free_device);
+  g_list_free_full (device_manager->devices, free_device);

-  G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
+  G_OBJECT_CLASS (gdk_wayland_device_manager_parent_class)->finalize (object);
 }

 static GList *
-gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+gdk_wayland_device_manager_list_devices (GdkDeviceManager *device_manager,
                                      GdkDeviceType     type)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkWaylandDeviceManager *wayland_device_manager;
  GList *devices = NULL;

  if (type == GDK_DEVICE_TYPE_MASTER)
    {
-      device_manager_core = (GdkDeviceManagerCore *) device_manager;
-      devices = g_list_copy(device_manager_core->devices);
+      wayland_device_manager = (GdkWaylandDeviceManager *) device_manager;
+      devices = g_list_copy(wayland_device_manager->devices);
    }

  return devices;
 }

 static GdkDevice *
-gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
+gdk_wayland_device_manager_get_client_pointer (GdkDeviceManager *device_manager)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkWaylandDeviceManager *wayland_device_manager;
  GList *l;

-  device_manager_core = (GdkDeviceManagerCore *) device_manager;
+  wayland_device_manager = (GdkWaylandDeviceManager *) device_manager;

  /* Find the first pointer device */
-  for (l = device_manager_core->devices; l != NULL; l = l->next)
+  for (l = wayland_device_manager->devices; l != NULL; l = l->next)
    {
      GdkDevice *device = l->data;

@@ -1231,25 +1287,25 @@ gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
 }

 static void
-gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
+gdk_wayland_device_manager_class_init (GdkWaylandDeviceManagerClass *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;
+  object_class->finalize = gdk_wayland_device_manager_finalize;
+  device_manager_class->list_devices = gdk_wayland_device_manager_list_devices;
+  device_manager_class->get_client_pointer = gdk_wayland_device_manager_get_client_pointer;
 }

 static void
-gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
+gdk_wayland_device_manager_init (GdkWaylandDeviceManager *device_manager)
 {
 }

 GdkDeviceManager *
 _gdk_wayland_device_manager_new (GdkDisplay *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
+  return g_object_new (GDK_TYPE_WAYLAND_DEVICE_MANAGER,
                       "display", display,
                       NULL);
 }
@@ -1420,7 +1476,7 @@ data_source_send (void                  *data,
                  const char            *mime_type,
                  int32_t                fd)
 {
-  GdkWaylandSelectionOffer *offer = (GdkWaylandSelectionOffer *)data;;
+  GdkWaylandSelectionOffer *offer = (GdkWaylandSelectionOffer *)data;
  gchar *buf;
  gssize len, bytes_written = 0;

@@ -204,9 +204,7 @@ gdk_wayland_display_finalize (GObject *object)
 {
  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (object);

-  /* Keymap */
-  if (display_wayland->keymap)
-    g_object_unref (display_wayland->keymap);
+  _gdk_wayland_display_finalize_cursors (display_wayland);

  /* input GdkDevice list */
  g_list_free_full (display_wayland->input_devices, g_object_unref);
@@ -272,7 +270,7 @@ gdk_wayland_display_flush (GdkDisplay *display)
  g_return_if_fail (GDK_IS_DISPLAY (display));

  if (!display->closed)
-    wl_display_flush(GDK_WAYLAND_DISPLAY (display)->wl_display);;
+    wl_display_flush(GDK_WAYLAND_DISPLAY (display)->wl_display);
 }

 static gboolean
@@ -564,27 +562,56 @@ gdk_wayland_display_init (GdkWaylandDisplay *display)
  display->xkb_context = xkb_context_new (0);
 }

+void
+gdk_wayland_display_set_cursor_theme (GdkDisplay  *display,
+                                      const gchar *name,
+                                      gint         size)
+{
+  GdkWaylandDisplay *wayland_display = GDK_WAYLAND_DISPLAY(display);
+  struct wl_cursor_theme *theme;
+
+  g_assert (wayland_display);
+  g_assert (wayland_display->shm);
+
+  theme = wl_cursor_theme_load (name, size, wayland_display->shm);
+  if (theme == NULL)
+    {
+      g_warning ("Failed to load cursor theme %s\n", name);
+      return;
+    }
+
+  _gdk_wayland_display_update_cursors (wayland_display, theme);
+
+  if (wayland_display->cursor_theme != NULL)
+    wl_cursor_theme_destroy (wayland_display->cursor_theme);
+  wayland_display->cursor_theme = theme;
+}
+
 static void
 _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *wayland_display)
 {
-  guint w, h;
-  const gchar *theme_name;
+  guint size;
+  const gchar *name;
  GValue v = G_VALUE_INIT;

  g_assert (wayland_display);
  g_assert (wayland_display->shm);

-  _gdk_wayland_display_get_default_cursor_size (GDK_DISPLAY (wayland_display),
-                                                &w, &h);
+  g_value_init (&v, G_TYPE_INT);
+  if (gdk_setting_get ("gtk-cursor-theme-size", &v))
+    size = g_value_get_int (&v);
+  else
+    size = 32;
+  g_value_unset (&v);
+
  g_value_init (&v, G_TYPE_STRING);
  if (gdk_setting_get ("gtk-cursor-theme-name", &v))
-    theme_name = g_value_get_string (&v);
+    name = g_value_get_string (&v);
  else
-    theme_name = "default";
+    name = "default";

-  wayland_display->cursor_theme = wl_cursor_theme_load (theme_name,
-                                                        w,
-                                                        wayland_display->shm);
+  gdk_wayland_display_set_cursor_theme (GDK_DISPLAY (wayland_display),
+                                        name, size);
  g_value_unset (&v);
 }

@@ -42,9 +42,6 @@ struct _GdkWaylandDisplay
  GdkDisplay parent_instance;
  GdkScreen *screen;

-  /* Keyboard related information */
-  GdkKeymap *keymap;
-
  /* input GdkDevice list */
  GList *input_devices;

@@ -65,6 +62,7 @@ struct _GdkWaylandDisplay
  struct wl_data_device_manager *data_device_manager;

  struct wl_cursor_theme *cursor_theme;
+  GSList *cursor_cache;

  GSource *event_source;

@@ -38,6 +38,8 @@ struct _GdkWaylandDisplayManager

  GHashTable *name_to_atoms;
  guint next_atom;
+
+  gboolean init_failed;
 };

 struct _GdkWaylandDisplayManagerClass
@@ -45,12 +47,44 @@ struct _GdkWaylandDisplayManagerClass
  GdkDisplayManagerClass parent_class;
 };

-G_DEFINE_TYPE (GdkWaylandDisplayManager, gdk_wayland_display_manager, GDK_TYPE_DISPLAY_MANAGER)
+static void g_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GdkWaylandDisplayManager, gdk_wayland_display_manager, GDK_TYPE_DISPLAY_MANAGER,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, g_initable_iface_init))
+
+static gboolean
+gdk_wayland_display_manager_initable_init (GInitable     *initable,
+                                           GCancellable  *cancellable,
+                                           GError       **error)
+{
+  struct wl_display *wl_display;
+
+  /* check that a connection to the default display is possible */
+  wl_display = wl_display_connect (gdk_get_display_arg_name ());
+
+  if (!wl_display)
+    {
+      GDK_WAYLAND_DISPLAY_MANAGER (initable)->init_failed = TRUE;
+      return FALSE;
+    }
+
+  wl_display_disconnect (wl_display);
+
+  return TRUE;
+}
+
+void
+g_initable_iface_init (GInitableIface *iface)
+{
+  iface->init = gdk_wayland_display_manager_initable_init;
+}

 static void
 gdk_wayland_display_manager_finalize (GObject *object)
 {
-  g_error ("A GdkWaylandDisplayManager object was finalized. This should not happen");
+  if (GDK_WAYLAND_DISPLAY_MANAGER (object)->init_failed == FALSE)
+    g_error ("A GdkWaylandDisplayManager object was finalized. This should not happen");
+
  G_OBJECT_CLASS (gdk_wayland_display_manager_parent_class)->finalize (object);
 }

@@ -66,6 +66,11 @@ G_DEFINE_TYPE (GdkWaylandKeymap, _gdk_wayland_keymap, GDK_TYPE_KEYMAP)
 static void
 gdk_wayland_keymap_finalize (GObject *object)
 {
+  GdkWaylandKeymap *keymap = GDK_WAYLAND_KEYMAP (object);
+
+  xkb_keymap_unref (keymap->xkb_keymap);
+  xkb_state_unref (keymap->xkb_state);
+
  G_OBJECT_CLASS (_gdk_wayland_keymap_parent_class)->finalize (object);
 }

@@ -228,31 +233,34 @@ _gdk_wayland_keymap_new ()
  return GDK_KEYMAP (keymap);
 }

-GdkKeymap *
-_gdk_wayland_keymap_new_from_fd (uint32_t format,
-                                 uint32_t fd, uint32_t size)
+void
+_gdk_wayland_keymap_update_from_fd (GdkKeymap *keymap,
+                                    uint32_t   format,
+                                    uint32_t   fd,
+                                    uint32_t   size)
 {
-  GdkWaylandKeymap *keymap;
+  GdkWaylandKeymap *keymap_wayland = GDK_WAYLAND_KEYMAP (keymap);
  struct xkb_context *context;
  char *map_str;

-  keymap = g_object_new (_gdk_wayland_keymap_get_type(), NULL);
-
  context = xkb_context_new (0);

  map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
-  if (map_str == MAP_FAILED) {
-    close(fd);
-    return NULL;
+  if (map_str == MAP_FAILED)
+    {
+      close(fd);
+      return;
  }

-  keymap->xkb_keymap = xkb_keymap_new_from_string (context, map_str, format, 0);
+  xkb_keymap_unref (keymap_wayland->xkb_keymap);
+  keymap_wayland->xkb_keymap = xkb_keymap_new_from_string (context, map_str, format, 0);
  munmap (map_str, size);
  close (fd);
-  keymap->xkb_state = xkb_state_new (keymap->xkb_keymap);
-  xkb_context_unref (context);

-  return GDK_KEYMAP (keymap);
+  xkb_state_unref (keymap_wayland->xkb_state);
+  keymap_wayland->xkb_state = xkb_state_new (keymap_wayland->xkb_keymap);
+
+  xkb_context_unref (context);
 }

 struct xkb_keymap *_gdk_wayland_keymap_get_xkb_keymap (GdkKeymap *keymap)
@@ -49,9 +49,16 @@ void _gdk_wayland_window_add_focus    (GdkWindow *window);
 void _gdk_wayland_window_remove_focus (GdkWindow *window);

 GdkKeymap *_gdk_wayland_keymap_new (void);
-GdkKeymap *_gdk_wayland_keymap_new_from_fd (uint32_t format,
-                                            uint32_t fd, uint32_t size);
+void       _gdk_wayland_keymap_update_from_fd (GdkKeymap *keymap,
+                                               uint32_t   format,
+                                               uint32_t   fd,
+                                               uint32_t   size);
 struct xkb_state *_gdk_wayland_keymap_get_xkb_state (GdkKeymap *keymap);
+struct xkb_keymap *_gdk_wayland_keymap_get_xkb_keymap (GdkKeymap *keymap);
+
+void       _gdk_wayland_display_finalize_cursors (GdkWaylandDisplay *display);
+void       _gdk_wayland_display_update_cursors (GdkWaylandDisplay      *display,
+                                                struct wl_cursor_theme *theme);

 GdkCursor *_gdk_wayland_display_get_cursor_for_type (GdkDisplay    *display,
 						     GdkCursorType  cursor_type);
@@ -162,4 +169,10 @@ void _gdk_wayland_window_set_device_grabbed (GdkWindow      *window,
 guint32 _gdk_wayland_display_get_serial (GdkWaylandDisplay *wayland_display);
 void _gdk_wayland_display_update_serial (GdkWaylandDisplay *wayland_display, guint32 serial);

+struct wl_shm_pool * _create_shm_pool (struct wl_shm *shm,
+                                      int             width,
+                                      int             height,
+                                      size_t         *buf_length,
+                                      void          **data_out);
+
 #endif /* __GDK_PRIVATE_WAYLAND_H__ */
@@ -21,6 +21,7 @@
 #include <string.h>

 #include <glib.h>
+#include <gio/gio.h>
 #include "gdkscreenprivate.h"
 #include "gdkvisualprivate.h"
 #include "gdkdisplay.h"
@@ -38,6 +39,14 @@ typedef struct _GdkWaylandScreenClass GdkWaylandScreenClass;
 #define GDK_IS_WAYLAND_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_SCREEN))
 #define GDK_WAYLAND_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_SCREEN, GdkWaylandScreenClass))

+typedef struct {
+        gboolean     antialias;
+        gboolean     hinting;
+        gint         dpi;
+        const gchar *rgba;
+        const gchar *hintstyle;
+} GsdXftSettings;
+
 typedef struct _GdkWaylandMonitor GdkWaylandMonitor;

 struct _GdkWaylandScreen
@@ -56,6 +65,9 @@ struct _GdkWaylandScreen
  /* Xinerama/RandR 1.2 */
  GPtrArray *monitors;
  gint       primary_monitor;
+
+  GHashTable *settings;
+  GsdXftSettings xft_settings;
 };

 struct _GdkWaylandScreenClass
@@ -133,6 +145,8 @@ gdk_wayland_screen_finalize (GObject *object)

  deinit_multihead (GDK_SCREEN (object));

+  g_hash_table_destroy (screen_wayland->settings);
+
  G_OBJECT_CLASS (_gdk_wayland_screen_parent_class)->finalize (object);
 }

@@ -274,80 +288,375 @@ gdk_wayland_screen_broadcast_client_message (GdkScreen *screen,
 {
 }

+static void
+notify_setting (GdkScreen   *screen,
+                const gchar *setting)
+{
+  GdkEvent event;
+
+  event.type = GDK_SETTING;
+  event.setting.window = gdk_screen_get_root_window (screen);
+  event.setting.send_event = FALSE;
+  event.setting.action = GDK_SETTING_ACTION_CHANGED;
+  event.setting.name = (gchar *)setting;
+  gdk_event_put (&event);
+}
+
+typedef enum
+{
+  GSD_FONT_ANTIALIASING_MODE_NONE,
+  GSD_FONT_ANTIALIASING_MODE_GRAYSCALE,
+  GSD_FONT_ANTIALIASING_MODE_RGBA
+} GsdFontAntialiasingMode;
+
+typedef enum
+{
+  GSD_FONT_HINTING_NONE,
+  GSD_FONT_HINTING_SLIGHT,
+  GSD_FONT_HINTING_MEDIUM,
+  GSD_FONT_HINTING_FULL
+} GsdFontHinting;
+
+typedef enum
+{
+  GSD_FONT_RGBA_ORDER_RGBA,
+  GSD_FONT_RGBA_ORDER_RGB,
+  GSD_FONT_RGBA_ORDER_BGR,
+  GSD_FONT_RGBA_ORDER_VRGB,
+  GSD_FONT_RGBA_ORDER_VBGR
+} GsdFontRgbaOrder;
+
+static gdouble
+get_dpi_from_gsettings (GdkWaylandScreen *screen_wayland)
+{
+        GSettings  *interface_settings;
+        gdouble      factor;
+
+        interface_settings = g_hash_table_lookup (screen_wayland->settings,
+                                                  "org.gnome.desktop.interface");
+        if (interface_settings != NULL)
+          factor = g_settings_get_double (interface_settings, "text-scaling-factor");
+        else
+          factor = 1.0;
+
+        return 96.0 * factor;
+}
+
+static void
+update_xft_settings (GdkScreen *screen)
+{
+  GdkWaylandScreen *screen_wayland = GDK_WAYLAND_SCREEN (screen);
+  GSettings *settings;
+  GsdFontAntialiasingMode antialiasing;
+  GsdFontHinting hinting;
+  GsdFontRgbaOrder order;
+  gboolean use_rgba = FALSE;
+  GsdXftSettings xft_settings;
+
+  settings = g_hash_table_lookup (screen_wayland->settings, "org.gnome.settings-daemon.plugins.xsettings");
+
+  if (settings)
+    {
+      antialiasing = g_settings_get_enum (settings, "antialiasing");
+      hinting = g_settings_get_enum (settings, "hinting");
+      order = g_settings_get_enum (settings, "rgba-order");
+    }
+  else
+    {
+      antialiasing = GSD_FONT_ANTIALIASING_MODE_GRAYSCALE;
+      hinting = GSD_FONT_HINTING_MEDIUM;
+      order = GSD_FONT_RGBA_ORDER_RGB;
+    }
+
+  xft_settings.antialias = (antialiasing != GSD_FONT_ANTIALIASING_MODE_NONE);
+  xft_settings.hinting = (hinting != GSD_FONT_HINTING_NONE);
+  xft_settings.dpi = get_dpi_from_gsettings (screen_wayland) * 1024; /* Xft wants 1/1024ths of an inch */
+  xft_settings.rgba = "rgb";
+  xft_settings.hintstyle = "hintfull";
+
+  switch (hinting)
+    {
+    case GSD_FONT_HINTING_NONE:
+      xft_settings.hintstyle = "hintnone";
+      break;
+    case GSD_FONT_HINTING_SLIGHT:
+      xft_settings.hintstyle = "hintslight";
+      break;
+    case GSD_FONT_HINTING_MEDIUM:
+      xft_settings.hintstyle = "hintmedium";
+      break;
+    case GSD_FONT_HINTING_FULL:
+      xft_settings.hintstyle = "hintfull";
+      break;
+    }
+
+  switch (order)
+    {
+    case GSD_FONT_RGBA_ORDER_RGBA:
+      xft_settings.rgba = "rgba";
+      break;
+    case GSD_FONT_RGBA_ORDER_RGB:
+      xft_settings.rgba = "rgb";
+      break;
+    case GSD_FONT_RGBA_ORDER_BGR:
+      xft_settings.rgba = "bgr";
+      break;
+    case GSD_FONT_RGBA_ORDER_VRGB:
+      xft_settings.rgba = "vrgb";
+      break;
+    case GSD_FONT_RGBA_ORDER_VBGR:
+      xft_settings.rgba = "vbgr";
+      break;
+    }
+
+  switch (antialiasing)
+   {
+   case GSD_FONT_ANTIALIASING_MODE_NONE:
+     xft_settings.antialias = FALSE;
+     break;
+   case GSD_FONT_ANTIALIASING_MODE_GRAYSCALE:
+     xft_settings.antialias = TRUE;
+     break;
+   case GSD_FONT_ANTIALIASING_MODE_RGBA:
+     xft_settings.antialias = TRUE;
+     use_rgba = TRUE;
+   }
+
+  if (!use_rgba)
+    xft_settings.rgba = "none";
+
+  if (screen_wayland->xft_settings.antialias != xft_settings.antialias)
+    {
+      screen_wayland->xft_settings.antialias = xft_settings.antialias;
+      notify_setting (screen, "gtk-xft-antialias");
+    }
+
+  if (screen_wayland->xft_settings.hinting != xft_settings.hinting)
+    {
+      screen_wayland->xft_settings.hinting = xft_settings.hinting;
+      notify_setting (screen, "gtk-xft-hinting");
+    }
+
+  if (screen_wayland->xft_settings.hintstyle != xft_settings.hintstyle)
+    {
+      screen_wayland->xft_settings.hintstyle = xft_settings.hintstyle;
+      notify_setting (screen, "gtk-xft-hintstyle");
+    }
+
+  if (screen_wayland->xft_settings.rgba != xft_settings.rgba)
+    {
+      screen_wayland->xft_settings.rgba = xft_settings.rgba;
+      notify_setting (screen, "gtk-xft-rgba");
+    }
+
+  if (screen_wayland->xft_settings.dpi != xft_settings.dpi)
+    {
+      screen_wayland->xft_settings.dpi = xft_settings.dpi;
+      notify_setting (screen, "gtk-xft-dpi");
+    }
+}
+
+typedef struct _TranslationEntry TranslationEntry;
+struct _TranslationEntry {
+  const gchar *schema;
+  const gchar *key;
+  const gchar *setting;
+  GType type;
+  union {
+    const gchar *s;
+    gint         i;
+    gboolean     b;
+  } fallback;
+};
+
+static TranslationEntry translations[] = {
+  { "org.gnome.desktop.interface", "gtk-theme", "gtk-theme-name" , G_TYPE_STRING, { .s = "Adwaita" } },
+  { "org.gnome.desktop.interface", "icon-theme", "gtk-icon-theme-name", G_TYPE_STRING, { .s = "gnome" } },
+  { "org.gnome.desktop.interface", "cursor-theme", "gtk-cursor-theme-name", G_TYPE_STRING, { .s = "Adwaita" } },
+  { "org.gnome.desktop.interface", "cursor-size", "gtk-cursor-theme-size", G_TYPE_INT, { .i = 32 } },
+  { "org.gnome.desktop.interface", "font-name", "gtk-font-name", G_TYPE_STRING, { .s = "Cantarell 11" } },
+  { "org.gnome.desktop.interface", "cursor-blink", "gtk-cursor-blink", G_TYPE_BOOLEAN,  { .b = TRUE } },
+  { "org.gnome.desktop.interface", "cursor-blink-time", "gtk-cursor-blink-time", G_TYPE_INT, { .i = 1200 } },
+  { "org.gnome.desktop.interface", "cursor-blink-timeout", "gtk-cursor-blink-timeout", G_TYPE_INT, { .i = 3600 } },
+  { "org.gnome.desktop.interface", "menus-have-icons", "gtk-menu-images", G_TYPE_BOOLEAN, { .b = FALSE } },
+  { "org.gnome.desktop.interface", "buttons-have-icons", "gtk-button-images", G_TYPE_BOOLEAN, { .b = FALSE } },
+  { "org.gnome.desktop.interface", "gtk-im-module", "gtk-im-module", G_TYPE_STRING, { .s = "simple" } },
+  { "org.gnome.desktop.interface", "enable-animations", "gtk-enable-animations", G_TYPE_BOOLEAN, { .b = TRUE } },
+  { "org.gnome.desktop.interface", "show-input-method-menu", "gtk-show-input-method-menu", G_TYPE_BOOLEAN, { .b = FALSE } },
+  { "org.gnome.desktop.interface", "show-unicode-menu", "gtk-show-unicode-menu", G_TYPE_BOOLEAN, { .b = FALSE } },
+  { "org.gnome.desktop.interface", "automatic-mnemonics", "gtk-auto-mnemonics", G_TYPE_BOOLEAN, { .b = TRUE } },
+  { "org.gnome.desktop.interface", "toolbar-style", "gtk-toolbar-style", G_TYPE_STRING, { .s = "both-horiz"} },
+  { "org.gnome.desktop.interface", "toolbar-icons-size", "gtk-toolbar-icon-size", G_TYPE_STRING, { .s = "large"} },
+  { "org.gnome.settings-daemon.peripherals.mouse", "double-click", "gtk-double-click-time", G_TYPE_INT, { .i = 250 } },
+  { "org.gnome.settings-daemon.peripherals.mouse", "drag-threshold", "gtk-dnd-drag-threshold", G_TYPE_INT, {.i = 8 } },
+  { "org.gnome.desktop.sound", "theme-name", "gtk-sound-theme-name", G_TYPE_STRING, { .s = "freedesktop" } },
+  { "org.gnome.desktop.sound", "event-sounds", "gtk-enable-event-sounds", G_TYPE_BOOLEAN, { .b = TRUE } },
+  { "org.gnome.desktop.sound", "input-feedback-sounds", "gtk-enable-input-feedback-sounds", G_TYPE_BOOLEAN, { . b = FALSE } },
+  { "org.gnome.desktop.privacy", "recent-files-max-age", "gtk-recent-files-max-age", G_TYPE_INT, { .i = 30 } },
+  { "org.gnome.desktop.privacy", "remember-recent-files",    "gtk-recent-files-enabled", G_TYPE_BOOLEAN, { .b = TRUE } },
+  { "org.gnome.settings-daemon.plugins.xsettings", "antialiasing", "gtk-xft-antialias", G_TYPE_NONE, { .i = 0 } },
+  { "org.gnome.settings-daemon.plugins.xsettings", "hinting", "gtk-xft-hinting", G_TYPE_NONE, { .i = 0 } },
+  { "org.gnome.settings-daemon.plugins.xsettings", "hinting", "gtk-xft-hintstyle", G_TYPE_NONE, { .i = 0 } },
+  { "org.gnome.settings-daemon.plugins.xsettings", "rgba-order", "gtk-xft-rgba", G_TYPE_NONE, { .i = 0 } },
+  { "org.gnome.desktop.interface", "text-scaling-factor", "gtk-xft-dpi" , G_TYPE_NONE, { .i = 0 } },
+
+};
+
+static TranslationEntry *
+find_translation_entry_by_key (GSettings *settings, const gchar *key)
+{
+  guint i;
+  gchar *schema;
+
+  g_object_get (settings, "schema", &schema, NULL);
+
+  for (i = 0; i < G_N_ELEMENTS (translations); i++)
+    {
+      if (g_str_equal (schema, translations[i].schema) &&
+          g_str_equal (key, translations[i].key))
+        {
+          g_free (schema);
+          return &translations[i];
+        }
+    }
+
+  g_free (schema);
+
+  return NULL;
+}
+
+static TranslationEntry *
+find_translation_entry_by_setting (const gchar *setting)
+{
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS (translations); i++)
+    {
+      if (g_str_equal (setting, translations[i].setting))
+        return &translations[i];
+    }
+
+  return NULL;
+}
+
+static void
+settings_changed (GSettings   *settings,
+                  const gchar *key,
+                  GdkScreen   *screen)
+{
+  TranslationEntry *entry;
+
+  entry = find_translation_entry_by_key (settings, key);
+
+  if (entry != NULL)
+    {
+      if (entry->type != G_TYPE_NONE)
+        notify_setting (screen, entry->setting);
+      else
+        update_xft_settings (screen);
+    }
+}
+
+static void
+init_settings (GdkScreen *screen)
+{
+  GdkWaylandScreen *screen_wayland = GDK_WAYLAND_SCREEN (screen);
+  GSettingsSchemaSource *source;
+  GSettingsSchema *schema;
+  GSettings *settings;
+  gint i;
+
+  screen_wayland->settings = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
+
+  source = g_settings_schema_source_get_default ();
+
+  for (i = 0; i < G_N_ELEMENTS (translations); i++)
+    {
+      if (g_hash_table_lookup (screen_wayland->settings, (gpointer)translations[i].schema) != NULL)
+        continue;
+
+      schema = g_settings_schema_source_lookup (source, translations[i].schema, FALSE);
+      if (schema != NULL)
+        {
+          settings = g_settings_new_full (schema, NULL, NULL);
+          g_signal_connect (settings, "changed",
+                            G_CALLBACK (settings_changed), screen);
+          g_hash_table_insert (screen_wayland->settings, (gpointer)translations[i].schema, settings);
+          g_settings_schema_unref (schema);
+        }
+    }
+
+  update_xft_settings (screen);
+}
+
+static void
+set_value_from_entry (GdkScreen        *screen,
+                      TranslationEntry *entry,
+                      GValue           *value)
+{
+  GdkWaylandScreen *screen_wayland = GDK_WAYLAND_SCREEN (screen);
+  GSettings *settings;
+
+  settings = (GSettings *)g_hash_table_lookup (screen_wayland->settings, entry->schema);
+  switch (entry->type)
+    {
+    case G_TYPE_STRING:
+      if (settings)
+        {
+          gchar *s;
+          s = g_settings_get_string (settings, entry->key);
+          g_value_set_string (value, s);
+          g_free (s);
+        }
+      else
+        {
+          g_value_set_static_string (value, entry->fallback.s);
+        }
+      break;
+    case G_TYPE_INT:
+      g_value_set_int (value, settings != NULL
+                              ? g_settings_get_int (settings, entry->key)
+                              : entry->fallback.i);
+      break;
+    case G_TYPE_BOOLEAN:
+      g_value_set_boolean (value, settings != NULL
+                                  ? g_settings_get_boolean (settings, entry->key)
+                                  : entry->fallback.b);
+      break;
+    case G_TYPE_NONE:
+      if (g_str_equal (entry->setting, "gtk-xft-antialias"))
+        g_value_set_int (value, screen_wayland->xft_settings.antialias);
+      else if (g_str_equal (entry->setting, "gtk-xft-hinting"))
+        g_value_set_int (value, screen_wayland->xft_settings.hinting);
+      else if (g_str_equal (entry->setting, "gtk-xft-hintstyle"))
+        g_value_set_static_string (value, screen_wayland->xft_settings.hintstyle);
+      else if (g_str_equal (entry->setting, "gtk-xft-rgba"))
+        g_value_set_static_string (value, screen_wayland->xft_settings.rgba);
+      else if (g_str_equal (entry->setting, "gtk-xft-dpi"))
+        g_value_set_int (value, screen_wayland->xft_settings.dpi);
+      else
+        g_assert_not_reached ();
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
 static gboolean
 gdk_wayland_screen_get_setting (GdkScreen   *screen,
 				const gchar *name,
 				GValue      *value)
 {
+  TranslationEntry *entry;
+
  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);

-  if (strcmp ("gtk-theme-name", name) == 0)
+  entry = find_translation_entry_by_setting (name);
+  if (entry != NULL)
    {
-      const gchar *s = "Adwaita";
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %s\n", name, s));
-      g_value_set_static_string (value, s);
+      set_value_from_entry (screen, entry, value);
      return TRUE;
-    }
-  if (strcmp ("gtk-cursor-theme-name", name) == 0)
-    {
-      const gchar *s = "Adwaita";
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %s\n", name, s));
-      g_value_set_static_string (value, s);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-icon-theme-name", name) == 0)
-    {
-      const gchar *s = "gnome";
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %s\n", name, s));
-      g_value_set_static_string (value, s);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-double-click-time", name) == 0)
-    {
-      gint i = 250;
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
-      g_value_set_int (value, i);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-double-click-distance", name) == 0)
-    {
-      gint i = 5;
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
-      g_value_set_int (value, i);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-dnd-drag-threshold", name) == 0)
-    {
-      gint i = 8;
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
-      g_value_set_int (value, i);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-split-cursor", name) == 0)
-    {
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : FALSE\n", name));
-      g_value_set_boolean (value, FALSE);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-alternative-button-order", name) == 0)
-    {
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : TRUE\n", name));
-      g_value_set_boolean (value, TRUE);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-alternative-sort-arrows", name) == 0)
-    {
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : TRUE\n", name));
-      g_value_set_boolean (value, TRUE);
-      return TRUE;
-    }
-  else if (strcmp ("gtk-xft-dpi", name) == 0)
-    {
-      gint i = 96*1024;
-      GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : TRUE\n", name));
-      g_value_set_int (value, i);
-      return TRUE;
-    }
+   }

  return FALSE;
 }
@@ -490,6 +799,7 @@ _gdk_wayland_screen_new (GdkDisplay *display)
 					    screen_wayland->height);

  init_multihead (screen);
+  init_settings (screen);

  return screen;
 }
@@ -47,6 +47,9 @@ GType                   gdk_wayland_display_get_type            (void);
 struct wl_display      *gdk_wayland_display_get_wl_display      (GdkDisplay *display);
 struct wl_compositor   *gdk_wayland_display_get_wl_compositor   (GdkDisplay *display);
 struct wl_shell        *gdk_wayland_display_get_wl_shell        (GdkDisplay *display);
+void                    gdk_wayland_display_set_cursor_theme    (GdkDisplay  *display,
+                                                                 const gchar *theme,
+                                                                 gint         size);

 G_END_DECLS

@@ -47,6 +47,8 @@ GType                    gdk_wayland_window_get_type             (void);
 struct wl_surface       *gdk_wayland_window_get_wl_surface       (GdkWindow *window);
 struct wl_shell_surface *gdk_wayland_window_get_wl_shell_surface (GdkWindow *window);

+void                     gdk_wayland_window_set_use_custom_surface (GdkWindow *window);
+
 G_END_DECLS

 #endif /* __GDK_WAYLAND_WINDOW_H__ */
@@ -36,7 +36,6 @@
 #include <sys/mman.h>
 #include <errno.h>

-#include <wayland-egl.h>

 #define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window) \
  (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
@@ -115,6 +114,8 @@ struct _GdkWindowImplWayland
   */
  cairo_surface_t *server_surface;

+  gchar *title;
+
  uint32_t resize_edges;

  int focus_count;
@@ -135,7 +136,12 @@ struct _GdkWindowImplWayland
  guint32 grab_time;

  gboolean fullscreen;
-  int saved_width, saved_height; /* before going fullscreen */
+  struct
+    {
+      int width, height;
+    } saved_fullscreen, saved_maximized;
+
+  gboolean use_custom_surface;
 };

 struct _GdkWindowImplWaylandClass
@@ -282,6 +288,8 @@ _gdk_wayland_display_create_window_impl (GdkDisplay    *display,

  g_object_ref (window);

+  impl->title = NULL;
+
  switch (GDK_WINDOW_TYPE (window))
    {
    case GDK_WINDOW_TOPLEVEL:
@@ -324,13 +332,6 @@ gdk_wayland_window_attach_image (GdkWindow *window)
  if (GDK_WINDOW_DESTROYED (window))
    return;

-  /* The "drawn to" Cairo surface is the same as the Cairo surface from which
-   * we are driving the buffer for the Wayland surface. Therefore we don't
-   * need to do anything here
-   */
-  if (impl->server_surface == impl->cairo_surface)
-    return;
-
  /* The wayland surface is attached to a buffer that is from the old "drawn
   * to" surface. Unref the surface and restore the state.
   */
@@ -388,7 +389,7 @@ gdk_wayland_cairo_surface_destroy (void *p)
 }


-static struct wl_shm_pool *
+struct wl_shm_pool *
 _create_shm_pool (struct wl_shm  *shm,
                  int             width,
                  int             height,
@@ -566,13 +567,13 @@ gdk_wayland_window_map (GdkWindow *window)
    GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
  GdkWindow *transient_for;

-  if (!impl->mapped)
+  if (!impl->mapped && !impl->use_custom_surface)
    {
      /* Popup menus can appear without a transient parent, which means they
       * cannot be positioned properly on Wayland. This attempts to guess the
       * surface they should be positioned with by finding the surface beneath
-       * the device that created the grab for the popup window */
-
+       * the device that created the grab for the popup window
+       */
      if (!impl->transient_for && impl->hint == GDK_WINDOW_TYPE_HINT_POPUP_MENU)
        {
          transient_for = gdk_device_get_window_at_position (impl->grab_device, NULL, NULL);
@@ -711,15 +712,21 @@ gdk_wayland_window_show (GdkWindow *window, gboolean already_mapped)
      XSERVER_TIME_IS_LATER (display_wayland->user_time, impl->user_time))
    gdk_wayland_window_set_user_time (window, impl->user_time);

-  impl->surface = wl_compositor_create_surface(display_wayland->compositor);
-  wl_surface_set_user_data(impl->surface, window);
+  if (!impl->surface)
+    {
+      impl->surface = wl_compositor_create_surface(display_wayland->compositor);
+      wl_surface_set_user_data(impl->surface, window);
+    }

-  impl->shell_surface = wl_shell_get_shell_surface (display_wayland->shell,
-                                                    impl->surface);
-  wl_shell_surface_add_listener(impl->shell_surface,
-                                &shell_surface_listener, window);
+  if (!impl->use_custom_surface && display_wayland->shell)
+    {
+      impl->shell_surface = wl_shell_get_shell_surface (display_wayland->shell,
+                                                        impl->surface);
+      wl_shell_surface_add_listener(impl->shell_surface,
+                                    &shell_surface_listener, window);
+    }

-  gdk_window_set_type_hint (window, impl->hint);  
+  gdk_window_set_type_hint (window, impl->hint);

  _gdk_make_event (window, GDK_MAP, NULL, FALSE);
  event = _gdk_make_event (window, GDK_VISIBILITY_NOTIFY, NULL, FALSE);
@@ -727,6 +734,9 @@ gdk_wayland_window_show (GdkWindow *window, gboolean already_mapped)

  if (impl->cairo_surface)
    gdk_wayland_window_attach_image (window);
+
+  if (impl->shell_surface && impl->title)
+    wl_shell_surface_set_title (impl->shell_surface, impl->title);
 }

 static void
@@ -738,10 +748,17 @@ gdk_wayland_window_hide (GdkWindow *window)
    {
      if (impl->shell_surface)
        wl_shell_surface_destroy(impl->shell_surface);
-      if (impl->surface)
-        wl_surface_destroy(impl->surface);
+      if (impl->use_custom_surface)
+        {
+          wl_surface_attach (impl->surface, NULL, 0, 0);
+          wl_surface_commit (impl->surface);
+        }
+      else if (impl->surface)
+        {
+          wl_surface_destroy(impl->surface);
+          impl->surface = NULL;
+        }
      impl->shell_surface = NULL;
-      impl->surface = NULL;
      cairo_surface_destroy(impl->server_surface);
      impl->server_surface = NULL;
      impl->mapped = FALSE;
@@ -767,10 +784,17 @@ gdk_window_wayland_withdraw (GdkWindow *window)
        {
          if (impl->shell_surface)
            wl_shell_surface_destroy(impl->shell_surface);
-          if (impl->surface)
-            wl_surface_destroy(impl->surface);
+          if (impl->use_custom_surface)
+            {
+              wl_surface_attach (impl->surface, NULL, 0, 0);
+              wl_surface_commit (impl->surface);
+            }
+          else if (impl->surface)
+            {
+              wl_surface_destroy(impl->surface);
+              impl->surface = NULL;
+            }
          impl->shell_surface = NULL;
-          impl->surface = NULL;
          cairo_surface_destroy(impl->server_surface);
          impl->server_surface = NULL;
          impl->mapped = FALSE;
@@ -1158,10 +1182,15 @@ static void
 gdk_wayland_window_set_title (GdkWindow   *window,
 			      const gchar *title)
 {
+  GdkWindowImplWayland *impl;
  g_return_if_fail (title != NULL);

  if (GDK_WINDOW_DESTROYED (window))
    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  impl->title = strdup (title);
 }

 static void
@@ -1291,15 +1320,59 @@ gdk_wayland_window_unstick (GdkWindow *window)
 static void
 gdk_wayland_window_maximize (GdkWindow *window)
 {
-  if (GDK_WINDOW_DESTROYED (window))
+  GdkWindowImplWayland *impl;
+
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (GDK_WINDOW_IS_MAPPED (window))
+    {
+      if (impl->surface)
+        {
+          impl->saved_maximized.width = gdk_window_get_width (window);
+          impl->saved_maximized.height = gdk_window_get_height (window);
+
+          if (impl->shell_surface)
+            wl_shell_surface_set_maximized (impl->shell_surface, NULL);
+        }
+
+      gdk_synthesize_window_state (window,
+                                   0,
+                                   GDK_WINDOW_STATE_MAXIMIZED);
+    }
 }

 static void
 gdk_wayland_window_unmaximize (GdkWindow *window)
 {
-  if (GDK_WINDOW_DESTROYED (window))
+  GdkWindowImplWayland *impl;
+
+  if (GDK_WINDOW_DESTROYED (window) ||
+      !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
    return;
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (GDK_WINDOW_IS_MAPPED (window))
+    {
+      if (impl->surface)
+        {
+          if (impl->shell_surface)
+            wl_shell_surface_set_toplevel (impl->shell_surface);
+        }
+
+      gdk_synthesize_window_state (window,
+                                   GDK_WINDOW_STATE_MAXIMIZED,
+                                   0);
+
+      gdk_wayland_window_configure (window,
+                                    impl->saved_maximized.width,
+                                    impl->saved_maximized.height,
+                                    0);
+    }
 }

 static void
@@ -1313,8 +1386,12 @@ gdk_wayland_window_fullscreen (GdkWindow *window)
  if (impl->fullscreen)
    return;

-  impl->saved_width = gdk_window_get_width (window);
-  impl->saved_height = gdk_window_get_height (window);
+  if (!impl->shell_surface)
+    return;
+
+  impl->saved_fullscreen.width = gdk_window_get_width (window);
+  impl->saved_fullscreen.height = gdk_window_get_height (window);
+    
  wl_shell_surface_set_fullscreen (impl->shell_surface,
                                   WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
                                   0,
@@ -1336,12 +1413,16 @@ gdk_wayland_window_unfullscreen (GdkWindow *window)
  if (!impl->fullscreen)
    return;

+  if (!impl->shell_surface)
+    return;
+
  wl_shell_surface_set_toplevel (impl->shell_surface);
  gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FULLSCREEN, 0);
-  gdk_wayland_window_configure (window, impl->saved_width, impl->saved_height,
+  gdk_wayland_window_configure (window,
+                                impl->saved_fullscreen.width,
+                                impl->saved_fullscreen.height,
                                0);

-
  impl->fullscreen = FALSE;
 }

@@ -1463,6 +1544,9 @@ gdk_wayland_window_begin_resize_drag (GdkWindow     *window,

  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);

+  if (!impl->shell_surface)
+    return;
+    
  wl_shell_surface_resize (impl->shell_surface,
                           gdk_wayland_device_get_wl_seat (device),
                           _gdk_wayland_display_get_serial (wayland_display),
@@ -1492,6 +1576,9 @@ gdk_wayland_window_begin_move_drag (GdkWindow *window,

  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);

+  if (!impl->shell_surface)
+    return;
+
  wl_shell_surface_move (impl->shell_surface,
                         gdk_wayland_device_get_wl_seat (device),
                         _gdk_wayland_display_get_serial (wayland_display));
@@ -1761,3 +1848,69 @@ gdk_wayland_window_get_wl_shell_surface (GdkWindow *window)

  return impl->shell_surface;
 }
+
+/**
+ * gdk_wayland_window_set_use_custom_surface:
+ * @window: (type GdkWaylandWindow): a #GdkWindow
+ *
+ * Marks a #GdkWindow as a custom Wayland surface. The application is
+ * expected to register the surface as some type of surface using
+ * some Wayland interface.
+ *
+ * Agood example would be writing a panel or on-screen-keyboard as an
+ * out-of-process helper - as opposed to having those in the compositor
+ * process. In this case the underlying surface isn't a wl_shell
+ * surface and the panel or OSK client need to identify the wl_surface
+ * as a panel or OSK to the compositor. The assumption is that the
+ * compositor will expose a private interface to the special client
+ * that lets the client identify the wl_surface as a panel or such.
+ *
+ * This function should be called before a #GdkWindow is shown. This is
+ * best done by connecting to the #GtkWidget::realized signal:
+ *
+ * <informalexample>
+ * <programlisting>
+ *   static void
+ *   widget_realize_cb (GtkWidget *widget)
+ *   {
+ *     GdkWindow *window;
+ *     struct wl_surface *surface;
+ *     struct input_panel_surface *ip_surface;
+ *
+ *     window = gtk_widget_get_window (widget);
+ *     gdk_wayland_window_set_custom_surface (window);
+ *
+ *     surface = gdk_wayland_window_get_wl_surface (window);
+ *     ip_surface = input_panel_get_input_panel_surface (input_panel, surface);
+ *     input_panel_surface_set_panel (ip_surface);
+ *   }
+ *
+ *   static void
+ *   setup_window (GtkWindow *window)
+ *   {
+ *     g_signal_connect (window, "realize", G_CALLBACK (widget_realize_cb), NULL);
+ *   }
+ * </programlisting>
+ * </informalexample>
+ *
+ * Since: 3.10
+ */
+void
+gdk_wayland_window_set_use_custom_surface (GdkWindow *window)
+{
+  GdkWindowImplWayland *impl;
+  GdkWaylandDisplay *display;
+
+  g_return_if_fail (GDK_IS_WAYLAND_WINDOW (window));
+
+  impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
+
+  if (!impl->surface)
+    {
+      display = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
+      impl->surface = wl_compositor_create_surface (display->compositor);
+      wl_surface_set_user_data (impl->surface, window);
+    }
+
+  impl->use_custom_surface = TRUE;
+}
@@ -150,6 +150,7 @@ _gdk_win32_window_change_property (GdkWindow    *window,
  guchar *ucptr;
  wchar_t *wcptr, *p;
  glong wclen;
+  GError *err = NULL;

  g_return_if_fail (window != NULL);
  g_return_if_fail (GDK_IS_WINDOW (window));
@@ -193,7 +194,13 @@ _gdk_win32_window_change_property (GdkWindow    *window,
 	      return;
 	    }

-	  wcptr = g_utf8_to_utf16 ((char *) data, nelements, NULL, &wclen, NULL);
+	  wcptr = g_utf8_to_utf16 ((char *) data, nelements, NULL, &wclen, &err);
+          if (err != NULL)
+            {
+              g_warning ("Failed to convert utf8: %s", err->message);
+              g_clear_error (&err);
+              return;
+            }

 	  wclen++;		/* Terminating 0 */
 	  size = wclen * 2;
@@ -34,6 +34,8 @@ struct _GdkX11DisplayManager

  GdkDisplay *default_display;
  GSList *displays;
+
+  gboolean init_failed;
 };

 struct _GdkX11DisplayManagerClass
@@ -41,7 +43,37 @@ struct _GdkX11DisplayManagerClass
  GdkDisplayManagerClass parent_class;
 };

-G_DEFINE_TYPE (GdkX11DisplayManager, gdk_x11_display_manager, GDK_TYPE_DISPLAY_MANAGER)
+static void g_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GdkX11DisplayManager, gdk_x11_display_manager, GDK_TYPE_DISPLAY_MANAGER,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, g_initable_iface_init))
+
+static gboolean
+gdk_x11_display_manager_initable_init (GInitable     *initable,
+                                       GCancellable  *cancellable,
+                                       GError       **error)
+{
+  Display *display;
+
+  /* check that a connection to the default display is possible */
+  display = XOpenDisplay (gdk_get_display_arg_name ());
+  if (!display)
+    {
+      GDK_X11_DISPLAY_MANAGER (initable)->init_failed = TRUE;
+      return FALSE;
+    }
+
+  XCloseDisplay (display);
+
+  return TRUE;
+}
+
+void
+g_initable_iface_init (GInitableIface *iface)
+{
+  iface->init = gdk_x11_display_manager_initable_init;
+}
+

 static GdkDisplay *
 gdk_x11_display_manager_open_display (GdkDisplayManager *manager,
@@ -93,7 +125,8 @@ gdk_x11_display_manager_init (GdkX11DisplayManager *manager)
 static void
 gdk_x11_display_manager_finalize (GObject *object)
 {
-  g_error ("A GdkX11DisplayManager object was finalized. This should not happen");
+  if (GDK_X11_DISPLAY_MANAGER (object)->init_failed == FALSE)
+    g_error ("A GdkX11DisplayManager object was finalized. This should not happen");
  G_OBJECT_CLASS (gdk_x11_display_manager_parent_class)->finalize (object);
 }

@@ -257,6 +257,7 @@ gtk_public_h_sources = 		\
 	gtkfontchooserwidget.h	\
 	gtkframe.h		\
 	gtkgrid.h		\
+	gtkheaderbar.h		\
 	gtkiconfactory.h	\
 	gtkicontheme.h		\
 	gtkiconview.h		\
@@ -731,6 +732,7 @@ gtk_base_c_sources = 		\
 	gtkfontchooserwidget.c	\
 	gtkframe.c		\
 	gtkgrid.c		\
+	gtkheaderbar.c		\
 	gtkhsla.c		\
 	gtkiconcache.c		\
 	gtkiconcachevalidator.c	\
@@ -1374,6 +1376,10 @@ STOCK_ICONS = \
 	stock-icons/16/list-add.png 			\
 	stock-icons/16/media-optical.png 		\
 	stock-icons/16/window-close.png 		\
+	stock-icons/16/window-minimize.png 		\
+	stock-icons/16/window-maximize.png 		\
+	stock-icons/16/window-restore.png 		\
+	stock-icons/16/window-delete.png 		\
 	stock-icons/16/gtk-connect.png 			\
 	stock-icons/16/gtk-convert.png 			\
 	stock-icons/16/edit-clear.png 			\
@@ -106,6 +106,7 @@ gtka11y_private_h_sources =		\
 	gtkcellaccessibleprivate.h	\
 	gtkcolorswatchaccessibleprivate.h \
 	gtkiconviewaccessibleprivate.h	\
+	gtklabelaccessibleprivate.h 	\
 	gtklockbuttonaccessibleprivate.h \
 	gtktextviewaccessibleprivate.h  \
 	gtktreeviewaccessibleprivate.h	\
@@ -572,9 +572,17 @@ gtk_entry_accessible_notify_gtk (GObject    *obj,
          gchar *text;
          text = gtk_entry_get_icon_tooltip_text (gtk_entry,
                                                    GTK_ENTRY_ICON_PRIMARY);
-          atk_object_set_description (priv->icons[GTK_ENTRY_ICON_PRIMARY],
+          if (text)
+            {
+              atk_object_set_description (priv->icons[GTK_ENTRY_ICON_PRIMARY],
                                      text);
-          g_free (text);
+              g_free (text);
+            }
+          else
+            {
+              atk_object_set_description (priv->icons[GTK_ENTRY_ICON_PRIMARY],
+                                      "");
+            }
        }
    }
  else if (g_strcmp0 (pspec->name, "secondary-icon-tooltip-text") == 0)
@@ -584,9 +592,17 @@ gtk_entry_accessible_notify_gtk (GObject    *obj,
          gchar *text;
          text = gtk_entry_get_icon_tooltip_text (gtk_entry,
                                                    GTK_ENTRY_ICON_SECONDARY);
-          atk_object_set_description (priv->icons[GTK_ENTRY_ICON_SECONDARY],
+          if (text)
+            {
+              atk_object_set_description (priv->icons[GTK_ENTRY_ICON_SECONDARY],
                                      text);
-          g_free (text);
+              g_free (text);
+            }
+          else
+            {
+              atk_object_set_description (priv->icons[GTK_ENTRY_ICON_PRIMARY],
+                                      "");
+            }
        }
    }
  else if (g_strcmp0 (pspec->name, "primary-icon-activatable") == 0)
@@ -19,11 +19,11 @@

 #include <gtk/gtk.h>
 #include <gtk/gtkpango.h>
+#include "gtkwidgetprivate.h"
 #include "gtklabelaccessible.h"

 struct _GtkLabelAccessiblePrivate
 {
-  gchar *text;
  gint cursor_position;
  gint selection_bound;
 };
@@ -46,16 +46,11 @@ gtk_label_accessible_initialize (AtkObject *obj,
                                 gpointer   data)
 {
  GtkWidget  *widget;
-  GtkLabelAccessible *accessible;

  ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->initialize (obj, data);

-  accessible = GTK_LABEL_ACCESSIBLE (obj);
-
  widget = GTK_WIDGET (data);

-  accessible->priv->text = g_strdup (gtk_label_get_text (GTK_LABEL (widget)));
-
  /*
   * Check whether ancestor of GtkLabel is a GtkButton and if so
   * set accessible parent for GtkLabelAccessible
@@ -97,6 +92,45 @@ check_for_selection_change (GtkLabelAccessible *accessible,
  return ret_val;
 }

+void
+_gtk_label_accessible_text_deleted (GtkLabel *label)
+{
+  AtkObject *obj;
+  const char *text;
+  guint length;
+
+  obj = _gtk_widget_peek_accessible (GTK_WIDGET (label));
+  if (obj == NULL)
+    return;
+
+  text = gtk_label_get_text (label);
+  length = g_utf8_strlen (text, -1);
+  if (length > 0)
+    g_signal_emit_by_name (obj, "text-changed::delete", 0, length);
+}
+
+void
+_gtk_label_accessible_text_inserted (GtkLabel *label)
+{
+  AtkObject *obj;
+  const char *text;
+  guint length;
+
+  obj = _gtk_widget_peek_accessible (GTK_WIDGET (label));
+  if (obj == NULL)
+    return;
+
+  text = gtk_label_get_text (label);
+  length = g_utf8_strlen (text, -1);
+  if (length > 0)
+    g_signal_emit_by_name (obj, "text-changed::insert", 0, length);
+
+  if (obj->name == NULL)
+    /* The label has changed so notify a change in accessible-name */
+    g_object_notify (G_OBJECT (obj), "accessible-name");
+
+  g_signal_emit_by_name (obj, "visible-data-changed");
+}

 static void
 gtk_label_accessible_notify_gtk (GObject    *obj,
@@ -105,37 +139,10 @@ gtk_label_accessible_notify_gtk (GObject    *obj,
  GtkWidget *widget = GTK_WIDGET (obj);
  AtkObject* atk_obj = gtk_widget_get_accessible (widget);
  GtkLabelAccessible *accessible;
-  gint length;

  accessible = GTK_LABEL_ACCESSIBLE (atk_obj);

-  if (g_strcmp0 (pspec->name, "label") == 0)
-    {
-      const gchar *text;
-
-      text = gtk_label_get_text (GTK_LABEL (widget));
-      if (g_strcmp0 (accessible->priv->text, text) == 0)
-        return;
-
-      /* Create a delete text and an insert text signal */
-      length = g_utf8_strlen (accessible->priv->text, -1);
-      if (length > 0)
-        g_signal_emit_by_name (atk_obj, "text-changed::delete", 0, length);
-
-      g_free (accessible->priv->text);
-      accessible->priv->text = g_strdup (text);
-
-      length = g_utf8_strlen (accessible->priv->text, -1);
-      if (length > 0)
-        g_signal_emit_by_name (atk_obj, "text-changed::insert", 0, length);
-
-      if (atk_obj->name == NULL)
-        /* The label has changed so notify a change in accessible-name */
-        g_object_notify (G_OBJECT (atk_obj), "accessible-name");
-
-      g_signal_emit_by_name (atk_obj, "visible-data-changed");
-    }
-  else if (g_strcmp0 (pspec->name, "cursor-position") == 0)
+  if (g_strcmp0 (pspec->name, "cursor-position") == 0)
    {
      g_signal_emit_by_name (atk_obj, "text-caret-moved",
                             _gtk_label_get_cursor_position (GTK_LABEL (widget)));
@@ -151,17 +158,6 @@ gtk_label_accessible_notify_gtk (GObject    *obj,
    GTK_WIDGET_ACCESSIBLE_CLASS (gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
 }

-static void
-gtk_label_accessible_finalize (GObject *object)
-{
-  GtkLabelAccessible *accessible = GTK_LABEL_ACCESSIBLE (object);
-
-  g_free (accessible->priv->text);
-
-  G_OBJECT_CLASS (gtk_label_accessible_parent_class)->finalize (object);
-}
-
-
 /* atkobject.h */

 static AtkStateSet *
@@ -274,11 +270,8 @@ gtk_label_accessible_get_name (AtkObject *accessible)
 static void
 gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
 {
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
-  GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
-
-  gobject_class->finalize = gtk_label_accessible_finalize;
+  GtkWidgetAccessibleClass *widget_class = GTK_WIDGET_ACCESSIBLE_CLASS (klass);

  widget_class->notify_gtk = gtk_label_accessible_notify_gtk;

@@ -0,0 +1,30 @@
+/* GTK+ - accessibility implementations
+ * Copyright (C) 2002, 2004  Anders Carlsson <andersca@gnu.org>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_LABEL_ACCESSIBLE_PRIVATE_H__
+#define __GTK_LABEL_ACCESSIBLE_PRIVATE_H__
+
+#include <gtk/a11y/gtklabelaccessible.h>
+
+G_BEGIN_DECLS
+
+void            _gtk_label_accessible_text_deleted              (GtkLabel       *label);
+void            _gtk_label_accessible_text_inserted             (GtkLabel       *label);
+
+G_END_DECLS
+
+#endif /* __GTK_LABEL_ACCESSIBLE_PRIVATE_H__ */
@@ -23,6 +23,9 @@
  color: @fg_color;
  border-color: shade (@bg_color, 0.6);
  padding: 2px;
+  -GtkWindow-resize-grip-width: 0;
+  -GtkWindow-resize-grip-height: 0;
+  -GtkWindow-decoration-button-layout: 'icon:minimize,maximize,close';
 }

 GtkWindow, .button, .slider {
@@ -729,3 +732,73 @@ GtkCalendar.button:hover {
                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent));
  animation: spinner 1s infinite linear;
 }
+
+/* Client side decorations */
+.titlebar > GtkLabel:backdrop {
+  color: darker (@bg_color);
+  text-shadow: none;
+}
+
+.titlebar GtkLabel {
+  font: Sans Bold 10;
+  text-shadow: 1px 1px lighter (@bg_color);
+}
+
+.titlebar GtkButton:backdrop {
+  border-image: none;
+  background-image: none;
+}
+
+.titlebar GtkButton GtkLabel:backdrop {
+  text-shadow: none;
+  color: darker (@bg_color);
+}
+
+.titlebar GtkButton GtkLabel {
+  font: Sans Bold 12;
+  color: white;
+  text-shadow: 0px 1px darker (darker (@bg_color));
+}
+
+.titlebar GtkButton {
+  border-style: none;
+  border-color: darker (@bg_color);
+
+  background-image: -gtk-gradient (linear, center top, center bottom,
+       from (@bg_color),
+       color-stop (0.5, darker (@bg_color)),
+       to (@bg_color));
+}
+
+.titlebar GtkButton:first-child {
+  border-radius: 10px 0px 0px 0px;
+}
+
+.titlebar GtkButton:last-child {
+  border-radius: 0px 10px 0px 0px;
+}
+
+.titlebar:backdrop {
+  background-image: none;
+}
+
+.titlebar {
+  background-image: -gtk-gradient (linear, center top, center bottom,
+       from (white),
+       to (@bg_color));
+  border-radius: 10px 10px 0px 0px;
+}
+
+.window-border {
+  border-color: darker (@bg_color);
+  border-radius: 10px;
+  border-width: 2px;
+  border-style: solid;
+}
+
+.window-outer-border {
+  border-color: transparent;
+  border-radius: 10px;
+  border-width: 10px 10px 10px 10px;
+  border-style: solid;
+}
@@ -791,7 +791,7 @@ GtkSwitch.trough:active {
 /* Assistant */

 GtkAssistant .sidebar .highlight {
-    background-color: blue;
+    background-color: gray;
    font: bold;
 }

@@ -834,3 +834,354 @@ GtkStatusbar > GtkFrame {
    background-image:  -gtk-win32-theme-part(status, 3 1);
 }
 */
+
+@keyframes spinner {
+   0% { background-image: none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)); }
+   0% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)); }
+   8% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none; }
+   8% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)); }
+  16% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)); }
+  16% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)); }
+  25% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)); }
+  25% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)); }
+  33% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)); }
+  33% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)); }
+  41% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)); }
+  41% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)); }
+  50% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)); }
+  50% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)); }
+  58% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)); }
+  58% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)); }
+  66% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)); }
+  66% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)); }
+  75% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)); }
+  75% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)); }
+  83% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)); }
+  83% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)); }
+  91% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)); }
+  91% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)); }
+ 100% { background-image: none,
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)); }
+ 100% { background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                          -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)); }
+}
+
+.spinner {
+  background-color: transparent;
+  background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent)),
+                    -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent));
+  background-position: 25.00% 6.70%, 6.70% 25.00%, 0.00% 50.00%, 6.70% 75.00%, 25.00% 93.30%, 50.00% 100.00%, 75.00% 93.30%, 93.30% 75.00%, 100.00% 50.00%, 93.30% 25.00%, 75.00% 6.70%, 50.00% 0.00%;
+  background-size: 20% 20%;
+  background-repeat: no-repeat;
+  transition: background-image 500ms ease-out;
+}
+
+.spinner:active {
+   background-image: -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.916667)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.833333)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.75)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.666667)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.583333)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.5)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.416667)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.333333)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.25)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.166667)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(alpha(currentColor, 0.0833333)), to(transparent)),
+                     -gtk-gradient(radial, center center, 0, center center, 0.5, to(currentColor), to(transparent));
+  animation: spinner 1s infinite linear;
+}
@@ -108,6 +108,7 @@
 #include <gtk/gtkfontchooserwidget.h>
 #include <gtk/gtkframe.h>
 #include <gtk/gtkgrid.h>
+#include <gtk/gtkheaderbar.h>
 #include <gtk/gtkiconfactory.h>
 #include <gtk/gtkicontheme.h>
 #include <gtk/gtkiconview.h>
@@ -288,6 +288,7 @@ gtk_assistant_set_page_title
 gtk_assistant_set_page_type
 gtk_assistant_update_buttons_state
 gtk_attach_options_get_type
+gtk_baseline_position_get_type
 gtk_binding_entry_add_signal
 gtk_binding_entry_add_signall
 gtk_binding_entry_add_signal_from_string
@@ -308,6 +309,7 @@ gtk_border_free
 gtk_border_get_type
 gtk_border_new
 gtk_border_style_get_type
+gtk_box_get_baseline_position
 gtk_box_get_homogeneous
 gtk_box_get_spacing
 gtk_box_get_type
@@ -316,6 +318,7 @@ gtk_box_pack_end
 gtk_box_pack_start
 gtk_box_query_child_packing
 gtk_box_reorder_child
+gtk_box_set_baseline_position
 gtk_box_set_child_packing
 gtk_box_set_homogeneous
 gtk_box_set_spacing
@@ -1195,9 +1198,11 @@ gtk_grab_get_current
 gtk_grab_remove
 gtk_grid_attach
 gtk_grid_attach_next_to
+gtk_grid_get_baseline_row
 gtk_grid_get_child_at
 gtk_grid_get_column_homogeneous
 gtk_grid_get_column_spacing
+gtk_grid_get_row_baseline_position
 gtk_grid_get_row_homogeneous
 gtk_grid_get_row_spacing
 gtk_grid_get_type
@@ -1205,8 +1210,12 @@ gtk_grid_insert_column
 gtk_grid_insert_next_to
 gtk_grid_insert_row
 gtk_grid_new
+gtk_grid_remove_column
+gtk_grid_remove_row
+gtk_grid_set_baseline_row
 gtk_grid_set_column_homogeneous
 gtk_grid_set_column_spacing
+gtk_grid_set_row_baseline_position
 gtk_grid_set_row_homogeneous
 gtk_grid_set_row_spacing
 gtk_handle_box_get_child_detached
@@ -1222,6 +1231,15 @@ gtk_hbox_get_type
 gtk_hbox_new
 gtk_hbutton_box_get_type
 gtk_hbutton_box_new
+gtk_header_bar_new
+gtk_header_bar_pack_start
+gtk_header_bar_pack_end
+gtk_header_bar_set_title
+gtk_header_bar_get_title
+gtk_header_bar_set_subtitle
+gtk_header_bar_get_subtitle
+gtk_header_bar_set_custom_title
+gtk_header_bar_get_custom_title
 gtk_hpaned_get_type
 gtk_hpaned_new
 gtk_hscale_get_type
@@ -3696,6 +3714,7 @@ gtk_widget_error_bell
 gtk_widget_event
 gtk_widget_freeze_child_notify
 gtk_widget_get_accessible
+gtk_widget_get_allocated_baseline
 gtk_widget_get_allocated_height
 gtk_widget_get_allocated_width
 gtk_widget_get_allocation
@@ -3737,8 +3756,10 @@ gtk_widget_get_parent_window
 gtk_widget_get_path
 gtk_widget_get_pointer
 gtk_widget_get_preferred_height
+gtk_widget_get_preferred_height_and_baseline_for_width
 gtk_widget_get_preferred_height_for_width
 gtk_widget_get_preferred_size
+gtk_widget_get_preferred_size_and_baseline
 gtk_widget_get_preferred_width
 gtk_widget_get_preferred_width_for_height
 gtk_widget_get_realized
@@ -3761,6 +3782,7 @@ gtk_widget_get_tooltip_window
 gtk_widget_get_toplevel
 gtk_widget_get_type
 gtk_widget_get_valign
+gtk_widget_get_valign_with_baseline
 gtk_widget_get_vexpand
 gtk_widget_get_vexpand_set
 gtk_widget_get_visible
@@ -3913,6 +3935,7 @@ gtk_widget_show
 gtk_widget_show_all
 gtk_widget_show_now
 gtk_widget_size_allocate
+gtk_widget_size_allocate_with_baseline
 gtk_widget_size_request
 gtk_widget_style_attach
 gtk_widget_style_get
@@ -4044,6 +4067,7 @@ gtk_window_set_skip_pager_hint
 gtk_window_set_skip_taskbar_hint
 gtk_window_set_startup_id
 gtk_window_set_title
+gtk_window_set_titlebar
 gtk_window_set_transient_for
 gtk_window_set_attached_to
 gtk_window_set_type_hint
@@ -108,6 +108,12 @@ static void gtk_alignment_get_preferred_height_for_width (GtkWidget           *w
 							  gint                 for_size,
 							  gint                *minimum_size,
 							  gint                *natural_size);
+static void gtk_alignment_get_preferred_height_and_baseline_for_width (GtkWidget           *widget,
+								       gint                 for_size,
+								       gint                *minimum_size,
+								       gint                *natural_size,
+								       gint                *minimum_baseline,
+								       gint                *natural_baseline);

 G_DEFINE_TYPE (GtkAlignment, gtk_alignment, GTK_TYPE_BIN)

@@ -128,6 +134,7 @@ gtk_alignment_class_init (GtkAlignmentClass *class)
  widget_class->get_preferred_height = gtk_alignment_get_preferred_height;
  widget_class->get_preferred_width_for_height = gtk_alignment_get_preferred_width_for_height;
  widget_class->get_preferred_height_for_width = gtk_alignment_get_preferred_height_for_width;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_alignment_get_preferred_height_and_baseline_for_width;

  g_object_class_install_property (gobject_class,
                                   PROP_XALIGN,
@@ -507,6 +514,7 @@ gtk_alignment_size_allocate (GtkWidget     *widget,
  gint width, height;
  guint border_width;
  gint padding_horizontal, padding_vertical;
+  gint baseline;

  padding_horizontal = 0;
  padding_vertical = 0;
@@ -520,6 +528,7 @@ gtk_alignment_size_allocate (GtkWidget     *widget,
      gint child_nat_width;
      gint child_nat_height;
      gint child_width, child_height;
+      double yalign, yscale;

      border_width = gtk_container_get_border_width (GTK_CONTAINER (alignment));

@@ -529,6 +538,25 @@ gtk_alignment_size_allocate (GtkWidget     *widget,
      width  = MAX (1, allocation->width - padding_horizontal - 2 * border_width);
      height = MAX (1, allocation->height - padding_vertical - 2 * border_width);

+      baseline = gtk_widget_get_allocated_baseline (widget);
+      if (baseline != -1)
+	baseline -= border_width + priv->padding_top;
+
+      /* If we get a baseline set that means we're baseline aligned, and the parent
+	 honored that. In that case we have to ignore yalign/yscale as we need
+	 yalign based on the baseline and always FILL mode to ensure we can place
+	 the baseline anywhere */
+      if (baseline != -1)
+	{
+	  yalign = 0;
+	  yscale = 1.0;
+	}
+      else
+	{
+	  yalign = priv->yalign;
+	  yscale = priv->yscale;
+	}
+
      if (gtk_widget_get_request_mode (child) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
 	{
 	  gtk_widget_get_preferred_width (child, NULL, &child_nat_width);
@@ -559,8 +587,8 @@ gtk_alignment_size_allocate (GtkWidget     *widget,

      if (height > child_height)
 	child_allocation.height = (child_height *
-				   (1.0 - priv->yscale) +
-				   height * priv->yscale);
+				   (1.0 - yscale) +
+				   height * yscale);
      else
 	child_allocation.height = height;

@@ -569,9 +597,9 @@ gtk_alignment_size_allocate (GtkWidget     *widget,
      else 
 	child_allocation.x = priv->xalign * (width - child_allocation.width) + allocation->x + border_width + priv->padding_left;

-      child_allocation.y = priv->yalign * (height - child_allocation.height) + allocation->y + border_width + priv->padding_top;
+      child_allocation.y = yalign * (height - child_allocation.height) + allocation->y + border_width + priv->padding_top;

-      gtk_widget_size_allocate (child, &child_allocation);
+      gtk_widget_size_allocate_with_baseline (child, &child_allocation, baseline);
    }
 }

@@ -581,18 +609,30 @@ gtk_alignment_get_preferred_size (GtkWidget      *widget,
                                  GtkOrientation  orientation,
 				  gint            for_size,
                                  gint           *minimum_size,
-                                  gint           *natural_size)
+                                  gint           *natural_size,
+                                  gint           *minimum_baseline,
+                                  gint           *natural_baseline)
 {
  GtkAlignment *alignment = GTK_ALIGNMENT (widget);
  GtkAlignmentPrivate *priv = alignment->priv;
  GtkWidget *child;
  guint minimum, natural;
+  guint top_offset;
+  guint border;

-  natural = minimum = gtk_container_get_border_width (GTK_CONTAINER (widget)) * 2;
+  if (minimum_baseline)
+    *minimum_baseline = -1;
+  if (natural_baseline)
+    *natural_baseline = -1;
+
+  border = gtk_container_get_border_width (GTK_CONTAINER (widget));
+  natural = minimum = border * 2;
+  top_offset = border;

  if ((child = gtk_bin_get_child (GTK_BIN (widget))) && gtk_widget_get_visible (child))
    {
      gint child_min, child_nat;
+      gint child_min_baseline = -1, child_nat_baseline = -1;

      /* Request extra space for the padding: */
      if (orientation == GTK_ORIENTATION_HORIZONTAL)
@@ -619,9 +659,10 @@ gtk_alignment_get_preferred_size (GtkWidget      *widget,
      else
 	{
 	  minimum += (priv->padding_top + priv->padding_bottom);
+	  top_offset += priv->padding_top;

 	  if (for_size < 0)
-	    gtk_widget_get_preferred_height (child, &child_min, &child_nat);
+	    gtk_widget_get_preferred_height_and_baseline_for_width (child, -1, &child_min, &child_nat, &child_min_baseline, &child_nat_baseline);
 	  else
 	    {
 	      gint min_width;
@@ -634,8 +675,13 @@ gtk_alignment_get_preferred_size (GtkWidget      *widget,
 		for_size = (min_width * (1.0 - priv->xscale) +
 			    for_size * priv->xscale);

-	      gtk_widget_get_preferred_height_for_width (child, for_size, &child_min, &child_nat);
+	      gtk_widget_get_preferred_height_and_baseline_for_width (child, for_size, &child_min, &child_nat, &child_min_baseline, &child_nat_baseline);
 	    }
+
+	  if (minimum_baseline && child_min_baseline >= 0)
+	    *minimum_baseline = child_min_baseline + top_offset;
+	  if (natural_baseline && child_nat_baseline >= 0)
+	    *natural_baseline = child_nat_baseline + top_offset;
 	}

      natural = minimum;
@@ -656,7 +702,7 @@ gtk_alignment_get_preferred_width (GtkWidget      *widget,
                                   gint           *minimum_size,
                                   gint           *natural_size)
 {
-  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, -1, minimum_size, natural_size);
+  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, -1, minimum_size, natural_size, NULL, NULL);
 }

 static void
@@ -664,7 +710,7 @@ gtk_alignment_get_preferred_height (GtkWidget      *widget,
                                    gint           *minimum_size,
                                    gint           *natural_size)
 {
-  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, -1, minimum_size, natural_size);
+  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, -1, minimum_size, natural_size, NULL, NULL);
 }


@@ -674,7 +720,7 @@ gtk_alignment_get_preferred_width_for_height (GtkWidget           *widget,
 					      gint                *minimum_size,
 					      gint                *natural_size)
 {
-  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, for_size, minimum_size, natural_size);
+  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, for_size, minimum_size, natural_size, NULL, NULL);
 }

 static void
@@ -683,9 +729,21 @@ gtk_alignment_get_preferred_height_for_width (GtkWidget           *widget,
 					      gint                *minimum_size,
 					      gint                *natural_size)
 {
-  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, for_size, minimum_size, natural_size);
+  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, for_size, minimum_size, natural_size, NULL, NULL);
 }

+static void
+gtk_alignment_get_preferred_height_and_baseline_for_width (GtkWidget           *widget,
+							   gint                 for_size,
+							   gint                *minimum_size,
+							   gint                *natural_size,
+							   gint                *minimum_baseline,
+							   gint                *natural_baseline)
+{
+  gtk_alignment_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, for_size, minimum_size, natural_size, minimum_baseline, natural_baseline);
+}
+
+
 /**
 * gtk_alignment_set_padding:
 * @alignment: a #GtkAlignment
@@ -348,6 +348,9 @@ gtk_app_chooser_button_populate (GtkAppChooserButton *self)
    {
      app = l->data;

+      if (!g_app_info_should_show (app))
+        continue;
+
      if (default_app != NULL && g_app_info_equal (app, default_app))
        continue;

@@ -1431,8 +1431,10 @@ gtk_application_inhibit (GtkApplication             *application,
      gdkwindow = gtk_widget_get_window (GTK_WIDGET (window));
      if (gdkwindow == NULL)
        g_warning ("Inhibit called with an unrealized window");
-      else
+#ifdef GDK_WINDOWING_X11
+      else if (GDK_IS_X11_WINDOW (gdkwindow))
        xid = GDK_WINDOW_XID (gdkwindow);
+#endif
    }

  res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
@@ -703,13 +703,17 @@ gtk_application_window_real_size_allocate (GtkWidget     *widget,

  if (window->priv->menubar != NULL)
    {
-      GtkAllocation menubar_allocation = *allocation;
+      GtkAllocation menubar_allocation;
+      GtkAllocation child_allocation;
      gint menubar_height;
      GtkWidget *child;

-      _gtk_window_set_allocation (GTK_WINDOW (widget), allocation);
+      _gtk_window_set_allocation (GTK_WINDOW (widget), allocation, &child_allocation);
+      menubar_allocation = child_allocation;

-      gtk_widget_get_preferred_height_for_width (window->priv->menubar, allocation->width, &menubar_height, NULL);
+      gtk_widget_get_preferred_height_for_width (window->priv->menubar,
+                                                 menubar_allocation.width,
+                                                 &menubar_height, NULL);

      menubar_allocation.height = menubar_height;
      gtk_widget_size_allocate (window->priv->menubar, &menubar_allocation);
@@ -717,7 +721,6 @@ gtk_application_window_real_size_allocate (GtkWidget     *widget,
      child = gtk_bin_get_child (GTK_BIN (window));
      if (child != NULL && gtk_widget_get_visible (child))
        {
-          GtkAllocation child_allocation = *allocation;
          gint border_width;

          border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
@@ -32,7 +32,7 @@
 * one of the four cardinal directions (up, down, left, or right).  The
 * style of the arrow can be one of shadow in, shadow out, etched in, or
 * etched out.  Note that these directions and style types may be
- * ammended in versions of GTK+ to come.
+ * amended in versions of GTK+ to come.
 *
 * GtkArrow will fill any space alloted to it, but since it is inherited
 * from #GtkMisc, it can be padded and/or aligned, to fill exactly the
@@ -101,6 +101,12 @@ static void gtk_button_box_get_preferred_height_for_width (GtkWidget *widget,
                                                           gint       width,
                                                           gint      *minimum,
                                                           gint      *natural);
+static void gtk_button_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+									gint       width,
+									gint      *minimum,
+									gint      *natural,
+									gint      *minimum_baseline,
+									gint      *natural_baseline);

 static void gtk_button_box_size_allocate      (GtkWidget         *widget,
                                               GtkAllocation     *allocation);
@@ -143,6 +149,7 @@ gtk_button_box_class_init (GtkButtonBoxClass *class)
  widget_class->get_preferred_height = gtk_button_box_get_preferred_height;
  widget_class->get_preferred_width_for_height = gtk_button_box_get_preferred_width_for_height;
  widget_class->get_preferred_height_for_width = gtk_button_box_get_preferred_height_for_width;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_button_box_get_preferred_height_and_baseline_for_width;
  widget_class->size_allocate = gtk_button_box_size_allocate;

  container_class->remove = gtk_button_box_remove;
@@ -438,7 +445,10 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
                                  gint       *nvis_children,
                                  gint       *nvis_secondaries,
                                  gint      **widths,
-                                  gint      **heights)
+                                  gint      **heights,
+                                  gint      **baselines,
+				  gint       *baseline,
+				  gint       *baseline_height)
 {
  GtkButtonBox *bbox;
  GList *children, *list;
@@ -446,6 +456,7 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
  gint nsecondaries;
  gint needed_width;
  gint needed_height;
+  gint needed_above, needed_below;
  gint avg_w, avg_h;
  GtkRequisition child_requisition;
  gint ipad_w;
@@ -456,11 +467,15 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
  gint ipad_y;
  gboolean homogeneous;
  gint i;
+  gint max_above, max_below, child_baseline;
+  GtkOrientation orientation;
+  gboolean have_baseline;

  g_return_if_fail (GTK_IS_BUTTON_BOX (widget));

  bbox = GTK_BUTTON_BOX (widget);

+  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (widget));
  homogeneous = gtk_box_get_homogeneous (GTK_BOX (widget));

  gtk_widget_style_get (widget,
@@ -475,22 +490,33 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
  list = children = _gtk_box_get_children (GTK_BOX (bbox));
  needed_width = child_min_width;
  needed_height = child_min_height;
+  needed_above = 0;
+  needed_below = 0;
  ipad_w = ipad_x * 2;
  ipad_h = ipad_y * 2;

+  have_baseline = FALSE;
+  max_above = max_below = 0;
  avg_w = avg_h = 0;
-  while (children)
+  for (children = list; children != NULL; children = children->next)
    {
      GtkWidget *child;

      child = children->data;
-      children = children->next;

      if (gtk_widget_get_visible (child))
        {
          nchildren += 1;
-          gtk_widget_get_preferred_size (child,
-                                         &child_requisition, NULL);
+          gtk_widget_get_preferred_size_and_baseline (child,
+						      &child_requisition, NULL, &child_baseline, NULL);
+	  if (orientation == GTK_ORIENTATION_HORIZONTAL &&
+	      gtk_widget_get_valign_with_baseline (child) == GTK_ALIGN_BASELINE &&
+	      child_baseline != -1)
+	    {
+	      have_baseline = TRUE;
+	      max_above = MAX (max_above, child_baseline + ipad_y);
+	      max_below = MAX (max_below , child_requisition.height + ipad_h - (child_baseline + ipad_y));
+	    }
          avg_w += child_requisition.width + ipad_w;
          avg_h += child_requisition.height + ipad_h;
        }
@@ -498,8 +524,14 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
  avg_w /= MAX (nchildren, 1);
  avg_h /= MAX (nchildren, 1);

+  if (baseline)
+    *baseline = have_baseline ? max_above : -1;
+  if (baseline_height)
+    *baseline_height = max_above + max_below;
+
  *widths = g_new (gint, nchildren);
  *heights = g_new (gint, nchildren);
+  *baselines = g_new (gint, nchildren);

  i = 0;
  children = list;
@@ -520,7 +552,8 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
          if (is_secondary)
            nsecondaries++;

-          gtk_widget_get_preferred_size (child, &child_requisition, NULL);
+          gtk_widget_get_preferred_size_and_baseline (child,
+						      &child_requisition, NULL, &child_baseline, NULL);

          if (homogeneous ||
              (!non_homogeneous && (child_requisition.width + ipad_w < avg_w * 1.5)))
@@ -534,16 +567,38 @@ gtk_button_box_child_requisition (GtkWidget  *widget,
              (*widths)[i] = child_requisition.width + ipad_w;
            }

+	  (*baselines)[i] = -1;
+
          if (homogeneous ||
              (!non_homogeneous && (child_requisition.height + ipad_h < avg_h * 1.5)))
            {
              (*heights)[i] = -1;
-              if (child_requisition.height + ipad_h > needed_height)
-                needed_height = child_requisition.height + ipad_h;
+
+	      if (orientation == GTK_ORIENTATION_HORIZONTAL &&
+		  gtk_widget_get_valign_with_baseline (child) == GTK_ALIGN_BASELINE &&
+		  child_baseline != -1)
+		{
+		  (*baselines)[i] = child_baseline + ipad_y;
+
+		  if (child_baseline + ipad_y > needed_above)
+		    needed_above = child_baseline + ipad_y;
+		  if (child_requisition.height - child_baseline + ipad_y > needed_below)
+		    needed_below = child_requisition.height - child_baseline + ipad_y;
+		}
+	      else
+		{
+		  if (child_requisition.height + ipad_h > needed_height)
+		    needed_height = child_requisition.height + ipad_h;
+		}
            }
          else
            {
              (*heights)[i] = child_requisition.height + ipad_h;
+
+	      if (orientation == GTK_ORIENTATION_HORIZONTAL &&
+		  gtk_widget_get_valign_with_baseline (child) == GTK_ALIGN_BASELINE &&
+		  child_baseline != -1)
+		(*baselines)[i] = child_baseline + ipad_y;
            }

          i++;
@@ -552,12 +607,18 @@ gtk_button_box_child_requisition (GtkWidget  *widget,

  g_list_free (list);

+  needed_height = MAX (needed_height, needed_above + needed_below);
+
  for (i = 0; i < nchildren; i++)
    {
      if ((*widths)[i] == -1)
        (*widths)[i] = needed_width;
      if ((*heights)[i] == -1)
-        (*heights)[i] = needed_height;
+	{
+	  (*heights)[i] = needed_height;
+	  if ((*baselines)[i] != -1)
+	    (*baselines)[i] = needed_above;
+	}
    }

  if (nvis_children)
@@ -569,19 +630,24 @@ gtk_button_box_child_requisition (GtkWidget  *widget,

 static void
 gtk_button_box_size_request (GtkWidget      *widget,
-                             GtkRequisition *requisition)
+                             GtkRequisition *requisition,
+			     gint           *baseline)
 {
  GtkButtonBoxPrivate *priv;
  GtkButtonBox *bbox;
  gint nvis_children;
-  gint max_size;
+  gint max_size, max_above, max_below;
  gint total_size;
  gint spacing;
  GtkOrientation orientation;
  gint *widths;
  gint *heights;
+  gint *baselines;
  gint i;

+  if (baseline)
+    *baseline = -1;
+
  bbox = GTK_BUTTON_BOX (widget);
  priv = bbox->priv;

@@ -591,16 +657,22 @@ gtk_button_box_size_request (GtkWidget      *widget,
  gtk_button_box_child_requisition (widget,
                                    &nvis_children,
                                    NULL,
-                                    &widths, &heights);
+                                    &widths, &heights, &baselines, baseline, NULL);

-  max_size = 0;
+  max_size = max_above = max_below = 0;
  total_size = 0;
  for (i = 0; i < nvis_children; i++)
    {
      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        {
          total_size += widths[i];
-          max_size = MAX (max_size, heights[i]);
+	  if (baselines[i] == -1)
+	    max_size = MAX (max_size, heights[i]);
+	  else
+	    {
+	      max_above = MAX (max_above, baselines[i]);
+	      max_below = MAX (max_below, heights[i] - baselines[i]);
+	    }
        }
      else
        {
@@ -610,6 +682,23 @@ gtk_button_box_size_request (GtkWidget      *widget,
    }
  g_free (widths);
  g_free (heights);
+  g_free (baselines);
+
+  max_size = MAX (max_size, max_above + max_below);
+
+  switch (gtk_box_get_baseline_position (GTK_BOX (widget)))
+    {
+    case GTK_BASELINE_POSITION_TOP:
+      break;
+    case GTK_BASELINE_POSITION_CENTER:
+      if (baseline != NULL && *baseline != -1)
+	*baseline += (max_size - (max_above + max_below)) / 2;
+      break;
+    case GTK_BASELINE_POSITION_BOTTOM:
+      if (baseline != NULL && *baseline != -1)
+	*baseline += max_size - (max_above + max_below);
+      break;
+    }

  if (nvis_children == 0)
    {
@@ -656,7 +745,7 @@ gtk_button_box_get_preferred_width (GtkWidget *widget,
 {
  GtkRequisition requisition;

-  gtk_button_box_size_request (widget, &requisition);
+  gtk_button_box_size_request (widget, &requisition, NULL);

  *minimum = *natural = requisition.width;
 }
@@ -666,11 +755,9 @@ gtk_button_box_get_preferred_height (GtkWidget *widget,
                                     gint      *minimum,
                                     gint      *natural)
 {
-  GtkRequisition requisition;
-
-  gtk_button_box_size_request (widget, &requisition);
-
-  *minimum = *natural = requisition.height;
+  gtk_button_box_get_preferred_height_and_baseline_for_width (widget, -1,
+							      minimum, natural,
+							      NULL, NULL);
 }

 static void
@@ -691,6 +778,26 @@ gtk_button_box_get_preferred_height_for_width (GtkWidget *widget,
  gtk_button_box_get_preferred_height (widget, minimum, natural);
 }

+static void
+gtk_button_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+							    gint       width,
+							    gint      *minimum,
+							    gint      *natural,
+							    gint      *minimum_baseline,
+							    gint      *natural_baseline)
+{
+  GtkRequisition requisition;
+  gint baseline;
+
+  gtk_button_box_size_request (widget, &requisition, &baseline);
+
+  *minimum = *natural = requisition.height;
+  if (minimum_baseline)
+    *minimum_baseline = baseline;
+  if (natural_baseline)
+    *natural_baseline = baseline;
+}
+
 static void
 gtk_button_box_size_allocate (GtkWidget     *widget,
                              GtkAllocation *allocation)
@@ -714,10 +821,13 @@ gtk_button_box_size_allocate (GtkWidget     *widget,
  gint ipad_x, ipad_y;
  gint *widths;
  gint *heights;
+  gint *baselines;
  gint *sizes;
  gint primary_size;
  gint secondary_size;
  gint total_size;
+  gint baseline, baseline_height;
+  gint child_baseline, allocated_baseline;
  gint i;

  bbox = GTK_BUTTON_BOX (widget);
@@ -733,7 +843,27 @@ gtk_button_box_size_allocate (GtkWidget     *widget,
  gtk_button_box_child_requisition (widget,
                                    &nvis_children,
                                    &n_secondaries,
-                                    &widths, &heights);
+                                    &widths, &heights, &baselines, &baseline, &baseline_height);
+
+  allocated_baseline = gtk_widget_get_allocated_baseline (widget);
+  if (allocated_baseline != -1)
+    baseline = allocated_baseline;
+  else if (baseline != -1)
+    {
+      /* TODO: modify baseline based on baseline_pos && allocated_baseline*/
+      switch (gtk_box_get_baseline_position (GTK_BOX (widget)))
+	{
+	case GTK_BASELINE_POSITION_TOP:
+	  baseline = baseline;
+	  break;
+	case GTK_BASELINE_POSITION_CENTER:
+	  baseline = baseline + (allocation->height - baseline_height) / 2;
+	  break;
+	case GTK_BASELINE_POSITION_BOTTOM:
+	  baseline = allocation->height - (baseline_height - baseline);
+	  break;
+	}
+    }

  n_primaries = nvis_children - n_secondaries;
  primary_size = 0;
@@ -917,10 +1047,17 @@ gtk_button_box_size_allocate (GtkWidget     *widget,
        {
          child_allocation.width = widths[i];
          child_allocation.height = heights[i];
+	  child_baseline = -1;

          if (orientation == GTK_ORIENTATION_HORIZONTAL)
            {
-              child_allocation.y = allocation->y + (allocation->height - child_allocation.height) / 2;
+	      if (baselines[i] != -1)
+		{
+		  child_allocation.y = allocation->y + baseline - baselines[i];
+		  child_baseline = baselines[i];
+		}
+	      else
+		child_allocation.y = allocation->y + (allocation->height - child_allocation.height) / 2;

              if (gtk_button_box_get_child_secondary (bbox, child))
                {
@@ -953,7 +1090,7 @@ gtk_button_box_size_allocate (GtkWidget     *widget,
                }
            }

-          gtk_widget_size_allocate (child, &child_allocation);
+          gtk_widget_size_allocate_with_baseline (child, &child_allocation, child_baseline);
          i++;
        }
    }
@@ -961,6 +1098,7 @@ gtk_button_box_size_allocate (GtkWidget     *widget,
  g_list_free (list);
  g_free (widths);
  g_free (heights);
+  g_free (baselines);
 }

 /**
@@ -94,7 +94,8 @@ enum {
  PROP_0,
  PROP_ORIENTATION,
  PROP_SPACING,
-  PROP_HOMOGENEOUS
+  PROP_HOMOGENEOUS,
+  PROP_BASELINE_POSITION
 };

 enum {
@@ -116,6 +117,7 @@ struct _GtkBoxPrivate
  guint           default_expand : 1;
  guint           homogeneous    : 1;
  guint           spacing_set    : 1;
+  guint           baseline_pos   : 2;
 };

 typedef struct _GtkBoxChild        GtkBoxChild;
@@ -200,6 +202,12 @@ static void               gtk_box_get_preferred_height_for_width (GtkWidget
                                                                  gint                 width,
                                                                  gint                *minimum_height,
                                                                  gint                *natural_height);
+static void  gtk_box_get_preferred_height_and_baseline_for_width (GtkWidget           *widget,
+								  gint                 width,
+								  gint                *minimum_height,
+								  gint                *natural_height,
+								  gint                *minimum_baseline,
+								  gint                *natural_baseline);


 G_DEFINE_TYPE_WITH_CODE (GtkBox, gtk_box, GTK_TYPE_CONTAINER,
@@ -220,6 +228,7 @@ gtk_box_class_init (GtkBoxClass *class)
  widget_class->get_preferred_width            = gtk_box_get_preferred_width;
  widget_class->get_preferred_height           = gtk_box_get_preferred_height;
  widget_class->get_preferred_height_for_width = gtk_box_get_preferred_height_for_width;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_box_get_preferred_height_and_baseline_for_width;
  widget_class->get_preferred_width_for_height = gtk_box_get_preferred_width_for_height;
  widget_class->compute_expand                 = gtk_box_compute_expand;
  widget_class->direction_changed              = gtk_box_direction_changed;
@@ -255,6 +264,15 @@ gtk_box_class_init (GtkBoxClass *class)
 							 FALSE,
 							 GTK_PARAM_READWRITE));

+  g_object_class_install_property (object_class,
+                                   PROP_BASELINE_POSITION,
+                                   g_param_spec_enum ("baseline-position",
+                                                     P_("Baseline position"),
+                                                     P_("The position of the baseline aligned widgets if extra space is availible"),
+                                                     GTK_TYPE_BASELINE_POSITION,
+                                                     GTK_BASELINE_POSITION_CENTER,
+                                                     GTK_PARAM_READWRITE));
+
  /**
   * GtkBox:expand:
   *
@@ -340,6 +358,7 @@ gtk_box_init (GtkBox *box)
  private->homogeneous = FALSE;
  private->spacing = 0;
  private->spacing_set = FALSE;
+  private->baseline_pos = GTK_BASELINE_POSITION_CENTER;
 }

 static void
@@ -361,6 +380,9 @@ gtk_box_set_property (GObject      *object,
    case PROP_SPACING:
      gtk_box_set_spacing (box, g_value_get_int (value));
      break;
+    case PROP_BASELINE_POSITION:
+      gtk_box_set_baseline_position (box, g_value_get_enum (value));
+      break;
    case PROP_HOMOGENEOUS:
      gtk_box_set_homogeneous (box, g_value_get_boolean (value));
      break;
@@ -387,6 +409,9 @@ gtk_box_get_property (GObject    *object,
    case PROP_SPACING:
      g_value_set_int (value, private->spacing);
      break;
+    case PROP_BASELINE_POSITION:
+      g_value_set_enum (value, private->baseline_pos);
+      break;
    case PROP_HOMOGENEOUS:
      g_value_set_boolean (value, private->homogeneous);
      break;
@@ -435,6 +460,11 @@ gtk_box_size_allocate (GtkWidget     *widget,
  GtkTextDirection direction;
  GtkAllocation child_allocation;
  GtkRequestedSize *sizes;
+  gint child_minimum_baseline, child_natural_baseline;
+  gint minimum_above, natural_above;
+  gint minimum_below, natural_below;
+  gboolean have_baseline;
+  gint baseline;

  GtkPackType packing;

@@ -461,6 +491,10 @@ gtk_box_size_allocate (GtkWidget     *widget,
  else
    size = allocation->height - (nvis_children - 1) * private->spacing;

+  have_baseline = FALSE;
+  minimum_above = natural_above = 0;
+  minimum_below = natural_below = 0;
+
  /* Retrieve desired size for visible children. */
  for (i = 0, children = private->children; children; children = children->next)
    {
@@ -475,11 +509,11 @@ gtk_box_size_allocate (GtkWidget     *widget,
                                                   &sizes[i].minimum_size,
                                                   &sizes[i].natural_size);
      else
-	gtk_widget_get_preferred_height_for_width (child->widget,
-                                                   allocation->width,
-                                                   &sizes[i].minimum_size,
-                                                   &sizes[i].natural_size);
-
+	gtk_widget_get_preferred_height_and_baseline_for_width (child->widget,
+								allocation->width,
+								&sizes[i].minimum_size,
+								&sizes[i].natural_size,
+								NULL, NULL);

      /* Assert the api is working properly */
      if (sizes[i].minimum_size < 0)
@@ -537,28 +571,9 @@ gtk_box_size_allocate (GtkWidget     *widget,
 	extra = 0;
    }

-  /* Allocate child positions. */
+  /* Allocate child sizes. */
  for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
    {
-      if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
-	{
-	  child_allocation.y = allocation->y;
-	  child_allocation.height = MAX (1, allocation->height);
-	  if (packing == GTK_PACK_START)
-	    x = allocation->x;
-	  else
-	    x = allocation->x + allocation->width;
-	}
-      else
-	{
-	  child_allocation.x = allocation->x;
-	  child_allocation.width = MAX (1, allocation->width);
-	  if (packing == GTK_PACK_START)
-	    y = allocation->y;
-	  else
-	    y = allocation->y + allocation->height;
-	}
-
      for (i = 0, children = private->children;
 	   children;
 	   children = children->next)
@@ -605,6 +620,105 @@ gtk_box_size_allocate (GtkWidget     *widget,
 		}
 	    }

+	  sizes[i].natural_size = child_size;
+
+	  if (private->orientation == GTK_ORIENTATION_HORIZONTAL &&
+	      gtk_widget_get_valign_with_baseline (child->widget) == GTK_ALIGN_BASELINE)
+	    {
+	      int child_allocation_width;
+	      int child_minimum_height, child_natural_height;
+
+	      if (child->fill)
+		child_allocation_width = MAX (1, child_size - child->padding * 2);
+	      else
+		child_allocation_width = sizes[i].minimum_size;
+
+	      child_minimum_baseline = -1;
+	      child_natural_baseline = -1;
+	      gtk_widget_get_preferred_height_and_baseline_for_width (child->widget,
+								      child_allocation_width,
+								      &child_minimum_height, &child_natural_height,
+								      &child_minimum_baseline, &child_natural_baseline);
+
+	      if (child_minimum_baseline >= 0)
+		{
+		  have_baseline = TRUE;
+		  minimum_below = MAX (minimum_below, child_minimum_height - child_minimum_baseline);
+		  natural_below = MAX (natural_below, child_natural_height - child_natural_baseline);
+		  minimum_above = MAX (minimum_above, child_minimum_baseline);
+		  natural_above = MAX (natural_above, child_natural_baseline);
+		}
+	    }
+
+	  i++;
+	}
+    }
+
+  baseline = gtk_widget_get_allocated_baseline (widget);
+  if (baseline == -1 && have_baseline)
+    {
+      gint height = MAX (1, allocation->height);
+
+      /* TODO: This is purely based on the minimum baseline, when things fit we should
+	 use the natural one? */
+
+      switch (private->baseline_pos)
+	{
+	case GTK_BASELINE_POSITION_TOP:
+	  baseline = minimum_above;
+	  break;
+	case GTK_BASELINE_POSITION_CENTER:
+	  baseline = minimum_above + (height - (minimum_above + minimum_below)) / 2;
+	  break;
+	case GTK_BASELINE_POSITION_BOTTOM:
+	  baseline = height - minimum_below;
+	  break;
+	}
+    }
+
+  /* Allocate child positions. */
+  for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
+    {
+      if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
+	{
+	  child_allocation.y = allocation->y;
+	  child_allocation.height = MAX (1, allocation->height);
+	  if (packing == GTK_PACK_START)
+	    x = allocation->x;
+	  else
+	    x = allocation->x + allocation->width;
+	}
+      else
+	{
+	  child_allocation.x = allocation->x;
+	  child_allocation.width = MAX (1, allocation->width);
+	  if (packing == GTK_PACK_START)
+	    y = allocation->y;
+	  else
+	    y = allocation->y + allocation->height;
+	}
+
+      for (i = 0, children = private->children;
+	   children;
+	   children = children->next)
+	{
+	  child = children->data;
+
+	  /* If widget is not visible, skip it. */
+	  if (!gtk_widget_get_visible (child->widget))
+	    continue;
+
+	  /* If widget is packed differently skip it, but still increment i,
+	   * since widget is visible and will be handled in next loop iteration.
+	   */
+	  if (child->pack != packing)
+	    {
+	      i++;
+	      continue;
+	    }
+
+	  child_size = sizes[i].natural_size;
+
 	  /* Assign the child's position. */
 	  if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 	    {
@@ -658,7 +772,7 @@ gtk_box_size_allocate (GtkWidget     *widget,
 		  child_allocation.y -= child_size;
 		}
 	    }
-	  gtk_widget_size_allocate (child->widget, &child_allocation);
+	  gtk_widget_size_allocate_with_baseline (child->widget, &child_allocation, baseline);

 	  i++;
 	}
@@ -1015,18 +1129,28 @@ static void
 gtk_box_get_size (GtkWidget      *widget,
 		  GtkOrientation  orientation,
 		  gint           *minimum_size,
-		  gint           *natural_size)
+		  gint           *natural_size,
+		  gint           *minimum_baseline,
+		  gint           *natural_baseline)
 {
  GtkBox *box;
  GtkBoxPrivate *private;
  GList *children;
  gint nvis_children;
  gint minimum, natural;
+  gint minimum_above, natural_above;
+  gint minimum_below, natural_below;
+  gboolean have_baseline;
+  gint min_baseline, nat_baseline;

  box = GTK_BOX (widget);
  private = box->priv;

+  have_baseline = FALSE;
  minimum = natural = 0;
+  minimum_above = natural_above = 0;
+  minimum_below = natural_below = 0;
+  min_baseline = nat_baseline = -1;

  nvis_children = 0;

@@ -1037,13 +1161,15 @@ gtk_box_get_size (GtkWidget      *widget,
      if (gtk_widget_get_visible (child->widget))
        {
          gint child_minimum, child_natural;
+          gint child_minimum_baseline = -1, child_natural_baseline = -1;

 	  if (orientation == GTK_ORIENTATION_HORIZONTAL)
 	    gtk_widget_get_preferred_width (child->widget,
                                            &child_minimum, &child_natural);
 	  else
-	    gtk_widget_get_preferred_height (child->widget,
-                                             &child_minimum, &child_natural);
+	    gtk_widget_get_preferred_height_and_baseline_for_width (child->widget, -1,
+								    &child_minimum, &child_natural,
+								    &child_minimum_baseline, &child_natural_baseline);

          if (private->orientation == orientation)
 	    {
@@ -1065,9 +1191,20 @@ gtk_box_get_size (GtkWidget      *widget,
 	    }
 	  else
 	    {
-	      /* The biggest mins and naturals in the opposing orientation */
-              minimum = MAX (minimum, child_minimum);
-              natural = MAX (natural, child_natural);
+	      if (child_minimum_baseline >= 0)
+		{
+		  have_baseline = TRUE;
+		  minimum_below = MAX (minimum_below, child_minimum - child_minimum_baseline);
+		  natural_below = MAX (natural_below, child_natural - child_natural_baseline);
+		  minimum_above = MAX (minimum_above, child_minimum_baseline);
+		  natural_above = MAX (natural_above, child_natural_baseline);
+		}
+	      else
+		{
+		  /* The biggest mins and naturals in the opposing orientation */
+		  minimum = MAX (minimum, child_minimum);
+		  natural = MAX (natural, child_natural);
+		}
 	    }

          nvis_children += 1;
@@ -1085,11 +1222,39 @@ gtk_box_get_size (GtkWidget      *widget,
      natural += (nvis_children - 1) * private->spacing;
    }

+  minimum = MAX (minimum, minimum_below + minimum_above);
+  natural = MAX (natural, natural_below + natural_above);
+
+  if (have_baseline)
+    {
+      switch (private->baseline_pos)
+	{
+	case GTK_BASELINE_POSITION_TOP:
+	  min_baseline = minimum_above;
+	  nat_baseline = natural_above;
+	  break;
+	case GTK_BASELINE_POSITION_CENTER:
+	  min_baseline = minimum_above + (minimum - (minimum_above + minimum_below)) / 2;
+	  nat_baseline = natural_above + (natural - (natural_above + natural_below)) / 2;
+	  break;
+	case GTK_BASELINE_POSITION_BOTTOM:
+	  min_baseline = minimum - minimum_below;
+	  nat_baseline = natural - natural_below;
+	  break;
+	}
+    }
+
  if (minimum_size)
    *minimum_size = minimum;

  if (natural_size)
    *natural_size = natural;
+
+  if (minimum_baseline)
+    *minimum_baseline = min_baseline;
+
+  if (natural_baseline)
+    *natural_baseline = nat_baseline;
 }

 static void
@@ -1097,7 +1262,7 @@ gtk_box_get_preferred_width (GtkWidget *widget,
                             gint      *minimum_size,
                             gint      *natural_size)
 {
-  gtk_box_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
+  gtk_box_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size, NULL, NULL);
 }

 static void
@@ -1105,14 +1270,16 @@ gtk_box_get_preferred_height (GtkWidget *widget,
                              gint      *minimum_size,
                              gint      *natural_size)
 {
-  gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
+  gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size, NULL, NULL);
 }

 static void
 gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
 					       gint    avail_size,
 					       gint   *minimum_size,
-					       gint   *natural_size)
+					       gint   *natural_size,
+					       gint   *minimum_baseline,
+					       gint   *natural_baseline)
 {
  GtkBoxPrivate       *private = box->priv;
  GtkBoxChild      *child;
@@ -1120,11 +1287,16 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
  gint              nvis_children;
  gint              nexpand_children;
  gint              computed_minimum = 0, computed_natural = 0;
+  gint              computed_minimum_above = 0, computed_natural_above = 0;
+  gint              computed_minimum_below = 0, computed_natural_below = 0;
+  gint              computed_minimum_baseline = -1, computed_natural_baseline = -1;
  GtkRequestedSize *sizes;
  GtkPackType       packing;
  gint              size, extra, i;
  gint              child_size, child_minimum, child_natural;
+  gint              child_minimum_baseline, child_natural_baseline;
  gint              n_extra_widgets = 0;
+  gboolean          have_baseline;

  count_expand_children (box, &nvis_children, &nexpand_children);

@@ -1199,6 +1371,7 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
 	extra = 0;
    }

+  have_baseline = FALSE;
  /* Allocate child positions. */
  for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
    {
@@ -1260,26 +1433,64 @@ gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
 		}


+	      child_minimum_baseline = child_natural_baseline = -1;
 	      /* Assign the child's position. */
 	      if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
-		gtk_widget_get_preferred_height_for_width (child->widget,
-                                                           child_size, &child_minimum, &child_natural);
+		gtk_widget_get_preferred_height_and_baseline_for_width (child->widget, child_size,
+									&child_minimum, &child_natural,
+									&child_minimum_baseline, &child_natural_baseline);
 	      else /* (private->orientation == GTK_ORIENTATION_VERTICAL) */
 		gtk_widget_get_preferred_width_for_height (child->widget,
                                                           child_size, &child_minimum, &child_natural);

-
-	      computed_minimum = MAX (computed_minimum, child_minimum);
-	      computed_natural = MAX (computed_natural, child_natural);
+	      if (child_minimum_baseline >= 0)
+		{
+		  have_baseline = TRUE;
+		  computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
+		  computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
+		  computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
+		  computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+		}
+	      else
+		{
+		  computed_minimum = MAX (computed_minimum, child_minimum);
+		  computed_natural = MAX (computed_natural, child_natural);
+		}
 	    }
 	  i += 1;
 	}
    }

+  if (have_baseline)
+    {
+      computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above);
+      computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
+      switch (private->baseline_pos)
+	{
+	case GTK_BASELINE_POSITION_TOP:
+	  computed_minimum_baseline = computed_minimum_above;
+	  computed_natural_baseline = computed_natural_above;
+	  break;
+	case GTK_BASELINE_POSITION_CENTER:
+	  computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum - (computed_minimum_above + computed_minimum_below)) / 2, 0);
+	  computed_natural_baseline = computed_natural_above + MAX((computed_natural - (computed_natural_above + computed_natural_below)) / 2, 0);
+	  break;
+	case GTK_BASELINE_POSITION_BOTTOM:
+	  computed_minimum_baseline = computed_minimum - computed_minimum_below;
+	  computed_natural_baseline = computed_natural - computed_natural_below;
+	  break;
+	}
+    }
+
+  if (minimum_baseline)
+    *minimum_baseline = computed_minimum_baseline;
+  if (natural_baseline)
+    *natural_baseline = computed_natural_baseline;
+
  if (minimum_size)
    *minimum_size = computed_minimum;
  if (natural_size)
-    *natural_size = computed_natural;
+    *natural_size = MAX (computed_natural, computed_natural_below + computed_natural_above);
 }

 static void
@@ -1355,24 +1566,46 @@ gtk_box_get_preferred_width_for_height (GtkWidget *widget,
  GtkBoxPrivate *private = box->priv;

  if (private->orientation == GTK_ORIENTATION_VERTICAL)
-    gtk_box_compute_size_for_opposing_orientation (box, height, minimum_width, natural_width);
+    gtk_box_compute_size_for_opposing_orientation (box, height, minimum_width, natural_width, NULL, NULL);
  else
    gtk_box_compute_size_for_orientation (box, height, minimum_width, natural_width);
 }

+static void
+gtk_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+						     gint       width,
+						     gint      *minimum_height,
+						     gint      *natural_height,
+						     gint      *minimum_baseline,
+						     gint      *natural_baseline)
+{
+  GtkBox        *box     = GTK_BOX (widget);
+  GtkBoxPrivate *private = box->priv;
+
+  if (width < 0)
+    gtk_box_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_height, natural_height, minimum_baseline, natural_baseline);
+  else
+    {
+      if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
+	gtk_box_compute_size_for_opposing_orientation (box, width, minimum_height, natural_height, minimum_baseline, natural_baseline);
+      else
+	{
+	  if (minimum_baseline)
+	    *minimum_baseline = -1;
+	  if (natural_baseline)
+	    *natural_baseline = -1;
+	  gtk_box_compute_size_for_orientation (box, width, minimum_height, natural_height);
+	}
+    }
+}
+
 static void
 gtk_box_get_preferred_height_for_width (GtkWidget *widget,
                                        gint       width,
                                        gint      *minimum_height,
                                        gint      *natural_height)
 {
-  GtkBox        *box     = GTK_BOX (widget);
-  GtkBoxPrivate *private = box->priv;
-
-  if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
-    gtk_box_compute_size_for_opposing_orientation (box, width, minimum_height, natural_height);
-  else
-    gtk_box_compute_size_for_orientation (box, width, minimum_height, natural_height);
+  gtk_box_get_preferred_height_and_baseline_for_width (widget, width, minimum_height, natural_height, NULL, NULL);
 }

 /**
@@ -1550,6 +1783,59 @@ gtk_box_get_spacing (GtkBox *box)
  return box->priv->spacing;
 }

+/**
+ * gtk_box_set_baseline_position:
+ * @box: a #GtkBox
+ * @position: a #GtkBaselinePosition
+ *
+ * Sets the baseline position of a box. This affects
+ * only horizontal boxes with at least one baseline aligned
+ * child. If there is more vertical space availible than requested,
+ * and the baseline is not allocated by the parent then
+ * @position is used to allocate the baseline wrt the
+ * extra space available.
+ *
+ * Since: 3.10
+ */
+void
+gtk_box_set_baseline_position (GtkBox             *box,
+			       GtkBaselinePosition position)
+{
+  GtkBoxPrivate *private;
+
+  g_return_if_fail (GTK_IS_BOX (box));
+
+  private = box->priv;
+
+  if (position != private->baseline_pos)
+    {
+      private->baseline_pos = position;
+
+      g_object_notify (G_OBJECT (box), "baseline-position");
+
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+    }
+}
+
+/**
+ * gtk_box_get_baseline_position:
+ * @box: a #GtkBox
+ *
+ * Gets the value set by gtk_box_set_baseline_position().
+ *
+ * Return value: the baseline position
+ *
+ * Since: 3.10
+ **/
+GtkBaselinePosition
+gtk_box_get_baseline_position (GtkBox         *box)
+{
+  g_return_val_if_fail (GTK_IS_BOX (box), GTK_BASELINE_POSITION_CENTER);
+
+  return box->priv->baseline_pos;
+}
+
+
 void
 _gtk_box_set_spacing_set (GtkBox  *box,
                          gboolean spacing_set)
@@ -89,6 +89,11 @@ gboolean    gtk_box_get_homogeneous     (GtkBox         *box);
 void        gtk_box_set_spacing         (GtkBox         *box,
                                         gint            spacing);
 gint        gtk_box_get_spacing         (GtkBox         *box);
+GDK_AVAILABLE_IN_3_10
+void        gtk_box_set_baseline_position (GtkBox             *box,
+					   GtkBaselinePosition position);
+GDK_AVAILABLE_IN_3_10
+GtkBaselinePosition gtk_box_get_baseline_position (GtkBox         *box);

 void        gtk_box_reorder_child       (GtkBox         *box,
                                         GtkWidget      *child,
@@ -1355,12 +1355,6 @@ gtk_builder_get_translation_domain (GtkBuilder *builder)
 *
 * Add @object to the @builder object pool so it can be referenced just like any
 * other object built by builder.
- *
- * To make this function even more useful a new special entry point element
- * &lt;external-object&gt; is defined. It is similar to &lt;object&gt; but has 
- * to reference an external object exposed with this function.
- * This way you can change properties and even add children to an
- * external object using builder, not just reference it.
 * 
 * Since: 3.8
 **/
@@ -170,6 +170,12 @@ static void gtk_button_get_preferred_width       (GtkWidget           *widget,
 static void gtk_button_get_preferred_height      (GtkWidget           *widget,
 						  gint                *minimum_size,
 						  gint                *natural_size);
+static void gtk_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+								    gint       width,
+								    gint      *minimum_size,
+								    gint      *natural_size,
+								    gint      *minimum_baseline,
+								    gint      *natural_baseline);
  
 static guint button_signals[LAST_SIGNAL] = { 0 };

@@ -196,6 +202,7 @@ gtk_button_class_init (GtkButtonClass *klass)

  widget_class->get_preferred_width  = gtk_button_get_preferred_width;
  widget_class->get_preferred_height = gtk_button_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_button_get_preferred_height_and_baseline_for_width;
  widget_class->destroy = gtk_button_destroy;
  widget_class->screen_changed = gtk_button_screen_changed;
  widget_class->realize = gtk_button_realize;
@@ -1150,11 +1157,16 @@ gtk_button_construct_child (GtkButton *button)
      else
 	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, image_spacing);

+      gtk_widget_set_valign (image, GTK_ALIGN_BASELINE);
+      gtk_widget_set_valign (box, GTK_ALIGN_BASELINE);
+
      if (priv->align_set)
 	align = gtk_alignment_new (priv->xalign, priv->yalign, 0.0, 0.0);
      else
 	align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);

+      gtk_widget_set_valign (align, GTK_ALIGN_BASELINE);
+
      if (priv->image_position == GTK_POS_LEFT ||
 	  priv->image_position == GTK_POS_TOP)
 	gtk_box_pack_start (GTK_BOX (box), priv->image, FALSE, FALSE, 0);
@@ -1172,6 +1184,8 @@ gtk_button_construct_child (GtkButton *button)
          else
            label = gtk_label_new (label_text);

+	  gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
+
 	  if (priv->image_position == GTK_POS_RIGHT ||
 	      priv->image_position == GTK_POS_BOTTOM)
 	    gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
@@ -1196,6 +1210,8 @@ gtk_button_construct_child (GtkButton *button)
  else
    label = gtk_label_new (priv->label_text);

+  gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
+
  if (priv->align_set)
    gtk_misc_set_alignment (GTK_MISC (label), priv->xalign, priv->yalign);

@@ -1584,6 +1600,7 @@ gtk_button_size_allocate (GtkWidget     *widget,
  GtkBorder border;
  gint focus_width;
  gint focus_pad;
+  gint baseline;

  context = gtk_widget_get_style_context (widget);

@@ -1635,6 +1652,10 @@ gtk_button_size_allocate (GtkWidget     *widget,
 	  child_allocation.height = child_allocation.height - (focus_width + focus_pad) * 2;
 	}

+      baseline = gtk_widget_get_allocated_baseline (widget);
+      if (baseline != -1)
+	baseline -= child_allocation.y - allocation->y;
+
      if (priv->depressed)
 	{
 	  gint child_displacement_x;
@@ -1651,7 +1672,7 @@ gtk_button_size_allocate (GtkWidget     *widget,
      child_allocation.width  = MAX (1, child_allocation.width);
      child_allocation.height = MAX (1, child_allocation.height);

-      gtk_widget_size_allocate (child, &child_allocation);
+      gtk_widget_size_allocate_with_baseline (child, &child_allocation, baseline);
    }
 }

@@ -2063,7 +2084,9 @@ static void
 gtk_button_get_size (GtkWidget      *widget,
 		     GtkOrientation  orientation,
 		     gint           *minimum_size,
-		     gint           *natural_size)
+		     gint           *natural_size,
+		     gint           *minimum_baseline,
+		     gint           *natural_baseline)
 {
  GtkButton *button = GTK_BUTTON (widget);
  GtkStyleContext *context;
@@ -2074,6 +2097,7 @@ gtk_button_get_size (GtkWidget      *widget,
  gint focus_width;
  gint focus_pad;
  gint minimum, natural;
+  gint top_offset;

  context = gtk_widget_get_style_context (widget);

@@ -2084,6 +2108,8 @@ gtk_button_get_size (GtkWidget      *widget,
                               "focus-padding", &focus_pad,
                               NULL);

+  top_offset = 0;
+
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      minimum = padding.left + padding.right +
@@ -2097,9 +2123,14 @@ gtk_button_get_size (GtkWidget      *widget,
      minimum = padding.top + padding.bottom +
        border.top + border.bottom;

+      top_offset = padding.top + border.top + focus_width + focus_pad;
+
      if (gtk_widget_get_can_default (GTK_WIDGET (widget)))
-	minimum += default_border.top + default_border.bottom;
-    }  
+	{
+	  minimum += default_border.top + default_border.bottom;
+	  top_offset += default_border.top;
+	}
+    }

  minimum += 2 * (focus_width + focus_pad);
  natural = minimum;
@@ -2108,11 +2139,17 @@ gtk_button_get_size (GtkWidget      *widget,
      gtk_widget_get_visible (child))
    {
      gint child_min, child_nat;
+      gint child_min_baseline = -1, child_nat_baseline = -1;

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
 	gtk_widget_get_preferred_width (child, &child_min, &child_nat);
      else
-	gtk_widget_get_preferred_height (child, &child_min, &child_nat);
+	gtk_widget_get_preferred_height_and_baseline_for_width (child, -1, &child_min, &child_nat, &child_min_baseline, &child_nat_baseline);
+
+      if (minimum_baseline && child_min_baseline >= 0)
+	*minimum_baseline = child_min_baseline + top_offset;
+      if (natural_baseline && child_nat_baseline >= 0)
+	*natural_baseline = child_nat_baseline + top_offset;

      minimum += child_min;
      natural += child_nat;
@@ -2130,7 +2167,7 @@ gtk_button_get_preferred_width (GtkWidget *widget,
                                gint      *minimum_size,
                                gint      *natural_size)
 {
-  gtk_button_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
+  gtk_button_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size, NULL, NULL);
 }

 static void 
@@ -2138,7 +2175,20 @@ gtk_button_get_preferred_height (GtkWidget *widget,
                                 gint      *minimum_size,
                                 gint      *natural_size)
 {
-  gtk_button_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
+  gtk_button_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size, NULL, NULL);
+}
+
+static void
+gtk_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+							gint       width,
+							gint      *minimum_size,
+							gint      *natural_size,
+							gint      *minimum_baseline,
+							gint      *natural_baseline)
+{
+  /* GtkButton is GTK_SIZE_REQUEST_CONSTANT mode, so width will be -1 all the time */
+  g_assert (width == -1);
+  gtk_button_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size, minimum_baseline, natural_baseline);
 }

 /**
@@ -39,6 +39,9 @@ struct _GtkButtonPrivate
  gfloat                 xalign;
  gfloat                 yalign;

+  /* This is only used by checkbox and subclasses */
+  gfloat                 baseline_align;
+
  guint                  activate_timeout;
  guint32                grab_time;

@@ -58,6 +58,12 @@ static void gtk_check_button_get_preferred_width  (GtkWidget          *widget,
 static void gtk_check_button_get_preferred_height (GtkWidget          *widget,
                                                   gint               *minimum,
                                                   gint               *natural);
+static void gtk_check_button_get_preferred_height_and_baseline_for_width (GtkWidget          *widget,
+									  gint                width,
+									  gint               *minimum,
+									  gint               *natural,
+									  gint               *minimum_baseline,
+									  gint               *natural_baseline);
 static void gtk_check_button_size_allocate       (GtkWidget           *widget,
 						  GtkAllocation       *allocation);
 static gboolean gtk_check_button_draw            (GtkWidget           *widget,
@@ -80,6 +86,7 @@ gtk_check_button_class_init (GtkCheckButtonClass *class)

  widget_class->get_preferred_width = gtk_check_button_get_preferred_width;
  widget_class->get_preferred_height = gtk_check_button_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_check_button_get_preferred_height_and_baseline_for_width;
  widget_class->size_allocate = gtk_check_button_size_allocate;
  widget_class->draw = gtk_check_button_draw;

@@ -287,9 +294,12 @@ gtk_check_button_get_preferred_width (GtkWidget *widget,
 }

 static void
-gtk_check_button_get_preferred_height (GtkWidget *widget,
-                                       gint      *minimum,
-                                       gint      *natural)
+gtk_check_button_get_preferred_height_and_baseline_for_width (GtkWidget          *widget,
+							      gint                width,
+							      gint               *minimum,
+							      gint               *natural,
+							      gint               *minimum_baseline,
+							      gint               *natural_baseline)
 {
  GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (widget);

@@ -301,6 +311,7 @@ gtk_check_button_get_preferred_height (GtkWidget *widget,
      gint indicator_spacing;
      gint focus_width;
      gint focus_pad;
+      gint old_minimum, old_natural;
      guint border_width;

      border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
@@ -320,29 +331,61 @@ gtk_check_button_get_preferred_height (GtkWidget *widget,
      if (child && gtk_widget_get_visible (child))
        {
          gint child_min, child_nat;
+	  gint child_min_baseline = -1, child_nat_baseline = -1;

-          gtk_widget_get_preferred_height (child, &child_min, &child_nat);
+          gtk_widget_get_preferred_height_and_baseline_for_width (child, -1,
+								  &child_min, &child_nat,
+								  &child_min_baseline, &child_nat_baseline);
+
+	  if (minimum_baseline && child_min_baseline >= 0)
+	    *minimum_baseline = child_min_baseline + border_width;
+	  if (natural_baseline && child_nat_baseline >= 0)
+	    *natural_baseline = child_nat_baseline + border_width;

          *minimum += child_min;
          *natural += child_nat;
+
        }

+      old_minimum = *minimum;
+      old_natural = *natural;
+
      temp = indicator_size + indicator_spacing * 2;
      *minimum = MAX (*minimum, temp) + 2 * (focus_width + focus_pad);
      *natural = MAX (*natural, temp) + 2 * (focus_width + focus_pad);
+
+      if (minimum_baseline && *minimum_baseline != -1)
+	minimum_baseline += (*minimum - old_minimum) / 2;
+      if (natural_baseline && *natural_baseline != -1)
+	natural_baseline += (*natural - old_natural) / 2;
    }
  else
-    GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_height (widget, minimum, natural);
+    GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_height_and_baseline_for_width (widget, width,
+												   minimum, natural,
+												   minimum_baseline, natural_baseline);
+}
+
+static void
+gtk_check_button_get_preferred_height (GtkWidget *widget,
+                                       gint      *minimum,
+                                       gint      *natural)
+{
+  gtk_check_button_get_preferred_height_and_baseline_for_width (widget, -1,
+								minimum, natural,
+								NULL, NULL);
 }

 static void
 gtk_check_button_size_allocate (GtkWidget     *widget,
 				GtkAllocation *allocation)
 {
+  PangoContext *pango_context;
+  PangoFontMetrics *metrics;
  GtkCheckButton *check_button;
  GtkToggleButton *toggle_button;
  GtkButton *button;
  GtkAllocation child_allocation;
+  gint baseline;

  button = GTK_BUTTON (widget);
  check_button = GTK_CHECK_BUTTON (widget);
@@ -389,8 +432,21 @@ gtk_check_button_size_allocate (GtkWidget     *widget,
 	    child_allocation.x = allocation->x + allocation->width
 	      - (child_allocation.x - allocation->x + child_allocation.width);
 	  
-	  gtk_widget_size_allocate (child, &child_allocation);
+	  baseline = gtk_widget_get_allocated_baseline (widget);
+	  if (baseline != -1)
+	    baseline -= child_allocation.y - allocation->y;
+	  gtk_widget_size_allocate_with_baseline (child, &child_allocation, baseline);
 	}
+
+      pango_context = gtk_widget_get_pango_context (widget);
+      metrics = pango_context_get_metrics (pango_context,
+					   pango_context_get_font_description (pango_context),
+					   pango_context_get_language (pango_context));
+      button->priv->baseline_align =
+	(double)pango_font_metrics_get_ascent (metrics) /
+	(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics));
+      pango_font_metrics_unref (metrics);
+
    }
  else
    GTK_WIDGET_CLASS (gtk_check_button_parent_class)->size_allocate (widget, allocation);
@@ -448,6 +504,7 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button,
  gint indicator_spacing;
  gint focus_width;
  gint focus_pad;
+  gint baseline;
  guint border_width;
  gboolean interior_focus;
  GtkAllocation allocation;
@@ -458,6 +515,7 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button,
  toggle_button = GTK_TOGGLE_BUTTON (check_button);

  gtk_widget_get_allocation (widget, &allocation);
+  baseline = gtk_widget_get_allocated_baseline (widget);
  context = gtk_widget_get_style_context (widget);
  state = gtk_widget_get_state_flags (widget);

@@ -472,7 +530,11 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button,
  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  x = indicator_spacing + border_width;
-  y = (allocation.height - indicator_size) / 2;
+  if (baseline == -1)
+    y = (allocation.height - indicator_size) / 2;
+  else
+    y = CLAMP (baseline - indicator_size * button->priv->baseline_align,
+	       0, allocation.height - indicator_size);

  child = gtk_bin_get_child (GTK_BIN (check_button));
  if (!interior_focus || !(child && gtk_widget_get_visible (child)))
@@ -96,7 +96,6 @@ selected_cb (GtkButton *button,
             GtkDialog *dialog)
 {
  save_color (GTK_COLOR_CHOOSER_DIALOG (dialog));
-  gtk_dialog_response (dialog, GTK_RESPONSE_OK);
 }

 static void
@@ -152,8 +151,7 @@ gtk_color_chooser_dialog_init (GtkColorChooserDialog *cc)
                    G_CALLBACK (selected_cb), dialog);
  gtk_widget_set_can_default (priv->select_button, TRUE);
  gtk_widget_show (priv->select_button);
-  gtk_box_pack_end (GTK_BOX (gtk_dialog_get_action_area (dialog)),
-                    priv->select_button, FALSE, TRUE, 0);
+  gtk_dialog_add_action_widget (dialog, priv->select_button, GTK_RESPONSE_OK);
  gtk_widget_grab_default (priv->select_button);

  gtk_dialog_set_alternative_button_order (dialog,
@@ -483,6 +483,10 @@ swatch_button_press (GtkWidget      *widget,
      g_signal_emit (swatch, signals[ACTIVATE], 0);
      return TRUE;
    }
+  else if (event->button == GDK_BUTTON_PRIMARY)
+    {
+      return TRUE;
+    }

  return FALSE;
 }
@@ -309,12 +309,17 @@ static void     gtk_container_adjust_size_request  (GtkWidget         *widget,
                                                    GtkOrientation     orientation,
                                                    gint              *minimum_size,
                                                    gint              *natural_size);
+static void     gtk_container_adjust_baseline_request (GtkWidget      *widget,
+						       gint           *minimum_baseline,
+						       gint           *natural_baseline);
 static void     gtk_container_adjust_size_allocation (GtkWidget       *widget,
                                                      GtkOrientation   orientation,
                                                      gint            *minimum_size,
                                                      gint            *natural_size,
                                                      gint            *allocated_pos,
                                                      gint            *allocated_size);
+static void     gtk_container_adjust_baseline_allocation (GtkWidget      *widget,
+							  gint           *baseline);
 static GtkSizeRequestMode gtk_container_get_request_mode (GtkWidget   *widget);

 static gchar* gtk_container_child_default_composite_name (GtkContainer *container,
@@ -444,7 +449,9 @@ gtk_container_class_init (GtkContainerClass *class)
  widget_class->focus = gtk_container_focus;

  widget_class->adjust_size_request = gtk_container_adjust_size_request;
+  widget_class->adjust_baseline_request = gtk_container_adjust_baseline_request;
  widget_class->adjust_size_allocation = gtk_container_adjust_size_allocation;
+  widget_class->adjust_baseline_allocation = gtk_container_adjust_baseline_allocation;
  widget_class->get_request_mode = gtk_container_get_request_mode;

  class->add = gtk_container_add_unimplemented;
@@ -1917,6 +1924,28 @@ gtk_container_adjust_size_request (GtkWidget         *widget,
                                     minimum_size, natural_size);
 }

+static void
+gtk_container_adjust_baseline_request (GtkWidget         *widget,
+				       gint              *minimum_baseline,
+				       gint              *natural_baseline)
+{
+  GtkContainer *container;
+
+  container = GTK_CONTAINER (widget);
+
+  if (GTK_CONTAINER_GET_CLASS (widget)->_handle_border_width)
+    {
+      int border_width;
+
+      border_width = container->priv->border_width;
+
+      *minimum_baseline += border_width;
+      *natural_baseline += border_width;
+    }
+
+  parent_class->adjust_baseline_request (widget, minimum_baseline, natural_baseline);
+}
+
 static void
 gtk_container_adjust_size_allocation (GtkWidget         *widget,
                                      GtkOrientation     orientation,
@@ -1952,6 +1981,27 @@ gtk_container_adjust_size_allocation (GtkWidget         *widget,
                                        allocated_size);
 }

+static void
+gtk_container_adjust_baseline_allocation (GtkWidget         *widget,
+					  gint              *baseline)
+{
+  GtkContainer *container;
+  int border_width;
+
+  container = GTK_CONTAINER (widget);
+
+  if (GTK_CONTAINER_GET_CLASS (widget)->_handle_border_width)
+    {
+      border_width = container->priv->border_width;
+
+      if (*baseline >= 0)
+	*baseline -= border_width;
+    }
+
+  parent_class->adjust_baseline_allocation (widget, baseline);
+}
+
+
 typedef struct {
  gint hfw;
  gint wfh;
@@ -47,7 +47,8 @@ typedef enum {
  GTK_DEBUG_PRINTING        = 1 << 10,
  GTK_DEBUG_BUILDER         = 1 << 11,
  GTK_DEBUG_SIZE_REQUEST    = 1 << 12,
-  GTK_DEBUG_NO_CSS_CACHE    = 1 << 13
+  GTK_DEBUG_NO_CSS_CACHE    = 1 << 13,
+  GTK_DEBUG_BASELINES       = 1 << 14
 } GtkDebugFlag;

 #ifdef G_ENABLE_DEBUG
@@ -787,6 +787,7 @@ gtk_dialog_add_button (GtkDialog   *dialog,
  button = gtk_button_new_from_stock (button_text);

  gtk_widget_set_can_default (button, TRUE);
+  gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);

  gtk_widget_show (button);

@@ -185,9 +185,7 @@ typedef gboolean (* GtkDragDestCallback) (GtkWidget      *widget,
 /* Enumeration for some targets we handle internally */

 enum {
-  TARGET_MOTIF_SUCCESS = 0x40000000,
-  TARGET_MOTIF_FAILURE,
-  TARGET_DELETE
+  TARGET_DELETE = 0x40000002
 };

 /* Forward declarations */
@@ -1200,12 +1198,6 @@ gtk_drag_finish (GdkDragContext *context,
    {
      target = gdk_atom_intern_static_string ("DELETE");
    }
-  else if (gdk_drag_context_get_protocol (context) == GDK_DRAG_PROTO_MOTIF)
-    {
-      target = gdk_atom_intern_static_string (success ? 
-					      "XmTRANSFER_SUCCESS" : 
-					      "XmTRANSFER_FAILURE");
-    }

  if (target != GDK_NONE)
    {
@@ -1781,8 +1773,6 @@ _gtk_drag_dest_handle_event (GtkWidget *toplevel,
 	else if (event->type == GDK_DROP_START && !info->proxy_source)
 	  {
 	    gdk_drop_reply (context, found, event->dnd.time);
-            if ((gdk_drag_context_get_protocol (context) == GDK_DRAG_PROTO_MOTIF) && !found)
-	      gtk_drag_finish (context, FALSE, FALSE, event->dnd.time);
 	  }
      }
      break;
@@ -3575,7 +3565,7 @@ _gtk_drag_source_handle_event (GtkWidget *widget,
 		  {
 		    gboolean result = gdk_drag_context_get_selected_action (context) != 0;
 		    
-		    /* Aha - we can finally pass the MOTIF DROP on... */
+		    /* Aha - we can finally pass the DROP on... */
 		    gdk_drop_reply (info->proxy_dest->context, result, info->proxy_dest->proxy_drop_time);
 		    if (result)
 		      gdk_drag_drop (info->context, info->proxy_dest->proxy_drop_time);
@@ -3663,18 +3653,6 @@ gtk_drag_source_check_selection (GtkDragSourceInfo *info,
 				pair->info);
      tmp_list = tmp_list->next;
    }
-  
-  if (gdk_drag_context_get_protocol (info->context) == GDK_DRAG_PROTO_MOTIF)
-    {
-      gtk_selection_add_target (info->ipc_widget,
-				selection,
-				gdk_atom_intern_static_string ("XmTRANSFER_SUCCESS"),
-				TARGET_MOTIF_SUCCESS);
-      gtk_selection_add_target (info->ipc_widget,
-				selection,
-				gdk_atom_intern_static_string ("XmTRANSFER_FAILURE"),
-				TARGET_MOTIF_FAILURE);
-    }

  gtk_selection_add_target (info->ipc_widget,
 			    selection,
@@ -3922,14 +3900,6 @@ gtk_drag_selection_get (GtkWidget        *widget,
 			     info->context);
      gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
      break;
-    case TARGET_MOTIF_SUCCESS:
-      gtk_drag_drop_finished (info, GTK_DRAG_RESULT_SUCCESS, time);
-      gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
-      break;
-    case TARGET_MOTIF_FAILURE:
-      gtk_drag_drop_finished (info, GTK_DRAG_RESULT_NO_TARGET, time);
-      gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
-      break;
    default:
      if (info->proxy_dest)
 	{
@@ -367,6 +367,12 @@ static void   gtk_entry_get_preferred_width  (GtkWidget        *widget,
 static void   gtk_entry_get_preferred_height (GtkWidget        *widget,
                                              gint             *minimum,
                                              gint             *natural);
+static void  gtk_entry_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+                                                                    gint       width,
+                                                                    gint      *minimum_height,
+                                                                    gint      *natural_height,
+                                                                    gint      *minimum_baseline,
+                                                                    gint      *natural_baseline);
 static void   gtk_entry_size_allocate        (GtkWidget        *widget,
 					      GtkAllocation    *allocation);
 static void   gtk_entry_draw_frame           (GtkWidget        *widget,
@@ -682,6 +688,7 @@ gtk_entry_class_init (GtkEntryClass *class)
  widget_class->unrealize = gtk_entry_unrealize;
  widget_class->get_preferred_width = gtk_entry_get_preferred_width;
  widget_class->get_preferred_height = gtk_entry_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_entry_get_preferred_height_and_baseline_for_width;
  widget_class->size_allocate = gtk_entry_size_allocate;
  widget_class->draw = gtk_entry_draw;
  widget_class->enter_notify_event = gtk_entry_enter_notify;
@@ -3305,16 +3312,19 @@ gtk_entry_get_preferred_width (GtkWidget *widget,
 }

 static void
-gtk_entry_get_preferred_height (GtkWidget *widget,
-                                gint      *minimum,
-                                gint      *natural)
+gtk_entry_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+						       gint       width,
+						       gint      *minimum,
+						       gint      *natural,
+						       gint      *minimum_baseline,
+						       gint      *natural_baseline)
 {
  GtkEntry *entry = GTK_ENTRY (widget);
  GtkEntryPrivate *priv = entry->priv;
  PangoFontMetrics *metrics;
  GtkBorder borders;
  PangoContext *context;
-  gint height;
+  gint height, baseline;
  PangoLayout *layout;

  layout = gtk_entry_ensure_layout (entry, TRUE);
@@ -3333,8 +3343,27 @@ gtk_entry_get_preferred_height (GtkWidget *widget,

  height += borders.top + borders.bottom;

+  baseline = pango_layout_get_baseline (layout) / PANGO_SCALE;
+  baseline += borders.top;
+
  *minimum = height;
  *natural = height;
+  if (minimum_baseline)
+    *minimum_baseline = baseline;
+  if (natural_baseline)
+    *natural_baseline = baseline;
+}
+
+static void
+gtk_entry_get_preferred_height (GtkWidget *widget,
+                                gint      *minimum,
+                                gint      *natural)
+{
+  gtk_entry_get_preferred_height_and_baseline_for_width (widget,
+                                                         -1,
+                                                         minimum,
+                                                         natural,
+                                                         NULL, NULL);
 }

 static void
@@ -3452,13 +3481,17 @@ gtk_entry_get_frame_size (GtkEntry *entry,
  GtkAllocation allocation;
  GtkRequisition requisition;
  GtkWidget *widget = GTK_WIDGET (entry);
+  gint area_height, y_pos;
+  gint baseline;
  gint req_height;
+  GtkBorder borders;

  gtk_widget_get_preferred_size (widget, &requisition, NULL);

  req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget);

  gtk_widget_get_allocation (widget, &allocation);
+  baseline = gtk_widget_get_allocated_baseline (widget);

  if (x)
    *x = allocation.x;
@@ -3468,7 +3501,17 @@ gtk_entry_get_frame_size (GtkEntry *entry,
      if (priv->is_cell_renderer)
        *y = 0;
      else
-        *y = (allocation.height - req_height) / 2;
+        {
+          if (baseline == -1)
+            *y = (allocation.height - req_height) / 2;
+          else
+            {
+              _gtk_entry_get_borders (entry, &borders);
+              area_height = req_height - borders.top - borders.bottom;
+              y_pos = ((area_height * PANGO_SCALE - priv->ascent - priv->descent) / 2 + priv->ascent) / PANGO_SCALE;
+              *y = baseline - y_pos - borders.top;
+            }
+        }

      *y += allocation.y;
    }
@@ -51,6 +51,7 @@ G_BEGIN_DECLS
 *     or top
 * @GTK_ALIGN_CENTER: center natural width of widget inside the
 *     allocation
+ * @GTK_ALIGN_BASELINE: align the widget according to the baseline. Since 3.10.
 *
 * Controls how a widget deals with extra space in a single (x or y)
 * dimension.
@@ -64,13 +65,18 @@ G_BEGIN_DECLS
 *
 * Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END
 * are interpreted relative to text direction.
+ *
+ * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
+ * it is only supported for vertical alignment.  When its not supported by
+ * a child or a container it is treated as @GTK_ALIGN_FILL.
 */
 typedef enum
 {
  GTK_ALIGN_FILL,
  GTK_ALIGN_START,
  GTK_ALIGN_END,
-  GTK_ALIGN_CENTER
+  GTK_ALIGN_CENTER,
+  GTK_ALIGN_BASELINE
 } GtkAlign;


@@ -125,6 +131,28 @@ typedef enum
  GTK_FILL   = 1 << 2
 } GtkAttachOptions;

+/**
+ * GtkBaselinePosition:
+ * @GTK_BASELINE_POSITION_TOP: Align the baseline at the top
+ * @GTK_BASELINE_POSITION_CENTER: Center the baseline
+ * @GTK_BASELINE_POSITION_BOTTOM: Align the baseline at the bottom
+ *
+ * Whenever a container has some form of natural row it may align
+ * children in that row along a common typographical baseline. If
+ * the amount of verical space in the row is taller than the total
+ * requested height of the baseline-aligned children then it can use a
+ * #GtkBaselinePosition to select where to put the baseline inside the
+ * extra availible space.
+ *
+ * Since: 3.10
+ */
+typedef enum
+{
+  GTK_BASELINE_POSITION_TOP,
+  GTK_BASELINE_POSITION_CENTER,
+  GTK_BASELINE_POSITION_BOTTOM
+} GtkBaselinePosition;
+
 /**
 * GtkButtonBoxStyle:
 * @GTK_BUTTONBOX_DEFAULT_STYLE: Default packing.
@@ -65,6 +65,12 @@ static void     gtk_event_box_get_preferred_width  (GtkWidget *widget,
 static void     gtk_event_box_get_preferred_height (GtkWidget *widget,
                                                    gint      *minimum,
                                                    gint      *natural);
+static void     gtk_event_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+									   gint       width,
+									   gint      *minimum,
+									   gint      *natural,
+									   gint      *minimum_baseline,
+									   gint      *natural_baseline);
 static void     gtk_event_box_size_allocate (GtkWidget        *widget,
                                             GtkAllocation    *allocation);
 static gboolean gtk_event_box_draw          (GtkWidget        *widget,
@@ -96,6 +102,7 @@ gtk_event_box_class_init (GtkEventBoxClass *class)
  widget_class->unmap = gtk_event_box_unmap;
  widget_class->get_preferred_width = gtk_event_box_get_preferred_width;
  widget_class->get_preferred_height = gtk_event_box_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_event_box_get_preferred_height_and_baseline_for_width;
  widget_class->size_allocate = gtk_event_box_size_allocate;
  widget_class->draw = gtk_event_box_draw;

@@ -515,9 +522,12 @@ gtk_event_box_get_preferred_width (GtkWidget *widget,
 }

 static void
-gtk_event_box_get_preferred_height (GtkWidget *widget,
-                                    gint      *minimum,
-                                    gint      *natural)
+gtk_event_box_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+							   gint       width,
+							   gint      *minimum,
+							   gint      *natural,
+							   gint      *minimum_baseline,
+							   gint      *natural_baseline)
 {
  GtkBin *bin = GTK_BIN (widget);
  GtkWidget *child;
@@ -528,9 +538,30 @@ gtk_event_box_get_preferred_height (GtkWidget *widget,
  if (natural)
    *natural = 0;

+  if (minimum_baseline)
+    *minimum_baseline = -1;
+
+  if (natural_baseline)
+    *natural_baseline = -1;
+
  child = gtk_bin_get_child (bin);
  if (child && gtk_widget_get_visible (child))
-    gtk_widget_get_preferred_height (child, minimum, natural);
+    gtk_widget_get_preferred_height_and_baseline_for_width (child,
+							    -1,
+							    minimum,
+							    natural,
+							    minimum_baseline,
+							    natural_baseline);
+}
+
+static void
+gtk_event_box_get_preferred_height (GtkWidget *widget,
+                                    gint      *minimum,
+                                    gint      *natural)
+{
+  gtk_event_box_get_preferred_height_and_baseline_for_width (widget, -1,
+							     minimum, natural,
+							     NULL, NULL);
 }

 static void
@@ -539,6 +570,7 @@ gtk_event_box_size_allocate (GtkWidget     *widget,
 {
  GtkBin *bin;
  GtkAllocation child_allocation;
+  gint baseline;
  GtkEventBoxPrivate *priv;
  GtkWidget *child;

@@ -578,9 +610,10 @@ gtk_event_box_size_allocate (GtkWidget     *widget,
                                child_allocation.height);
    }

+  baseline = gtk_widget_get_allocated_baseline (widget);
  child = gtk_bin_get_child (bin);
  if (child)
-    gtk_widget_size_allocate (child, &child_allocation);
+    gtk_widget_size_allocate_with_baseline (child, &child_allocation, baseline);
 }

 static gboolean
@@ -555,7 +555,7 @@ gtk_font_button_init (GtkFontButton *font_button)
  font_button->priv->use_size = FALSE;
  font_button->priv->show_style = TRUE;
  font_button->priv->show_size = TRUE;
-  font_button->priv->show_preview_entry = FALSE;
+  font_button->priv->show_preview_entry = TRUE;
  font_button->priv->font_dialog = NULL;
  font_button->priv->font_family = NULL;
  font_button->priv->font_face = NULL;
@@ -107,11 +107,11 @@ gtk_font_chooser_default_init (GtkFontChooserInterface *iface)
                          GTK_PARAM_READWRITE));

  /**
-   * GtkFontChooserWidget::font-activated:
+   * GtkFontChooser::font-activated:
   * @self: the object which received the signal
   * @fontname: the font name
   *
-   * Emitted when a font is activated from the widget's list.
+   * Emitted when a font is activated.
   * This usually happens when the user double clicks an item,
   * or an item is selected and the user presses one of the keys
   * Space, Shift+Space, Return or Enter.
@@ -87,6 +87,12 @@ void       gtk_grid_insert_row             (GtkGrid         *grid,
 GDK_AVAILABLE_IN_3_2
 void       gtk_grid_insert_column          (GtkGrid         *grid,
                                            gint             position);
+GDK_AVAILABLE_IN_3_10
+void       gtk_grid_remove_row             (GtkGrid         *grid,
+                                            gint             position);
+GDK_AVAILABLE_IN_3_10
+void       gtk_grid_remove_column          (GtkGrid         *grid,
+                                            gint             position);
 GDK_AVAILABLE_IN_3_2
 void       gtk_grid_insert_next_to         (GtkGrid         *grid,
                                            GtkWidget       *sibling,
@@ -103,6 +109,18 @@ gboolean   gtk_grid_get_column_homogeneous (GtkGrid         *grid);
 void       gtk_grid_set_column_spacing     (GtkGrid         *grid,
                                            guint            spacing);
 guint      gtk_grid_get_column_spacing     (GtkGrid         *grid);
+GDK_AVAILABLE_IN_3_10
+void       gtk_grid_set_row_baseline_position (GtkGrid      *grid,
+					       gint          row,
+					       GtkBaselinePosition pos);
+GDK_AVAILABLE_IN_3_10
+GtkBaselinePosition gtk_grid_get_row_baseline_position (GtkGrid      *grid,
+							gint          row);
+GDK_AVAILABLE_IN_3_10
+void       gtk_grid_set_baseline_row       (GtkGrid         *grid,
+					    gint             row);
+GDK_AVAILABLE_IN_3_10
+gint       gtk_grid_get_baseline_row       (GtkGrid         *grid);


 G_END_DECLS
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2013 Red Hat, Inc.
+ *
+ * This program 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 program 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 program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __GTK_HEADER_BAR_H__
+#define __GTK_HEADER_BAR_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkcontainer.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_HEADER_BAR            (gtk_header_bar_get_type ())
+#define GTK_HEADER_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HEADER_BAR, GtkHeaderBar))
+#define GTK_HEADER_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HEADER_BAR, GtkHeaderBarClass))
+#define GTK_IS_HEADER_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HEADER_BAR))
+#define GTK_IS_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HEADER_BAR))
+#define GTK_HEADER_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HEADER_BAR, GtkHeaderBarClass))
+
+typedef struct _GtkHeaderBar              GtkHeaderBar;
+typedef struct _GtkHeaderBarPrivate       GtkHeaderBarPrivate;
+typedef struct _GtkHeaderBarClass         GtkHeaderBarClass;
+
+struct _GtkHeaderBar
+{
+  GtkContainer container;
+
+  /*< private >*/
+  GtkHeaderBarPrivate *priv;
+};
+
+struct _GtkHeaderBarClass
+{
+  GtkContainerClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GDK_AVAILABLE_IN_3_10
+GType        gtk_header_bar_get_type          (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_3_10
+GtkWidget   *gtk_header_bar_new               (void);
+GDK_AVAILABLE_IN_3_10
+void         gtk_header_bar_set_title         (GtkHeaderBar *bar,
+                                               const gchar  *title);
+GDK_AVAILABLE_IN_3_10
+const gchar *gtk_header_bar_get_title         (GtkHeaderBar *bar);
+GDK_AVAILABLE_IN_3_10
+void         gtk_header_bar_set_subtitle      (GtkHeaderBar *bar,
+                                               const gchar  *subtitle);
+GDK_AVAILABLE_IN_3_10
+const gchar *gtk_header_bar_get_subtitle      (GtkHeaderBar *bar);
+
+
+GDK_AVAILABLE_IN_3_10
+void         gtk_header_bar_set_custom_title  (GtkHeaderBar *bar,
+                                               GtkWidget    *title_widget);
+GDK_AVAILABLE_IN_3_10
+GtkWidget   *gtk_header_bar_get_custom_title  (GtkHeaderBar *bar);
+GDK_AVAILABLE_IN_3_10
+void         gtk_header_bar_pack_start        (GtkHeaderBar *bar,
+                                               GtkWidget    *child);
+GDK_AVAILABLE_IN_3_10
+void         gtk_header_bar_pack_end          (GtkHeaderBar *bar,
+                                               GtkWidget    *child);
+
+G_END_DECLS
+
+#endif /* __GTK_HEADER_BAR_H__ */
@@ -140,6 +140,8 @@ struct _GtkImagePrivate

  gchar                *filename;       /* Only used with GTK_IMAGE_ANIMATION, GTK_IMAGE_PIXBUF */
  gchar                *resource_path;  /* Only used with GTK_IMAGE_PIXBUF */
+
+  float baseline_align;
 };


@@ -154,6 +156,12 @@ static void gtk_image_get_preferred_width  (GtkWidget    *widget,
 static void gtk_image_get_preferred_height (GtkWidget    *widget,
                                            gint         *minimum,
                                            gint         *natural);
+static void gtk_image_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+								   gint       width,
+								   gint      *minimum,
+								   gint      *natural,
+								   gint      *minimum_baseline,
+								   gint      *natural_baseline);

 static void gtk_image_style_updated        (GtkWidget    *widget);
 static void gtk_image_screen_changed       (GtkWidget    *widget,
@@ -207,6 +215,7 @@ gtk_image_class_init (GtkImageClass *class)
  widget_class->draw = gtk_image_draw;
  widget_class->get_preferred_width = gtk_image_get_preferred_width;
  widget_class->get_preferred_height = gtk_image_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_image_get_preferred_height_and_baseline_for_width;
  widget_class->unmap = gtk_image_unmap;
  widget_class->unrealize = gtk_image_unrealize;
  widget_class->style_updated = gtk_image_style_updated;
@@ -1393,6 +1402,26 @@ gtk_image_get_preferred_size (GtkImage *image,
    *height_out = height;
 }

+static float
+gtk_image_get_baseline_align (GtkImage *image)
+{
+  PangoContext *pango_context;
+  PangoFontMetrics *metrics;
+
+  if (image->priv->baseline_align == 0.0)
+    {
+      pango_context = gtk_widget_get_pango_context (GTK_WIDGET (image));
+      metrics = pango_context_get_metrics (pango_context,
+					   pango_context_get_font_description (pango_context),
+					   pango_context_get_language (pango_context));
+      image->priv->baseline_align =
+	(float)pango_font_metrics_get_ascent (metrics) /
+	(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics));
+    }
+
+  return image->priv->baseline_align;
+}
+
 static gint
 gtk_image_draw (GtkWidget *widget,
                cairo_t   *cr)
@@ -1401,7 +1430,7 @@ gtk_image_draw (GtkWidget *widget,
  GtkImagePrivate *priv;
  GtkMisc *misc;
  GtkStyleContext *context;
-  gint x, y, width, height;
+  gint x, y, width, height, baseline;
  gfloat xalign, yalign;
  GtkBorder border;

@@ -1427,8 +1456,14 @@ gtk_image_draw (GtkWidget *widget,
  if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)
    xalign = 1.0 - xalign;

+  baseline = gtk_widget_get_allocated_baseline (widget);
+
  x = floor ((gtk_widget_get_allocated_width (widget) - width) * xalign) + border.left;
-  y = floor ((gtk_widget_get_allocated_height (widget) - height) * yalign) + border.top;
+  if (baseline == -1)
+    y = floor ((gtk_widget_get_allocated_height (widget) - height) * yalign) + border.top;
+  else
+    y = CLAMP (baseline - height * gtk_image_get_baseline_align (image),
+	       border.top, gtk_widget_get_allocated_height (widget) - height);

  if (gtk_image_get_storage_type (image) == GTK_IMAGE_ANIMATION)
    {
@@ -1535,15 +1570,37 @@ gtk_image_get_preferred_width (GtkWidget *widget,
  *minimum = *natural = width;
 } 

+static void
+gtk_image_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+						       gint       width,
+						       gint      *minimum,
+						       gint      *natural,
+						       gint      *minimum_baseline,
+						       gint      *natural_baseline)
+{
+  gint height;
+  float baseline_align;
+
+  gtk_image_get_preferred_size (GTK_IMAGE (widget), NULL, &height);
+  *minimum = *natural = height;
+
+  if (minimum_baseline || natural_baseline)
+    {
+      baseline_align = gtk_image_get_baseline_align (GTK_IMAGE (widget));
+      if (minimum_baseline)
+	*minimum_baseline = height * baseline_align;
+      if (natural_baseline)
+	*natural_baseline = height * baseline_align;
+    }
+}
+
 static void
 gtk_image_get_preferred_height (GtkWidget *widget,
                                gint      *minimum,
                                gint      *natural)
 {
-  gint height;
-
-  gtk_image_get_preferred_size (GTK_IMAGE (widget), NULL, &height);
-  *minimum = *natural = height;
+  gtk_image_get_preferred_height_and_baseline_for_width (widget, -1, minimum, natural,
+							 NULL, NULL);
 }

 static void
@@ -1558,9 +1615,13 @@ icon_theme_changed (GtkImage *image)
 static void
 gtk_image_style_updated (GtkWidget *widget)
 {
+  GtkImage *image = GTK_IMAGE (widget);
+  GtkImagePrivate *priv = image->priv;
+
  GTK_WIDGET_CLASS (gtk_image_parent_class)->style_updated (widget);

-  icon_theme_changed (GTK_IMAGE (widget));
+  icon_theme_changed (image);
+  priv->baseline_align = 0.0;
 }

 static void
@@ -52,7 +52,7 @@
 #include "gtktypebuiltins.h"
 #include "gtkmain.h"

-#include "a11y/gtklabelaccessible.h"
+#include "a11y/gtklabelaccessibleprivate.h"

 /* this is in case rint() is not provided by the compiler, 
 * such as in the case of C89 compilers, like MSVC
@@ -519,6 +519,12 @@ static void               gtk_label_get_preferred_height_for_width  (GtkWidget
                                                                     gint                 width,
                                                                     gint                *minimum_height,
                                                                     gint                *natural_height);
+static void    gtk_label_get_preferred_height_and_baseline_for_width (GtkWidget          *widget,
+								      gint                width,
+								      gint               *minimum_height,
+								      gint               *natural_height,
+								      gint               *minimum_baseline,
+								      gint               *natural_baseline);

 static GtkBuildableIface *buildable_parent_iface = NULL;

@@ -585,6 +591,7 @@ gtk_label_class_init (GtkLabelClass *class)
  widget_class->get_preferred_height = gtk_label_get_preferred_height;
  widget_class->get_preferred_width_for_height = gtk_label_get_preferred_width_for_height;
  widget_class->get_preferred_height_for_width = gtk_label_get_preferred_height_for_width;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_label_get_preferred_height_and_baseline_for_width;

  class->move_cursor = gtk_label_move_cursor;
  class->copy_clipboard = gtk_label_copy_clipboard;
@@ -1987,9 +1994,12 @@ gtk_label_set_text_internal (GtkLabel *label,
      return;
    }

+  _gtk_label_accessible_text_deleted (label);
  g_free (priv->text);
  priv->text = str;

+  _gtk_label_accessible_text_inserted (label);
+
  gtk_label_select_region_index (label, 0, 0);
 }

@@ -2514,10 +2524,11 @@ gtk_label_set_markup_internal (GtkLabel    *label,
  GError *error = NULL;
  PangoAttrList *attrs = NULL;
  gunichar accel_char = 0;
-  gchar *new_str;
+  gchar *str_for_display = NULL;
+  gchar *str_for_accel = NULL;
  GList *links = NULL;

-  if (!parse_uri_markup (label, str, &new_str, &links, &error))
+  if (!parse_uri_markup (label, str, &str_for_display, &links, &error))
    {
      g_warning ("Failed to set text from markup due to error parsing markup: %s",
                 error->message);
@@ -2525,6 +2536,8 @@ gtk_label_set_markup_internal (GtkLabel    *label,
      return;
    }

+  str_for_accel = g_strdup (str_for_display);
+
  if (links)
    {
      gtk_label_ensure_select_info (label);
@@ -2552,31 +2565,51 @@ gtk_label_set_markup_internal (GtkLabel    *label,
          gchar *pattern;
          guint key;

-          if (separate_uline_pattern (new_str, &key, &tmp, &pattern))
+          if (separate_uline_pattern (str_for_display, &key, &tmp, &pattern))
            {
-              g_free (new_str);
-              new_str = tmp;
+              g_free (str_for_display);
+              str_for_display = tmp;
              g_free (pattern);
            }
        }
    }

-  if (!pango_parse_markup (new_str,
+  /* Extract the text to display */
+  if (!pango_parse_markup (str_for_display,
                           -1,
                           with_uline ? '_' : 0,
                           &attrs,
                           &text,
-                           with_uline ? &accel_char : NULL,
+                           NULL,
                           &error))
    {
      g_warning ("Failed to set text from markup due to error parsing markup: %s",
                 error->message);
-      g_free (new_str);
+      g_free (str_for_display);
+      g_free (str_for_accel);
      g_error_free (error);
      return;
    }

-  g_free (new_str);
+  /* Extract the accelerator character */
+  if (with_uline && !pango_parse_markup (str_for_accel,
+					 -1,
+					 '_',
+					 NULL,
+					 NULL,
+					 &accel_char,
+					 &error))
+    {
+      g_warning ("Failed to set text from markup due to error parsing markup: %s",
+                 error->message);
+      g_free (str_for_display);
+      g_free (str_for_accel);
+      g_error_free (error);
+      return;
+    }
+
+  g_free (str_for_display);
+  g_free (str_for_accel);

  if (text)
    gtk_label_set_text_internal (label, text);
@@ -3436,15 +3469,18 @@ gtk_label_get_request_mode (GtkWidget *widget)
    return GTK_SIZE_REQUEST_CONSTANT_SIZE;
 }

+
 static void
 get_size_for_allocation (GtkLabel        *label,
                         GtkOrientation   orientation,
                         gint             allocation,
                         gint            *minimum_size,
-                         gint            *natural_size)
+                         gint            *natural_size,
+			 gint            *minimum_baseline,
+                         gint            *natural_baseline)
 {
  PangoLayout *layout;
-  gint text_height;
+  gint text_height, baseline;

  layout = gtk_label_get_measuring_layout (label, NULL, allocation * PANGO_SCALE);

@@ -3456,6 +3492,16 @@ get_size_for_allocation (GtkLabel        *label,
  if (natural_size)
    *natural_size = text_height;

+  if (minimum_baseline || natural_baseline)
+    {
+      baseline = pango_layout_get_baseline (layout) / PANGO_SCALE;
+      if (minimum_baseline)
+	*minimum_baseline = baseline;
+
+      if (natural_baseline)
+	*natural_baseline = baseline;
+    }
+
  g_object_unref (layout);
 }

@@ -3552,7 +3598,9 @@ static void
 gtk_label_get_preferred_size (GtkWidget      *widget,
                              GtkOrientation  orientation,
                              gint           *minimum_size,
-                              gint           *natural_size)
+                              gint           *natural_size,
+			      gint           *minimum_baseline,
+			      gint           *natural_baseline)
 {
  GtkLabel      *label = GTK_LABEL (widget);
  GtkLabelPrivate  *priv = label->priv;
@@ -3560,6 +3608,12 @@ gtk_label_get_preferred_size (GtkWidget      *widget,
  PangoRectangle smallest_rect;
  GtkBorder border;

+  if (minimum_baseline)
+    *minimum_baseline = -1;
+
+  if (natural_baseline)
+    *natural_baseline = -1;
+
  gtk_label_get_preferred_layout_size (label, &smallest_rect, &widest_rect);

  /* Now that we have minimum and natural sizes in pango extents, apply a possible transform */
@@ -3614,7 +3668,8 @@ gtk_label_get_preferred_size (GtkWidget      *widget,
          get_size_for_allocation (label,
                                   GTK_ORIENTATION_VERTICAL,
                                   smallest_rect.height,
-                                   minimum_size, natural_size);
+                                   minimum_size, natural_size,
+				   NULL, NULL);

        }
      else
@@ -3641,7 +3696,16 @@ gtk_label_get_preferred_size (GtkWidget      *widget,
          get_size_for_allocation (label,
                                   GTK_ORIENTATION_HORIZONTAL,
                                   widest_rect.width,
-                                   minimum_size, natural_size);
+                                   minimum_size, natural_size,
+				   minimum_baseline, natural_baseline);
+
+	  if (priv->angle == 180)
+	    {
+	      if (minimum_baseline)
+		*minimum_baseline = *minimum_size - *minimum_baseline;
+	      if (natural_baseline)
+		*natural_baseline = *natural_size - *natural_baseline;
+	    }
        }
      else
        {
@@ -3654,6 +3718,12 @@ gtk_label_get_preferred_size (GtkWidget      *widget,

      *minimum_size += border.top + border.bottom;
      *natural_size += border.top + border.bottom;
+
+      if (minimum_baseline && *minimum_baseline != -1)
+	*minimum_baseline += border.top;
+
+      if (natural_baseline && *natural_baseline != -1)
+	*natural_baseline += border.top;
    }
 }

@@ -3662,7 +3732,7 @@ gtk_label_get_preferred_width (GtkWidget *widget,
                               gint      *minimum_size,
                               gint      *natural_size)
 {
-  gtk_label_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
+  gtk_label_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size, NULL, NULL);
 }

 static void
@@ -3670,7 +3740,7 @@ gtk_label_get_preferred_height (GtkWidget *widget,
                                gint      *minimum_size,
                                gint      *natural_size)
 {
-  gtk_label_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
+  gtk_label_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size, NULL, NULL);
 }

 static void
@@ -3693,7 +3763,8 @@ gtk_label_get_preferred_width_for_height (GtkWidget *widget,

      get_size_for_allocation (label, GTK_ORIENTATION_VERTICAL,
                               MAX (1, height - border.top - border.bottom),
-                               minimum_width, natural_width);
+                               minimum_width, natural_width,
+			       NULL, NULL);

      if (minimum_width)
        *minimum_width += border.right + border.left;
@@ -3706,15 +3777,17 @@ gtk_label_get_preferred_width_for_height (GtkWidget *widget,
 }

 static void
-gtk_label_get_preferred_height_for_width (GtkWidget *widget,
-                                          gint       width,
-                                          gint      *minimum_height,
-                                          gint      *natural_height)
+gtk_label_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+						       gint       width,
+						       gint      *minimum_height,
+						       gint      *natural_height,
+						       gint      *minimum_baseline,
+						       gint      *natural_baseline)
 {
  GtkLabel *label = GTK_LABEL (widget);
  GtkLabelPrivate *priv = label->priv;

-  if (priv->wrap && (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
+  if (width != -1 && priv->wrap && (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
    {
      GtkBorder border;

@@ -3725,7 +3798,13 @@ gtk_label_get_preferred_height_for_width (GtkWidget *widget,

      get_size_for_allocation (label, GTK_ORIENTATION_HORIZONTAL,
                               MAX (1, width - border.left - border.right),
-                               minimum_height, natural_height);
+                               minimum_height, natural_height,
+			       minimum_baseline, natural_baseline);
+
+      if (minimum_baseline && *minimum_baseline != -1)
+	*minimum_baseline += border.top;
+      if (natural_baseline && *natural_baseline != -1)
+	*natural_baseline += border.top;

      if (minimum_height)
        *minimum_height += border.top + border.bottom;
@@ -3734,7 +3813,18 @@ gtk_label_get_preferred_height_for_width (GtkWidget *widget,
        *natural_height += border.top + border.bottom;
    }
  else
-    GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
+    gtk_label_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_height, natural_height, minimum_baseline, natural_baseline);
+}
+
+static void
+gtk_label_get_preferred_height_for_width (GtkWidget *widget,
+                                          gint       width,
+                                          gint      *minimum_height,
+                                          gint      *natural_height)
+{
+  return gtk_label_get_preferred_height_and_baseline_for_width (widget, width,
+								minimum_height, natural_height,
+								NULL, NULL);
 }

 static void
@@ -3829,6 +3919,7 @@ get_layout_location (GtkLabel  *label,
  gint req_height;
  gfloat xalign, yalign;
  PangoRectangle logical;
+  gint baseline, layout_baseline, baseline_offset;

  misc   = GTK_MISC (label);
  widget = GTK_WIDGET (label);
@@ -3861,6 +3952,15 @@ get_layout_location (GtkLabel  *label,

  x = floor (allocation.x + border.left + xalign * (allocation.width - req_width) - logical.x);

+  baseline_offset = 0;
+  baseline = gtk_widget_get_allocated_baseline (widget);
+  if (baseline != -1 && !priv->have_transform)
+    {
+      layout_baseline = pango_layout_get_baseline (priv->layout) / PANGO_SCALE;
+      baseline_offset = baseline - layout_baseline;
+      yalign = 0.0; /* Can't support yalign while baseline aligning */
+    }
+
  /* bgo#315462 - For single-line labels, *do* align the requisition with
   * respect to the allocation, even if we are under-allocated.  For multi-line
   * labels, always show the top of the text when they are under-allocated.  The
@@ -3875,9 +3975,9 @@ get_layout_location (GtkLabel  *label,
   *   middle".  You want to read the first line, at least, to get some context.
   */
  if (pango_layout_get_line_count (priv->layout) == 1)
-    y = floor (allocation.y + border.top + (allocation.height - req_height) * yalign) - logical.y;
+    y = floor (allocation.y + border.top + (allocation.height - req_height) * yalign) - logical.y + baseline_offset;
  else
-    y = floor (allocation.y + border.top + MAX ((allocation.height - req_height) * yalign, 0)) - logical.y;
+    y = floor (allocation.y + border.top + MAX ((allocation.height - req_height) * yalign, 0)) - logical.y + baseline_offset;

  if (xp)
    *xp = x;
@@ -4571,6 +4671,8 @@ gtk_label_button_press (GtkWidget      *widget,
        {
          info->link_clicked = 1;
          gtk_widget_queue_draw (widget);
+          if (!info->selectable)
+            return TRUE;
        }
    }

@@ -172,7 +172,8 @@ static const GDebugKey gtk_debug_keys[] = {
  {"printing", GTK_DEBUG_PRINTING},
  {"builder", GTK_DEBUG_BUILDER},
  {"size-request", GTK_DEBUG_SIZE_REQUEST},
-  {"no-css-cache", GTK_DEBUG_NO_CSS_CACHE}
+  {"no-css-cache", GTK_DEBUG_NO_CSS_CACHE},
+  {"baselines", GTK_DEBUG_BASELINES}
 };
 #endif /* G_ENABLE_DEBUG */

@@ -849,7 +850,7 @@ gtk_get_option_group (gboolean open_default_display)
 * @argv: (array length=argc) (inout) (allow-none): Address of the
 *     <parameter>argv</parameter> parameter of main(), or %NULL. Any options
 *     understood by GTK+ are stripped before return.
- * @parameter_string: a string which is displayed in
+ * @parameter_string: (allow-none): a string which is displayed in
 *    the first line of <option>--help</option> output, after
 *    <literal><replaceable>programname</replaceable> [OPTION...]</literal>
 * @entries: (array zero-terminated=1): a %NULL-terminated array
@@ -517,8 +517,8 @@ display_opened_cb (GdkDisplayManager *display_manager,
 }

 void
-_gtk_modules_init (gint        *argc, 
-		   gchar     ***argv, 
+_gtk_modules_init (gint        *argc,
+		   gchar     ***argv,
 		   const gchar *gtk_modules_args)
 {
  GdkDisplayManager *display_manager;
@@ -526,7 +526,7 @@ _gtk_modules_init (gint        *argc,

  g_assert (gtk_argv == NULL);

-  if (argc && argv) 
+  if (argc && argv)
    {
      /* store argc and argv for later use in mod initialization */
      gtk_argc = *argc;
@@ -536,22 +536,26 @@ _gtk_modules_init (gint        *argc,
      gtk_argv [*argc] = NULL;
    }

-  display_manager = gdk_display_manager_get ();
-  default_display_opened = gdk_display_get_default () != NULL;
-  g_signal_connect (display_manager, "notify::default-display",
-		    G_CALLBACK (default_display_notify_cb), 
-		    NULL);
-  g_signal_connect (display_manager, "display-opened",
-		    G_CALLBACK (display_opened_cb), 
-		    NULL);
+  display_manager = gdk_display_manager_peek ();
+  if (display_manager != NULL)
+    {
+      default_display_opened = gdk_display_get_default () != NULL;
+      g_signal_connect (display_manager, "notify::default-display",
+                        G_CALLBACK (default_display_notify_cb),
+                        NULL);
+      g_signal_connect (display_manager, "display-opened",
+                        G_CALLBACK (display_opened_cb),
+                        NULL);
+    }

-  if (gtk_modules_args) {
-    /* Modules specified in the GTK_MODULES environment variable
-     * or on the command line are always loaded, so we'll just leak 
-     * the refcounts.
-     */
-    g_slist_free (load_modules (gtk_modules_args));
-  }
+  if (gtk_modules_args)
+    {
+      /* Modules specified in the GTK_MODULES environment variable
+       * or on the command line are always loaded, so we'll just leak
+       * the refcounts.
+       */
+      g_slist_free (load_modules (gtk_modules_args));
+    }
 }

 static void
@@ -903,6 +903,7 @@ gtk_radio_button_draw_indicator (GtkCheckButton *check_button,
  gint indicator_size, indicator_spacing;
  gint focus_width;
  gint focus_pad;
+  gint baseline;
  guint border_width;
  gboolean interior_focus;

@@ -923,9 +924,14 @@ gtk_radio_button_draw_indicator (GtkCheckButton *check_button,
  _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing);

  gtk_widget_get_allocation (widget, &allocation);
+  baseline = gtk_widget_get_allocated_baseline (widget);

  x = indicator_spacing + border_width;
-  y = (allocation.height - indicator_size) / 2;
+  if (baseline == -1)
+    y = (allocation.height - indicator_size) / 2;
+  else
+    y = CLAMP (baseline - indicator_size * button->priv->baseline_align,
+	       0, allocation.height - indicator_size);

  child = gtk_bin_get_child (GTK_BIN (check_button));
  if (!interior_focus || !(child && gtk_widget_get_visible (child)))
@@ -167,17 +167,10 @@ gtk_separator_get_preferred_size (GtkWidget      *widget,
 {
  GtkSeparator *separator = GTK_SEPARATOR (widget);
  GtkSeparatorPrivate *private = separator->priv;
-  GtkStyleContext *context;
-  GtkStateFlags state;
-  GtkBorder border;
  gboolean wide_sep;
  gint     sep_width;
  gint     sep_height;

-  context = gtk_widget_get_style_context (widget);
-  state = gtk_widget_get_state_flags (widget);
-  gtk_style_context_get_border (context, state, &border);
-
  gtk_widget_style_get (widget,
                        "wide-separators",  &wide_sep,
                        "separator-width",  &sep_width,
@@ -190,11 +183,11 @@ gtk_separator_get_preferred_size (GtkWidget      *widget,
    }
  else if (orientation == GTK_ORIENTATION_VERTICAL)
    {
-      *minimum = *natural = wide_sep ? sep_height : border.top;
+      *minimum = *natural = wide_sep ? sep_height : 1;
    }
  else
    {
-      *minimum = *natural = wide_sep ? sep_width : border.left;
+      *minimum = *natural = wide_sep ? sep_width : 1;
    }
 }

@@ -220,27 +213,22 @@ gtk_separator_draw (GtkWidget *widget,
 {
  GtkSeparator *separator = GTK_SEPARATOR (widget);
  GtkSeparatorPrivate *private = separator->priv;
-  GtkStateFlags state;
  GtkStyleContext *context;
-  GtkBorder padding;
  gboolean wide_separators;
  gint separator_width;
  gint separator_height;
  int width, height;

-  context = gtk_widget_get_style_context (widget);
  gtk_widget_style_get (widget,
                        "wide-separators",  &wide_separators,
                        "separator-width",  &separator_width,
                        "separator-height", &separator_height,
                        NULL);

-  state = gtk_widget_get_state_flags (widget);
+  context = gtk_widget_get_style_context (widget);
  width = gtk_widget_get_allocated_width (widget);
  height = gtk_widget_get_allocated_height (widget);

-  gtk_style_context_get_padding (context, state, &padding);
-
  if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      if (wide_separators)
@@ -249,8 +237,8 @@ gtk_separator_draw (GtkWidget *widget,
                          width, separator_height);
      else
        gtk_render_line (context, cr,
-                         0, (height - padding.top) / 2,
-                         width - 1, (height - padding.top) / 2);
+                         0, height / 2,
+                         width - 1, height / 2);
    }
  else
    {
@@ -260,8 +248,8 @@ gtk_separator_draw (GtkWidget *widget,
                          separator_width, height);
      else
        gtk_render_line (context, cr,
-                         (width - padding.left) / 2, 0,
-                         (width - padding.left) / 2, height - 1);
+                         width / 2, 0,
+                         width / 2, height - 1);
    }

  return FALSE;
@@ -40,6 +40,10 @@
 #include <pango/pangofc-fontmap.h>
 #endif

+#ifdef GDK_WINDOWING_WAYLAND
+#include "wayland/gdkwayland.h"
+#endif
+
 #ifdef GDK_WINDOWING_QUARTZ
 #include "quartz/gdkquartz.h"
 #endif
@@ -2552,23 +2556,27 @@ settings_update_modules (GtkSettings *settings)
 static void
 settings_update_cursor_theme (GtkSettings *settings)
 {
-#ifdef GDK_WINDOWING_X11
-  GdkDisplay *display = gdk_screen_get_display (settings->priv->screen);
  gchar *theme = NULL;
  gint size = 0;
+  GdkDisplay *display = gdk_screen_get_display (settings->priv->screen);

+  g_object_get (settings,
+                "gtk-cursor-theme-name", &theme,
+                "gtk-cursor-theme-size", &size,
+                NULL);
+
+#ifdef GDK_WINDOWING_X11
  if (GDK_IS_X11_DISPLAY (display))
-    {
-      g_object_get (settings,
-                    "gtk-cursor-theme-name", &theme,
-                    "gtk-cursor-theme-size", &size,
-                    NULL);
-
-      gdk_x11_display_set_cursor_theme (display, theme, size);
-
-      g_free (theme);
-    }
+    gdk_x11_display_set_cursor_theme (display, theme, size);
+  else
 #endif
+#ifdef GDK_WINDOWING_WAYLAND
+  if (GDK_IS_WAYLAND_DISPLAY (display))
+    gdk_wayland_display_set_cursor_theme (display, theme, size);
+  else
+#endif
+    g_warning ("unsupported GDK backend\n");
+  g_free (theme);
 }

 static void
@@ -93,16 +93,61 @@ get_vfunc_name (GtkOrientation orientation,
    return for_size < 0 ? "get_preferred_height" : "get_preferred_height_for_width";
 }

+static gboolean
+widget_class_has_baseline_support (GtkWidgetClass *widget_class)
+{
+  GtkWidgetClass *parent_class;
+
+  if (widget_class->get_preferred_height_and_baseline_for_width == NULL)
+    return FALSE;
+
+  /* This is kinda hacky, but for backwards compatibility reasons we have to handle the case
+     where a class previously did not support get_preferred_height_and_baseline_for_width,
+     but then gained support for it, and a subclass of it overrides the previous non-baseline
+     methods. If this happens we need to call the overridden (non-baseline supporting) versions
+     on the subclass, rather than the inherited but not overriddent new get_preferred_height_and_baseline_for_width.
+  */
+
+  /* Loop over all parent classes that inherit the same get_preferred_height_and_baseline_for_width */
+  parent_class = g_type_class_peek_parent (widget_class);
+  while (parent_class != NULL &&
+	 parent_class->get_preferred_height_and_baseline_for_width == widget_class->get_preferred_height_and_baseline_for_width)
+    {
+      if (parent_class->get_preferred_height != widget_class->get_preferred_height ||
+	  parent_class->get_preferred_height_for_width != widget_class->get_preferred_height_for_width)
+	return FALSE;
+
+	parent_class = g_type_class_peek_parent (parent_class);
+    }
+
+  return TRUE;
+}
+
+gboolean
+_gtk_widget_has_baseline_support (GtkWidget *widget)
+{
+  GtkWidgetClass *widget_class;
+
+  widget_class = GTK_WIDGET_GET_CLASS (widget);
+
+  return widget_class_has_baseline_support (widget_class);
+}
+
 static void
 gtk_widget_query_size_for_orientation (GtkWidget        *widget,
                                       GtkOrientation    orientation,
                                       gint              for_size,
                                       gint             *minimum_size,
-                                       gint             *natural_size)
+                                       gint             *natural_size,
+                                       gint             *minimum_baseline,
+                                       gint             *natural_baseline)
 {
  SizeRequestCache *cache;
+  GtkWidgetClass *widget_class;
  gint min_size = 0;
  gint nat_size = 0;
+  gint min_baseline = -1;
+  gint nat_baseline = -1;
  gboolean found_in_cache;

  if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_CONSTANT_SIZE)
@@ -113,7 +158,11 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
                                                   orientation,
                                                   for_size,
                                                   &min_size,
-                                                   &nat_size);
+                                                   &nat_size,
+						   &min_baseline,
+						   &nat_baseline);
+
+  widget_class = GTK_WIDGET_GET_CLASS (widget);
  
  if (!found_in_cache)
    {
@@ -126,7 +175,7 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
          if (for_size < 0)
            {
 	      push_recursion_check (widget, orientation, for_size);
-              GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_size, &nat_size);
+              widget_class->get_preferred_width (widget, &min_size, &nat_size);
 	      pop_recursion_check (widget, orientation);
            }
          else
@@ -140,17 +189,17 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
 	      gtk_widget_get_preferred_height (widget, &minimum_height, &natural_height);

              /* convert for_size to unadjusted height (for_size is a proposed allocation) */
-              GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
-                                                                     GTK_ORIENTATION_VERTICAL,
-                                                                     &minimum_height,
-								     &natural_height,
-                                                                     &ignored_position,
-                                                                     &adjusted_for_size);
+              widget_class->adjust_size_allocation (widget,
+						    GTK_ORIENTATION_VERTICAL,
+						    &minimum_height,
+						    &natural_height,
+						    &ignored_position,
+						    &adjusted_for_size);

 	      push_recursion_check (widget, orientation, for_size);
-              GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget, 
-									     MAX (adjusted_for_size, minimum_height),
-									     &min_size, &nat_size);
+              widget_class->get_preferred_width_for_height (widget,
+							    MAX (adjusted_for_size, minimum_height),
+							    &min_size, &nat_size);
 	      pop_recursion_check (widget, orientation);
            }
        }
@@ -159,7 +208,12 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
          if (for_size < 0)
            {
 	      push_recursion_check (widget, orientation, for_size);
-              GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_size, &nat_size);
+	      if (widget_class_has_baseline_support (widget_class))
+		widget_class->get_preferred_height_and_baseline_for_width (widget, -1,
+									   &min_size, &nat_size,
+									   &min_baseline, &nat_baseline);
+	      else
+		widget_class->get_preferred_height (widget, &min_size, &nat_size);
 	      pop_recursion_check (widget, orientation);
            }
          else
@@ -173,17 +227,21 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
 	      gtk_widget_get_preferred_width (widget, &minimum_width, &natural_width);

              /* convert for_size to unadjusted width (for_size is a proposed allocation) */
-              GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
-                                                                     GTK_ORIENTATION_HORIZONTAL,
-								     &minimum_width,
-                                                                     &natural_width,
-                                                                     &ignored_position,
-                                                                     &adjusted_for_size);
+              widget_class->adjust_size_allocation (widget,
+						    GTK_ORIENTATION_HORIZONTAL,
+						    &minimum_width,
+						    &natural_width,
+						    &ignored_position,
+						    &adjusted_for_size);

 	      push_recursion_check (widget, orientation, for_size);
-              GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, 
-									     MAX (adjusted_for_size, minimum_width),
-									     &min_size, &nat_size);
+	      if (widget_class_has_baseline_support (widget_class))
+		widget_class->get_preferred_height_and_baseline_for_width (widget, MAX (adjusted_for_size, minimum_width),
+									   &min_size, &nat_size,
+									   &min_baseline, &nat_baseline);
+	      else
+		widget_class->get_preferred_height_for_width (widget, MAX (adjusted_for_size, minimum_width),
+							      &min_size, &nat_size);
 	      pop_recursion_check (widget, orientation);
            }
        }
@@ -196,10 +254,10 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,

      adjusted_min     = min_size;
      adjusted_natural = nat_size;
-      GTK_WIDGET_GET_CLASS (widget)->adjust_size_request (widget,
-                                                          orientation,
-                                                          &adjusted_min,
-                                                          &adjusted_natural);
+      widget_class->adjust_size_request (widget,
+					 orientation,
+					 &adjusted_min,
+					 &adjusted_natural);

      if (adjusted_min < min_size ||
          adjusted_natural < nat_size)
@@ -227,11 +285,42 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
          nat_size = adjusted_natural;
        }

+      if (min_baseline != -1 || nat_baseline != -1)
+	{
+	  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+	    {
+	      g_warning ("%s %p reported a horizontal baseline",
+			 G_OBJECT_TYPE_NAME (widget), widget);
+	      min_baseline = -1;
+	      nat_baseline = -1;
+	    }
+	  else if (min_baseline == -1 || nat_baseline == -1)
+	    {
+	      g_warning ("%s %p reported baseline for only one of min/natural (min: %d, natural: %d)",
+			 G_OBJECT_TYPE_NAME (widget), widget,
+			 min_baseline, nat_baseline);
+	      min_baseline = -1;
+	      nat_baseline = -1;
+	    }
+	  else if (gtk_widget_get_valign_with_baseline (widget) != GTK_ALIGN_BASELINE)
+	    {
+	      /* Ignore requested baseline for non-aligned widgets */
+	      min_baseline = -1;
+	      nat_baseline = -1;
+	    }
+	  else
+	    widget_class->adjust_baseline_request (widget,
+						   &min_baseline,
+						   &nat_baseline);
+	}
+
      _gtk_size_request_cache_commit (cache,
                                      orientation,
                                      for_size,
                                      min_size,
-                                      nat_size);
+                                      nat_size,
+				      min_baseline,
+				      nat_baseline);
    }

  if (minimum_size)
@@ -240,15 +329,26 @@ gtk_widget_query_size_for_orientation (GtkWidget        *widget,
  if (natural_size)
    *natural_size = nat_size;

+  if (minimum_baseline)
+    *minimum_baseline = min_baseline;
+
+  if (natural_baseline)
+    *natural_baseline = nat_baseline;
+
  g_assert (min_size <= nat_size);

  GTK_NOTE (SIZE_REQUEST,
-            g_print ("[%p] %s\t%s: %d is minimum %d and natural: %d (hit cache: %s)\n",
+            g_print ("[%p] %s\t%s: %d is minimum %d and natural: %d",
                     widget, G_OBJECT_TYPE_NAME (widget),
                     orientation == GTK_ORIENTATION_HORIZONTAL ?
                     "width for height" : "height for width" ,
-                     for_size, min_size, nat_size,
-                     found_in_cache ? "yes" : "no"));
+                     for_size, min_size, nat_size);
+	    if (min_baseline != -1 || nat_baseline != -1)
+	      g_print (", baseline %d/%d",
+		       min_baseline, nat_baseline);
+	    g_print (" (hit cache: %s)\n",
+		     found_in_cache ? "yes" : "no")
+	    );
 }

 /* This is the main function that checks for a cached size and
@@ -261,7 +361,9 @@ _gtk_widget_compute_size_for_orientation (GtkWidget        *widget,
                                          GtkOrientation    orientation,
                                          gint              for_size,
                                          gint             *minimum,
-                                          gint             *natural)
+                                          gint             *natural,
+					  gint             *minimum_baseline,
+					  gint             *natural_baseline)
 {
  GHashTable *widgets;
  GHashTableIter iter;
@@ -274,12 +376,17 @@ _gtk_widget_compute_size_for_orientation (GtkWidget        *widget,
        *minimum = 0;
      if (natural)
        *natural = 0;
+      if (minimum_baseline)
+        *minimum_baseline = -1;
+      if (natural_baseline)
+        *natural_baseline = -1;
      return;
    }

  if (G_LIKELY (!_gtk_widget_get_sizegroups (widget)))
    {
-      gtk_widget_query_size_for_orientation (widget, orientation, for_size, minimum, natural);
+      gtk_widget_query_size_for_orientation (widget, orientation, for_size, minimum, natural,
+					     minimum_baseline, natural_baseline);
      return;
    }

@@ -293,7 +400,7 @@ _gtk_widget_compute_size_for_orientation (GtkWidget        *widget,
      GtkWidget *tmp_widget = key;
      gint min_dimension, nat_dimension;

-      gtk_widget_query_size_for_orientation (tmp_widget, orientation, for_size, &min_dimension, &nat_dimension);
+      gtk_widget_query_size_for_orientation (tmp_widget, orientation, for_size, &min_dimension, &nat_dimension, NULL, NULL);

      min_result = MAX (min_result, min_dimension);
      nat_result = MAX (nat_result, nat_dimension);
@@ -303,6 +410,13 @@ _gtk_widget_compute_size_for_orientation (GtkWidget        *widget,

  g_hash_table_destroy (widgets);

+  /* Baselines make no sense with sizegroups really */
+  if (minimum_baseline)
+    *minimum_baseline = -1;
+
+  if (natural_baseline)
+    *natural_baseline = -1;
+
  if (minimum)
    *minimum = min_result;

@@ -375,7 +489,8 @@ gtk_widget_get_preferred_width (GtkWidget *widget,
                                            GTK_ORIENTATION_HORIZONTAL,
                                            -1,
                                            minimum_width,
-                                            natural_width);
+                                            natural_width,
+					    NULL, NULL);
 }


@@ -409,7 +524,8 @@ gtk_widget_get_preferred_height (GtkWidget *widget,
                                            GTK_ORIENTATION_VERTICAL,
                                            -1,
                                            minimum_height,
-                                            natural_height);
+                                            natural_height,
+					    NULL, NULL);
 }


@@ -446,7 +562,8 @@ gtk_widget_get_preferred_width_for_height (GtkWidget *widget,
                                            GTK_ORIENTATION_HORIZONTAL,
                                            height,
                                            minimum_width,
-                                            natural_width);
+                                            natural_width,
+					    NULL, NULL);
 }

 /**
@@ -481,7 +598,122 @@ gtk_widget_get_preferred_height_for_width (GtkWidget *widget,
                                            GTK_ORIENTATION_VERTICAL,
                                            width,
                                            minimum_height,
-                                            natural_height);
+                                            natural_height,
+					    NULL, NULL);
+}
+
+/**
+ * gtk_widget_get_preferred_height_and_baseline_for_width:
+ * @widget: a #GtkWidget instance
+ * @width: the width which is available for allocation, or -1 if none
+ * @minimum_height: (out) (allow-none): location for storing the minimum height, or %NULL
+ * @natural_height: (out) (allow-none): location for storing the natural height, or %NULL
+ * @minimum_baseline: (out) (allow-none): location for storing the baseline for the minimum height, or %NULL
+ * @natural_baseline: (out) (allow-none): location for storing the baseline for the natural height, or %NULL
+ *
+ * Retrieves a widget's minimum and natural height and the corresponding baselines if it would be given
+ * the specified @width, or the default height if @width is -1. The baselines may be -1 which means
+ * that no baseline is requested for this widget.
+ *
+ * The returned request will be modified by the
+ * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+ * and by any #GtkSizeGroup<!-- -->s that have been applied. That is, the returned request
+ * is the one that should be used for layout, not necessarily the one
+ * returned by the widget itself.
+ *
+ * Since: 3.10
+ */
+void
+gtk_widget_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+							gint       width,
+							gint      *minimum_height,
+							gint      *natural_height,
+							gint      *minimum_baseline,
+							gint      *natural_baseline)
+{
+  g_return_if_fail (GTK_IS_WIDGET (widget));
+  g_return_if_fail (minimum_height != NULL || natural_height != NULL);
+  g_return_if_fail (width >= -1);
+
+  _gtk_widget_compute_size_for_orientation (widget,
+                                            GTK_ORIENTATION_VERTICAL,
+                                            width,
+                                            minimum_height,
+                                            natural_height,
+					    minimum_baseline,
+					    natural_baseline);
+}
+
+/**
+ * gtk_widget_get_preferred_size_and_baseline:
+ * @widget: a #GtkWidget instance
+ * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
+ * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
+ *
+ * Retrieves the minimum and natural size  and the corresponding baselines of a widget, taking
+ * into account the widget's preference for height-for-width management. The baselines may
+ * be -1 which means that no baseline is requested for this widget.
+ *
+ * This is used to retrieve a suitable size by container widgets which do
+ * not impose any restrictions on the child placement. It can be used
+ * to deduce toplevel window and menu sizes as well as child widgets in
+ * free-form containers such as GtkLayout.
+ *
+ * <note><para>Handle with care. Note that the natural height of a height-for-width
+ * widget will generally be a smaller size than the minimum height, since the required
+ * height for the natural width is generally smaller than the required height for
+ * the minimum width.</para></note>
+ *
+ * Since: 3.10
+ */
+void
+gtk_widget_get_preferred_size_and_baseline (GtkWidget      *widget,
+					    GtkRequisition *minimum_size,
+					    GtkRequisition *natural_size,
+					    gint           *minimum_baseline,
+					    gint           *natural_baseline)
+{
+  gint min_width, nat_width;
+  gint min_height, nat_height;
+
+  g_return_if_fail (GTK_IS_WIDGET (widget));
+
+  if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      gtk_widget_get_preferred_width (widget, &min_width, &nat_width);
+
+      if (minimum_size)
+	{
+	  minimum_size->width = min_width;
+	  gtk_widget_get_preferred_height_and_baseline_for_width (widget, min_width,
+								  &minimum_size->height, NULL, minimum_baseline, NULL);
+	}
+
+      if (natural_size)
+	{
+	  natural_size->width = nat_width;
+	  gtk_widget_get_preferred_height_and_baseline_for_width (widget, nat_width,
+								  NULL, &natural_size->height, NULL, natural_baseline);
+	}
+    }
+  else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT or CONSTANT_SIZE */
+    {
+      gtk_widget_get_preferred_height_and_baseline_for_width (widget, -1, &min_height, &nat_height, minimum_baseline, natural_baseline);
+
+      if (minimum_size)
+	{
+	  minimum_size->height = min_height;
+	  gtk_widget_get_preferred_width_for_height (widget, min_height,
+                                                     &minimum_size->width, NULL);
+	}
+
+      if (natural_size)
+	{
+	  natural_size->height = nat_height;
+	  gtk_widget_get_preferred_width_for_height (widget, nat_height,
+                                                     NULL, &natural_size->width);
+	}
+    }
 }

 /**
@@ -503,6 +735,9 @@ gtk_widget_get_preferred_height_for_width (GtkWidget *widget,
 * height for the natural width is generally smaller than the required height for
 * the minimum width.</para></note>
 *
+ * Use gtk_widget_get_preferred_size_and_baseline() if you want to support
+ * baseline alignment.
+ *
 * Since: 3.0
 */
 void
@@ -510,50 +745,10 @@ gtk_widget_get_preferred_size (GtkWidget      *widget,
                               GtkRequisition *minimum_size,
                               GtkRequisition *natural_size)
 {
-  gint min_width, nat_width;
-  gint min_height, nat_height;
-
-  g_return_if_fail (GTK_IS_WIDGET (widget));
-
-  if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
-    {
-      gtk_widget_get_preferred_width (widget, &min_width, &nat_width);
-
-      if (minimum_size)
-	{
-	  minimum_size->width = min_width;
-	  gtk_widget_get_preferred_height_for_width (widget, min_width,
-                                                     &minimum_size->height, NULL);
-	}
-
-      if (natural_size)
-	{
-	  natural_size->width = nat_width;
-	  gtk_widget_get_preferred_height_for_width (widget, nat_width,
-                                                     NULL, &natural_size->height);
-	}
-    }
-  else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT or CONSTANT_SIZE */
-    {
-      gtk_widget_get_preferred_height (widget, &min_height, &nat_height);
-
-      if (minimum_size)
-	{
-	  minimum_size->height = min_height;
-	  gtk_widget_get_preferred_width_for_height (widget, min_height,
-                                                     &minimum_size->width, NULL);
-	}
-
-      if (natural_size)
-	{
-	  natural_size->height = nat_height;
-	  gtk_widget_get_preferred_width_for_height (widget, nat_height,
-                                                     NULL, &natural_size->width);
-	}
-    }
+  gtk_widget_get_preferred_size_and_baseline (widget, minimum_size, natural_size,
+					      NULL, NULL);
 }

-
 static gint
 compare_gap (gconstpointer p1,
 	     gconstpointer p2,
@@ -32,31 +32,38 @@ _gtk_size_request_cache_init (SizeRequestCache *cache)
 }

 static void
-free_sizes (SizeRequest **sizes)
+free_sizes_x (SizeRequestX **sizes)
 {
  gint i;

  for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
-    g_slice_free (SizeRequest, sizes[i]);
-      
-  g_slice_free1 (sizeof (SizeRequest *) * GTK_SIZE_REQUEST_CACHED_SIZES, sizes);
+    g_slice_free (SizeRequestX, sizes[i]);
+
+  g_slice_free1 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES, sizes);
+}
+
+static void
+free_sizes_y (SizeRequestY **sizes)
+{
+  gint i;
+
+  for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
+    g_slice_free (SizeRequestY, sizes[i]);
+
+  g_slice_free1 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES, sizes);
 }

 void
 _gtk_size_request_cache_free (SizeRequestCache *cache)
 {
-  guint i;
-
-  for (i = 0; i < 2; i++)
-    {
-      if (cache->requests[i])
-        free_sizes (cache->requests[i]);
-    }
+  if (cache->requests_x)
+    free_sizes_x (cache->requests_x);
+  if (cache->requests_x)
+    free_sizes_y (cache->requests_y);
 }

 void
 _gtk_size_request_cache_clear (SizeRequestCache *cache)
-                               
 {
  _gtk_size_request_cache_free (cache);
  _gtk_size_request_cache_init (cache);
@@ -67,17 +74,34 @@ _gtk_size_request_cache_commit (SizeRequestCache *cache,
                                GtkOrientation    orientation,
                                gint              for_size,
                                gint              minimum_size,
-                                gint              natural_size)
+                                gint              natural_size,
+				gint              minimum_baseline,
+				gint              natural_baseline)
 {
-  SizeRequest **cached_sizes;
-  SizeRequest  *cached_size;
  guint         i, n_sizes;

+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      g_assert (minimum_baseline == -1);
+      g_assert (natural_baseline == -1);
+    }
+
  /* First handle caching of the base requests */
  if (for_size < 0)
    {
-      cache->cached_size[orientation].minimum_size = minimum_size;
-      cache->cached_size[orientation].natural_size = natural_size;
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+	{
+	  cache->cached_size_x.minimum_size = minimum_size;
+	  cache->cached_size_x.natural_size = natural_size;
+	}
+      else
+	{
+	  cache->cached_size_y.minimum_size = minimum_size;
+	  cache->cached_size_y.natural_size = natural_size;
+	  cache->cached_size_y.minimum_baseline = minimum_baseline;
+	  cache->cached_size_y.natural_baseline = natural_baseline;
+	}
+
      cache->flags[orientation].cached_size_valid = TRUE;
      return;
    }
@@ -86,45 +110,99 @@ _gtk_size_request_cache_commit (SizeRequestCache *cache,
   * in the cache and if this result can be used to extend
   * that cache entry 
   */
-  cached_sizes = cache->requests[orientation];
  n_sizes = cache->flags[orientation].n_cached_requests;

-  for (i = 0; i < n_sizes; i++)
-    {
-      if (cached_sizes[i]->cached_size.minimum_size == minimum_size &&
-	  cached_sizes[i]->cached_size.natural_size == natural_size)
-	{
-	  cached_sizes[i]->lower_for_size = MIN (cached_sizes[i]->lower_for_size, for_size);
-	  cached_sizes[i]->upper_for_size = MAX (cached_sizes[i]->upper_for_size, for_size);
-	  return;
-	}
-    }

-  /* If not found, pull a new size from the cache, the returned size cache
-   * will immediately be used to cache the new computed size so we go ahead
-   * and increment the last_cached_request right away */
-  if (n_sizes < GTK_SIZE_REQUEST_CACHED_SIZES)
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
-      cache->flags[orientation].n_cached_requests++;
-      cache->flags[orientation].last_cached_request = cache->flags[orientation].n_cached_requests - 1;
+      SizeRequestX **cached_sizes;
+      SizeRequestX  *cached_size;
+      cached_sizes = cache->requests_x;
+
+      for (i = 0; i < n_sizes; i++)
+	{
+	  if (cached_sizes[i]->cached_size.minimum_size == minimum_size &&
+	      cached_sizes[i]->cached_size.natural_size == natural_size)
+	    {
+	      cached_sizes[i]->lower_for_size = MIN (cached_sizes[i]->lower_for_size, for_size);
+	      cached_sizes[i]->upper_for_size = MAX (cached_sizes[i]->upper_for_size, for_size);
+	      return;
+	    }
+	}
+
+      /* If not found, pull a new size from the cache, the returned size cache
+       * will immediately be used to cache the new computed size so we go ahead
+       * and increment the last_cached_request right away */
+      if (n_sizes < GTK_SIZE_REQUEST_CACHED_SIZES)
+	{
+	  cache->flags[orientation].n_cached_requests++;
+	  cache->flags[orientation].last_cached_request = cache->flags[orientation].n_cached_requests - 1;
+	}
+      else
+	{
+	  if (++cache->flags[orientation].last_cached_request == GTK_SIZE_REQUEST_CACHED_SIZES)
+	    cache->flags[orientation].last_cached_request = 0;
+	}
+
+      if (cache->requests_x == NULL)
+	cache->requests_x = g_slice_alloc0 (sizeof (SizeRequestX *) * GTK_SIZE_REQUEST_CACHED_SIZES);
+
+      if (cache->requests_x[cache->flags[orientation].last_cached_request] == NULL)
+	cache->requests_x[cache->flags[orientation].last_cached_request] = g_slice_new (SizeRequestX);
+
+      cached_size = cache->requests_x[cache->flags[orientation].last_cached_request];
+      cached_size->lower_for_size = for_size;
+      cached_size->upper_for_size = for_size;
+      cached_size->cached_size.minimum_size = minimum_size;
+      cached_size->cached_size.natural_size = natural_size;
    }
  else
    {
-      if (++cache->flags[orientation].last_cached_request == GTK_SIZE_REQUEST_CACHED_SIZES)
-        cache->flags[orientation].last_cached_request = 0;
+      SizeRequestY **cached_sizes;
+      SizeRequestY  *cached_size;
+      cached_sizes = cache->requests_y;
+
+      for (i = 0; i < n_sizes; i++)
+	{
+	  if (cached_sizes[i]->cached_size.minimum_size == minimum_size &&
+	      cached_sizes[i]->cached_size.natural_size == natural_size &&
+	      cached_sizes[i]->cached_size.minimum_baseline == minimum_baseline &&
+	      cached_sizes[i]->cached_size.natural_baseline == natural_baseline)
+	    {
+	      cached_sizes[i]->lower_for_size = MIN (cached_sizes[i]->lower_for_size, for_size);
+	      cached_sizes[i]->upper_for_size = MAX (cached_sizes[i]->upper_for_size, for_size);
+	      return;
+	    }
+	}
+
+      /* If not found, pull a new size from the cache, the returned size cache
+       * will immediately be used to cache the new computed size so we go ahead
+       * and increment the last_cached_request right away */
+      if (n_sizes < GTK_SIZE_REQUEST_CACHED_SIZES)
+	{
+	  cache->flags[orientation].n_cached_requests++;
+	  cache->flags[orientation].last_cached_request = cache->flags[orientation].n_cached_requests - 1;
+	}
+      else
+	{
+	  if (++cache->flags[orientation].last_cached_request == GTK_SIZE_REQUEST_CACHED_SIZES)
+	    cache->flags[orientation].last_cached_request = 0;
+	}
+
+      if (cache->requests_y == NULL)
+	cache->requests_y = g_slice_alloc0 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES);
+
+      if (cache->requests_y[cache->flags[orientation].last_cached_request] == NULL)
+	cache->requests_y[cache->flags[orientation].last_cached_request] = g_slice_new (SizeRequestY);
+
+      cached_size = cache->requests_y[cache->flags[orientation].last_cached_request];
+      cached_size->lower_for_size = for_size;
+      cached_size->upper_for_size = for_size;
+      cached_size->cached_size.minimum_size = minimum_size;
+      cached_size->cached_size.natural_size = natural_size;
+      cached_size->cached_size.minimum_baseline = minimum_baseline;
+      cached_size->cached_size.natural_baseline = natural_baseline;
    }
-
-  if (cache->requests[orientation] == NULL)
-    cache->requests[orientation] = g_slice_alloc0 (sizeof (SizeRequest *) * GTK_SIZE_REQUEST_CACHED_SIZES);
-
-  if (cache->requests[orientation][cache->flags[orientation].last_cached_request] == NULL)
-    cache->requests[orientation][cache->flags[orientation].last_cached_request] = g_slice_new (SizeRequest);
-
-  cached_size = cache->requests[orientation][cache->flags[orientation].last_cached_request];
-  cached_size->lower_for_size = for_size;
-  cached_size->upper_for_size = for_size;
-  cached_size->cached_size.minimum_size = minimum_size;
-  cached_size->cached_size.natural_size = natural_size;
 }

 /* looks for a cached size request for this for_size.
@@ -137,40 +215,85 @@ _gtk_size_request_cache_lookup (SizeRequestCache *cache,
                                GtkOrientation    orientation,
                                gint              for_size,
                                gint             *minimum,
-                                gint             *natural)
+                                gint             *natural,
+				gint             *minimum_baseline,
+				gint             *natural_baseline)
 {
-  CachedSize *result = NULL;
-
-  if (for_size < 0)
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
-      if (cache->flags[orientation].cached_size_valid)
-	result = &cache->cached_size[orientation];
+      CachedSizeX *result = NULL;
+
+      if (for_size < 0)
+	{
+	  if (cache->flags[orientation].cached_size_valid)
+	    result = &cache->cached_size_x;
+	}
+      else
+	{
+	  guint i;
+
+	  /* Search for an already cached size */
+	  for (i = 0; i < cache->flags[orientation].n_cached_requests; i++)
+	    {
+	      SizeRequestX *cur = cache->requests_x[i];
+
+	      if (cur->lower_for_size <= for_size &&
+		  cur->upper_for_size >= for_size)
+		{
+		  result = &cur->cached_size;
+		  break;
+		}
+	    }
+	}
+
+      if (result)
+	{
+	  *minimum = result->minimum_size;
+	  *natural = result->natural_size;
+	  *minimum_baseline = -1;
+	  *natural_baseline = -1;
+	  return TRUE;
+	}
+      else
+	return FALSE;
    }
  else
    {
-      guint i;
+      CachedSizeY *result = NULL;

-      /* Search for an already cached size */
-      for (i = 0; i < cache->flags[orientation].n_cached_requests; i++)
-        {
-          SizeRequest *cur = cache->requests[orientation][i];
+      if (for_size < 0)
+	{
+	  if (cache->flags[orientation].cached_size_valid)
+	    result = &cache->cached_size_y;
+	}
+      else
+	{
+	  guint i;

-          if (cur->lower_for_size <= for_size &&
-              cur->upper_for_size >= for_size)
-            {
-              result = &cur->cached_size;
-              break;
-            }
-        }
+	  /* Search for an already cached size */
+	  for (i = 0; i < cache->flags[orientation].n_cached_requests; i++)
+	    {
+	      SizeRequestY *cur = cache->requests_y[i];
+
+	      if (cur->lower_for_size <= for_size &&
+		  cur->upper_for_size >= for_size)
+		{
+		  result = &cur->cached_size;
+		  break;
+		}
+	    }
+	}
+
+      if (result)
+	{
+	  *minimum = result->minimum_size;
+	  *natural = result->natural_size;
+	  *minimum_baseline = result->minimum_baseline;
+	  *natural_baseline = result->natural_baseline;
+	  return TRUE;
+	}
+      else
+	return FALSE;
    }
-
-  if (result)
-    {
-      *minimum = result->minimum_size;
-      *natural = result->natural_size;
-      return TRUE;
-    }
-  else
-    return FALSE;
 }

@@ -41,19 +41,35 @@ G_BEGIN_DECLS
 typedef struct {
  gint minimum_size;
  gint natural_size;
-} CachedSize;
+} CachedSizeX;
+
+typedef struct {
+  gint minimum_size;
+  gint natural_size;
+  gint minimum_baseline;
+  gint natural_baseline;
+} CachedSizeY;

 typedef struct
 {
  gint       lower_for_size; /* The minimum for_size with the same result */
  gint       upper_for_size; /* The maximum for_size with the same result */
-  CachedSize cached_size;
-} SizeRequest;
+  CachedSizeX cached_size;
+} SizeRequestX;
+
+typedef struct
+{
+  gint       lower_for_size; /* The minimum for_size with the same result */
+  gint       upper_for_size; /* The maximum for_size with the same result */
+  CachedSizeY cached_size;
+} SizeRequestY;

 typedef struct {
-  SizeRequest **requests[2];
+  SizeRequestX **requests_x;
+  SizeRequestY **requests_y;

-  CachedSize  cached_size[2];
+  CachedSizeX  cached_size_x;
+  CachedSizeY  cached_size_y;

  GtkSizeRequestMode request_mode   : 3;
  guint       request_mode_valid    : 1;
@@ -72,12 +88,16 @@ void            _gtk_size_request_cache_commit                  (SizeRequestCach
                                                                 GtkOrientation          orientation,
                                                                 gint                    for_size,
                                                                 gint                    minimum_size,
-                                                                 gint                    natural_size);
+                                                                 gint                    natural_size,
+                                                                 gint                    minimum_baseline,
+                                                                 gint                    natural_baseline);
 gboolean        _gtk_size_request_cache_lookup                  (SizeRequestCache       *cache,
                                                                 GtkOrientation          orientation,
                                                                 gint                    for_size,
                                                                 gint                   *minimum,
-                                                                 gint                   *natural);
+                                                                 gint                   *natural,
+                                                                 gint                   *minimum_baseline,
+                                                                 gint                   *natural_baseline);

 G_END_DECLS

@@ -222,6 +222,12 @@ static void gtk_spin_button_get_preferred_width  (GtkWidget          *widget,
 static void gtk_spin_button_get_preferred_height (GtkWidget          *widget,
                                                  gint               *minimum,
                                                  gint               *natural);
+static void gtk_spin_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+									 gint       width,
+									 gint      *minimum,
+									 gint      *natural,
+									 gint      *minimum_baseline,
+									 gint      *natural_baseline);
 static void gtk_spin_button_size_allocate  (GtkWidget          *widget,
                                            GtkAllocation      *allocation);
 static gint gtk_spin_button_draw           (GtkWidget          *widget,
@@ -309,6 +315,7 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class)
  widget_class->unrealize = gtk_spin_button_unrealize;
  widget_class->get_preferred_width = gtk_spin_button_get_preferred_width;
  widget_class->get_preferred_height = gtk_spin_button_get_preferred_height;
+  widget_class->get_preferred_height_and_baseline_for_width = gtk_spin_button_get_preferred_height_and_baseline_for_width;
  widget_class->size_allocate = gtk_spin_button_size_allocate;
  widget_class->draw = gtk_spin_button_draw;
  widget_class->scroll_event = gtk_spin_button_scroll;
@@ -1197,14 +1204,20 @@ gtk_spin_button_get_preferred_width (GtkWidget *widget,
 }

 static void
-gtk_spin_button_get_preferred_height (GtkWidget *widget,
-                                      gint      *minimum,
-                                      gint      *natural)
+gtk_spin_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget,
+							     gint       width,
+							     gint      *minimum,
+							     gint      *natural,
+							     gint      *minimum_baseline,
+							     gint      *natural_baseline)
 {
  GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
  GtkSpinButtonPrivate *priv = spin_button->priv;

-  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->get_preferred_height (widget, minimum, natural);
+  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->get_preferred_height_and_baseline_for_width (widget, width,
+												minimum, natural,
+												minimum_baseline,
+												natural_baseline);

  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
    {
@@ -1216,9 +1229,22 @@ gtk_spin_button_get_preferred_height (GtkWidget *widget,

      *minimum += up_panel_height + down_panel_height;
      *natural += up_panel_height + down_panel_height;
+
+      if (minimum_baseline && *minimum_baseline != -1)
+	*minimum_baseline += up_panel_height;
+      if (natural_baseline && *natural_baseline != -1)
+	*natural_baseline += up_panel_height;
    }
 }

+static void
+gtk_spin_button_get_preferred_height (GtkWidget *widget,
+                                      gint      *minimum,
+                                      gint      *natural)
+{
+  gtk_spin_button_get_preferred_height_and_baseline_for_width (widget, -1, minimum, natural, NULL, NULL);
+}
+
 static void
 gtk_spin_button_size_allocate (GtkWidget     *widget,
                               GtkAllocation *allocation)
@@ -1071,10 +1071,10 @@ gtk_style_context_set_invalid (GtkStyleContext *context,

  if (invalid)
    {
-      if (priv->parent)
-        gtk_style_context_set_invalid (priv->parent, TRUE);
-      else if (GTK_IS_RESIZE_CONTAINER (priv->widget))
+      if (GTK_IS_RESIZE_CONTAINER (priv->widget))
        _gtk_container_queue_restyle (GTK_CONTAINER (priv->widget));
+      else if (priv->parent)
+        gtk_style_context_set_invalid (priv->parent, TRUE);
    }
 }

@@ -389,7 +389,7 @@ gtk_text_buffer_class_init (GtkTextBufferClass *klass)
   * Note that if your handler runs before the default handler it must not 
   * invalidate the @start and @end iters (or has to revalidate them). 
   * The default signal handler revalidates the @start and @end iters to 
-   * both point point to the location where text was deleted. Handlers
+   * both point to the location where text was deleted. Handlers
   * which run after the default handler (see g_signal_connect_after())
   * do not have access to the deleted text.
   * 
@@ -844,16 +844,16 @@ gtk_text_iter_get_visible_line_index (const GtkTextIter *iter)
 * gtk_text_iter_get_char:
 * @iter: an iterator
 *
- * Returns the Unicode character at this iterator.  (Equivalent to
+ * The Unicode character at this iterator is returned.  (Equivalent to
 * operator* on a C++ iterator.)  If the element at this iterator is a
 * non-character element, such as an image embedded in the buffer, the
 * Unicode "unknown" character 0xFFFC is returned. If invoked on
 * the end iterator, zero is returned; zero is not a valid Unicode character.
- * So you can write a loop which ends when gtk_text_iter_get_char ()
+ * So you can write a loop which ends when gtk_text_iter_get_char()
 * returns 0.
 *
- * Return value: a Unicode character, or 0 if @iter is not dereferenceable
- **/
+ * Returns: a Unicode character, or 0 if @iter is not dereferenceable
+ */
 gunichar
 gtk_text_iter_get_char (const GtkTextIter *iter)
 {
@@ -216,6 +216,12 @@ gtk_tool_palette_init (GtkToolPalette *palette)
  palette->priv->style_set = FALSE;

  palette->priv->text_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
+
+  if (dnd_target_atom_item == GDK_NONE)
+    {
+      dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0].target);
+      dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1].target);
+    }
 }

 static void
@@ -1080,9 +1086,6 @@ gtk_tool_palette_class_init (GtkToolPaletteClass *cls)
                                                                    GTK_PARAM_READWRITE));

  g_type_class_add_private (cls, sizeof (GtkToolPalettePrivate));
-
-  dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0].target);
-  dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1].target);
 }

 /**
--- a/Show More
+++ b/Show More