testrevealer: Cover the new transitions

Add tests for all the swing transitions.

.gitlab-ci.yml

@@ -13,7 +13,7 @@ stages:
     - subprojects/pango/
 
 fedora-x86_64:
-  image: registry.gitlab.gnome.org/gnome/gtk/master:v2
+  image: registry.gitlab.gnome.org/gnome/gtk/master:v3
   stage: build
   script:
     - bash -x ./.gitlab-ci/test-docker.sh
@@ -64,7 +64,7 @@ flatpak:widget-factory:
   <<: *flatpak-defaults
 
 pages:
-  image: registry.gitlab.gnome.org/gnome/gtk/master:v2
+  image: registry.gitlab.gnome.org/gnome/gtk/master:v3
   stage: deploy 
   script:
     - meson -Ddocumentation=true _build .

.gitlab-ci/Dockerfile

@@ -70,7 +70,7 @@ RUN dnf -y install \
     xorg-x11-server-Xvfb \
  && dnf clean all
 
-RUN pip3 install meson==0.49.0
+RUN pip3 install meson==0.50.0
 
 ARG HOST_USER_ID=5555
 ENV HOST_USER_ID ${HOST_USER_ID}

.gitlab-ci/run-docker.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-TAG="registry.gitlab.gnome.org/gnome/gtk/master:v2"
+TAG="registry.gitlab.gnome.org/gnome/gtk/master:v3"
 
 sudo docker build --build-arg HOST_USER_ID="$UID" --tag "${TAG}" \
     --file "Dockerfile" .

.gitlab-ci/test-docker.sh

@@ -26,7 +26,9 @@ ccache --show-stats
 
 xvfb-run -a -s "-screen 0 1024x768x24" \
     meson test \
+        --timeout-multiplier 2 \
         --print-errorlogs \
         --suite=gtk \
         --no-suite=gtk:gsk \
+        --no-suite=gtk:reftest \
         --no-suite=gtk:a11y

demos/gtk-demo/demo.gresource.xml

@@ -207,6 +207,7 @@
     <file>spinbutton.c</file>
     <file>spinner.c</file>
     <file>tabs.c</file>
+    <file>tagged_entry.c</file>
     <file>textview.c</file>
     <file>textscroll.c</file>
     <file>theming_style_classes.c</file>
@@ -218,6 +219,9 @@
   <gresource prefix="/textview">
     <file>floppybuddy.gif</file>
   </gresource>
+  <gresource prefix="/tagged_entry">
+    <file>tagstyle.css</file>
+  </gresource>
   <gresource prefix="/listbox">
     <file>listbox.ui</file>
     <file>messages.txt</file>
@@ -262,6 +266,10 @@
   <gresource prefix="/dnd">
     <file>dnd.css</file>
   </gresource>
+  <gresource prefix="/tagged_entry">
+    <file>demotaggedentry.c</file>
+    <file>demotaggedentry.h</file>
+  </gresource>
   <gresource prefix="/org/gtk/Demo">
     <file>icons/16x16/actions/application-exit.png</file>
     <file>icons/16x16/actions/document-new.png</file>

demos/gtk-demo/demotaggedentry.c

@@ -0,0 +1,493 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * Authors:
+ * - Matthias Clasen <mclasen@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "demotaggedentry.h"
+
+#include <gtk/gtk.h>
+#include <gtk/gtk-a11y.h>
+
+typedef struct {
+  GtkWidget *box;
+  GtkWidget *entry;
+} DemoTaggedEntryPrivate;
+
+static void demo_tagged_entry_editable_init (GtkEditableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (DemoTaggedEntry, demo_tagged_entry, GTK_TYPE_WIDGET,
+                         G_ADD_PRIVATE (DemoTaggedEntry)
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE, demo_tagged_entry_editable_init))
+
+static void
+demo_tagged_entry_init (DemoTaggedEntry *entry)
+{
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  gtk_widget_set_has_surface (GTK_WIDGET (entry), FALSE);
+
+  priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_widget_set_parent (priv->box, GTK_WIDGET (entry));
+
+  priv->entry = gtk_text_new ();
+  gtk_widget_set_hexpand (priv->entry, TRUE);
+  gtk_widget_set_vexpand (priv->entry, TRUE);
+  gtk_widget_set_hexpand (priv->box, FALSE);
+  gtk_widget_set_vexpand (priv->box, FALSE);
+  gtk_container_add (GTK_CONTAINER (priv->box), priv->entry);
+  gtk_editable_init_delegate (GTK_EDITABLE (entry));
+}
+
+static void
+demo_tagged_entry_dispose (GObject *object)
+{
+  DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (object);
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  if (priv->entry)
+    gtk_editable_finish_delegate (GTK_EDITABLE (entry));
+
+  g_clear_pointer (&priv->entry, gtk_widget_unparent);
+  g_clear_pointer (&priv->box, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (demo_tagged_entry_parent_class)->dispose (object);
+}
+
+static void
+demo_tagged_entry_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (demo_tagged_entry_parent_class)->finalize (object);
+}
+
+static void
+demo_tagged_entry_set_property (GObject      *object,
+                                guint         prop_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
+    return;
+
+  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+}
+
+static void
+demo_tagged_entry_get_property (GObject    *object,
+                                guint       prop_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  if (gtk_editable_delegate_get_property (object, prop_id, value, pspec))
+    return;
+
+  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+}
+
+static void
+demo_tagged_entry_measure (GtkWidget      *widget,
+                           GtkOrientation  orientation,
+                           int             for_size,
+                           int            *minimum,
+                           int            *natural,
+                           int            *minimum_baseline,
+                           int            *natural_baseline)
+{
+  DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (widget);
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  gtk_widget_measure (priv->box, orientation, for_size,
+                      minimum, natural,
+                      minimum_baseline, natural_baseline);
+}
+
+static void
+demo_tagged_entry_size_allocate (GtkWidget *widget,
+                                 int        width,
+                                 int        height,
+                                 int        baseline)
+{
+  DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (widget);
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  gtk_widget_size_allocate (priv->box,
+                            &(GtkAllocation) { 0, 0, width, height },
+                            baseline);
+}
+
+static void
+demo_tagged_entry_grab_focus (GtkWidget *widget)
+{
+  DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (widget);
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  gtk_widget_grab_focus (priv->entry);
+}
+
+static void
+demo_tagged_entry_class_init (DemoTaggedEntryClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = demo_tagged_entry_dispose;
+  object_class->finalize = demo_tagged_entry_finalize;
+  object_class->get_property = demo_tagged_entry_get_property;
+  object_class->set_property = demo_tagged_entry_set_property;
+
+  widget_class->measure = demo_tagged_entry_measure;
+  widget_class->size_allocate = demo_tagged_entry_size_allocate;
+  widget_class->grab_focus = demo_tagged_entry_grab_focus;
+ 
+  gtk_editable_install_properties (object_class, 1);
+
+  gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_ENTRY_ACCESSIBLE);
+  gtk_widget_class_set_css_name (widget_class, "entry");
+}
+
+static GtkEditable *
+demo_tagged_entry_get_delegate (GtkEditable *editable)
+{
+  DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (editable);
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  return GTK_EDITABLE (priv->entry);
+}
+
+static void
+demo_tagged_entry_editable_init (GtkEditableInterface *iface)
+{
+  iface->get_delegate = demo_tagged_entry_get_delegate;
+}
+
+GtkWidget *
+demo_tagged_entry_new (void)
+{
+  return GTK_WIDGET (g_object_new (DEMO_TYPE_TAGGED_ENTRY, NULL));
+}
+
+void
+demo_tagged_entry_add_tag (DemoTaggedEntry *entry,
+                           GtkWidget       *tag)
+{
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
+
+  gtk_container_add (GTK_CONTAINER (priv->box), tag);
+}
+
+void
+demo_tagged_entry_insert_tag_after (DemoTaggedEntry *entry,
+                                    GtkWidget       *tag,
+                                    GtkWidget       *sibling)
+{
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
+
+  if (sibling == NULL)
+    gtk_container_add (GTK_CONTAINER (priv->box), tag);
+  else
+    gtk_box_insert_child_after (GTK_BOX (priv->box), tag, sibling); 
+}
+
+void
+demo_tagged_entry_remove_tag (DemoTaggedEntry *entry,
+                              GtkWidget       *tag)
+{
+  DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
+
+  g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
+
+  gtk_container_remove (GTK_CONTAINER (priv->box), tag);
+}
+
+struct _DemoTaggedEntryTag
+{
+  GtkWidget parent;
+  GtkWidget *box;
+  GtkWidget *label;
+  GtkWidget *button;
+
+  gboolean has_close_button;
+  char *style;
+};
+
+struct _DemoTaggedEntryTagClass
+{
+  GtkWidgetClass parent_class;
+};
+
+enum {
+  PROP_0,
+  PROP_LABEL,
+  PROP_HAS_CLOSE_BUTTON,
+};
+
+enum {
+  SIGNAL_CLICKED,
+  SIGNAL_BUTTON_CLICKED,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE (DemoTaggedEntryTag, demo_tagged_entry_tag, GTK_TYPE_WIDGET)
+
+static void
+on_released (GtkGestureMultiPress *gesture,
+             int                   n_press,
+             double                x,
+             double                y,
+             DemoTaggedEntryTag          *tag)
+{
+  g_signal_emit (tag, signals[SIGNAL_CLICKED], 0);
+}
+
+static void
+demo_tagged_entry_tag_init (DemoTaggedEntryTag *tag)
+{
+  GtkGesture *gesture;
+  GtkCssProvider *provider;
+
+  gtk_widget_set_has_surface (GTK_WIDGET (tag), FALSE);
+
+  tag->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_widget_set_parent (tag->box, GTK_WIDGET (tag));
+  tag->label = gtk_label_new ("");
+  gtk_container_add (GTK_CONTAINER (tag->box), tag->label);
+
+  gesture = gtk_gesture_multi_press_new ();
+  g_signal_connect (gesture, "released", G_CALLBACK (on_released), tag);
+  gtk_widget_add_controller (GTK_WIDGET (tag), GTK_EVENT_CONTROLLER (gesture));
+
+  provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_resource (provider, "/tagged_entry/tagstyle.css");
+  gtk_style_context_add_provider_for_display (gdk_display_get_default (),
+                                              GTK_STYLE_PROVIDER (provider),
+                                              800);
+  g_object_unref (provider);
+}
+
+static void
+demo_tagged_entry_tag_dispose (GObject *object)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (object);
+
+  g_clear_pointer (&tag->box, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (demo_tagged_entry_tag_parent_class)->dispose (object);
+}
+
+static void
+demo_tagged_entry_tag_finalize (GObject *object)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (object);
+
+  g_clear_pointer (&tag->box, gtk_widget_unparent);
+  g_clear_pointer (&tag->style, g_free);
+
+  G_OBJECT_CLASS (demo_tagged_entry_tag_parent_class)->finalize (object);
+}
+
+static void
+demo_tagged_entry_tag_set_property (GObject      *object,
+                                    guint         prop_id,
+                                    const GValue *value,
+                                    GParamSpec   *pspec)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (object);
+
+  switch (prop_id)
+    {
+    case PROP_LABEL:
+      demo_tagged_entry_tag_set_label (tag, g_value_get_string (value));
+      break;
+
+    case PROP_HAS_CLOSE_BUTTON:
+      demo_tagged_entry_tag_set_has_close_button (tag, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+demo_tagged_entry_tag_get_property (GObject    *object,
+                                    guint       prop_id,
+                                    GValue     *value,
+                                    GParamSpec *pspec)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (object);
+
+  switch (prop_id)
+    {
+    case PROP_LABEL:
+      g_value_set_string (value, demo_tagged_entry_tag_get_label (tag));
+      break;
+
+    case PROP_HAS_CLOSE_BUTTON:
+      g_value_set_boolean (value, demo_tagged_entry_tag_get_has_close_button (tag));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+demo_tagged_entry_tag_measure (GtkWidget      *widget,
+                               GtkOrientation  orientation,
+                               int             for_size,
+                               int            *minimum,
+                               int            *natural,
+                               int            *minimum_baseline,
+                               int            *natural_baseline)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (widget);
+
+  gtk_widget_measure (tag->box, orientation, for_size,
+                      minimum, natural,
+                      minimum_baseline, natural_baseline);
+}
+
+static void
+demo_tagged_entry_tag_size_allocate (GtkWidget *widget,
+                                     int        width,
+                                     int        height,
+                                     int        baseline)
+{
+  DemoTaggedEntryTag *tag = DEMO_TAGGED_ENTRY_TAG (widget);
+
+  gtk_widget_size_allocate (tag->box,
+                            &(GtkAllocation) { 0, 0, width, height },
+                            baseline);
+}
+
+static void
+demo_tagged_entry_tag_class_init (DemoTaggedEntryTagClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = demo_tagged_entry_tag_dispose;
+  object_class->finalize = demo_tagged_entry_tag_finalize;
+  object_class->set_property = demo_tagged_entry_tag_set_property;
+  object_class->get_property = demo_tagged_entry_tag_get_property;
+
+  widget_class->measure = demo_tagged_entry_tag_measure;
+  widget_class->size_allocate = demo_tagged_entry_tag_size_allocate;
+
+  signals[SIGNAL_CLICKED] =
+      g_signal_new ("clicked",
+                    DEMO_TYPE_TAGGED_ENTRY_TAG,
+                    G_SIGNAL_RUN_FIRST,
+                    0, NULL, NULL, NULL,
+                    G_TYPE_NONE, 0);
+  signals[SIGNAL_BUTTON_CLICKED] =
+      g_signal_new ("button-clicked",
+                    DEMO_TYPE_TAGGED_ENTRY_TAG,
+                    G_SIGNAL_RUN_FIRST,
+                    0, NULL, NULL, NULL,
+                    G_TYPE_NONE, 0);
+
+  g_object_class_install_property (object_class, PROP_LABEL,
+      g_param_spec_string ("label", "Label", "Label",
+                           NULL, G_PARAM_READWRITE));
+  g_object_class_install_property (object_class, PROP_HAS_CLOSE_BUTTON,
+      g_param_spec_boolean ("has-close-button", "Has close button", "Whether this tag has a close button",
+                            FALSE, G_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
+
+  gtk_widget_class_set_css_name (widget_class, "tag");
+}
+
+DemoTaggedEntryTag *
+demo_tagged_entry_tag_new (const char *label)
+{
+  return DEMO_TAGGED_ENTRY_TAG (g_object_new (DEMO_TYPE_TAGGED_ENTRY_TAG,
+                                              "label", label,
+                                              NULL));
+}
+
+const char *
+demo_tagged_entry_tag_get_label (DemoTaggedEntryTag *tag)
+{
+  g_return_val_if_fail (DEMO_IS_TAGGED_ENTRY_TAG (tag), NULL);
+
+  return gtk_label_get_label (GTK_LABEL (tag->label));
+}
+
+void
+demo_tagged_entry_tag_set_label (DemoTaggedEntryTag *tag,
+                                 const char         *label)
+{
+  g_return_if_fail (DEMO_IS_TAGGED_ENTRY_TAG (tag));
+
+  gtk_label_set_label (GTK_LABEL (tag->label), label);
+}
+
+static void
+on_button_clicked (GtkButton          *button,
+                   DemoTaggedEntryTag *tag)
+{
+  g_signal_emit (tag, signals[SIGNAL_BUTTON_CLICKED], 0);
+}
+
+void
+demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *tag,
+                                            gboolean            has_close_button)
+{
+  g_return_if_fail (DEMO_IS_TAGGED_ENTRY_TAG (tag));
+
+  if ((tag->button != NULL) == has_close_button)
+    return;
+
+  if (!has_close_button && tag->button)
+    {
+      gtk_container_remove (GTK_CONTAINER (tag->box), tag->button);
+      tag->button = NULL;
+    }
+  else if (has_close_button && tag->button == NULL)
+    {
+      GtkWidget *image;
+
+      image = gtk_image_new_from_icon_name ("window-close-symbolic");
+      tag->button = gtk_button_new ();
+      gtk_container_add (GTK_CONTAINER (tag->button), image);
+      gtk_widget_set_halign (tag->button, GTK_ALIGN_CENTER);
+      gtk_widget_set_valign (tag->button, GTK_ALIGN_CENTER);
+      gtk_button_set_relief (GTK_BUTTON (tag->button), GTK_RELIEF_NONE);
+      gtk_container_add (GTK_CONTAINER (tag->box), tag->button);
+      g_signal_connect (tag->button, "clicked", G_CALLBACK (on_button_clicked), tag);
+    }
+
+  g_object_notify (G_OBJECT (tag), "has-close-button");
+}
+
+gboolean
+demo_tagged_entry_tag_get_has_close_button (DemoTaggedEntryTag *tag)
+{
+  g_return_val_if_fail (DEMO_IS_TAGGED_ENTRY_TAG (tag), FALSE);
+
+  return tag->button != NULL;
+}

demos/gtk-demo/demotaggedentry.h

@@ -0,0 +1,89 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * Authors:
+ * - Matthias Clasen <mclasen@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __DEMO_TAGGED_ENTRY_H__
+#define __DEMO_TAGGED_ENTRY_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define DEMO_TYPE_TAGGED_ENTRY                 (demo_tagged_entry_get_type ())
+#define DEMO_TAGGED_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), DEMO_TYPE_TAGGED_ENTRY, DemoTaggedEntry))
+#define DEMO_TAGGED_ENTRY_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), DEMO_TYPE_TAGGED_ENTRY, DemoTaggedEntryClass))
+#define DEMO_IS_TAGGED_ENTRY(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DEMO_TYPE_TAGGED_ENTRY))
+#define DEMO_IS_TAGGED_ENTRY_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), DEMO_TYPE_TAGGED_ENTRY))
+#define DEMO_TAGGED_ENTRY_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), DEMO_TYPE_TAGGED_ENTRY, DemoTaggedEntryClass))
+
+typedef struct _DemoTaggedEntry       DemoTaggedEntry;
+typedef struct _DemoTaggedEntryClass  DemoTaggedEntryClass;
+
+struct _DemoTaggedEntry
+{
+  GtkWidget parent;
+};
+
+struct _DemoTaggedEntryClass
+{
+  GtkWidgetClass parent_class;
+};
+
+#define DEMO_TYPE_TAGGED_ENTRY_TAG                (demo_tagged_entry_tag_get_type ())
+#define DEMO_TAGGED_ENTRY_TAG(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), DEMO_TYPE_TAGGED_ENTRY_TAG, DemoTaggedEntryTag))
+#define DEMO_TAGGED_ENTRY_TAG_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), DEMO_TYPE_TAGGED_ENTRY_TAG, DemoTaggedEntryTag))
+#define DEMO_IS_TAGGED_ENTRY_TAG(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DEMO_TYPE_TAGGED_ENTRY_TAG))
+#define DEMO_IS_TAGGED_ENTRY_TAG_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), DEMO_TYPE_TAGGED_ENTRY_TAG))
+#define DEMO_TAGGED_ENTRY_TAG_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), DEMO_TYPE_TAGGED_ENTRY_TAG, DemoTaggedEntryTagClass))
+
+typedef struct _DemoTaggedEntryTag       DemoTaggedEntryTag;
+typedef struct _DemoTaggedEntryTagClass  DemoTaggedEntryTagClass;
+
+
+GType           demo_tagged_entry_get_type (void) G_GNUC_CONST;
+GType           demo_tagged_entry_tag_get_type (void) G_GNUC_CONST;
+
+GtkWidget *     demo_tagged_entry_new     (void);
+
+void            demo_tagged_entry_add_tag (DemoTaggedEntry *entry,
+                                           GtkWidget       *tag);
+
+void            demo_tagged_entry_insert_tag_after (DemoTaggedEntry *entry,
+                                                    GtkWidget       *tag,
+                                                    GtkWidget       *sibling);
+
+void            demo_tagged_entry_remove_tag (DemoTaggedEntry *entry,
+                                              GtkWidget       *tag);
+
+DemoTaggedEntryTag *
+                demo_tagged_entry_tag_new (const char *label);
+
+const char *    demo_tagged_entry_tag_get_label (DemoTaggedEntryTag *tag);
+
+void            demo_tagged_entry_tag_set_label (DemoTaggedEntryTag *tag,
+                                                 const char         *label);
+
+gboolean        demo_tagged_entry_tag_get_has_close_button (DemoTaggedEntryTag *tag);
+
+void            demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *tag,
+                                                            gboolean            has_close_button);
+
+G_END_DECLS
+
+#endif /* __DEMO_TAGGED_ENTRY_H__ */

demos/gtk-demo/dnd.c

@@ -196,7 +196,7 @@ edit_label_done (GtkWidget *entry, gpointer data)
   GtkWidget *label;
   int x, y;
 
-  gtk_container_child_get (GTK_CONTAINER (fixed), entry, "x", &x, "y", &y, NULL);
+  gtk_fixed_get_child_position (GTK_FIXED (fixed), entry, &x, &y);
 
   label = GTK_WIDGET (g_object_get_data (G_OBJECT (entry), "label"));
   gtk_label_set_text (GTK_LABEL (label), gtk_editable_get_text (GTK_EDITABLE (entry)));
@@ -210,7 +210,7 @@ edit_cb (GtkWidget *child)
   GtkWidget *fixed = gtk_widget_get_parent (child);
   int x, y;
 
-  gtk_container_child_get (GTK_CONTAINER (fixed), child, "x", &x, "y", &y, NULL);
+  gtk_fixed_get_child_position (GTK_FIXED (fixed), child, &x, &y);
 
   if (GTK_IS_LABEL (child))
     {

demos/gtk-demo/fishbowl.ui

@@ -23,58 +23,46 @@
             </child>
           </object>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkLabel">
             <property name="label">fps</property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkLabel">
             <property name="label" bind-source="bowl" bind-property="framerate"/>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkLabel">
             <property name="label">Icons, </property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkLabel">
             <property name="label" bind-source="bowl" bind-property="count"/>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkToggleButton" id="changes_allow">
             <property name="visible" bind-source="changes_allow" bind-property="active" bind-flags="invert-boolean"/>
             <property name="icon-name">changes-allow</property>
             <property name="relief">none</property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkToggleButton" id="changes_prevent">
-            <property name="active" bind-source="changes_allow" bind-property="active" bind-flags="bidirectional|invert-boolean">1</property>
-            <property name="visible" bind-source="changes_prevent" bind-property="active" bind-flags="invert-boolean">0</property>
+            <property name="active" bind-source="changes_allow" bind-property="active" bind-flags="bidirectional|invert-boolean"/>
+            <property name="visible" bind-source="changes_prevent" bind-property="active" bind-flags="invert-boolean"/>
             <property name="icon-name">changes-prevent</property>
             <property name="relief">none</property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
       </object>
     </child>
@@ -82,7 +70,7 @@
       <object class="GtkFishbowl" id="bowl">
         <property name="visible">True</property>
         <property name="animating">True</property>
-        <property name="benchmark" bind-source="changes_allow" bind-property="active" bind-flags="invert-boolean">1</property>
+        <property name="benchmark" bind-source="changes_allow" bind-property="active" bind-flags="invert-boolean"/>
       </object>
     </child>
   </object>

demos/gtk-demo/meson.build

@@ -65,6 +65,7 @@ demos = files([
   'spinner.c',
   'stack.c',
   'tabs.c',
+  'tagged_entry.c',
   'textmask.c',
   'textview.c',
   'textscroll.c',
@@ -76,7 +77,13 @@ demos = files([
 
 gtkdemo_deps = [ libgtk_dep, ]
 
-extra_demo_sources = files(['main.c', 'gtkfishbowl.c', 'fontplane.c', 'gtkgears.c', 'puzzlepiece.c', 'bluroverlay.c'])
+extra_demo_sources = files(['main.c',
+                            'gtkfishbowl.c',
+                            'fontplane.c',
+                            'gtkgears.c',
+                            'puzzlepiece.c',
+                            'bluroverlay.c',
+                            'demotaggedentry.c'])
 
 if harfbuzz_dep.found() and pangoft_dep.found()
   demos += files('font_features.c')

demos/gtk-demo/org.gtk.Demo.appdata.xml

@@ -30,4 +30,11 @@
   <translation type="gettext">gtk-4.0</translation>
   <update_contact>matthias.clasen_at_gmail.com</update_contact>
   <developer_name>Matthias Clasen and others</developer_name>
+  <releases>
+    <release version="3.94.0" date="2018-06-25">
+      <description>
+        <p>A new developers snapshot towards GTK 4.0.</p>
+      </description>
+    </release>
+  </releases>
 </component>

demos/gtk-demo/password_entry.c

@@ -27,19 +27,6 @@ update_button (GObject    *object,
                             text[0] != '\0' && g_str_equal (text, text2));
 }
 
-static int
-get_strength (GtkPasswordEntry *entry)
-{
-  const char *text;
-  int strength;
-
-  text = gtk_editable_get_text (GTK_EDITABLE (entry));
-
-  strength = CLAMP (10 * strlen (text), 0, 100);
-
-  return strength;
-}
-
 GtkWidget *
 do_password_entry (GtkWidget *do_widget)
 {
@@ -72,8 +59,6 @@ do_password_entry (GtkWidget *do_widget)
                     "activates-default", TRUE,
                     NULL);
       g_signal_connect (entry, "notify::text", G_CALLBACK (update_button), NULL);
-      gtk_password_entry_set_show_strength (GTK_PASSWORD_ENTRY (entry), TRUE);
-      g_signal_connect (entry, "get-strength", G_CALLBACK (get_strength), NULL);
       gtk_container_add (GTK_CONTAINER (box), entry);
 
       entry2 = gtk_password_entry_new ();

demos/gtk-demo/tagged_entry.c

@@ -0,0 +1,112 @@
+/* Entry/Tagged Entry
+ *
+ * This example shows how to build a complex composite
+ * entry using GtkText, outside of GTK.
+ *
+ * This tagged entry can display tags and other widgets
+ * inside the entry area.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include "demotaggedentry.h"
+
+static GtkWidget *spinner = NULL;
+
+static void
+closed_cb (DemoTaggedEntryTag *tag, DemoTaggedEntry *entry)
+{
+  demo_tagged_entry_remove_tag (entry, GTK_WIDGET (tag));
+}
+
+static void
+add_tag (GtkButton *button, DemoTaggedEntry *entry)
+{
+  DemoTaggedEntryTag *tag;
+
+  tag = demo_tagged_entry_tag_new ("Blue");
+  gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tag)), "blue");
+  demo_tagged_entry_tag_set_has_close_button (tag, TRUE);
+  g_signal_connect (tag, "button-clicked", G_CALLBACK (closed_cb), entry);
+
+  if (spinner == NULL)
+    demo_tagged_entry_add_tag (entry, GTK_WIDGET (tag));
+  else
+    demo_tagged_entry_insert_tag_after (entry, GTK_WIDGET (tag), gtk_widget_get_prev_sibling (spinner));
+}
+
+static void
+toggle_spinner (GtkCheckButton *button, DemoTaggedEntry *entry)
+{
+  if (spinner)
+    {
+      demo_tagged_entry_remove_tag (entry, spinner);
+      spinner = NULL; 
+    }
+  else
+    {
+      spinner = gtk_spinner_new ();
+      gtk_spinner_start (GTK_SPINNER (spinner));
+      demo_tagged_entry_add_tag (entry, spinner);
+    }
+}
+
+GtkWidget *
+do_tagged_entry (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *box;
+  GtkWidget *box2;
+  GtkWidget *header;
+  GtkWidget *entry;
+  GtkWidget *button;
+
+  if (!window)
+    {
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      header = gtk_header_bar_new ();
+      gtk_header_bar_set_title (GTK_HEADER_BAR (header), "A tagged entry");
+      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_deletable (GTK_WINDOW (window), FALSE);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+      g_object_set (box, "margin", 18, NULL);
+      gtk_container_add (GTK_CONTAINER (window), box);
+
+      entry = demo_tagged_entry_new ();
+      gtk_container_add (GTK_CONTAINER (box), entry);
+
+      box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+      gtk_widget_set_halign (box2, GTK_ALIGN_END);
+      gtk_container_add (GTK_CONTAINER (box), box2);
+
+      button = gtk_button_new_with_mnemonic ("Add _Tag");
+      g_signal_connect (button, "clicked", G_CALLBACK (add_tag), entry);
+      gtk_container_add (GTK_CONTAINER (box2), button);
+
+      button = gtk_check_button_new_with_mnemonic ("_Spinner");
+      g_signal_connect (button, "toggled", G_CALLBACK (toggle_spinner), entry);
+      gtk_container_add (GTK_CONTAINER (box2), button);
+      
+      button = gtk_button_new_with_mnemonic ("_Done");
+      gtk_style_context_add_class (gtk_widget_get_style_context (button), "suggested-action");
+      g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
+      gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
+
+      gtk_widget_set_can_default (button, TRUE);
+      gtk_window_set_default (GTK_WINDOW (window), button);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/tagstyle.css

@@ -0,0 +1,19 @@
+tag {
+  margin: 4px;
+  padding: 4px;
+  border-radius: 4px;
+  background: lightskyblue;
+}
+tag box {
+  border-spacing: 4px;
+}
+tag label,
+tag image {
+  color: white;
+}
+tag button {
+  min-height: 0;
+  min-width: 0;
+  padding: 0;
+  border: 1px solid white;
+}

demos/gtk-demo/theming.ui

@@ -11,41 +11,36 @@
         </style>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Normal</property>
             <property name="use-underline">1</property>
             <property name="is-important">1</property>
             <property name="icon-name">edit-find</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Active</property>
             <property name="use-underline">1</property>
             <property name="is-important">1</property>
             <property name="icon-name">edit-find</property>
             <property name="active">1</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="sensitive">0</property>
             <property name="label" translatable="yes">Insensitive</property>
             <property name="use-underline">1</property>
             <property name="is-important">1</property>
             <property name="icon-name">edit-find</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Raised</property>
             <property name="use-underline">1</property>
             <property name="is-important">1</property>
@@ -54,12 +49,10 @@
               <class name="raised"/>
             </style>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Raised Active</property>
             <property name="use-underline">1</property>
             <property name="is-important">1</property>
@@ -69,12 +62,10 @@
               <class name="raised"/>
             </style>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="sensitive">0</property>
             <property name="label" translatable="yes">Insensitive Active</property>
             <property name="use-underline">1</property>
@@ -82,9 +73,6 @@
             <property name="is-important">1</property>
             <property name="active">1</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToolItem">
@@ -149,68 +137,56 @@
         </style>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Normal</property>
             <property name="use-underline">1</property>
             <property name="icon-name">list-add-symbolic</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Normal</property>
             <property name="use-underline">1</property>
             <property name="icon-name">list-add-symbolic</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Active</property>
             <property name="use-underline">1</property>
             <property name="icon-name">list-remove-symbolic</property>
             <property name="active">1</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="label" translatable="yes">Active</property>
             <property name="use-underline">1</property>
             <property name="icon-name">list-remove-symbolic</property>
             <property name="active">1</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="sensitive">0</property>
             <property name="label" translatable="yes">Insensitive</property>
             <property name="use-underline">1</property>
             <property name="icon-name">edit-find-symbolic</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
         <child>
           <object class="GtkToggleToolButton">
+            <property name="homogeneous">1</property>
             <property name="sensitive">0</property>
             <property name="label" translatable="yes">Insensitive Active</property>
             <property name="use-underline">1</property>
             <property name="icon-name">go-up-symbolic</property>
             <property name="active">1</property>
           </object>
-          <packing>
-            <property name="homogeneous">1</property>
-          </packing>
         </child>
       </object>
     </child>

demos/icon-browser/window.ui

@@ -35,7 +35,7 @@
             </child>
           </object>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkToggleButton" id="search">
             <style>
               <class name="image-button"/>
@@ -46,9 +46,7 @@
               </object>
             </child>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
       </object>
     </child>

demos/widget-factory/org.gtk.WidgetFactory.appdata.xml

@@ -31,4 +31,11 @@
   <translation type="gettext">gtk-4.0</translation>
   <update_contact>matthias.clasen_at_gmail.com</update_contact>
   <developer_name>Matthias Clasen and others</developer_name>
+  <releases>
+    <release version="3.94.0" date="2018-06-25">
+      <description>
+        <p>A new developers snapshot towards GTK 4.0.</p>
+      </description>
+    </release>
+  </releases>
 </component>

demos/widget-factory/widget-factory.c

@@ -48,7 +48,7 @@ change_transition_state (GSimpleAction *action,
   GtkStackTransitionType transition;
 
   if (g_variant_get_boolean (state))
-    transition = GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT;
+    transition = GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT;
   else
     transition = GTK_STACK_TRANSITION_TYPE_NONE;
 

demos/widget-factory/widget-factory.ui

@@ -411,15 +411,12 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
             <property name="stack">toplevel_stack</property>
           </object>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkMenuButton" id="gear_menu_button">
             <property name="valign">center</property>
             <property name="menu-model">gear_menu</property>
             <property name="icon-name">open-menu-symbolic</property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
         </child>
       </object>
     </child>
@@ -429,7 +426,7 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
         <property name="margin">10</property>
         <child>
           <object class="GtkStack" id="toplevel_stack">
-            <property name="transition-duration">30000</property>
+            <property name="transition-duration">1000</property>
             <child>
               <object class="GtkStackPage">
                 <property name="name">page1</property>
@@ -1588,16 +1585,13 @@ microphone-sensitivity-medium-symbolic</property>
                                             <property name="halign">center</property>
                                           </object>
                                         </child>
-                                        <child>
+                                        <child type="end">
                                           <object class="GtkMenuButton">
                                             <property name="menu-model">dinner_menu</property>
                                             <property name="halign">center</property>
                                             <property name="valign">center</property>
                                             <property name="icon-name">emblem-system-symbolic</property>
                                           </object>
-                                          <packing>
-                                            <property name="pack-type">end</property>
-                                          </packing>
                                         </child>
                                       </object>
                                     </child>
@@ -2848,6 +2842,7 @@ microphone-sensitivity-medium-symbolic</property>
                                 </child>
                                 <child>
                                   <object class="GtkToolItem">
+                                    <property name="expand-item">1</property>
                                     <child>
                                       <object class="GtkScale">
                                         <property name="draw-value">0</property>
@@ -2855,9 +2850,6 @@ microphone-sensitivity-medium-symbolic</property>
                                       </object>
                                     </child>
                                   </object>
-                                  <packing>
-                                    <property name="expand">1</property>
-                                  </packing>
                                 </child>
                                 <child>
                                   <object class="GtkToolItem">

docs/reference/gdk/gdk4-sections.txt

@@ -271,7 +271,6 @@ gdk_surface_get_frame_extents
 gdk_surface_get_origin
 gdk_surface_get_root_coords
 gdk_surface_get_device_position
-gdk_surface_get_device_position_double
 GdkModifierType
 GdkModifierIntent
 gdk_surface_get_parent
@@ -280,7 +279,6 @@ gdk_surface_get_children
 gdk_surface_peek_children
 gdk_surface_set_icon_name
 gdk_surface_set_transient_for
-gdk_surface_set_role
 gdk_surface_set_startup_id
 gdk_surface_set_group
 gdk_surface_get_group
@@ -502,7 +500,6 @@ gdk_device_get_has_cursor
 gdk_device_get_n_axes
 gdk_device_get_n_keys
 gdk_device_get_axes
-gdk_device_warp
 gdk_device_get_seat
 
 <SUBSECTION>
@@ -512,9 +509,7 @@ gdk_device_ungrab
 <SUBSECTION>
 gdk_device_get_state
 gdk_device_get_position
-gdk_device_get_position_double
 gdk_device_get_surface_at_position
-gdk_device_get_surface_at_position_double
 gdk_device_get_history
 gdk_device_free_history
 GdkTimeCoord

docs/reference/gsk/gsk4-docs.xml

@@ -18,6 +18,7 @@
     <title>API Reference</title>
     <xi:include href="xml/GskRenderer.xml" />
     <xi:include href="xml/GskRenderNode.xml" />
+    <xi:include href="xml/GskRoundedRect.xml" />
     <xi:include href="xml/GskTransform.xml" />
   </reference>
 

docs/reference/gsk/gsk4-sections.txt

@@ -2,9 +2,9 @@
 <FILE>GskRenderer</FILE>
 gsk_renderer_new_for_surface
 gsk_renderer_get_surface
-gsk_renderer_get_display
 gsk_renderer_realize
 gsk_renderer_unrealize
+gsk_renderer_is_realized
 gsk_renderer_render
 gsk_renderer_render_texture
 <SUBSECTION Standard>
@@ -67,11 +67,7 @@ gsk_container_node_get_n_children
 gsk_container_node_get_child
 gsk_transform_node_new
 gsk_transform_node_get_child
-gsk_transform_node_peek_transform
-gsk_offset_node_new
-gsk_offset_node_get_child
-gsk_offset_node_get_x_offset
-gsk_offset_node_get_y_offset
+gsk_transform_node_get_transform
 gsk_opacity_node_new
 gsk_opacity_node_get_child
 gsk_opacity_node_get_opacity
@@ -147,7 +143,6 @@ gsk_rounded_rect_intersects_rect
 
 <SECTION>
 <FILE>GskTransform</FILE>
-<TITLE>3D transformations</TITLE>
 GskTransform
 gsk_transform_ref
 gsk_transform_unref

docs/reference/gtk/css-overview.xml

@@ -546,7 +546,7 @@ checkbutton:indeterminate {
       GTK adds several additional ways to specify colors.
     </para>
 
-<literallayout><code>〈gtk color〉 = 〈symbolic color〉 | 〈color expression〉 | 〈win32 color〉</code>
+<literallayout><code>〈gtk color〉 = 〈symbolic color〉 | 〈color expression〉</code>
 </literallayout>
 
     <para>
@@ -592,13 +592,6 @@ checkbutton:indeterminate {
 
 <literallayout><code>〈color expression〉 = lighter( 〈color〉 ) | darker( 〈color〉 ) | shade( 〈color〉, 〈number〉 ) |</code>
 <code>                     alpha( 〈color〉, 〈number〉 ) | mix( 〈color〉, 〈color〉, 〈number〉 )</code>
-</literallayout>
-
-    <para>
-      On Windows, GTK allows to refer to system colors, as follows:
-    </para>
-
-<literallayout><code>〈win32 color〉 = -gtk-win32-color( 〈name〉, 〈integer〉 )</code>
 </literallayout>
 
   </refsect2>
@@ -737,7 +730,7 @@ label {
       GTK extends the CSS syntax for images and also uses it for specifying icons.
     </para>
 
-<literallayout><code>〈gtk image〉 = 〈themed icon〉 | 〈scaled image〉 | 〈recolored image〉 | 〈win32 theme part〉</code>
+<literallayout><code>〈gtk image〉 = 〈themed icon〉 | 〈scaled image〉 | 〈recolored image〉</code>
 </literallayout>
 
     <para>
@@ -815,13 +808,6 @@ arrow {
 }
 ]]></programlisting>
     </example>
-    <para>
-      On Windows, GTK allows to refer to system theme parts as images, as follows:
-    </para>
-
-<literallayout><code>〈win32 theme part〉 = -gtk-win32-theme-part( 〈name〉, 〈integer〉 〈integer〉</code>
-<code>                                              [ , [ over( 〈integer〉 〈integer〉 [ , 〈alpha value〉 ]? ) | margins( 〈integer〉{1,4} ) ] ]* )</code>
-</literallayout>
 
   </refsect2>
 

docs/reference/gtk/css-properties.xml

@@ -65,20 +65,6 @@ We use <literallayout> for syntax productions, and each line is put in a <code>
       not quite the same as the CSS definition of rem.
     </para>
 
-    <para>
-      Whereever a number is allowed, GTK also accepts a Windows-specific
-      theme size:
-    </para>
-
-<literallayout>
-<code>〈win32 theme size〉 = 〈win32 size〉 | 〈win32 part size〉</code>
-<code>〈win32 size〉 = -gtk-win32-size ( 〈theme name〉, 〈metric id〉 )</code>
-<code>〈win32 part size〉 = [ -gtk-win32-part-width | -gtk-win32-part-height |</code>
-<code>                      -gtk-win32-part-border-top | -gtk-win32-part-border-right |</code>
-<code>                      -gtk-win32-part-border-bottom | -gtk-win32-part-border-left ]</code>
-<code>                    ( 〈theme name〉 , 〈integer〉 , 〈integer〉 )</code>
-</literallayout>
-
 <literallayout><code>〈calc expression〉 = calc( 〈calc sum〉 )</code>
 <code>〈calc sum〉 = 〈calc product〉 [ [ + | - ] 〈calc product〉 ]*</code>
 <code>〈calc product〉 = 〈calc value〉 [ * 〈calc value〉 | / 〈number〉 ]*</code>

docs/reference/gtk/gtk4-docs.xml

@@ -100,6 +100,13 @@
       <xi:include href="xml/gtkfixed.xml" />
     </chapter>
 
+    <chapter id="LayoutManagers">
+      <title>Layout Managers</title>
+      <xi:include href="xml/gtklayoutmanager.xml" />
+      <xi:include href="xml/gtklayoutchild.xml" />
+      <xi:include href="xml/gtkboxlayout.xml" />
+    </chapter>
+
     <chapter id="DisplayWidgets">
       <title>Display Widgets</title>
       <xi:include href="xml/gtklabel.xml" />

docs/reference/gtk/gtk4-sections.txt

@@ -424,6 +424,7 @@ gtk_selection_model_select_range
 gtk_selection_model_unselect_range
 gtk_selection_model_select_all
 gtk_selection_model_unselect_all
+gtk_selection_model_query_range
 <SUBSECTION>
 gtk_selection_model_selection_changed
 <SUBSECTION Standard>
@@ -1297,6 +1298,8 @@ gtk_file_filter_get_type
 <TITLE>GtkFilterListModel</TITLE>
 GtkFilterListModel
 gtk_filter_list_model_new
+gtk_filter_list_model_new_for_type
+gtk_filter_list_model_set_model
 gtk_filter_list_model_get_model
 gtk_filter_list_model_set_filter_func
 gtk_filter_list_model_has_filter
@@ -1386,6 +1389,7 @@ gtk_font_chooser_set_font
 gtk_font_chooser_get_font_desc
 gtk_font_chooser_set_font_desc
 gtk_font_chooser_get_font_features
+gtk_font_chooser_get_language
 gtk_font_chooser_set_language
 gtk_font_chooser_get_preview_text
 gtk_font_chooser_set_preview_text
@@ -4378,6 +4382,8 @@ gtk_snapshot_push_clip
 gtk_snapshot_push_rounded_clip
 gtk_snapshot_push_cross_fade
 gtk_snapshot_push_blend
+gtk_snapshot_push_blur
+gtk_snapshot_push_shadow
 gtk_snapshot_push_debug
 gtk_snapshot_pop
 gtk_snapshot_save
@@ -4406,6 +4412,8 @@ gtk_snapshot_render_frame
 gtk_snapshot_render_focus
 gtk_snapshot_render_layout
 gtk_snapshot_render_insertion_cursor
+<SUBSECTION Private>
+gtk_snapshot_get_type
 </SECTION>
 
 <SECTION>
@@ -4496,7 +4504,6 @@ gtk_widget_get_cursor
 gtk_widget_set_cursor
 gtk_widget_set_cursor_from_name
 gtk_widget_mnemonic_activate
-gtk_widget_send_focus_change
 gtk_widget_class_set_accessible_type
 gtk_widget_class_set_accessible_role
 gtk_widget_get_accessible
@@ -4590,6 +4597,8 @@ gtk_widget_get_first_child
 gtk_widget_get_last_child
 gtk_widget_insert_before
 gtk_widget_insert_after
+gtk_widget_set_layout_manager
+gtk_widget_get_layout_manager
 
 <SUBSECTION>
 gtk_widget_get_path
@@ -4686,8 +4695,6 @@ gtk_window_activate_focus
 gtk_window_activate_default
 gtk_window_set_modal
 gtk_window_set_default_size
-gtk_window_set_gravity
-gtk_window_get_gravity
 gtk_window_set_hide_on_close
 gtk_window_get_hide_on_close
 GtkWindowPosition
@@ -4735,7 +4742,6 @@ gtk_window_set_urgency_hint
 gtk_window_set_accept_focus
 gtk_window_set_focus_on_map
 gtk_window_set_startup_id
-gtk_window_set_role
 gtk_window_get_decorated
 gtk_window_get_deletable
 gtk_window_get_default_icon_name
@@ -4744,8 +4750,6 @@ gtk_window_get_destroy_with_parent
 gtk_window_get_icon_name
 gtk_window_get_mnemonic_modifier
 gtk_window_get_modal
-gtk_window_get_position
-gtk_window_get_role
 gtk_window_get_size
 gtk_window_get_title
 gtk_window_get_transient_for
@@ -4759,7 +4763,6 @@ gtk_window_get_focus_on_map
 gtk_window_get_group
 gtk_window_has_group
 gtk_window_get_window_type
-gtk_window_move
 gtk_window_resize
 gtk_window_set_default_icon_name
 gtk_window_set_icon_name
@@ -6216,6 +6219,10 @@ gtk_color_chooser_get_use_alpha
 gtk_color_chooser_set_use_alpha
 gtk_color_chooser_add_palette
 
+<SUBSECTION>
+gtk_hsv_to_rgb
+gtk_rgb_to_hsv
+
 <SUBSECTION Standard>
 GTK_TYPE_COLOR_CHOOSER
 GTK_COLOR_CHOOSER
@@ -6333,6 +6340,7 @@ gtk_stack_add_named
 gtk_stack_add_titled
 gtk_stack_get_child_by_name
 gtk_stack_get_page
+gtk_stack_get_pages
 gtk_stack_page_get_child
 gtk_stack_set_visible_child
 gtk_stack_get_visible_child
@@ -6363,6 +6371,7 @@ GTK_STACK_GET_CLASS
 
 <SUBSECTION Private>
 gtk_stack_get_type
+gtk_stack_page_get_type
 </SECTION>
 
 <SECTION>
@@ -6524,6 +6533,7 @@ gtk_popover_get_type
 <TITLE>GtkPopoverMenu</TITLE>
 GtkPopoverMenu
 gtk_popover_menu_new
+gtk_popover_menu_add_submenu
 gtk_popover_menu_open_submenu
 
 <SUBSECTION Standard>
@@ -6684,6 +6694,8 @@ gtk_event_controller_scroll_get_type
 <TITLE>GtkEventControllerMotion</TITLE>
 GtkEventControllerMotion
 gtk_event_controller_motion_new
+gtk_event_controller_motion_get_pointer_origin
+gtk_event_controller_motion_get_pointer_target
 
 <SUBSECTION Standard>
 GTK_TYPE_EVENT_CONTROLLER_MOTION
@@ -6702,6 +6714,12 @@ gtk_event_controller_motion_get_type
 <TITLE>GtkEventControllerKey</TITLE>
 GtkEventControllerKey
 gtk_event_controller_key_new
+gtk_event_controller_key_set_im_context
+gtk_event_controller_key_get_im_context
+gtk_event_controller_key_forward
+gtk_event_controller_key_get_group
+gtk_event_controller_key_get_focus_origin
+gtk_event_controller_key_get_focus_target
 
 <SUBSECTION Standard>
 GTK_TYPE_EVENT_CONTROLLER_KEY
@@ -7141,6 +7159,59 @@ gtk_media_stream_get_type
 <TITLE>GtkRoot</TITLE>
 GtkRoot
 gtk_root_get_for_surface
+gtk_root_get_focus
+gtk_root_set_focus
+
+<SUBSECTION>
+gtk_root_install_properties
+
 <SUBSECTION Private>
 gtk_root_get_type
 </SECTION>
+
+<SECTION>
+<FILE>gtklayoutmanager</FILE>
+GtkLayoutManager
+GtkLayoutManagerClass
+
+gtk_layout_manager_measure
+gtk_layout_manager_allocate
+gtk_layout_manager_get_request_mode
+gtk_layout_manager_get_widget
+gtk_layout_manager_get_layout_child
+gtk_layout_manager_layout_changed
+
+<SUBSECTION Standard>
+GTK_TYPE_LAYOUT_MANAGER
+gtk_layout_manager_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtklayoutchild</FILE>
+GtkLayoutChild
+GtkLayoutChildClass
+
+gtk_layout_child_get_layout_manager
+gtk_layout_child_get_child_widget
+
+<SUBSECTION Standard>
+GTK_TYPE_LAYOUT_CHILD
+gtk_layout_child_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkboxlayout</FILE>
+GtkBoxLayout
+
+gtk_box_layout_new
+gtk_box_layout_set_homogeneous
+gtk_box_layout_get_homogeneous
+gtk_box_layout_set_spacing
+gtk_box_layout_get_spacing
+gtk_box_layout_set_baseline_position
+gtk_box_layout_get_baseline_position
+
+<SUBSECTION Standard>
+GTK_TYPE_BOX_LAYOUT
+gtk_box_layout_get_type
+</SECTION>

docs/reference/gtk/migrating-3to4.xml

@@ -289,6 +289,28 @@
       </para>
     </section>
 
+    <section>
+      <title>Stop using gdk_pointer_warp()</title>
+      <para>
+        Warping the pointer is disorienting and unfriendly to users.
+        GTK 4 does not support it. In special circumstances (such as when
+        implementing remote connection UIs) it can be necessary to
+        warp the pointer; in this case, use platform APIs such as XWarpPointer
+        directly.
+      </para>
+    </section>
+
+    <section>
+      <title>Adapt to coordinate api changes</title>
+      <para>
+        A number of coordinate apis in GTK 3 had _double variants: 
+        gdk_device_get_position(), gdk_device_get_surface_at_position(),
+        gdk_surface_get_device_position(). These have been changed to use
+        doubles, and the _double variants have been removed. Update your
+        code accordingly.
+      </para>
+    </section>
+
     <section>
       <title>Adapt to GdkKeymap API changes</title>
       <para>
@@ -321,12 +343,22 @@
     </section>
 
     <section>
-      <title>Adapt to GtkHeaderBar API changes</title>
+      <title>Adapt to GtkHeaderBar and GtkActionBar API changes</title>
       <para>
         The gtk_header_bar_set_show_close_button() function has been renamed to
         the more accurate name gtk_header_bar_set_show_title_buttons(). The corresponding
         getter and the property itself have also been renamed.
       </para>
+      <para>
+        The ::pack-type child properties of GtkHeaderBar and GtkActionBar have
+        been removed. If you need to programmatically place children, use the
+        pack_start() and pack_end() APIs. In ui files, use the type attribute
+        on the child element.
+      </para>
+      <para>
+        gtk4-builder-tool can help with this conversion, with the --3to4 option
+        of the simplify command.
+      </para>
     </section>
 
     <section>

docs/reference/gtk/x11.sgml

@@ -150,11 +150,8 @@ see for example <link
 linkend="gtk-window-iconify">gtk_window_iconify()</link> or <link
 linkend="gtk-window-maximize">gtk_window_maximize()</link> or <link
 linkend="gtk-window-set-decorated">gtk_window_set_decorated()</link>.
-Keep in mind that <link
-linkend="gtk-window-move">gtk_window_move()</link> and window sizing
-are ultimately controlled by the window manager as well and most
-window managers <emphasis>will</emphasis> ignore certain requests from
-time to time, in the interests of good user interface.
+Keep in mind that most window managers <emphasis>will</emphasis> ignore
+certain requests from time to time, in the interests of good user interface.
 </para>
 
 <!--

examples/application10/window.ui

@@ -22,25 +22,21 @@
             <property name="stack">stack</property>
           </object>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkToggleButton" id="search">
             <property name="sensitive">0</property>
             <property name="icon-name">edit-find-symbolic</property>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
-        <child>
+        <child type="end">
           <object class="GtkMenuButton" id="gears">
             <property name="direction">none</property>
             <style>
               <class name="image-button"/>
             </style>
           </object>
-          <packing>
-            <property name="pack-type">end</property>
-          </packing>
+          <packing/>
         </child>
       </object>
     </child>

examples/application7/window.ui

@@ -13,14 +13,12 @@
                 <property name="stack">stack</property>
               </object>
             </child>
-            <child>
+            <child type="end">
               <object class="GtkToggleButton" id="search">
                 <property name="sensitive">0</property>
                 <property name="icon-name">edit-find-symbolic</property>
               </object>
-              <packing>
-                <property name="pack-type">end</property>
-              </packing>
+              <packing/>
             </child>
           </object>
         </child>

examples/application8/window.ui

@@ -13,25 +13,21 @@
                 <property name="stack">stack</property>
               </object>
             </child>
-            <child>
+            <child type="end">
               <object class="GtkToggleButton" id="search">
                 <property name="sensitive">0</property>
                 <property name="icon-name">edit-find-symbolic</property>
               </object>
-              <packing>
-                <property name="pack-type">end</property>
-              </packing>
+              <packing/>
             </child>
-            <child>
+            <child type="end">
               <object class="GtkMenuButton" id="gears">
                 <property name="direction">none</property>
                 <style>
                   <class name="image-button"/>
                 </style>
               </object>
-              <packing>
-                <property name="pack-type">end</property>
-              </packing>
+              <packing/>
             </child>
           </object>
         </child>

examples/application9/window.ui

@@ -24,25 +24,21 @@
                 <property name="stack">stack</property>
               </object>
             </child>
-            <child>
+            <child type="end">
               <object class="GtkToggleButton" id="search">
                 <property name="sensitive">0</property>
                 <property name="icon-name">edit-find-symbolic</property>
               </object>
-              <packing>
-                <property name="pack-type">end</property>
-              </packing>
+              <packing/>
             </child>
-            <child>
+            <child type="end">
               <object class="GtkMenuButton" id="gears">
                 <property name="direction">none</property>
                 <style>
                   <class name="image-button"/>
                 </style>
               </object>
-              <packing>
-                <property name="pack-type">end</property>
-              </packing>
+              <packing/>
             </child>
           </object>
         </child>

gdk/broadway/broadway-protocol.h

@@ -22,6 +22,9 @@ typedef enum { /* Sync changes with broadway.js */
   BROADWAY_NODE_CLIP = 10,
   BROADWAY_NODE_KEEP_ALL = 11,
   BROADWAY_NODE_KEEP_THIS = 12,
+  BROADWAY_NODE_TRANSFORM = 13,
+  BROADWAY_NODE_DEBUG = 14,
+  BROADWAY_NODE_REUSE = 15,
 } BroadwayNodeType;
 
 static const char *broadway_node_type_names[] G_GNUC_UNUSED =  {
@@ -38,6 +41,8 @@ static const char *broadway_node_type_names[] G_GNUC_UNUSED =  {
   "CLIP",
   "KEEP_ALL",
   "KEEP_THIS",
+  "TRANSLATE",
+  "DEBUG",
 };
 
 typedef enum {

gdk/broadway/broadway-server.c

@@ -35,7 +35,6 @@
 #include <string.h>
 #endif
 
-
 typedef struct {
   int id;
   guint32 tag;
@@ -126,23 +125,56 @@ struct BroadwaySurface {
   gint32 transient_for;
   guint32 texture;
   BroadwayNode *nodes;
+  GHashTable *node_lookup;
+};
+
+struct _BroadwayTexture {
+  grefcount refcount;
+  guint32 id;
+  GBytes *bytes;
 };
 
 static void broadway_server_resync_surfaces (BroadwayServer *server);
 static void send_outstanding_roundtrips (BroadwayServer *server);
 
+static void broadway_server_ref_texture (BroadwayServer   *server,
+                                         guint32           id);
+
 static GType broadway_server_get_type (void);
 
 G_DEFINE_TYPE (BroadwayServer, broadway_server, G_TYPE_OBJECT)
 
 static void
-broadway_node_free (BroadwayNode *node)
+broadway_texture_free (BroadwayTexture *texture)
+{
+  g_bytes_unref (texture->bytes);
+  g_free (texture);
+}
+
+static void
+broadway_node_unref (BroadwayServer *server,
+                     BroadwayNode *node)
 {
   int i;
-  for (i = 0; i < node->n_children; i++)
-    broadway_node_free (node->children[i]);
 
-  g_free (node);
+  if (g_ref_count_dec (&node->refcount))
+    {
+      for (i = 0; i < node->n_children; i++)
+        broadway_node_unref (server, node->children[i]);
+
+      if (node->texture_id)
+        broadway_server_release_texture (server, node->texture_id);
+
+      g_free (node);
+    }
+}
+
+static BroadwayNode *
+broadway_node_ref (BroadwayNode *node)
+{
+  g_ref_count_inc (&node->refcount);
+
+  return node;
 }
 
 gboolean
@@ -204,7 +236,7 @@ broadway_server_init (BroadwayServer *server)
   server->surface_id_hash = g_hash_table_new (NULL, NULL);
   server->id_counter = 0;
   server->textures = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
-                                            (GDestroyNotify)g_bytes_unref);
+                                            (GDestroyNotify)broadway_texture_free);
 
   root = g_new0 (BroadwaySurface, 1);
   root->id = server->id_counter++;
@@ -241,10 +273,12 @@ broadway_server_class_init (BroadwayServerClass * class)
 }
 
 static void
-broadway_surface_free (BroadwaySurface *surface)
+broadway_surface_free (BroadwayServer *server,
+                       BroadwaySurface *surface)
 {
   if (surface->nodes)
-    broadway_node_free (surface->nodes);
+    broadway_node_unref (server, surface->nodes);
+  g_hash_table_unref (surface->node_lookup);
   g_free (surface);
 }
 
@@ -1477,7 +1511,7 @@ broadway_server_destroy_surface (BroadwayServer *server,
       server->surfaces = g_list_remove (server->surfaces, surface);
       g_hash_table_remove (server->surface_id_hash,
                            GINT_TO_POINTER (id));
-      broadway_surface_free (surface);
+      broadway_surface_free (server, surface);
     }
 }
 
@@ -1605,53 +1639,242 @@ broadway_server_has_client (BroadwayServer *server)
   return server->output != NULL;
 }
 
+#define NODE_SIZE_COLOR 1
+#define NODE_SIZE_FLOAT 1
+#define NODE_SIZE_POINT 2
+#define NODE_SIZE_MATRIX 16
+#define NODE_SIZE_SIZE 2
+#define NODE_SIZE_RECT (NODE_SIZE_POINT + NODE_SIZE_SIZE)
+#define NODE_SIZE_RRECT (NODE_SIZE_RECT + 4 * NODE_SIZE_SIZE)
+#define NODE_SIZE_COLOR_STOP (NODE_SIZE_FLOAT + NODE_SIZE_COLOR)
+#define NODE_SIZE_SHADOW (NODE_SIZE_COLOR + 3 * NODE_SIZE_FLOAT)
+
+static guint32
+rotl (guint32 value, int shift)
+{
+  if ((shift &= 32 - 1) == 0)
+    return value;
+  return (value << shift) | (value >> (32 - shift));
+}
+
+static BroadwayNode *
+decode_nodes (BroadwayServer *server,
+              BroadwaySurface *surface,
+              int len,
+              guint32 data[],
+              GHashTable  *client_texture_map,
+              int *pos)
+{
+  BroadwayNode *node;
+  guint32 type, id;
+  guint32 i, n_stops, n_shadows, n_chars;
+  guint32 size, n_children;
+  gint32 texture_offset;
+  guint32 hash;
+  guint32 transform_type;
+
+  g_assert (*pos < len);
+
+  size = 0;
+  n_children = 0;
+  texture_offset = -1;
+
+  type = data[(*pos)++];
+  id = data[(*pos)++];
+  switch (type) {
+  case BROADWAY_NODE_REUSE:
+    node = g_hash_table_lookup (surface->node_lookup, GINT_TO_POINTER(id));
+    g_assert (node != NULL);
+    return broadway_node_ref (node);
+    break;
+  case BROADWAY_NODE_COLOR:
+    size = NODE_SIZE_RECT + NODE_SIZE_COLOR;
+    break;
+  case BROADWAY_NODE_BORDER:
+    size = NODE_SIZE_RRECT + 4 * NODE_SIZE_FLOAT + 4 * NODE_SIZE_COLOR;
+    break;
+  case BROADWAY_NODE_INSET_SHADOW:
+  case BROADWAY_NODE_OUTSET_SHADOW:
+    size = NODE_SIZE_RRECT + NODE_SIZE_COLOR + 4 * NODE_SIZE_FLOAT;
+    break;
+  case BROADWAY_NODE_TEXTURE:
+    texture_offset = 4;
+    size = 5;
+    break;
+  case BROADWAY_NODE_CONTAINER:
+    size = 1;
+    n_children = data[*pos];
+    break;
+  case BROADWAY_NODE_ROUNDED_CLIP:
+    size = NODE_SIZE_RRECT;
+    n_children = 1;
+    break;
+  case BROADWAY_NODE_CLIP:
+    size = NODE_SIZE_RECT;
+    n_children = 1;
+    break;
+  case BROADWAY_NODE_TRANSFORM:
+    transform_type = data[(*pos)];
+    size = 1;
+    if (transform_type == 0) {
+      size += NODE_SIZE_POINT;
+    } else if (transform_type == 1) {
+      size += NODE_SIZE_MATRIX;
+    } else {
+      g_assert_not_reached();
+    }
+    n_children = 1;
+    break;
+  case BROADWAY_NODE_LINEAR_GRADIENT:
+    size = NODE_SIZE_RECT + 2 * NODE_SIZE_POINT;
+    n_stops = data[*pos + size++];
+    size += n_stops * NODE_SIZE_COLOR_STOP;
+    break;
+  case BROADWAY_NODE_SHADOW:
+    size = 1;
+    n_shadows = data[*pos];
+    size += n_shadows * NODE_SIZE_SHADOW;
+    n_children = 1;
+    break;
+  case BROADWAY_NODE_OPACITY:
+    size = NODE_SIZE_FLOAT;
+    n_children = 1;
+    break;
+  case BROADWAY_NODE_DEBUG:
+    n_chars = data[*pos];
+    size = 1 + (n_chars + 3) / 4;
+    n_children = 1;
+    break;
+  default:
+    g_assert_not_reached ();
+  }
+
+  node = g_malloc (sizeof(BroadwayNode) + (size - 1) * sizeof(guint32) + n_children * sizeof (BroadwayNode *));
+  g_ref_count_init (&node->refcount);
+  node->type = type;
+  node->id = id;
+  node->texture_id = 0;
+  node->n_children = n_children;
+  node->children = (BroadwayNode **)((char *)node + sizeof(BroadwayNode) + (size - 1) * sizeof(guint32));
+  node->n_data = size;
+  for (i = 0; i < size; i++)
+    {
+      node->data[i] = data[(*pos)++];
+      if (i == texture_offset)
+        {
+          node->texture_id = GPOINTER_TO_INT (g_hash_table_lookup (client_texture_map, GINT_TO_POINTER (node->data[i])));
+          broadway_server_ref_texture (server, node->texture_id);
+          node->data[i] = node->texture_id;
+        }
+    }
+
+  for (i = 0; i < n_children; i++)
+    node->children[i] = decode_nodes (server, surface, len, data, client_texture_map, pos);
+
+  hash = node->type << 16;
+
+  for (i = 0; i < size; i++)
+    hash ^= rotl (node->data[i], i);
+
+  for (i = 0; i < n_children; i++)
+    hash ^= rotl (node->children[i]->hash, i);
+
+  node->hash = hash;
+
+  return node;
+}
+
+static void
+init_node_lookup (BroadwaySurface *surface,
+                  BroadwayNode *node)
+{
+  int i;
+
+  g_hash_table_insert (surface->node_lookup, GINT_TO_POINTER(node->id), node);
+  for (i = 0; i < node->n_children; i++)
+    init_node_lookup (surface, node->children[i]);
+}
+
 /* passes ownership of nodes */
 void
-broadway_server_surface_set_nodes (BroadwayServer   *server,
-                                   gint              id,
-                                   BroadwayNode     *root)
+broadway_server_surface_update_nodes (BroadwayServer   *server,
+                                      gint              id,
+                                      guint32          data[],
+                                      int              len,
+                                      GHashTable      *client_texture_map)
 {
   BroadwaySurface *surface;
+  int pos = 0;
+  BroadwayNode *root;
 
   surface = broadway_server_lookup_surface (server, id);
   if (surface == NULL)
     return;
 
+  root = decode_nodes (server, surface, len, data, client_texture_map, &pos);
+
   if (server->output != NULL)
     broadway_output_surface_set_nodes (server->output, surface->id,
                                        root,
                                        surface->nodes);
 
   if (surface->nodes)
-    broadway_node_free (surface->nodes);
+    broadway_node_unref (server, surface->nodes);
+
   surface->nodes = root;
+
+  g_hash_table_remove_all (surface->node_lookup);
+
+  init_node_lookup (surface, surface->nodes);
 }
 
 guint32
 broadway_server_upload_texture (BroadwayServer   *server,
-                                GBytes           *texture)
+                                GBytes           *bytes)
 {
-  guint32 id;
+  BroadwayTexture *texture;
+
+  texture = g_new0 (BroadwayTexture, 1);
+  g_ref_count_init (&texture->refcount);
+  texture->id = ++server->next_texture_id;
+  texture->bytes = g_bytes_ref (bytes);
 
-  id = ++server->next_texture_id;
   g_hash_table_replace (server->textures,
-                        GINT_TO_POINTER (id),
-                        g_bytes_ref (texture));
+                        GINT_TO_POINTER (texture->id),
+                        texture);
 
   if (server->output)
-    broadway_output_upload_texture (server->output, id, texture);
+    broadway_output_upload_texture (server->output, texture->id, texture->bytes);
 
-  return id;
+  return texture->id;
+}
+
+static void
+broadway_server_ref_texture (BroadwayServer   *server,
+                             guint32           id)
+{
+  BroadwayTexture *texture;
+
+  texture = g_hash_table_lookup (server->textures, GINT_TO_POINTER (id));
+  if (texture)
+    g_ref_count_inc (&texture->refcount);
 }
 
 void
 broadway_server_release_texture (BroadwayServer   *server,
                                  guint32           id)
 {
-  g_hash_table_remove (server->textures, GINT_TO_POINTER (id));
+  BroadwayTexture *texture;
 
-  if (server->output)
-    broadway_output_release_texture (server->output, id);
+  texture = g_hash_table_lookup (server->textures, GINT_TO_POINTER (id));
+
+  if (texture && g_ref_count_dec (&texture->refcount))
+    {
+      g_hash_table_remove (server->textures, GINT_TO_POINTER (id));
+
+      if (server->output)
+        broadway_output_release_texture (server->output, id);
+    }
 }
 
 gboolean
@@ -1801,6 +2024,7 @@ broadway_server_new_surface (BroadwayServer *server,
   surface->width = width;
   surface->height = height;
   surface->is_temp = is_temp;
+  surface->node_lookup = g_hash_table_new (g_direct_hash, g_direct_equal);
 
   g_hash_table_insert (server->surface_id_hash,
                        GINT_TO_POINTER (surface->id),
@@ -1835,9 +2059,12 @@ broadway_server_resync_surfaces (BroadwayServer *server)
   /* First upload all textures */
   g_hash_table_iter_init (&iter, server->textures);
   while (g_hash_table_iter_next (&iter, &key, &value))
-    broadway_output_upload_texture (server->output,
-                                    GPOINTER_TO_INT (key),
-                                    (GBytes *)value);
+    {
+      BroadwayTexture *texture = value;
+      broadway_output_upload_texture (server->output,
+                                      GPOINTER_TO_INT (key),
+                                      texture->bytes);
+    }
 
   /* Then create all surfaces */
   for (l = server->surfaces; l != NULL; l = l->next)

gdk/broadway/broadway-server.h

@@ -19,12 +19,16 @@ typedef struct _BroadwayServerClass BroadwayServerClass;
 #define BROADWAY_SERVER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), BROADWAY_TYPE_SERVER, BroadwayServerClass))
 
 typedef struct _BroadwayNode BroadwayNode;
+typedef struct _BroadwayTexture BroadwayTexture;
 
 struct _BroadwayNode {
+  grefcount refcount;
   guint32 type;
+  guint32 id;
   guint32 hash; /* deep hash */
   guint32 n_children;
   BroadwayNode **children;
+  guint32 texture_id;
   guint32 n_data;
   guint32 data[1];
 };
@@ -99,9 +103,11 @@ void                broadway_server_release_texture           (BroadwayServer  *
                                                                guint32          id);
 cairo_surface_t   * broadway_server_create_surface            (int              width,
                                                                int              height);
-void                broadway_server_surface_set_nodes         (BroadwayServer  *server,
+void                broadway_server_surface_update_nodes      (BroadwayServer  *server,
                                                                gint             id,
-                                                               BroadwayNode    *root);
+                                                               guint32          data[],
+                                                               int              len,
+                                                               GHashTable      *client_texture_map);
 gboolean            broadway_server_surface_move_resize       (BroadwayServer  *server,
                                                                gint             id,
                                                                gboolean         with_move,

gdk/broadway/broadwayd.c

@@ -215,116 +215,6 @@ get_client_serial (BroadwayClient *client, guint32 daemon_serial)
   return client_serial;
 }
 
-#define NODE_SIZE_COLOR 1
-#define NODE_SIZE_FLOAT 1
-#define NODE_SIZE_POINT 2
-#define NODE_SIZE_SIZE 2
-#define NODE_SIZE_RECT (NODE_SIZE_POINT + NODE_SIZE_SIZE)
-#define NODE_SIZE_RRECT (NODE_SIZE_RECT + 4 * NODE_SIZE_SIZE)
-#define NODE_SIZE_COLOR_STOP (NODE_SIZE_FLOAT + NODE_SIZE_COLOR)
-#define NODE_SIZE_SHADOW (NODE_SIZE_COLOR + 3 * NODE_SIZE_FLOAT)
-
-static guint32
-rotl (guint32 value, int shift)
-{
-  if ((shift &= 32 - 1) == 0)
-    return value;
-  return (value << shift) | (value >> (32 - shift));
-}
-
-static BroadwayNode *
-decode_nodes (BroadwayClient *client,
-              int len, guint32 data[], int *pos)
-{
-  BroadwayNode *node;
-  guint32 type;
-  guint32 i, n_stops, n_shadows;
-  guint32 size, n_children;
-  gint32 texture_offset;
-  guint32 hash;
-
-  g_assert (*pos < len);
-
-  size = 0;
-  n_children = 0;
-  texture_offset = -1;
-
-  type = data[(*pos)++];
-  switch (type) {
-  case BROADWAY_NODE_COLOR:
-    size = NODE_SIZE_RECT + NODE_SIZE_COLOR;
-    break;
-  case BROADWAY_NODE_BORDER:
-    size = NODE_SIZE_RRECT + 4 * NODE_SIZE_FLOAT + 4 * NODE_SIZE_COLOR;
-    break;
-  case BROADWAY_NODE_INSET_SHADOW:
-  case BROADWAY_NODE_OUTSET_SHADOW:
-    size = NODE_SIZE_RRECT + NODE_SIZE_COLOR + 4 * NODE_SIZE_FLOAT;
-    break;
-  case BROADWAY_NODE_TEXTURE:
-    texture_offset = 4;
-    size = 5;
-    break;
-  case BROADWAY_NODE_CONTAINER:
-    size = 1;
-    n_children = data[*pos];
-    break;
-  case BROADWAY_NODE_ROUNDED_CLIP:
-    size = NODE_SIZE_RRECT;
-    n_children = 1;
-    break;
-  case BROADWAY_NODE_CLIP:
-    size = NODE_SIZE_RECT;
-    n_children = 1;
-    break;
-  case BROADWAY_NODE_LINEAR_GRADIENT:
-    size = NODE_SIZE_RECT + 2 * NODE_SIZE_POINT;
-    n_stops = data[*pos + size++];
-    size += n_stops * NODE_SIZE_COLOR_STOP;
-    break;
-  case BROADWAY_NODE_SHADOW:
-    size = 1;
-    n_shadows = data[*pos];
-    size += n_shadows * NODE_SIZE_SHADOW;
-    n_children = 1;
-    break;
-  case BROADWAY_NODE_OPACITY:
-    size = NODE_SIZE_FLOAT;
-    n_children = 1;
-    break;
-  default:
-    g_assert_not_reached ();
-  }
-
-  node = g_malloc (sizeof(BroadwayNode) + (size - 1) * sizeof(guint32) + n_children * sizeof (BroadwayNode *));
-  node->type = type;
-  node->n_children = n_children;
-  node->children = (BroadwayNode **)((char *)node + sizeof(BroadwayNode) + (size - 1) * sizeof(guint32));
-  node->n_data = size;
-  for (i = 0; i < size; i++)
-    {
-      node->data[i] = data[(*pos)++];
-      if (i == texture_offset)
-        node->data[i] = GPOINTER_TO_INT (g_hash_table_lookup (client->textures,
-                                                              GINT_TO_POINTER (node->data[i])));
-    }
-
-  for (i = 0; i < n_children; i++)
-    node->children[i] = decode_nodes (client, len, data, pos);
-
-  hash = node->type << 16;
-
-  for (i = 0; i < size; i++)
-    hash ^= rotl (node->data[i], i);
-
-  for (i = 0; i < n_children; i++)
-    hash ^= rotl (node->children[i]->hash, i);
-
-  node->hash = hash;
-
-  return node;
-}
-
 static void
 client_handle_request (BroadwayClient *client,
                        BroadwayRequest *request)
@@ -400,13 +290,10 @@ client_handle_request (BroadwayClient *client,
       {
         gsize array_size = request->base.size - sizeof (BroadwayRequestSetNodes) + sizeof(guint32);
         int n_data = array_size / sizeof(guint32);
-        int pos = 0;
-        BroadwayNode *node;
 
-        node = decode_nodes (client, n_data, request->set_nodes.data, &pos);
-
-        broadway_server_surface_set_nodes (server, request->set_nodes.id,
-                                           node);
+        broadway_server_surface_update_nodes (server, request->set_nodes.id,
+                                              request->set_nodes.data, n_data,
+                                              client->textures);
       }
       break;
     case BROADWAY_REQUEST_UPLOAD_TEXTURE:

gdk/broadway/gdkdevice-broadway.c

@@ -36,9 +36,6 @@ static void gdk_broadway_device_get_state (GdkDevice       *device,
 static void gdk_broadway_device_set_surface_cursor (GdkDevice *device,
                                                     GdkSurface *surface,
                                                     GdkCursor *cursor);
-static void gdk_broadway_device_warp (GdkDevice *device,
-                                      gdouble    x,
-                                      gdouble    y);
 static void gdk_broadway_device_query_state (GdkDevice        *device,
                                              GdkSurface        *surface,
                                              GdkSurface       **child_surface,
@@ -73,7 +70,6 @@ gdk_broadway_device_class_init (GdkBroadwayDeviceClass *klass)
   device_class->get_history = gdk_broadway_device_get_history;
   device_class->get_state = gdk_broadway_device_get_state;
   device_class->set_surface_cursor = gdk_broadway_device_set_surface_cursor;
-  device_class->warp = gdk_broadway_device_warp;
   device_class->query_state = gdk_broadway_device_query_state;
   device_class->grab = gdk_broadway_device_grab;
   device_class->ungrab = gdk_broadway_device_ungrab;
@@ -110,7 +106,7 @@ gdk_broadway_device_get_state (GdkDevice       *device,
 {
   gdouble x, y;
 
-  gdk_surface_get_device_position_double (surface, device, &x, &y, mask);
+  gdk_surface_get_device_position (surface, device, &x, &y, mask);
 
   if (axes)
     {
@@ -126,13 +122,6 @@ gdk_broadway_device_set_surface_cursor (GdkDevice *device,
 {
 }
 
-static void
-gdk_broadway_device_warp (GdkDevice *device,
-                          gdouble    x,
-                          gdouble    y)
-{
-}
-
 static void
 gdk_broadway_device_query_state (GdkDevice        *device,
                                  GdkSurface        *surface,

gdk/broadway/gdkdisplay-broadway.c

@@ -380,7 +380,7 @@ gdk_broadway_display_ensure_texture (GdkDisplay *display,
       data = g_new0 (BroadwayTextureData, 1);
       data->id = id;
       data->display = g_object_ref (display);
-      g_object_set_data_full (G_OBJECT (texture), "broadway-data", data, (GDestroyNotify)broadway_texture_data_free);
+     g_object_set_data_full (G_OBJECT (texture), "broadway-data", data, (GDestroyNotify)broadway_texture_data_free);
     }
 
   return data->id;

gdk/broadway/gdkdrawcontext-broadway.c

@@ -64,6 +64,8 @@ gdk_broadway_draw_context_end_frame (GdkDrawContext *draw_context,
 
   g_array_unref (self->nodes);
   self->nodes = NULL;
+
+  /* We now sent all new texture refs to the daemon via the nodes, so we can drop them here */
   g_ptr_array_unref (self->node_textures);
   self->node_textures = NULL;
 }

gdk/broadway/gdksurface-broadway.c

@@ -501,12 +501,6 @@ gdk_broadway_surface_set_title (GdkSurface   *surface,
 {
 }
 
-static void
-gdk_broadway_surface_set_role (GdkSurface   *surface,
-                               const gchar *role)
-{
-}
-
 static void
 gdk_broadway_surface_set_startup_id (GdkSurface   *surface,
                                      const gchar *startup_id)
@@ -1232,6 +1226,9 @@ gdk_broadway_surface_begin_resize_drag (GdkSurface     *surface,
 
   mv_resize = get_move_resize_data (gdk_surface_get_display (surface), TRUE);
 
+  if (mv_resize->moveresize_surface != NULL)
+    return; /* already a drag operation in progress */
+
   mv_resize->is_resize = TRUE;
   mv_resize->moveresize_button = button;
   mv_resize->resize_edge = edge;
@@ -1272,6 +1269,9 @@ gdk_broadway_surface_begin_move_drag (GdkSurface *surface,
 
   mv_resize = get_move_resize_data (gdk_surface_get_display (surface), TRUE);
 
+  if (mv_resize->moveresize_surface != NULL)
+    return; /* already a drag operation in progress */
+
   mv_resize->is_resize = FALSE;
   mv_resize->moveresize_button = button;
   mv_resize->moveresize_x = root_x;
@@ -1352,7 +1352,6 @@ gdk_surface_impl_broadway_class_init (GdkSurfaceImplBroadwayClass *klass)
   impl_class->set_urgency_hint = gdk_broadway_surface_set_urgency_hint;
   impl_class->set_geometry_hints = gdk_broadway_surface_set_geometry_hints;
   impl_class->set_title = gdk_broadway_surface_set_title;
-  impl_class->set_role = gdk_broadway_surface_set_role;
   impl_class->set_startup_id = gdk_broadway_surface_set_startup_id;
   impl_class->set_transient_for = gdk_broadway_surface_set_transient_for;
   impl_class->get_frame_extents = gdk_broadway_surface_get_frame_extents;

gdk/gdk-private.h

@@ -20,8 +20,6 @@ void            gdk_surface_thaw_toplevel_updates        (GdkSurface *surface);
 
 gboolean        gdk_surface_supports_edge_constraints    (GdkSurface *surface);
 
-GObject *       gdk_event_get_user_data         (const GdkEvent *event);
-
 guint32         gdk_display_get_last_seen_time  (GdkDisplay *display);
 
 void gdk_display_set_double_click_time     (GdkDisplay   *display,

gdk/gdk.c

@@ -33,6 +33,8 @@
 
 #include "gdk-private.h"
 
+#include "gdkconstructor.h"
+
 #ifndef HAVE_XCONVERTCASE
 #include "gdkkeysyms.h"
 #endif

gdk/gdkconstructor.h

@@ -0,0 +1,120 @@
+/*
+  If G_HAS_CONSTRUCTORS is true then the compiler support *both* constructors and
+  destructors, in a sane way, including e.g. on library unload. If not you're on
+  your own.
+
+  Some compilers need #pragma to handle this, which does not work with macros,
+  so the way you need to use this is (for constructors):
+
+  #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
+  #pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(my_constructor)
+  #endif
+  G_DEFINE_CONSTRUCTOR(my_constructor)
+  static void my_constructor(void) {
+   ...
+  }
+
+*/
+
+#ifndef __GTK_DOC_IGNORE__
+
+#if  __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
+
+#define G_HAS_CONSTRUCTORS 1
+
+#define G_DEFINE_CONSTRUCTOR(_func) static void __attribute__((constructor)) _func (void);
+#define G_DEFINE_DESTRUCTOR(_func) static void __attribute__((destructor)) _func (void);
+
+#elif defined (_MSC_VER) && (_MSC_VER >= 1500)
+/* Visual studio 2008 and later has _Pragma */
+
+#define G_HAS_CONSTRUCTORS 1
+
+/* We do some weird things to avoid the constructors being optimized
+ * away on VS2015 if WholeProgramOptimization is enabled. First we
+ * make a reference to the array from the wrapper to make sure its
+ * references. Then we use a pragma to make sure the wrapper function
+ * symbol is always included at the link stage. Also, the symbols
+ * need to be extern (but not dllexport), even though they are not
+ * really used from another object file.
+ */
+
+/* We need to account for differences between the mangling of symbols
+ * for Win32 (x86) and x64 programs, as symbols on Win32 are prefixed
+ * with an underscore but symbols on x64 are not.
+ */
+#ifdef _WIN64
+#define G_MSVC_SYMBOL_PREFIX ""
+#else
+#define G_MSVC_SYMBOL_PREFIX "_"
+#endif
+
+#define G_DEFINE_CONSTRUCTOR(_func) G_MSVC_CTOR (_func, G_MSVC_SYMBOL_PREFIX)
+#define G_DEFINE_DESTRUCTOR(_func) G_MSVC_DTOR (_func, G_MSVC_SYMBOL_PREFIX)
+
+#define G_MSVC_CTOR(_func,_sym_prefix) \
+  static void _func(void); \
+  extern int (* _array ## _func)(void);              \
+  int _func ## _wrapper(void) { _func(); g_slist_find (NULL,  _array ## _func); return 0; } \
+  __pragma(comment(linker,"/include:" _sym_prefix # _func "_wrapper")) \
+  __pragma(section(".CRT$XCU",read)) \
+  __declspec(allocate(".CRT$XCU")) int (* _array ## _func)(void) = _func ## _wrapper;
+
+#define G_MSVC_DTOR(_func,_sym_prefix) \
+  static void _func(void); \
+  extern int (* _array ## _func)(void);              \
+  int _func ## _constructor(void) { atexit (_func); g_slist_find (NULL,  _array ## _func); return 0; } \
+   __pragma(comment(linker,"/include:" _sym_prefix # _func "_constructor")) \
+  __pragma(section(".CRT$XCU",read)) \
+  __declspec(allocate(".CRT$XCU")) int (* _array ## _func)(void) = _func ## _constructor;
+
+#elif defined (_MSC_VER)
+
+#define G_HAS_CONSTRUCTORS 1
+
+/* Pre Visual studio 2008 must use #pragma section */
+#define G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA 1
+#define G_DEFINE_DESTRUCTOR_NEEDS_PRAGMA 1
+
+#define G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(_func) \
+  section(".CRT$XCU",read)
+#define G_DEFINE_CONSTRUCTOR(_func) \
+  static void _func(void); \
+  static int _func ## _wrapper(void) { _func(); return 0; } \
+  __declspec(allocate(".CRT$XCU")) static int (*p)(void) = _func ## _wrapper;
+
+#define G_DEFINE_DESTRUCTOR_PRAGMA_ARGS(_func) \
+  section(".CRT$XCU",read)
+#define G_DEFINE_DESTRUCTOR(_func) \
+  static void _func(void); \
+  static int _func ## _constructor(void) { atexit (_func); return 0; } \
+  __declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _constructor;
+
+#elif defined(__SUNPRO_C)
+
+/* This is not tested, but i believe it should work, based on:
+ * http://opensource.apple.com/source/OpenSSL098/OpenSSL098-35/src/fips/fips_premain.c
+ */
+
+#define G_HAS_CONSTRUCTORS 1
+
+#define G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA 1
+#define G_DEFINE_DESTRUCTOR_NEEDS_PRAGMA 1
+
+#define G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(_func) \
+  init(_func)
+#define G_DEFINE_CONSTRUCTOR(_func) \
+  static void _func(void);
+
+#define G_DEFINE_DESTRUCTOR_PRAGMA_ARGS(_func) \
+  fini(_func)
+#define G_DEFINE_DESTRUCTOR(_func) \
+  static void _func(void);
+
+#else
+
+/* constructors not supported for this compiler */
+
+#endif
+
+#endif /* __GTK_DOC_IGNORE__ */

gdk/gdkdevice.c

@@ -529,7 +529,7 @@ gdk_device_get_state (GdkDevice       *device,
 }
 
 /**
- * gdk_device_get_position_double:
+ * gdk_device_get_position:
  * @device: pointer device to query status about.
  * @x: (out) (allow-none): location to store root window X coordinate of @device, or %NULL.
  * @y: (out) (allow-none): location to store root window Y coordinate of @device, or %NULL.
@@ -540,9 +540,9 @@ gdk_device_get_state (GdkDevice       *device,
  * unless there is an ongoing grab on them. See gdk_device_grab().
  **/
 void
-gdk_device_get_position_double (GdkDevice        *device,
-                                gdouble          *x,
-                                gdouble          *y)
+gdk_device_get_position (GdkDevice *device,
+                         double    *x,
+                         double    *y)
 {
   GdkDisplay *display;
   gdouble tmp_x, tmp_y;
@@ -568,33 +568,7 @@ gdk_device_get_position_double (GdkDevice        *device,
 }
 
 /**
- * gdk_device_get_position:
- * @device: pointer device to query status about.
- * @x: (out) (allow-none): location to store root window X coordinate of @device, or %NULL.
- * @y: (out) (allow-none): location to store root window Y coordinate of @device, or %NULL.
- *
- * Gets the current location of @device. As a slave device
- * coordinates are those of its master pointer, This function
- * may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
- * unless there is an ongoing grab on them, see gdk_device_grab().
- **/
-void
-gdk_device_get_position (GdkDevice *device,
-                         gint      *x,
-                         gint      *y)
-{
-  gdouble tmp_x, tmp_y;
-
-  gdk_device_get_position_double (device, &tmp_x, &tmp_y);
-  if (x)
-    *x = round (tmp_x);
-  if (y)
-    *y = round (tmp_y);
-}
-
-
-/**
- * gdk_device_get_surface_at_position_double:
+ * gdk_device_get_surface_at_position:
  * @device: pointer #GdkDevice to query info to.
  * @win_x: (out) (allow-none): return location for the X coordinate of the device location,
  *         relative to the surface origin, or %NULL.
@@ -613,9 +587,9 @@ gdk_device_get_position (GdkDevice *device,
  *   device position, or %NULL.
  **/
 GdkSurface *
-gdk_device_get_surface_at_position_double (GdkDevice  *device,
-                                          gdouble    *win_x,
-                                          gdouble    *win_y)
+gdk_device_get_surface_at_position (GdkDevice *device,
+                                    double    *win_x,
+                                    double    *win_y)
 {
   gdouble tmp_x, tmp_y;
   GdkSurface *surface;
@@ -642,43 +616,6 @@ gdk_device_get_surface_at_position_double (GdkDevice  *device,
   return surface;
 }
 
-/**
- * gdk_device_get_surface_at_position:
- * @device: pointer #GdkDevice to query info to.
- * @win_x: (out) (allow-none): return location for the X coordinate of the device location,
- *         relative to the surface origin, or %NULL.
- * @win_y: (out) (allow-none): return location for the Y coordinate of the device location,
- *         relative to the surface origin, or %NULL.
- *
- * Obtains the surface underneath @device, returning the location of the device in @win_x and @win_y. Returns
- * %NULL if the surface tree under @device is not known to GDK (for example, belongs to another application).
- *
- * As a slave device coordinates are those of its master pointer, This
- * function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
- * unless there is an ongoing grab on them, see gdk_device_grab().
- *
- * Returns: (nullable) (transfer none): the #GdkSurface under the
- * device position, or %NULL.
- **/
-GdkSurface *
-gdk_device_get_surface_at_position (GdkDevice  *device,
-                                   gint       *win_x,
-                                   gint       *win_y)
-{
-  gdouble tmp_x, tmp_y;
-  GdkSurface *surface;
-
-  surface =
-    gdk_device_get_surface_at_position_double (device, &tmp_x, &tmp_y);
-
-  if (win_x)
-    *win_x = round (tmp_x);
-  if (win_y)
-    *win_y = round (tmp_y);
-
-  return surface;
-}
-
 /**
  * gdk_device_get_history: (skip)
  * @device: a #GdkDevice
@@ -1425,34 +1362,6 @@ gdk_device_ungrab (GdkDevice  *device,
   GDK_DEVICE_GET_CLASS (device)->ungrab (device, time_);
 }
 
-/**
- * gdk_device_warp:
- * @device: the device to warp.
- * @x: the X coordinate of the destination.
- * @y: the Y coordinate of the destination.
- *
- * Warps @device in @display to the point @x,@y,
- * unless the device is confined to a surface by a grab,
- * in which case it will be moved
- * as far as allowed by the grab. Warping the pointer
- * creates events as if the user had moved the mouse
- * instantaneously to the destination.
- *
- * Note that the pointer should normally be under the
- * control of the user. This function was added to cover
- * some rare use cases like keyboard navigation support
- * for the color picker in the #GtkColorSelectionDialog.
- **/
-void
-gdk_device_warp (GdkDevice  *device,
-                 gint        x,
-                 gint        y)
-{
-  g_return_if_fail (GDK_IS_DEVICE (device));
-
-  GDK_DEVICE_GET_CLASS (device)->warp (device, x, y);
-}
-
 /* Private API */
 void
 _gdk_device_reset_axes (GdkDevice *device)

gdk/gdkdevice.h

@@ -167,25 +167,13 @@ void     gdk_device_get_state    (GdkDevice         *device,
                                   gdouble           *axes,
                                   GdkModifierType   *mask);
 GDK_AVAILABLE_IN_ALL
-void     gdk_device_get_position (GdkDevice         *device,
-                                  gint              *x,
-                                  gint              *y);
+void     gdk_device_get_position (GdkDevice *device,
+                                  double    *x,
+                                  double    *y);
 GDK_AVAILABLE_IN_ALL
-GdkSurface *
-         gdk_device_get_surface_at_position
-                                 (GdkDevice         *device,
-                                  gint              *win_x,
-                                  gint              *win_y);
-GDK_AVAILABLE_IN_ALL
-void     gdk_device_get_position_double (GdkDevice         *device,
-                                         gdouble           *x,
-                                         gdouble           *y);
-GDK_AVAILABLE_IN_ALL
-GdkSurface *
-         gdk_device_get_surface_at_position_double
-                                 (GdkDevice         *device,
-                                  gdouble           *win_x,
-                                  gdouble           *win_y);
+GdkSurface * gdk_device_get_surface_at_position (GdkDevice *device,
+                                                 double    *win_x,
+                                                 double    *win_y);
 GDK_AVAILABLE_IN_ALL
 gboolean gdk_device_get_history  (GdkDevice         *device,
                                   GdkSurface         *surface,
@@ -236,11 +224,6 @@ GDK_DEPRECATED_FOR(gdk_seat_ungrab)
 void          gdk_device_ungrab      (GdkDevice        *device,
                                       guint32           time_);
 
-GDK_AVAILABLE_IN_ALL
-void          gdk_device_warp        (GdkDevice        *device,
-                                      gint              x,
-                                      gint              y);
-
 GDK_AVAILABLE_IN_ALL
 GdkSurface *gdk_device_get_last_event_surface (GdkDevice *device);
 

gdk/gdkdeviceprivate.h

@@ -86,9 +86,6 @@ struct _GdkDeviceClass
                               GdkSurface *surface,
                               GdkCursor *cursor);
 
-  void (* warp)              (GdkDevice  *device,
-                              gdouble     x,
-                              gdouble     y);
   void (* query_state)       (GdkDevice       *device,
                               GdkSurface       *surface,
                               GdkSurface      **child_surface,

gdk/gdkevents.c

@@ -564,8 +564,8 @@ gdk_event_copy (const GdkEvent *event)
     g_object_ref (new_event->any.device);
   if (new_event->any.source_device)
     g_object_ref (new_event->any.source_device);
-  if (new_event->any.user_data)
-    g_object_ref (new_event->any.user_data);
+  if (new_event->any.target)
+    g_object_ref (new_event->any.target);
 
   switch ((guint) event->any.type)
     {
@@ -573,6 +573,13 @@ gdk_event_copy (const GdkEvent *event)
     case GDK_LEAVE_NOTIFY:
       if (event->crossing.child_surface != NULL)
         g_object_ref (event->crossing.child_surface);
+      if (event->crossing.related_target)
+        g_object_ref (event->crossing.related_target);
+      break;
+
+    case GDK_FOCUS_CHANGE:
+      if (event->focus_change.related_target)
+        g_object_ref (event->focus_change.related_target);
       break;
 
     case GDK_DRAG_ENTER:
@@ -634,6 +641,11 @@ gdk_event_finalize (GObject *object)
     case GDK_ENTER_NOTIFY:
     case GDK_LEAVE_NOTIFY:
       g_clear_object (&event->crossing.child_surface);
+      g_clear_object (&event->crossing.related_target);
+      break;
+
+    case GDK_FOCUS_CHANGE:
+      g_clear_object (&event->focus_change.related_target);
       break;
 
     case GDK_DRAG_ENTER:
@@ -675,7 +687,7 @@ gdk_event_finalize (GObject *object)
 
   g_clear_object (&event->any.device);
   g_clear_object (&event->any.source_device);
-  g_clear_object (&event->any.user_data);
+  g_clear_object (&event->any.target);
 
   G_OBJECT_CLASS (gdk_event_parent_class)->finalize (object);
 }
@@ -1904,16 +1916,39 @@ gdk_event_get_scancode (GdkEvent *event)
 }
 
 void
-gdk_event_set_user_data (GdkEvent *event,
-                         GObject  *user_data)
+gdk_event_set_target (GdkEvent *event,
+                      GObject  *target)
 {
-  g_set_object (&event->any.user_data, user_data);
+  g_set_object (&event->any.target, target);
 }
 
 GObject *
-gdk_event_get_user_data (const GdkEvent *event)
+gdk_event_get_target (const GdkEvent *event)
 {
-  return event->any.user_data;
+  return event->any.target;
+}
+
+void
+gdk_event_set_related_target (GdkEvent *event,
+                              GObject  *target)
+{
+  if (event->any.type == GDK_ENTER_NOTIFY ||
+      event->any.type == GDK_LEAVE_NOTIFY)
+    g_set_object (&event->crossing.related_target, target);
+  else if (event->any.type == GDK_FOCUS_CHANGE)
+    g_set_object (&event->focus_change.related_target, target);
+}
+
+GObject *
+gdk_event_get_related_target (const GdkEvent *event)
+{
+  if (event->any.type == GDK_ENTER_NOTIFY ||
+      event->any.type == GDK_LEAVE_NOTIFY)
+    return event->crossing.related_target;
+  else if (event->any.type == GDK_FOCUS_CHANGE)
+    return event->focus_change.related_target;
+
+  return NULL;
 }
 
 /**
@@ -1980,6 +2015,11 @@ gdk_event_get_crossing_mode (const GdkEvent  *event,
       *mode = event->crossing.mode;
       return TRUE;
     }
+  else if (event->any.type == GDK_FOCUS_CHANGE)
+    {
+      *mode = event->focus_change.mode;
+      return TRUE;
+    }
 
   return FALSE;
 }
@@ -2006,6 +2046,11 @@ gdk_event_get_crossing_detail (const GdkEvent *event,
       *detail = event->crossing.detail;
       return TRUE;
     }
+  else if (event->any.type == GDK_FOCUS_CHANGE)
+    {
+      *detail = event->focus_change.detail;
+      return TRUE;
+    }
 
   return FALSE;
 }

gdk/gdkeventsprivate.h

@@ -61,7 +61,7 @@ struct _GdkEventAny
   GdkDevice *device;
   GdkDevice *source_device;
   GdkDisplay *display;
-  GObject *user_data;
+  GObject *target;
 };
 
 /*
@@ -303,6 +303,7 @@ struct _GdkEventCrossing
   GdkNotifyType detail;
   gboolean focus;
   guint state;
+  GObject *related_target;
 };
 
 /*
@@ -312,6 +313,8 @@ struct _GdkEventCrossing
  * @send_event: %TRUE if the event was sent explicitly.
  * @in: %TRUE if the surface has gained the keyboard focus, %FALSE if
  *   it has lost the focus.
+ * @mode: the crossing mode
+ * @detail: the kind of crossing that happened
  *
  * Describes a change of keyboard focus.
  */
@@ -319,6 +322,9 @@ struct _GdkEventFocus
 {
   GdkEventAny any;
   gint16 in;
+  GdkCrossingMode mode;
+  GdkNotifyType detail;
+  GObject *related_target;
 };
 
 /*
@@ -632,8 +638,12 @@ union _GdkEvent
   GdkEventPadGroupMode      pad_group_mode;
 };
 
-void           gdk_event_set_user_data              (GdkEvent *event,
-                                                     GObject  *user_data);
+void           gdk_event_set_target              (GdkEvent *event,
+                                                  GObject  *user_data);
+GObject *      gdk_event_get_target              (const GdkEvent *event);
+void           gdk_event_set_related_target       (GdkEvent *event,
+                                                  GObject  *user_data);
+GObject *      gdk_event_get_related_target      (const GdkEvent *event);
 
 
 #endif /* __GDK_EVENTS_PRIVATE_H__ */

gdk/gdksurface.h

@@ -570,9 +570,6 @@ GDK_AVAILABLE_IN_ALL
 void          gdk_surface_set_title         (GdkSurface   *surface,
                                              const gchar  *title);
 GDK_AVAILABLE_IN_ALL
-void          gdk_surface_set_role          (GdkSurface     *surface,
-                                             const gchar   *role);
-GDK_AVAILABLE_IN_ALL
 void          gdk_surface_set_startup_id    (GdkSurface     *surface,
                                              const gchar   *startup_id);
 GDK_AVAILABLE_IN_ALL
@@ -640,18 +637,12 @@ GDK_AVAILABLE_IN_ALL
 gint          gdk_surface_get_scale_factor  (GdkSurface     *surface);
 
 GDK_AVAILABLE_IN_ALL
-GdkSurface *   gdk_surface_get_device_position (GdkSurface       *surface,
+GdkSurface *   gdk_surface_get_device_position (GdkSurface      *surface,
                                                 GdkDevice       *device,
-                                                gint            *x,
-                                                gint            *y,
+                                                double          *x,
+                                                double          *y,
                                                 GdkModifierType *mask);
 GDK_AVAILABLE_IN_ALL
-GdkSurface *   gdk_surface_get_device_position_double (GdkSurface       *surface,
-                                                       GdkDevice       *device,
-                                                       gdouble         *x,
-                                                       gdouble         *y,
-                                                       GdkModifierType *mask);
-GDK_AVAILABLE_IN_ALL
 GdkSurface *   gdk_surface_get_parent      (GdkSurface       *surface);
 GDK_AVAILABLE_IN_ALL
 GdkSurface *   gdk_surface_get_toplevel    (GdkSurface       *surface);
@@ -731,31 +722,31 @@ void          gdk_surface_register_dnd    (GdkSurface       *surface);
 GDK_AVAILABLE_IN_ALL
 void gdk_surface_begin_resize_drag            (GdkSurface     *surface,
                                                GdkSurfaceEdge  edge,
-                                               gint           button,
-                                               gint           root_x,
-                                               gint           root_y,
-                                               guint32        timestamp);
+                                               gint            button,
+                                               gint            x,
+                                               gint            y,
+                                               guint32         timestamp);
 GDK_AVAILABLE_IN_ALL
 void gdk_surface_begin_resize_drag_for_device (GdkSurface     *surface,
                                                GdkSurfaceEdge  edge,
-                                               GdkDevice     *device,
-                                               gint           button,
-                                               gint           root_x,
-                                               gint           root_y,
-                                               guint32        timestamp);
+                                               GdkDevice      *device,
+                                               gint            button,
+                                               gint            x,
+                                               gint            y,
+                                               guint32         timestamp);
 GDK_AVAILABLE_IN_ALL
 void gdk_surface_begin_move_drag              (GdkSurface     *surface,
-                                               gint           button,
-                                               gint           root_x,
-                                               gint           root_y,
-                                               guint32        timestamp);
+                                               gint            button,
+                                               gint            x,
+                                               gint            y,
+                                               guint32         timestamp);
 GDK_AVAILABLE_IN_ALL
 void gdk_surface_begin_move_drag_for_device   (GdkSurface     *surface,
-                                               GdkDevice     *device,
-                                               gint           button,
-                                               gint           root_x,
-                                               gint           root_y,
-                                               guint32        timestamp);
+                                               GdkDevice      *device,
+                                               gint            button,
+                                               gint            x,
+                                               gint            y,
+                                               guint32         timestamp);
 
 /* Interface for dirty-region queueing */
 GDK_AVAILABLE_IN_ALL

gdk/gdksurfaceimpl.h

@@ -136,8 +136,6 @@ struct _GdkSurfaceImplClass
                                          GdkSurfaceHints     geom_mask);
   void         (* set_title)            (GdkSurface   *surface,
                                          const gchar *title);
-  void         (* set_role)             (GdkSurface   *surface,
-                                         const gchar *role);
   void         (* set_startup_id)       (GdkSurface   *surface,
                                          const gchar *startup_id);
   void         (* set_transient_for)    (GdkSurface *surface,

gdk/quartz/gdkdevice-core-quartz.c

@@ -125,7 +125,7 @@ gdk_quartz_device_core_get_state (GdkDevice       *device,
 {
   gdouble x_pos, y_pos;
 
-  gdk_surface_get_device_position_double (window, device, &x_pos, &y_pos, mask);
+  gdk_surface_get_device_position (window, device, &x_pos, &y_pos, mask);
 
   if (axes)
     {

gdk/quartz/gdksurface-quartz.c

@@ -1739,17 +1739,6 @@ gdk_quartz_surface_set_title (GdkSurface   *window,
     }
 }
 
-static void
-gdk_quartz_surface_set_role (GdkSurface   *window,
-                            const gchar *role)
-{
-  if (GDK_SURFACE_DESTROYED (window) ||
-      SURFACE_IS_TOPLEVEL (window))
-    return;
-
-  /* FIXME: Implement */
-}
-
 static void
 gdk_quartz_surface_set_startup_id (GdkSurface   *window,
                                   const gchar *startup_id)
@@ -2754,7 +2743,6 @@ gdk_surface_impl_quartz_class_init (GdkSurfaceImplQuartzClass *klass)
   impl_class->set_urgency_hint = gdk_quartz_surface_set_urgency_hint;
   impl_class->set_geometry_hints = gdk_quartz_surface_set_geometry_hints;
   impl_class->set_title = gdk_quartz_surface_set_title;
-  impl_class->set_role = gdk_quartz_surface_set_role;
   impl_class->set_startup_id = gdk_quartz_surface_set_startup_id;
   impl_class->set_transient_for = gdk_quartz_surface_set_transient_for;
   impl_class->get_frame_extents = gdk_quartz_surface_get_frame_extents;

gdk/wayland/gdkdevice-wayland.c

@@ -321,7 +321,7 @@ gdk_wayland_device_get_state (GdkDevice       *device,
 {
   gdouble x, y;
 
-  gdk_surface_get_device_position_double (surface, device, &x, &y, mask);
+  gdk_surface_get_device_position (surface, device, &x, &y, mask);
 
   if (axes)
     {
@@ -517,13 +517,6 @@ gdk_wayland_device_set_surface_cursor (GdkDevice *device,
   gdk_wayland_device_update_surface_cursor (device);
 }
 
-static void
-gdk_wayland_device_warp (GdkDevice *device,
-                         gdouble    x,
-                         gdouble    y)
-{
-}
-
 static void
 get_coordinates (GdkDevice *device,
                  double    *x,
@@ -621,9 +614,9 @@ emulate_crossing (GdkSurface       *surface,
   gdk_event_set_device (event, device);
   gdk_event_set_source_device (event, device);
 
-  gdk_surface_get_device_position_double (surface, device,
-                                         &event->crossing.x, &event->crossing.y,
-                                         &event->crossing.state);
+  gdk_surface_get_device_position (surface, device,
+                                   &event->crossing.x, &event->crossing.y,
+                                   &event->crossing.state);
   event->crossing.x_root = event->crossing.x;
   event->crossing.y_root = event->crossing.y;
 
@@ -871,7 +864,6 @@ gdk_wayland_device_class_init (GdkWaylandDeviceClass *klass)
   device_class->get_history = gdk_wayland_device_get_history;
   device_class->get_state = gdk_wayland_device_get_state;
   device_class->set_surface_cursor = gdk_wayland_device_set_surface_cursor;
-  device_class->warp = gdk_wayland_device_warp;
   device_class->query_state = gdk_wayland_device_query_state;
   device_class->grab = gdk_wayland_device_grab;
   device_class->ungrab = gdk_wayland_device_ungrab;

gdk/wayland/gdksurface-wayland.c

@@ -2447,8 +2447,7 @@ gdk_wayland_surface_map (GdkSurface *surface)
                     GDK_SURFACE_IMPL_WAYLAND (attached_grab_surface->impl);
                   grab_device = gdk_seat_get_pointer (attached_impl->grab_input_seat);
                   transient_for =
-                    gdk_device_get_surface_at_position (grab_device,
-                                                       NULL, NULL);
+                    gdk_device_get_surface_at_position (grab_device, NULL, NULL);
                 }
             }
           else
@@ -2465,8 +2464,13 @@ gdk_wayland_surface_map (GdkSurface *surface)
            * position of the device that holds the grab.
            */
           if (impl->position_method == POSITION_METHOD_NONE && grab_device)
-            gdk_surface_get_device_position (transient_for, grab_device,
-                                            &surface->x, &surface->y, NULL);
+            {
+              double px, py;
+              gdk_surface_get_device_position (transient_for, grab_device,
+                                               &px, &py, NULL);
+              surface->x = round (px);
+              surface->y = round (py);
+            }
         }
       else
         {
@@ -3182,12 +3186,6 @@ gdk_wayland_surface_set_title (GdkSurface  *surface,
   gdk_wayland_surface_sync_title (surface);
 }
 
-static void
-gdk_wayland_surface_set_role (GdkSurface  *surface,
-                              const gchar *role)
-{
-}
-
 static void
 gdk_wayland_surface_set_startup_id (GdkSurface  *surface,
                                     const gchar *startup_id)
@@ -3556,8 +3554,8 @@ gdk_wayland_surface_begin_resize_drag (GdkSurface     *surface,
                                        GdkSurfaceEdge  edge,
                                        GdkDevice      *device,
                                        gint            button,
-                                       gint            root_x,
-                                       gint            root_y,
+                                       gint            x,
+                                       gint            y,
                                        guint32         timestamp)
 {
   GdkSurfaceImplWayland *impl;
@@ -3646,8 +3644,8 @@ static void
 gdk_wayland_surface_begin_move_drag (GdkSurface *surface,
                                      GdkDevice  *device,
                                      gint        button,
-                                     gint        root_x,
-                                     gint        root_y,
+                                     gint        x,
+                                     gint        y,
                                      guint32     timestamp)
 {
   GdkSurfaceImplWayland *impl;
@@ -3854,7 +3852,6 @@ _gdk_surface_impl_wayland_class_init (GdkSurfaceImplWaylandClass *klass)
   impl_class->set_urgency_hint = gdk_wayland_surface_set_urgency_hint;
   impl_class->set_geometry_hints = gdk_wayland_surface_set_geometry_hints;
   impl_class->set_title = gdk_wayland_surface_set_title;
-  impl_class->set_role = gdk_wayland_surface_set_role;
   impl_class->set_startup_id = gdk_wayland_surface_set_startup_id;
   impl_class->set_transient_for = gdk_wayland_surface_set_transient_for;
   impl_class->get_frame_extents = gdk_wayland_surface_get_frame_extents;

gdk/win32/gdkdevice-virtual.c

@@ -112,14 +112,6 @@ gdk_device_virtual_set_surface_cursor (GdkDevice  *device,
   g_set_object (&GDK_SURFACE_IMPL_WIN32 (window->impl)->cursor, win32_hcursor);
 }
 
-static void
-gdk_device_virtual_warp (GdkDevice *device,
-			 gdouble   x,
-			 gdouble   y)
-{
-  SetCursorPos (x - _gdk_offset_x, y - _gdk_offset_y);
-}
-
 static void
 gdk_device_virtual_query_state (GdkDevice        *device,
 				GdkSurface        *window,
@@ -198,7 +190,6 @@ gdk_device_virtual_class_init (GdkDeviceVirtualClass *klass)
   device_class->get_history = gdk_device_virtual_get_history;
   device_class->get_state = gdk_device_virtual_get_state;
   device_class->set_surface_cursor = gdk_device_virtual_set_surface_cursor;
-  device_class->warp = gdk_device_virtual_warp;
   device_class->query_state = gdk_device_virtual_query_state;
   device_class->grab = gdk_device_virtual_grab;
   device_class->ungrab = gdk_device_virtual_ungrab;

gdk/win32/gdkdevice-win32.c

@@ -21,6 +21,7 @@
 
 #include <windowsx.h>
 #include <objbase.h>
+#include <math.h>
 
 #include "gdkdevice-win32.h"
 #include "gdkwin32.h"
@@ -45,14 +46,14 @@ gdk_device_win32_get_state (GdkDevice       *device,
                             gdouble         *axes,
                             GdkModifierType *mask)
 {
-  gint x_int, y_int;
+  double x, y;
 
-  gdk_surface_get_device_position (window, device, &x_int, &y_int, mask);
+  gdk_surface_get_device_position (window, device, &x, &y, mask);
 
   if (axes)
     {
-      axes[0] = x_int;
-      axes[1] = y_int;
+      axes[0] = round (x);
+      axes[1] = round (y);
     }
 }
 
@@ -63,13 +64,6 @@ gdk_device_win32_set_surface_cursor (GdkDevice *device,
 {
 }
 
-static void
-gdk_device_win32_warp (GdkDevice *device,
-                       gdouble    x,
-                       gdouble    y)
-{
-}
-
 static GdkModifierType
 get_current_mask (void)
 {
@@ -286,7 +280,6 @@ gdk_device_win32_class_init (GdkDeviceWin32Class *klass)
   device_class->get_history = gdk_device_win32_get_history;
   device_class->get_state = gdk_device_win32_get_state;
   device_class->set_surface_cursor = gdk_device_win32_set_surface_cursor;
-  device_class->warp = gdk_device_win32_warp;
   device_class->query_state = gdk_device_win32_query_state;
   device_class->grab = gdk_device_win32_grab;
   device_class->ungrab = gdk_device_win32_ungrab;

gdk/win32/gdkdevice-wintab.c

@@ -99,13 +99,6 @@ gdk_device_wintab_set_surface_cursor (GdkDevice *device,
 {
 }
 
-static void
-gdk_device_wintab_warp (GdkDevice *device,
-                        gdouble   x,
-                        gdouble   y)
-{
-}
-
 static void
 gdk_device_wintab_query_state (GdkDevice        *device,
                                GdkSurface        *window,
@@ -291,7 +284,6 @@ gdk_device_wintab_class_init (GdkDeviceWintabClass *klass)
   device_class->get_history = gdk_device_wintab_get_history;
   device_class->get_state = gdk_device_wintab_get_state;
   device_class->set_surface_cursor = gdk_device_wintab_set_surface_cursor;
-  device_class->warp = gdk_device_wintab_warp;
   device_class->query_state = gdk_device_wintab_query_state;
   device_class->grab = gdk_device_wintab_grab;
   device_class->ungrab = gdk_device_wintab_ungrab;

gdk/win32/gdkdevicemanager-win32.c

@@ -883,15 +883,12 @@ gdk_input_other_event (GdkDisplay *display,
   GdkDeviceManagerWin32 *device_manager;
   GdkDeviceWintab *source_device = NULL;
   GdkDeviceGrabInfo *last_grab;
-  GdkEventMask masktest;
   guint key_state;
-  POINT pt;
-  GdkSurfaceImplWin32 *impl;
 
   PACKET packet;
   gint root_x, root_y;
   gint num_axes;
-  gint x, y;
+  double x, y;
   guint translated_buttons, button_diff, button_mask;
   /* Translation from tablet button state to GDK button state for
    * buttons 1-3 - swap button 2 and 3.
@@ -911,7 +908,7 @@ gdk_input_other_event (GdkDisplay *display,
     g_object_ref (window);
 
   GDK_NOTE (EVENTS_OR_INPUT,
-	    g_print ("gdk_input_other_event: window=%p %+d%+d\n",
+	    g_print ("gdk_input_other_event: window=%p %+g%+g\n",
                window ? GDK_SURFACE_HWND (window) : NULL, x, y));
 
   if (msg->message == WT_PACKET || msg->message == WT_CSRCHANGE)

gdk/win32/gdkdisplay-win32.c

@@ -38,6 +38,8 @@
 
 #include <dwmapi.h>
 
+#include "gdkwin32langnotification.h"
+
 static int debug_indent = 0;
 
 /**
@@ -536,6 +538,7 @@ _gdk_win32_display_open (const gchar *display_name)
                                       NULL);
   _gdk_device_manager->display = _gdk_display;
 
+  _gdk_win32_lang_notification_init ();
   _gdk_drag_init ();
   _gdk_drop_init ();
 
@@ -701,6 +704,7 @@ gdk_win32_display_finalize (GObject *object)
 
   _gdk_win32_display_finalize_cursors (display_win32);
   _gdk_win32_dnd_exit ();
+  _gdk_win32_lang_notification_exit ();
 
   g_ptr_array_free (display_win32->monitors, TRUE);
 

gdk/win32/gdkdrag-win32.c

@@ -29,6 +29,7 @@
 
 #include <io.h>
 #include <fcntl.h>
+#include <math.h>
 
 /*
  * Support for OLE-2 drag and drop added at Archaeopteryx Software, 2001
@@ -1717,6 +1718,7 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
   GdkDrag *drag;
   GdkWin32Drag *drag_win32;
   GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
+  double px, py;
   int x_root, y_root;
 
   g_return_val_if_fail (surface != NULL, NULL);
@@ -1731,9 +1733,9 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
 
   GDK_NOTE (DND, g_print ("_gdk_win32_surface_drag_begin\n"));
 
-  gdk_device_get_position (device, &x_root, &y_root);
-  x_root += dx;
-  y_root += dy;
+  gdk_device_get_position (device, &px, &px);
+  x_root = round (px) + dx;
+  y_root = round (py) + dy;
 
   drag_win32->start_x = x_root;
   drag_win32->start_y = y_root;
@@ -1840,7 +1842,6 @@ gdk_win32_drag_find_window (GdkDrag    *drag,
 {
   GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
   find_window_enum_arg a;
-  HWND result;
 
   g_assert (_win32_main_thread == NULL ||
             _win32_main_thread == g_thread_self ());
@@ -2439,7 +2440,6 @@ gdk_dnd_handle_key_event (GdkDrag           *drag,
     {
       drag_win32->util_data.last_x += dx;
       drag_win32->util_data.last_y += dy;
-      gdk_device_warp (pointer, drag_win32->util_data.last_x, drag_win32->util_data.last_y);
     }
 
   if (drag_win32->drag_surface)

gdk/win32/gdkdrop-win32.c

@@ -1090,7 +1090,6 @@ static void
 gdk_win32_drop_finish (GdkDrop       *drop,
                        GdkDragAction  action)
 {
-  GdkDrag *drag;
   GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (drop);
 
   g_return_if_fail (drop != NULL);
@@ -1103,12 +1102,6 @@ gdk_win32_drop_finish (GdkDrop       *drop,
 
   if (drop_win32->protocol == GDK_DRAG_PROTO_OLE2)
     return;
-/* FIXME: remove?
-  drag = gdk_drop_get_drag (drop);
-
-  if (drag != NULL)
-    _gdk_win32_local_drag_drop_response (drag, action);
-*/
 }
 
 #if 0

gdk/win32/gdkevents-win32.c

@@ -1331,7 +1331,6 @@ _gdk_win32_do_emit_configure_event (GdkSurface *window,
                                     RECT       rect)
 {
   GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
-  GdkEvent *event;
 
   impl->unscaled_width = rect.right - rect.left;
   impl->unscaled_height = rect.bottom - rect.top;
@@ -2113,7 +2112,6 @@ gdk_event_translate (MSG  *msg,
     case WM_INPUTLANGCHANGE:
       _gdk_input_locale = (HKL) msg->lParam;
       _gdk_win32_keymap_set_active_layout (GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display)), _gdk_input_locale);
-      _gdk_input_locale_is_ime = ImmIsIME (_gdk_input_locale);
       GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
 		     LOCALE_IDEFAULTANSICODEPAGE,
 		     buf, sizeof (buf));
@@ -2125,6 +2123,20 @@ gdk_event_translate (MSG  *msg,
 			 (gpointer) msg->lParam, _gdk_input_locale_is_ime ? " (IME)" : "",
 			 _gdk_input_codepage));
       gdk_display_setting_changed (display, "gtk-im-module");
+
+      /* Generate a dummy key event to "nudge" IMContext */
+      event = gdk_event_new (GDK_KEY_PRESS);
+      event->any.surface = window;
+      event->key.time = _gdk_win32_get_next_tick (msg->time);
+      event->key.keyval = GDK_KEY_VoidSymbol;
+      event->key.hardware_keycode = 0;
+      event->key.group = 0;
+      gdk_event_set_scancode (event, 0);
+      gdk_event_set_device (event, device_manager_win32->core_keyboard);
+      gdk_event_set_source_device (event, device_manager_win32->system_keyboard);
+      event->key.is_modifier = FALSE;
+      event->key.state = 0;
+      _gdk_win32_append_event (event);
       break;
 
     case WM_SYSKEYUP:

gdk/win32/gdkglobals-win32.c

@@ -39,7 +39,7 @@ HINSTANCE	  _gdk_app_hmodule;
 gint		  _gdk_input_ignore_core;
 
 HKL		  _gdk_input_locale;
-gboolean	  _gdk_input_locale_is_ime;
+gboolean	  _gdk_input_locale_is_ime = FALSE;
 UINT		  _gdk_input_codepage;
 
 gint		  _gdk_input_ignore_wintab = FALSE;

gdk/win32/gdkmain-win32.c

@@ -83,7 +83,6 @@ _gdk_win32_surfaceing_init (void)
   _gdk_display_hdc = CreateDC ("DISPLAY", NULL, NULL, NULL);
   _gdk_input_locale = GetKeyboardLayout (0);
   _gdk_win32_keymap_set_active_layout (GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display)), _gdk_input_locale);
-  _gdk_input_locale_is_ime = ImmIsIME (_gdk_input_locale);
   GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
 		 LOCALE_IDEFAULTANSICODEPAGE,
 		 buf, sizeof (buf));

gdk/win32/gdkproperty-win32.c

@@ -215,9 +215,9 @@ _gdk_win32_get_setting (const gchar *name,
   else if (strcmp ("gtk-im-module", name) == 0)
     {
       if (_gdk_input_locale_is_ime)
-        g_value_set_string (value, "ime");
+        g_value_set_static_string (value, "ime");
       else
-        g_value_set_string (value, "");
+        g_value_set_static_string (value, "");
 
       return TRUE;
     }

gdk/win32/gdksurface-win32.c

@@ -1626,18 +1626,6 @@ gdk_win32_surface_set_title (GdkSurface   *window,
   GDK_NOTE (MISC_OR_EVENTS, g_free ((char *) title));
 }
 
-static void
-gdk_win32_surface_set_role (GdkSurface   *window,
-		     const gchar *role)
-{
-  g_return_if_fail (GDK_IS_SURFACE (window));
-
-  GDK_NOTE (MISC, g_print ("gdk_surface_set_role: %p: %s\n",
-			   GDK_SURFACE_HWND (window),
-			   (role ? role : "NULL")));
-  /* XXX */
-}
-
 static void
 gdk_win32_surface_set_transient_for (GdkSurface *window,
 			      GdkSurface *parent)
@@ -1953,19 +1941,6 @@ gdk_surface_win32_get_device_state (GdkSurface       *window,
   return (child != NULL);
 }
 
-void
-gdk_display_warp_device (GdkDisplay *display,
-                         GdkDevice  *device,
-                         gint        x,
-                         gint        y)
-{
-  g_return_if_fail (display == gdk_display_get_default ());
-  g_return_if_fail (GDK_IS_DEVICE (device));
-  g_return_if_fail (display == gdk_device_get_display (device));
-
-  GDK_DEVICE_GET_CLASS (device)->warp (device, x, y);
-}
-
 static void
 gdk_win32_surface_set_accept_focus (GdkSurface *window,
 			     gboolean accept_focus)
@@ -4125,7 +4100,7 @@ setup_drag_move_resize_context (GdkSurface                   *window,
            * the titlebar is, if any.
            */
           root_y = wy + wheight / 2;
-          gdk_device_warp (device, root_x, root_y);
+          SetCursorPos (root_x - _gdk_offset_x, root_y - _gdk_offset_y);
         }
     }
 
@@ -5341,7 +5316,6 @@ gdk_surface_impl_win32_class_init (GdkSurfaceImplWin32Class *klass)
   impl_class->set_urgency_hint = gdk_win32_surface_set_urgency_hint;
   impl_class->set_geometry_hints = gdk_win32_surface_set_geometry_hints;
   impl_class->set_title = gdk_win32_surface_set_title;
-  impl_class->set_role = gdk_win32_surface_set_role;
   //impl_class->set_startup_id = gdk_x11_surface_set_startup_id;
   impl_class->set_transient_for = gdk_win32_surface_set_transient_for;
   impl_class->get_frame_extents = gdk_win32_surface_get_frame_extents;

gdk/win32/gdkwin32langnotification.c

@@ -0,0 +1,172 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2019 Руслан Ижбулатов <lrn1986@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#define COBJMACROS
+#include <msctf.h>
+
+#include <gdk/gdk.h>
+
+#include "gdkprivate-win32.h"
+
+struct _GdkWin32ALPNSink
+{
+  ITfActiveLanguageProfileNotifySink itf_alpn_sink;
+
+  gint ref_count;
+};
+
+typedef struct _GdkWin32ALPNSink GdkWin32ALPNSink;
+
+static GdkWin32ALPNSink *actlangchangenotify = NULL;
+static ITfSource *itf_source = NULL;
+static DWORD actlangchangenotify_id = 0;
+
+static ULONG STDMETHODCALLTYPE
+alpn_sink_addref (ITfActiveLanguageProfileNotifySink *This)
+{
+  GdkWin32ALPNSink *alpn_sink = (GdkWin32ALPNSink *) This;
+  int ref_count = ++alpn_sink->ref_count;
+
+  return ref_count;
+}
+
+static HRESULT STDMETHODCALLTYPE
+alpn_sink_queryinterface (ITfActiveLanguageProfileNotifySink *This,
+                          REFIID                              riid,
+                          LPVOID                             *ppvObject)
+{
+  *ppvObject = NULL;
+
+  if (IsEqualGUID (riid, &IID_IUnknown))
+    {
+      ITfActiveLanguageProfileNotifySink_AddRef (This);
+      *ppvObject = This;
+      return S_OK;
+    }
+
+  if (IsEqualGUID (riid, &IID_ITfActiveLanguageProfileNotifySink))
+    {
+      ITfActiveLanguageProfileNotifySink_AddRef (This);
+      *ppvObject = This;
+      return S_OK;
+    }
+
+  return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE
+alpn_sink_release (ITfActiveLanguageProfileNotifySink *This)
+{
+  GdkWin32ALPNSink *alpn_sink = (GdkWin32ALPNSink *) This;
+  int ref_count = --alpn_sink->ref_count;
+
+  if (ref_count == 0)
+    {
+      g_free (This);
+    }
+
+  return ref_count;
+}
+
+static HRESULT STDMETHODCALLTYPE
+alpn_sink_on_activated (ITfActiveLanguageProfileNotifySink *This,
+                        REFCLSID                            clsid,
+                        REFGUID                             guidProfile,
+                        BOOL                                fActivated)
+{
+  _gdk_input_locale_is_ime = fActivated;
+  return S_OK;
+}
+
+static ITfActiveLanguageProfileNotifySinkVtbl alpn_sink_vtbl = {
+  alpn_sink_queryinterface,
+  alpn_sink_addref,
+  alpn_sink_release,
+  alpn_sink_on_activated,
+};
+
+static GdkWin32ALPNSink *
+alpn_sink_new ()
+{
+  GdkWin32ALPNSink *result;
+
+  result = g_new0 (GdkWin32ALPNSink, 1);
+  result->itf_alpn_sink.lpVtbl = &alpn_sink_vtbl;
+  result->ref_count = 0;
+
+  ITfActiveLanguageProfileNotifySink_AddRef (&result->itf_alpn_sink);
+
+  return result;
+}
+
+
+void
+_gdk_win32_lang_notification_init ()
+{
+  HRESULT hr;
+  ITfThreadMgr *itf_threadmgr;
+
+  CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
+
+  if (actlangchangenotify != NULL)
+    return;
+
+  hr = CoCreateInstance (&CLSID_TF_ThreadMgr,
+                         NULL,
+                         CLSCTX_INPROC_SERVER,
+                         &IID_ITfThreadMgr,
+                         (LPVOID *) &itf_threadmgr);
+
+  if (!SUCCEEDED (hr))
+    return;
+
+  hr = ITfThreadMgr_QueryInterface (itf_threadmgr, &IID_ITfSource, (VOID **) &itf_source);
+  ITfThreadMgr_Release (itf_threadmgr);
+
+  if (!SUCCEEDED (hr))
+    return;
+
+  actlangchangenotify = alpn_sink_new ();
+
+  hr = ITfSource_AdviseSink (itf_source,
+                             &IID_ITfActiveLanguageProfileNotifySink,
+                             (IUnknown *) actlangchangenotify,
+                             &actlangchangenotify_id);
+
+  if (!SUCCEEDED (hr))
+    {
+      ITfActiveLanguageProfileNotifySink_Release (&actlangchangenotify->itf_alpn_sink);
+      actlangchangenotify = NULL;
+      ITfSource_Release (itf_source);
+      itf_source = NULL;
+    }
+}
+
+void
+_gdk_win32_lang_notification_exit ()
+{
+  if (actlangchangenotify != NULL && itf_source != NULL)
+    {
+      ITfSource_UnadviseSink (itf_source, actlangchangenotify_id);
+      ITfSource_Release (itf_source);
+      ITfActiveLanguageProfileNotifySink_Release (&actlangchangenotify->itf_alpn_sink);
+    }
+
+  CoUninitialize ();
+}

gdk/win32/gdkwin32langnotification.h

@@ -0,0 +1,26 @@
+/*
+ * gdkwin32langnotification.h
+ *
+ * Copyright 2019 Руслан Ижбулатов <lrn1986@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GDK_WIN32_LANGNOTIFICATION_H__
+#define __GDK_WIN32_LANGNOTIFICATION_H__
+
+void _gdk_win32_lang_notification_init (void);
+void _gdk_win32_lang_notification_exit (void);
+
+#endif

gdk/win32/meson.build

@@ -17,6 +17,7 @@ gdk_win32_sources = files([
   'gdkglobals-win32.c',
   'gdkhdataoutputstream-win32.c',
   'gdkkeys-win32.c',
+  'gdkwin32langnotification.c',
   'gdkmain-win32.c',
   'gdkmonitor-win32.c',
   'gdkproperty-win32.c',

gdk/x11/gdkdevice-core-x11.c

@@ -52,9 +52,6 @@ static void     gdk_x11_device_core_get_state   (GdkDevice       *device,
 static void     gdk_x11_device_core_set_surface_cursor (GdkDevice *device,
                                                        GdkSurface *surface,
                                                        GdkCursor *cursor);
-static void     gdk_x11_device_core_warp (GdkDevice *device,
-                                          gdouble    x,
-                                          gdouble    y);
 static void gdk_x11_device_core_query_state (GdkDevice        *device,
                                              GdkSurface        *surface,
                                              GdkSurface       **child_surface,
@@ -88,7 +85,6 @@ gdk_x11_device_core_class_init (GdkX11DeviceCoreClass *klass)
   device_class->get_history = gdk_x11_device_core_get_history;
   device_class->get_state = gdk_x11_device_core_get_state;
   device_class->set_surface_cursor = gdk_x11_device_core_set_surface_cursor;
-  device_class->warp = gdk_x11_device_core_warp;
   device_class->query_state = gdk_x11_device_core_query_state;
   device_class->grab = gdk_x11_device_core_grab;
   device_class->ungrab = gdk_x11_device_core_ungrab;
@@ -196,7 +192,7 @@ gdk_x11_device_core_get_state (GdkDevice       *device,
 {
   gdouble x, y;
 
-  gdk_surface_get_device_position_double (surface, device, &x, &y, mask);
+  gdk_surface_get_device_position (surface, device, &x, &y, mask);
 
   if (axes)
     {
@@ -223,26 +219,6 @@ gdk_x11_device_core_set_surface_cursor (GdkDevice *device,
                  xcursor);
 }
 
-static void
-gdk_x11_device_core_warp (GdkDevice *device,
-                          gdouble    x,
-                          gdouble    y)
-{
-  GdkDisplay *display;
-  Display *xdisplay;
-  Window dest;
-  GdkX11Screen *screen;
-
-  display = gdk_device_get_display (device);
-  xdisplay = GDK_DISPLAY_XDISPLAY (display);
-  screen = GDK_X11_DISPLAY (display)->screen;
-  dest = GDK_SCREEN_XROOTWIN (screen);
-
-  XWarpPointer (xdisplay, None, dest, 0, 0, 0, 0,
-                round (x * screen->surface_scale),
-                round (y * screen->surface_scale));
-}
-
 static void
 gdk_x11_device_core_query_state (GdkDevice        *device,
                                  GdkSurface        *surface,

gdk/x11/gdkdevice-xi2.c

@@ -77,9 +77,6 @@ static void gdk_x11_device_xi2_get_state (GdkDevice       *device,
 static void gdk_x11_device_xi2_set_surface_cursor (GdkDevice *device,
                                                   GdkSurface *surface,
                                                   GdkCursor *cursor);
-static void gdk_x11_device_xi2_warp (GdkDevice *device,
-                                     gdouble    x,
-                                     gdouble    y);
 static void gdk_x11_device_xi2_query_state (GdkDevice        *device,
                                             GdkSurface        *surface,
                                             GdkSurface       **child_surface,
@@ -123,7 +120,6 @@ gdk_x11_device_xi2_class_init (GdkX11DeviceXI2Class *klass)
 
   device_class->get_state = gdk_x11_device_xi2_get_state;
   device_class->set_surface_cursor = gdk_x11_device_xi2_set_surface_cursor;
-  device_class->warp = gdk_x11_device_xi2_warp;
   device_class->query_state = gdk_x11_device_xi2_query_state;
   device_class->grab = gdk_x11_device_xi2_grab;
   device_class->ungrab = gdk_x11_device_xi2_ungrab;
@@ -292,24 +288,6 @@ gdk_x11_device_xi2_set_surface_cursor (GdkDevice *device,
                       GDK_SURFACE_XID (surface));
 }
 
-static void
-gdk_x11_device_xi2_warp (GdkDevice *device,
-                         gdouble    x,
-                         gdouble    y)
-{
-  GdkX11DeviceXI2 *device_xi2 = GDK_X11_DEVICE_XI2 (device);
-  GdkDisplay *display = gdk_device_get_display (device);
-  GdkX11Screen *screen = GDK_X11_DISPLAY (display)->screen;
-  Window dest = GDK_DISPLAY_XROOTWIN (display);
-
-  XIWarpPointer (GDK_SCREEN_XDISPLAY (screen),
-                 device_xi2->device_id,
-                 None, dest,
-                 0, 0, 0, 0,
-                 round (x * screen->surface_scale),
-                 round (y * screen->surface_scale));
-}
-
 static void
 gdk_x11_device_xi2_query_state (GdkDevice        *device,
                                 GdkSurface        *surface,

gdk/x11/gdkdrag-x11.c

@@ -41,6 +41,7 @@
 #include "gdkselectioninputstream-x11.h"
 #include "gdkselectionoutputstream-x11.h"
 
+#include <math.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
@@ -2076,6 +2077,7 @@ _gdk_x11_surface_drag_begin (GdkSurface         *surface,
   GdkX11Drag *x11_drag;
   GdkDrag *drag;
   GdkDisplay *display;
+  double px, py;
   int x_root, y_root;
   Atom xselection;
   GdkSurface *ipc_surface;
@@ -2096,9 +2098,9 @@ _gdk_x11_surface_drag_begin (GdkSurface         *surface,
 
   precache_target_list (drag);
 
-  gdk_device_get_position (device, &x_root, &y_root);
-  x_root += dx;
-  y_root += dy;
+  gdk_device_get_position (device, &px, &py);
+  x_root = round (px) + dx;
+  y_root = round (py) + dy;
 
   x11_drag->start_x = x_root;
   x11_drag->start_y = y_root;
@@ -2342,9 +2344,22 @@ gdk_dnd_handle_key_event (GdkDrag           *drag,
 
   if (dx != 0 || dy != 0)
     {
+      GdkDisplay *display;
+      Display *xdisplay;
+      GdkX11Screen *screen;
+      Window dest;
+
       x11_drag->last_x += dx;
       x11_drag->last_y += dy;
-      gdk_device_warp (pointer, x11_drag->last_x, x11_drag->last_y);
+
+      display = gdk_event_get_display ((GdkEvent *)event);
+      xdisplay = GDK_DISPLAY_XDISPLAY (display);
+      screen = GDK_X11_DISPLAY (display)->screen;
+      dest = GDK_SCREEN_XROOTWIN (screen);
+
+      XWarpPointer (xdisplay, None, dest, 0, 0, 0, 0,
+                   round (x11_drag->last_x * screen->surface_scale),
+                   round (x11_drag->last_y * screen->surface_scale));
     }
 
   gdk_drag_update (drag, x11_drag->last_x, x11_drag->last_y, state,

gdk/x11/gdksurface-x11.c

@@ -2231,27 +2231,6 @@ gdk_x11_surface_set_title (GdkSurface   *surface,
     }
 }
 
-static void
-gdk_x11_surface_set_role (GdkSurface   *surface,
-			 const gchar *role)
-{
-  GdkDisplay *display;
-
-  display = gdk_surface_get_display (surface);
-
-  if (GDK_SURFACE_DESTROYED (surface) ||
-      !SURFACE_IS_TOPLEVEL (surface))
-    return;
-
-  if (role)
-    XChangeProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (surface),
-                     gdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"),
-                     XA_STRING, 8, PropModeReplace, (guchar *)role, strlen (role));
-  else
-    XDeleteProperty (GDK_DISPLAY_XDISPLAY (display), GDK_SURFACE_XID (surface),
-                     gdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"));
-}
-
 static void
 gdk_x11_surface_set_startup_id (GdkSurface   *surface,
 			       const gchar *startup_id)
@@ -4293,12 +4272,12 @@ emulate_resize_drag (GdkSurface     *surface,
 }
 
 static void
-emulate_move_drag (GdkSurface     *surface,
-                   GdkDevice     *device,
-                   gint           button,
-                   gint           root_x,
-                   gint           root_y,
-                   guint32        timestamp)
+emulate_move_drag (GdkSurface *surface,
+                   GdkDevice  *device,
+                   gint        button,
+                   gint        root_x,
+                   gint        root_y,
+                   guint32     timestamp)
 {
   MoveResizeData *mv_resize = get_move_resize_data (GDK_SURFACE_DISPLAY (surface), TRUE);
 
@@ -4338,17 +4317,21 @@ _should_perform_ewmh_drag (GdkSurface *surface,
 
 static void
 gdk_x11_surface_begin_resize_drag (GdkSurface     *surface,
-                                  GdkSurfaceEdge  edge,
-                                  GdkDevice     *device,
-                                  gint           button,
-                                  gint           root_x,
-                                  gint           root_y,
-                                  guint32        timestamp)
+                                   GdkSurfaceEdge  edge,
+                                   GdkDevice      *device,
+                                   gint            button,
+                                   gint            x,
+                                   gint            y,
+                                   guint32         timestamp)
 {
+  int root_x, root_y;
+
   if (GDK_SURFACE_DESTROYED (surface) ||
       !SURFACE_IS_TOPLEVEL (surface))
     return;
 
+  gdk_surface_x11_get_root_coords (surface, x, y, &root_x, &root_y);
+
   /* Avoid EWMH for touch devices */
   if (_should_perform_ewmh_drag (surface, device))
     wmspec_resize_drag (surface, edge, device, button, root_x, root_y, timestamp);
@@ -4358,12 +4341,13 @@ gdk_x11_surface_begin_resize_drag (GdkSurface     *surface,
 
 static void
 gdk_x11_surface_begin_move_drag (GdkSurface *surface,
-                                GdkDevice *device,
-				gint       button,
-				gint       root_x,
-				gint       root_y,
-				guint32    timestamp)
+                                 GdkDevice  *device,
+                                 gint        button,
+                                 gint        x,
+                                 gint        y,
+                                 guint32     timestamp)
 {
+  int root_x, root_y;
   gint direction;
 
   if (GDK_SURFACE_DESTROYED (surface) || !SURFACE_IS_TOPLEVEL (surface))
@@ -4374,6 +4358,8 @@ gdk_x11_surface_begin_move_drag (GdkSurface *surface,
   else
     direction = _NET_WM_MOVERESIZE_MOVE;
 
+  gdk_surface_x11_get_root_coords (surface, x, y, &root_x, &root_y);
+
   /* Avoid EWMH for touch devices */
   if (_should_perform_ewmh_drag (surface, device))
     wmspec_moveresize (surface, direction, device, button, root_x, root_y, timestamp);
@@ -4677,7 +4663,6 @@ gdk_surface_impl_x11_class_init (GdkSurfaceImplX11Class *klass)
   impl_class->set_urgency_hint = gdk_x11_surface_set_urgency_hint;
   impl_class->set_geometry_hints = gdk_x11_surface_set_geometry_hints;
   impl_class->set_title = gdk_x11_surface_set_title;
-  impl_class->set_role = gdk_x11_surface_set_role;
   impl_class->set_startup_id = gdk_x11_surface_set_startup_id;
   impl_class->set_transient_for = gdk_x11_surface_set_transient_for;
   impl_class->get_frame_extents = gdk_x11_surface_get_frame_extents;

gsk/gskrenderer.c

@@ -68,7 +68,6 @@ typedef struct
   GdkSurface *surface;
   GskRenderNode *prev_node;
   GskRenderNode *root_node;
-  GdkDisplay *display;
 
   GskProfiler *profiler;
 
@@ -80,8 +79,9 @@ typedef struct
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GskRenderer, gsk_renderer, G_TYPE_OBJECT)
 
 enum {
-  PROP_SURFACE = 1,
-  PROP_DISPLAY,
+  PROP_0,
+  PROP_REALIZED,
+  PROP_SURFACE,
 
   N_PROPS
 };
@@ -134,33 +134,10 @@ gsk_renderer_dispose (GObject *gobject)
   g_assert (!priv->is_realized);
 
   g_clear_object (&priv->profiler);
-  g_clear_object (&priv->display);
 
   G_OBJECT_CLASS (gsk_renderer_parent_class)->dispose (gobject);
 }
 
-static void
-gsk_renderer_set_property (GObject      *gobject,
-                           guint         prop_id,
-                           const GValue *value,
-                           GParamSpec   *pspec)
-{
-  GskRenderer *self = GSK_RENDERER (gobject);
-  GskRendererPrivate *priv = gsk_renderer_get_instance_private (self);
-
-  switch (prop_id)
-    {
-    case PROP_DISPLAY:
-      /* Construct-only */
-      priv->display = g_value_dup_object (value);
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
-      break;
-    }
-}
-
 static void
 gsk_renderer_get_property (GObject    *gobject,
                            guint       prop_id,
@@ -172,12 +149,12 @@ gsk_renderer_get_property (GObject    *gobject,
 
   switch (prop_id)
     {
-    case PROP_SURFACE:
-      g_value_set_object (value, priv->surface);
+    case PROP_REALIZED:
+      g_value_set_boolean (value, priv->is_realized);
       break;
 
-    case PROP_DISPLAY:
-      g_value_set_object (value, priv->display);
+    case PROP_SURFACE:
+      g_value_set_object (value, priv->surface);
       break;
 
     default:
@@ -186,23 +163,6 @@ gsk_renderer_get_property (GObject    *gobject,
     }
 }
 
-static void
-gsk_renderer_constructed (GObject *gobject)
-{
-  GskRenderer *self = GSK_RENDERER (gobject);
-  GskRendererPrivate *priv = gsk_renderer_get_instance_private (self);
-
-  if (priv->display == NULL)
-    {
-      GdkDisplayManager *manager = gdk_display_manager_get ();
-
-      priv->display = gdk_display_manager_get_default_display (manager);
-      g_assert (priv->display != NULL);
-    }
-
-  G_OBJECT_CLASS (gsk_renderer_parent_class)->constructed (gobject);
-}
-
 static void
 gsk_renderer_class_init (GskRendererClass *klass)
 {
@@ -213,32 +173,22 @@ gsk_renderer_class_init (GskRendererClass *klass)
   klass->render = gsk_renderer_real_render;
   klass->render_texture = gsk_renderer_real_render_texture;
 
-  gobject_class->constructed = gsk_renderer_constructed;
-  gobject_class->set_property = gsk_renderer_set_property;
   gobject_class->get_property = gsk_renderer_get_property;
   gobject_class->dispose = gsk_renderer_dispose;
 
-  /**
-   * GskRenderer:display:
-   *
-   * The #GdkDisplay used by the #GskRenderer.
-   */
-  gsk_renderer_properties[PROP_DISPLAY] =
-    g_param_spec_object ("display",
-			 "Display",
-			 "The GdkDisplay object used by the renderer",
-			 GDK_TYPE_DISPLAY,
-			 G_PARAM_READWRITE |
-			 G_PARAM_CONSTRUCT_ONLY |
-			 G_PARAM_STATIC_STRINGS);
+  gsk_renderer_properties[PROP_REALIZED] =
+    g_param_spec_boolean ("realized",
+                          "Realized",
+                          "The renderer has been associated with a surface",
+                          FALSE,
+                          G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
   gsk_renderer_properties[PROP_SURFACE] =
     g_param_spec_object ("surface",
                          "Surface",
                          "The surface associated to the renderer",
                          GDK_TYPE_SURFACE,
-                         G_PARAM_READABLE |
-                         G_PARAM_STATIC_STRINGS);
+                         G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
   g_object_class_install_properties (gobject_class, N_PROPS, gsk_renderer_properties);
 }
@@ -290,24 +240,6 @@ gsk_renderer_get_root_node (GskRenderer *renderer)
 }
 
 /**
- * gsk_renderer_get_display:
- * @renderer: a #GskRenderer
- *
- * Retrieves the #GdkDisplay used when creating the #GskRenderer.
- *
- * Returns: (transfer none): a #GdkDisplay
- */
-GdkDisplay *
-gsk_renderer_get_display (GskRenderer *renderer)
-{
-  GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
-
-  g_return_val_if_fail (GSK_IS_RENDERER (renderer), NULL);
-
-  return priv->display;
-}
-
-/*< private >
  * gsk_renderer_is_realized:
  * @renderer: a #GskRenderer
  *
@@ -674,9 +606,7 @@ gsk_renderer_new_for_surface (GdkSurface *surface)
        * information to stdout.
        */
       verbose |= renderer_possibilities[i].verbose;
-      renderer = g_object_new (renderer_type,
-                               "display", gdk_surface_get_display (surface),
-                               NULL);
+      renderer = g_object_new (renderer_type, NULL);
 
       if (gsk_renderer_realize (renderer, surface, &error))
         {

gsk/gskrenderer.h

@@ -39,13 +39,10 @@ GDK_AVAILABLE_IN_ALL
 GType gsk_renderer_get_type (void) G_GNUC_CONST;
 
 GDK_AVAILABLE_IN_ALL
-GskRenderer *           gsk_renderer_new_for_surface           (GdkSurface               *surface);
+GskRenderer *           gsk_renderer_new_for_surface            (GdkSurface               *surface);
 
 GDK_AVAILABLE_IN_ALL
-GdkSurface *             gsk_renderer_get_surface               (GskRenderer             *renderer);
-
-GDK_AVAILABLE_IN_ALL
-GdkDisplay *            gsk_renderer_get_display                (GskRenderer             *renderer);
+GdkSurface *            gsk_renderer_get_surface                (GskRenderer             *renderer);
 
 GDK_AVAILABLE_IN_ALL
 gboolean                gsk_renderer_realize                    (GskRenderer             *renderer,
@@ -53,6 +50,8 @@ gboolean                gsk_renderer_realize                    (GskRenderer
                                                                  GError                 **error);
 GDK_AVAILABLE_IN_ALL
 void                    gsk_renderer_unrealize                  (GskRenderer             *renderer);
+GDK_AVAILABLE_IN_ALL
+gboolean                gsk_renderer_is_realized                (GskRenderer             *renderer);
 
 GDK_AVAILABLE_IN_ALL
 GdkTexture *            gsk_renderer_render_texture             (GskRenderer             *renderer,

gsk/gskrendererprivate.h

@@ -51,8 +51,6 @@ struct _GskRendererClass
                                                                  const cairo_region_t   *invalid);
 };
 
-gboolean                gsk_renderer_is_realized                (GskRenderer    *renderer);
-
 GskRenderNode *         gsk_renderer_get_root_node              (GskRenderer    *renderer);
 
 GskProfiler *           gsk_renderer_get_profiler               (GskRenderer    *renderer);

gsk/gskrendernodeimpl.c

@@ -3060,10 +3060,10 @@ gsk_color_matrix_node_draw (GskRenderNode *node,
           if (alpha > 0.0)
             {
               alpha = MIN (alpha, 1.0);
-              pixel_data[x] = (((guint32) (alpha * 255)) << 24) |
-                              (((guint32) (CLAMP (graphene_vec4_get_x (&pixel), 0, 1) * alpha * 255)) << 16) |
-                              (((guint32) (CLAMP (graphene_vec4_get_y (&pixel), 0, 1) * alpha * 255)) <<  8) |
-                               ((guint32) (CLAMP (graphene_vec4_get_z (&pixel), 0, 1) * alpha * 255));
+              pixel_data[x] = (((guint32) roundf (alpha * 255)) << 24) |
+                              (((guint32) roundf (CLAMP (graphene_vec4_get_x (&pixel), 0, 1) * alpha * 255)) << 16) |
+                              (((guint32) roundf (CLAMP (graphene_vec4_get_y (&pixel), 0, 1) * alpha * 255)) <<  8) |
+                               ((guint32) roundf (CLAMP (graphene_vec4_get_z (&pixel), 0, 1) * alpha * 255));
             }
           else
             {

gtk/a11y/gtkentryaccessible.c

@@ -876,12 +876,18 @@ static gint
 gtk_entry_accessible_get_caret_offset (AtkText *text)
 {
   GtkWidget *widget;
+  gboolean result;
+  int cursor_position;
 
   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
   if (widget == NULL)
-    return 0;
+    return -1;
 
-  return gtk_editable_get_position (GTK_EDITABLE (widget));
+  result = gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), NULL, &cursor_position);
+  if (!result)
+    return -1;
+
+  return cursor_position;
 }
 
 static gboolean

gtk/a11y/gtklabelaccessible.c

@@ -822,7 +822,11 @@ gtk_label_accessible_get_caret_offset (AtkText *text)
 
   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
   if (widget == NULL)
-    return 0;
+    return -1;
+
+  /* Non-selectable labels cannot have a caret. */
+  if (!gtk_label_get_selectable (GTK_LABEL (widget)))
+    return -1;
 
   return _gtk_label_get_cursor_position (GTK_LABEL (widget));
 }

gtk/a11y/gtktextaccessible.c

@@ -317,12 +317,18 @@ static gint
 gtk_text_accessible_get_caret_offset (AtkText *text)
 {
   GtkWidget *widget;
+  gboolean result;
+  int cursor_position;
 
   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
   if (widget == NULL)
-    return 0;
+    return -1;
 
-  return gtk_editable_get_position (GTK_EDITABLE (widget));
+  result = gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), NULL, &cursor_position);
+  if (!result)
+    return -1;
+
+  return cursor_position;
 }
 
 static gboolean

gtk/a11y/gtktextcellaccessible.c

@@ -198,6 +198,7 @@ static void
 gtk_text_cell_accessible_init (GtkTextCellAccessible *text_cell)
 {
   text_cell->priv = gtk_text_cell_accessible_get_instance_private (text_cell);
+  text_cell->priv->caret_pos = -1;
 }
 
 static gchar *

gtk/a11y/gtktextviewaccessible.c

@@ -412,7 +412,7 @@ gtk_text_view_accessible_get_caret_offset (AtkText *text)
 
   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
   if (widget == NULL)
-    return 0;
+    return -1;
 
   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
   return get_insert_offset (buffer);

gtk/a11y/gtkwidgetaccessible.c

@@ -625,39 +625,7 @@ gtk_widget_accessible_set_extents (AtkComponent *component,
                                    gint          height,
                                    AtkCoordType  coord_type)
 {
-  GtkWidget *widget;
-
-  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
-  if (widget == NULL)
-    return FALSE;
-
-  if (!gtk_widget_is_toplevel (widget))
-    return FALSE;
-
-  if (coord_type == ATK_XY_WINDOW)
-    {
-      gint x_current, y_current;
-      GdkSurface *surface = gtk_widget_get_surface (widget);
-
-      gdk_surface_get_origin (surface, &x_current, &y_current);
-      x_current += x;
-      y_current += y;
-      if (x_current < 0 || y_current < 0)
-        return FALSE;
-      else
-        {
-          gtk_window_move (GTK_WINDOW (widget), x_current, y_current);
-          gtk_widget_set_size_request (widget, width, height);
-          return TRUE;
-        }
-    }
-  else if (coord_type == ATK_XY_SCREEN)
-    {
-      gtk_window_move (GTK_WINDOW (widget), x, y);
-      gtk_widget_set_size_request (widget, width, height);
-      return TRUE;
-    }
-  return FALSE;
+   return FALSE;
 }
 
 static gboolean
@@ -666,37 +634,7 @@ gtk_widget_accessible_set_position (AtkComponent *component,
                                     gint          y,
                                     AtkCoordType  coord_type)
 {
-  GtkWidget *widget;
-
-  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
-  if (widget == NULL)
-    return FALSE;
-
-  if (gtk_widget_is_toplevel (widget))
-    {
-      if (coord_type == ATK_XY_WINDOW)
-        {
-          gint x_current, y_current;
-          GdkSurface *surface = gtk_widget_get_surface (widget);
-
-          gdk_surface_get_origin (surface, &x_current, &y_current);
-          x_current += x;
-          y_current += y;
-          if (x_current < 0 || y_current < 0)
-            return FALSE;
-          else
-            {
-              gtk_window_move (GTK_WINDOW (widget), x_current, y_current);
-              return TRUE;
-            }
-        }
-      else if (coord_type == ATK_XY_SCREEN)
-        {
-          gtk_window_move (GTK_WINDOW (widget), x, y);
-          return TRUE;
-        }
-    }
-  return FALSE;
+   return FALSE;
 }
 
 static gboolean
@@ -704,18 +642,6 @@ gtk_widget_accessible_set_size (AtkComponent *component,
                                 gint          width,
                                 gint          height)
 {
-  GtkWidget *widget;
-
-  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
-  if (widget == NULL)
-    return FALSE;
-
-  if (gtk_widget_is_toplevel (widget))
-    {
-      gtk_widget_set_size_request (widget, width, height);
-      return TRUE;
-    }
-  else
    return FALSE;
 }
 

gtk/gen-gtk-gresources-xml.py

@@ -46,11 +46,6 @@ xml += '\n'
 for f in get_files('theme/HighContrast/assets', '.svg'):
   xml += '    <file>theme/HighContrast/assets/{0}</file>\n'.format(f)
 
-xml += '''
-    <file>theme/win32/gtk-win32-base.css</file>
-    <file>theme/win32/gtk.css</file>
-'''
-
 for f in get_files('gesture', '.symbolic.png'):
   xml += '    <file alias=\'icons/64x64/actions/{0}\'>gesture/{0}</file>\n'.format(f)
 

gtk/gtk.h

@@ -45,8 +45,10 @@
 #include <gtk/gtkaspectframe.h>
 #include <gtk/gtkassistant.h>
 #include <gtk/gtkbin.h>
+#include <gtk/gtkbinlayout.h>
 #include <gtk/gtkbindings.h>
 #include <gtk/gtkborder.h>
+#include <gtk/gtkboxlayout.h>
 #include <gtk/gtkbox.h>
 #include <gtk/gtkbuildable.h>
 #include <gtk/gtkbuilder.h>
@@ -80,6 +82,7 @@
 #include <gtk/gtkcontainer.h>
 #include <gtk/gtkcssprovider.h>
 #include <gtk/gtkcsssection.h>
+#include <gtk/gtkcustomlayout.h>
 #include <gtk/gtkdebug.h>
 #include <gtk/gtkdialog.h>
 #include <gtk/gtkdnd.h>
@@ -98,6 +101,7 @@
 #include <gtk/gtkeventcontrollerscroll.h>
 #include <gtk/gtkexpander.h>
 #include <gtk/gtkfixed.h>
+#include <gtk/gtkfixedlayout.h>
 #include <gtk/gtkfilechooser.h>
 #include <gtk/gtkfilechooserbutton.h>
 #include <gtk/gtkfilechooserdialog.h>
@@ -134,6 +138,8 @@
 #include <gtk/gtkinfobar.h>
 #include <gtk/gtklabel.h>
 #include <gtk/gtklayout.h>
+#include <gtk/gtklayoutmanager.h>
+#include <gtk/gtklayoutchild.h>
 #include <gtk/gtklevelbar.h>
 #include <gtk/gtklinkbutton.h>
 #include <gtk/gtklistbox.h>

gtk/gtkactionbar.c

@@ -61,11 +61,6 @@ struct _GtkActionBarPrivate
   GtkWidget *revealer;
 };
 
-enum {
-  CHILD_PROP_0,
-  CHILD_PROP_PACK_TYPE,
-};
-
 enum {
   PROP_0,
   PROP_REVEALED,
@@ -139,78 +134,6 @@ gtk_action_bar_child_type (GtkContainer *container)
   return GTK_TYPE_WIDGET;
 }
 
-static void
-gtk_action_bar_get_child_property (GtkContainer *container,
-                                   GtkWidget    *child,
-                                   guint         property_id,
-                                   GValue       *value,
-                                   GParamSpec   *pspec)
-{
-  GtkActionBarPrivate *priv = gtk_action_bar_get_instance_private (GTK_ACTION_BAR (container));
-
-  switch (property_id)
-    {
-    case CHILD_PROP_PACK_TYPE:
-      if (gtk_widget_get_parent (child) == priv->start_box)
-        g_value_set_enum (value, GTK_PACK_START);
-      else if (gtk_widget_get_parent (child) == priv->end_box)
-        g_value_set_enum (value, GTK_PACK_END);
-      else /* Center widget */
-        g_value_set_enum (value, GTK_PACK_START);
-
-      break;
-
-    default:
-      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
-      break;
-    }
-}
-
-static void
-gtk_action_bar_set_child_property (GtkContainer *container,
-                                   GtkWidget    *child,
-                                   guint         property_id,
-                                   const GValue *value,
-                                   GParamSpec   *pspec)
-{
-  GtkActionBarPrivate *priv = gtk_action_bar_get_instance_private (GTK_ACTION_BAR (container));
-
-  switch (property_id)
-    {
-    case CHILD_PROP_PACK_TYPE:
-      if (gtk_widget_get_parent (child) == priv->start_box)
-        {
-          if (g_value_get_enum (value) == GTK_PACK_END)
-            {
-              g_object_ref (child);
-              gtk_container_remove (GTK_CONTAINER (priv->start_box), child);
-              gtk_box_insert_child_after (GTK_BOX (priv->end_box), child, NULL);
-              g_object_unref (child);
-            }
-        }
-      else if (gtk_widget_get_parent (child) == priv->end_box)
-        {
-          if (g_value_get_enum (value) == GTK_PACK_START)
-            {
-              g_object_ref (child);
-              gtk_container_remove (GTK_CONTAINER (priv->end_box), child);
-              gtk_container_add (GTK_CONTAINER (priv->start_box), child);
-              g_object_unref (child);
-            }
-        }
-      else
-        {
-          /* Ignore the center widget */
-        }
-
-      break;
-
-    default:
-      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
-      break;
-    }
-}
-
 static void
 gtk_action_bar_size_allocate (GtkWidget *widget,
                               int        width,
@@ -322,16 +245,6 @@ gtk_action_bar_class_init (GtkActionBarClass *klass)
   container_class->remove = gtk_action_bar_remove;
   container_class->forall = gtk_action_bar_forall;
   container_class->child_type = gtk_action_bar_child_type;
-  container_class->set_child_property = gtk_action_bar_set_child_property;
-  container_class->get_child_property = gtk_action_bar_get_child_property;
-
-  gtk_container_class_install_child_property (container_class,
-                                              CHILD_PROP_PACK_TYPE,
-                                              g_param_spec_enum ("pack-type",
-                                                                 P_("Pack type"),
-                                                                 P_("A GtkPackType indicating whether the child is packed with reference to the start or end of the parent"),
-                                                                 GTK_TYPE_PACK_TYPE, GTK_PACK_START,
-                                                                 G_PARAM_READWRITE));
 
   props[PROP_REVEALED] =
     g_param_spec_boolean ("revealed",
@@ -380,8 +293,12 @@ gtk_action_bar_buildable_add_child (GtkBuildable *buildable,
 {
   GtkActionBar *action_bar = GTK_ACTION_BAR (buildable);
 
-  if (type && strcmp (type, "center") == 0)
+  if (g_strcmp0 (type, "center") == 0)
     gtk_action_bar_set_center_widget (action_bar, GTK_WIDGET (child));
+  else if (g_strcmp0 (type, "start") == 0)
+    gtk_action_bar_pack_start (action_bar, GTK_WIDGET (child));
+  else if (g_strcmp0 (type, "end") == 0)
+    gtk_action_bar_pack_end (action_bar, GTK_WIDGET (child));
   else
     parent_buildable_iface->add_child (buildable, builder, child, type);
 }

gtk/gtkapplication-dbus.c

@@ -26,6 +26,8 @@
 #include "gtksettings.h"
 #include "gtkprivate.h"
 
+#include "gdk/gdkconstructor.h"
+
 G_DEFINE_TYPE (GtkApplicationImplDBus, gtk_application_impl_dbus, GTK_TYPE_APPLICATION_IMPL)
 
 #define DBUS_BUS_NAME               "org.freedesktop.DBus"

gtk/gtkassistant.c

@@ -74,14 +74,15 @@
 #include "gtkintl.h"
 #include "gtkimage.h"
 #include "gtklabel.h"
-#include "gtkstack.h"
+#include "gtklistlistmodelprivate.h"
+#include "gtkmaplistmodel.h"
 #include "gtkprivate.h"
 #include "gtksettings.h"
 #include "gtksizegroup.h"
 #include "gtksizerequest.h"
+#include "gtkstack.h"
+#include "gtkstylecontext.h"
 #include "gtktypebuiltins.h"
-#include "gtklistlistmodelprivate.h"
-#include "gtkmaplistmodel.h"
 
 #include "a11y/gtkwindowaccessible.h"
 

gtk/gtkbinlayout.c

@@ -0,0 +1,124 @@
+/* gtkbinlayout.c: Layout manager for bin-like widgets
+ * Copyright 2019  GNOME Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * SECTION:gtkbinlayout
+ * @Title: GtkBinLayout
+ * @Short_description: A layout manager for bin-like widgets
+ * @Include: gtk/gtk.h
+ *
+ * GtkBinLayout is a #GtkLayoutManager subclass useful for create "bins" of
+ * widgets. GtkBinLayout will stack each child of a widget on top of each
+ * other, using the #GtkWidget:hexpand, #GtkWidget:vexpand, #GtkWidget:halign,
+ * and #GtkWidget:valign properties of each child to determine where they
+ * should be positioned.
+ */
+
+#include "config.h"
+
+#include "gtkbinlayout.h"
+
+#include "gtkwidgetprivate.h"
+
+struct _GtkBinLayout
+{
+  GtkLayoutManager parent_instance;
+};
+
+G_DEFINE_TYPE (GtkBinLayout, gtk_bin_layout, GTK_TYPE_LAYOUT_MANAGER)
+
+static void
+gtk_bin_layout_measure (GtkLayoutManager *layout_manager,
+                        GtkWidget        *widget,
+                        GtkOrientation    orientation,
+                        int               for_size,
+                        int              *minimum,
+                        int              *natural,
+                        int              *minimum_baseline,
+                        int              *natural_baseline)
+{
+  GtkWidget *child;
+
+  for (child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      if (gtk_widget_get_visible (child))
+        {
+          int child_min = 0;
+          int child_nat = 0;
+          int child_min_baseline = -1;
+          int child_nat_baseline = -1;
+
+          gtk_widget_measure (child, orientation, for_size,
+                              &child_min, &child_nat,
+                              &child_min_baseline, &child_nat_baseline);
+
+          *minimum = MAX (*minimum, child_min);
+          *natural = MAX (*natural, child_nat);
+
+          if (child_min_baseline > -1)
+            *minimum_baseline = MAX (*minimum_baseline, child_min_baseline);
+          if (child_nat_baseline > -1)
+            *natural_baseline = MAX (*natural_baseline, child_nat_baseline);
+        }
+    }
+}
+
+static void
+gtk_bin_layout_allocate (GtkLayoutManager *layout_manager,
+                         GtkWidget        *widget,
+                         int               width,
+                         int               height,
+                         int               baseline)
+{
+  GtkWidget *child;
+
+  for (child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      if (child && gtk_widget_get_visible (child))
+        gtk_widget_allocate (child, width, height, baseline, NULL);
+    }
+}
+static void
+gtk_bin_layout_class_init (GtkBinLayoutClass *klass)
+{
+  GtkLayoutManagerClass *layout_manager_class = GTK_LAYOUT_MANAGER_CLASS (klass);
+
+  layout_manager_class->measure = gtk_bin_layout_measure;
+  layout_manager_class->allocate = gtk_bin_layout_allocate;
+}
+
+static void
+gtk_bin_layout_init (GtkBinLayout *self)
+{
+}
+
+/**
+ * gtk_bin_layout_new:
+ *
+ * Creates a new #GtkBinLayout instance.
+ *
+ * Returns: the newly created #GtkBinLayout
+ */
+GtkLayoutManager *
+gtk_bin_layout_new (void)
+{
+  return g_object_new (GTK_TYPE_BIN_LAYOUT, NULL);
+}

gtk/gtkbinlayout.h

@@ -1,5 +1,5 @@
-/*
- * Copyright © 2012 Red Hat Inc.
+/* gtkbinlayout.h: Layout manager for bin-like widgets
+ * Copyright 2019  GNOME Foundation
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -13,20 +13,19 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Alexander Larsson <alexl@gnome.org>
  */
+#pragma once
 
-#ifndef __GTK_CSS_WIN32_SIZE_VALUE_PRIVATE_H__
-#define __GTK_CSS_WIN32_SIZE_VALUE_PRIVATE_H__
-
-#include "gtkcssnumbervalueprivate.h"
+#include <gtk/gtklayoutmanager.h>
 
 G_BEGIN_DECLS
 
-GtkCssValue *   gtk_css_win32_size_value_parse      (GtkCssParser           *parser,
-                                                     GtkCssNumberParseFlags  flags);
+#define GTK_TYPE_BIN_LAYOUT (gtk_bin_layout_get_type ())
+
+GDK_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (GtkBinLayout, gtk_bin_layout, GTK, BIN_LAYOUT, GtkLayoutManager)
+
+GDK_AVAILABLE_IN_ALL
+GtkLayoutManager *      gtk_bin_layout_new      (void);
 
 G_END_DECLS
-
-#endif /* __GTK_CSS_WIN32_SIZE_VALUE_PRIVATE_H__ */

gtk/gtkbox.c

@@ -57,6 +57,7 @@
 #include "config.h"
 
 #include "gtkbox.h"
+#include "gtkboxlayout.h"
 #include "gtkcsspositionvalueprivate.h"
 #include "gtkintl.h"
 #include "gtkorientable.h"
@@ -92,11 +93,6 @@ typedef struct
 
 static GParamSpec *props[LAST_PROP] = { NULL, };
 
-static void gtk_box_size_allocate         (GtkWidget *widget,
-                                           int        width,
-                                           int        height,
-                                           int        baseline);
-
 static void gtk_box_set_property       (GObject        *object,
                                         guint           prop_id,
                                         const GValue   *value,
@@ -116,13 +112,6 @@ static GType gtk_box_child_type        (GtkContainer   *container);
 static GtkWidgetPath * gtk_box_get_path_for_child
                                        (GtkContainer   *container,
                                         GtkWidget      *child);
-static void gtk_box_measure (GtkWidget      *widget,
-                             GtkOrientation  orientation,
-                             int             for_size,
-                             int            *minimum,
-                             int            *natural,
-                             int            *minimum_baseline,
-                             int            *natural_baseline);
 
 G_DEFINE_TYPE_WITH_CODE (GtkBox, gtk_box, GTK_TYPE_CONTAINER,
                          G_ADD_PRIVATE (GtkBox)
@@ -138,9 +127,6 @@ gtk_box_class_init (GtkBoxClass *class)
   object_class->set_property = gtk_box_set_property;
   object_class->get_property = gtk_box_get_property;
 
-  widget_class->size_allocate = gtk_box_size_allocate;
-  widget_class->measure = gtk_box_measure;
-
   container_class->add = gtk_box_add;
   container_class->remove = gtk_box_remove;
   container_class->forall = gtk_box_forall;
@@ -187,6 +173,7 @@ gtk_box_set_property (GObject      *object,
 {
   GtkBox *box = GTK_BOX (object);
   GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkLayoutManager *box_layout = gtk_widget_get_layout_manager (GTK_WIDGET (box));
 
   switch (prop_id)
     {
@@ -196,8 +183,9 @@ gtk_box_set_property (GObject      *object,
         if (priv->orientation != orientation)
           {
             priv->orientation = orientation;
+            gtk_orientable_set_orientation (GTK_ORIENTABLE (box_layout),
+                                            priv->orientation);
             _gtk_orientable_set_style_classes (GTK_ORIENTABLE (box));
-            gtk_widget_queue_resize (GTK_WIDGET (box));
             g_object_notify (object, "orientation");
           }
       }
@@ -225,6 +213,7 @@ gtk_box_get_property (GObject    *object,
 {
   GtkBox *box = GTK_BOX (object);
   GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkBoxLayout *box_layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (box)));
 
   switch (prop_id)
     {
@@ -232,13 +221,13 @@ gtk_box_get_property (GObject    *object,
       g_value_set_enum (value, priv->orientation);
       break;
     case PROP_SPACING:
-      g_value_set_int (value, priv->spacing);
+      g_value_set_int (value, gtk_box_layout_get_spacing (box_layout));
       break;
     case PROP_BASELINE_POSITION:
-      g_value_set_enum (value, priv->baseline_pos);
+      g_value_set_enum (value, gtk_box_layout_get_baseline_position (box_layout));
       break;
     case PROP_HOMOGENEOUS:
-      g_value_set_boolean (value, priv->homogeneous);
+      g_value_set_boolean (value, gtk_box_layout_get_homogeneous (box_layout));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -246,285 +235,6 @@ gtk_box_get_property (GObject    *object,
     }
 }
 
-static void
-count_expand_children (GtkBox *box,
-                       gint *visible_children,
-                       gint *expand_children)
-{
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
-  GtkWidget *child;
-
-  *visible_children = *expand_children = 0;
-
-  for (child = _gtk_widget_get_first_child (GTK_WIDGET (box));
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      if (_gtk_widget_get_visible (child))
-        {
-          *visible_children += 1;
-
-          if (gtk_widget_compute_expand (child, priv->orientation))
-            *expand_children += 1;
-        }
-    }
-}
-
-static gint
-get_spacing (GtkBox *box)
-{
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
-  GtkCssValue *border_spacing;
-  gint css_spacing;
-
-  border_spacing = _gtk_style_context_peek_property (gtk_widget_get_style_context (GTK_WIDGET (box)), GTK_CSS_PROPERTY_BORDER_SPACING);
-  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-    css_spacing = _gtk_css_position_value_get_x (border_spacing, 100);
-  else
-    css_spacing = _gtk_css_position_value_get_y (border_spacing, 100);
-
-  return css_spacing + priv->spacing;
-}
-
-static void
-gtk_box_size_allocate (GtkWidget *widget,
-                       int        width,
-                       int        height,
-                       int        baseline)
-{
-  GtkBox *box = GTK_BOX (widget);
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
-  GtkWidget *child;
-  gint nvis_children;
-  gint nexpand_children;
-  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 extra_space;
-  gint children_minimum_size = 0;
-  gint size_given_to_child;
-  gint n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
-  gint x = 0, y = 0, i;
-  gint child_size;
-  gint spacing;
-
-
-  count_expand_children (box, &nvis_children, &nexpand_children);
-
-  /* If there is no visible child, simply return. */
-  if (nvis_children <= 0)
-    return;
-
-  direction = _gtk_widget_get_direction (widget);
-  sizes = g_newa (GtkRequestedSize, nvis_children);
-  spacing = get_spacing (box);
-
-  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-    extra_space = width - (nvis_children - 1) * spacing;
-  else
-    extra_space = height - (nvis_children - 1) * spacing;
-
-  have_baseline = FALSE;
-  minimum_above = natural_above = 0;
-  minimum_below = natural_below = 0;
-
-  /* Retrieve desired size for visible children. */
-  for (i = 0, child = _gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      if (!_gtk_widget_get_visible (child))
-	continue;
-
-      gtk_widget_measure (child,
-                          priv->orientation,
-                          priv->orientation == GTK_ORIENTATION_HORIZONTAL ? height : width,
-                          &sizes[i].minimum_size, &sizes[i].natural_size,
-                          NULL, NULL);
-
-      children_minimum_size += sizes[i].minimum_size;
-
-      sizes[i].data = child;
-
-      i++;
-    }
-
-  if (priv->homogeneous)
-    {
-      /* We still need to run the above loop to populate the minimum sizes for
-       * children that aren't going to fill.
-       */
-
-      size_given_to_child = extra_space / nvis_children;
-      n_extra_widgets = extra_space % nvis_children;
-    }
-  else
-    {
-      /* Bring children up to size first */
-      extra_space -= children_minimum_size;
-      extra_space = MAX (0, extra_space);
-      extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
-
-      /* Calculate space which hasn't distributed yet,
-       * and is available for expanding children.
-       */
-      if (nexpand_children > 0)
-	{
-          size_given_to_child = extra_space / nexpand_children;
-          n_extra_widgets = extra_space % nexpand_children;
-	}
-      else
-        {
-          size_given_to_child = 0;
-        }
-    }
-
-  /* Allocate child sizes. */
-  for (i = 0, child = _gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      /* If widget is not visible, skip it. */
-      if (!_gtk_widget_get_visible (child))
-        continue;
-
-      /* Assign the child's size. */
-      if (priv->homogeneous)
-        {
-          child_size = size_given_to_child;
-
-          if (n_extra_widgets > 0)
-            {
-              child_size++;
-              n_extra_widgets--;
-            }
-        }
-      else
-        {
-          child_size = sizes[i].minimum_size;
-
-          if (gtk_widget_compute_expand (child, priv->orientation))
-            {
-              child_size += size_given_to_child;
-
-              if (n_extra_widgets > 0)
-                {
-                  child_size++;
-                  n_extra_widgets--;
-                }
-            }
-        }
-
-      sizes[i].natural_size = child_size;
-
-      if (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
-          gtk_widget_get_valign (child) == GTK_ALIGN_BASELINE)
-        {
-          int child_allocation_width;
-          int child_minimum_height, child_natural_height;
-
-          child_allocation_width = child_size;
-
-          child_minimum_baseline = -1;
-          child_natural_baseline = -1;
-          gtk_widget_measure (child, GTK_ORIENTATION_VERTICAL,
-                              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++;
-    }
-
-  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    baseline = -1;
-
-  /* we only calculate our own baseline if we don't get one passed from the parent
-   * and any of the child widgets explicitly request one */
-  if (baseline == -1 && have_baseline)
-    {
-      /* TODO: This is purely based on the minimum baseline, when things fit we should
-	 use the natural one? */
-
-      switch (priv->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;
-        default:
-          break;
-	}
-    }
-
-  /* Allocate child positions. */
-  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-    {
-      child_allocation.y = 0;
-      child_allocation.height = height;
-      x = 0;
-    }
-  else
-    {
-      child_allocation.x = 0;
-      child_allocation.width = width;
-      y = 0;
-    }
-
-  for (i = 0, child = _gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      /* If widget is not visible, skip it. */
-      if (!_gtk_widget_get_visible (child))
-        continue;
-
-      child_size = sizes[i].natural_size;
-
-      /* Assign the child's position. */
-      if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
-        {
-          child_allocation.width = child_size;
-          child_allocation.x = x;
-
-          x += child_size + spacing;
-
-          if (direction == GTK_TEXT_DIR_RTL)
-            child_allocation.x = width - child_allocation.x - child_allocation.width;
-
-        }
-      else /* (priv->orientation == GTK_ORIENTATION_VERTICAL) */
-        {
-          child_allocation.height = child_size;
-          child_allocation.y = y;
-
-          y += child_size + spacing;
-        }
-
-      gtk_widget_size_allocate (child, &child_allocation, baseline);
-
-      i++;
-    }
-}
-
 static GType
 gtk_box_child_type (GtkContainer   *container)
 {
@@ -630,263 +340,17 @@ gtk_box_get_path_for_child (GtkContainer *container,
   return path;
 }
 
-static void
-gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
-                                               int     for_size,
-					       gint   *minimum_size,
-					       gint   *natural_size,
-					       gint   *minimum_baseline,
-					       gint   *natural_baseline)
-{
-  GtkBoxPrivate    *priv = gtk_box_get_instance_private (box);
-  GtkWidget        *widget = GTK_WIDGET (box);
-  GtkWidget        *child;
-  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;
-  gint              extra_space, size_given_to_child, i;
-  gint              children_minimum_size = 0;
-  gint              child_size, child_minimum, child_natural;
-  gint              child_minimum_baseline, child_natural_baseline;
-  gint              n_extra_widgets = 0;
-  gint              spacing;
-  gboolean          have_baseline;
-
-  count_expand_children (box, &nvis_children, &nexpand_children);
-
-  if (nvis_children <= 0)
-    return;
-
-  spacing = get_spacing (box);
-  sizes = g_newa (GtkRequestedSize, nvis_children);
-  extra_space = MAX (0, for_size - (nvis_children - 1) * spacing);
-
-  /* Retrieve desired size for visible children */
-  for (i = 0, child = _gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      if (_gtk_widget_get_visible (child))
-	{
-          gtk_widget_measure (child,
-                              priv->orientation,
-                              -1,
-                              &sizes[i].minimum_size, &sizes[i].natural_size,
-                              NULL, NULL);
-
-          children_minimum_size += sizes[i].minimum_size;
-	  i += 1;
-	}
-    }
-
-  if (priv->homogeneous)
-    {
-      /* We still need to run the above loop to populate the minimum sizes for
-       * children that aren't going to fill.
-       */
-
-      size_given_to_child = extra_space / nvis_children;
-      n_extra_widgets = extra_space % nvis_children;
-    }
-  else
-    {
-      /* Bring children up to size first */
-      extra_space -= children_minimum_size;
-      extra_space = MAX (0, extra_space);
-      extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
-
-      /* Calculate space which hasn't distributed yet,
-       * and is available for expanding children.
-       */
-      if (nexpand_children > 0)
-	{
-          size_given_to_child = extra_space / nexpand_children;
-          n_extra_widgets = extra_space % nexpand_children;
-	}
-      else
-        {
-          size_given_to_child = 0;
-        }
-    }
-
-  have_baseline = FALSE;
-  for (i = 0, child = _gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      /* If widget is not visible, skip it. */
-      if (!_gtk_widget_get_visible (child))
-        continue;
-
-      /* Assign the child's size. */
-      if (priv->homogeneous)
-        {
-          child_size = size_given_to_child;
-
-          if (n_extra_widgets > 0)
-            {
-              child_size++;
-              n_extra_widgets--;
-            }
-        }
-      else
-        {
-          child_size = sizes[i].minimum_size;
-
-          if (gtk_widget_compute_expand (child, priv->orientation))
-            {
-              child_size += size_given_to_child;
-
-              if (n_extra_widgets > 0)
-                {
-                  child_size++;
-                  n_extra_widgets--;
-                }
-            }
-        }
-
-      child_minimum_baseline = child_natural_baseline = -1;
-      /* Assign the child's position. */
-      gtk_widget_measure (child,
-                          OPPOSITE_ORIENTATION (priv->orientation),
-                          child_size,
-                          &child_minimum, &child_natural,
-                          &child_minimum_baseline, &child_natural_baseline);
-
-      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 (priv->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;
-        default:
-          break;
-	}
-    }
-
-    *minimum_size = computed_minimum;
-    *natural_size = MAX (computed_natural, computed_natural_below + computed_natural_above);
-
-    *minimum_baseline = computed_minimum_baseline;
-    *natural_baseline = computed_natural_baseline;
-}
-
-static void
-gtk_box_compute_size_for_orientation (GtkBox *box,
-                                      int     for_size,
-                                      int    *minimum_size,
-                                      int    *natural_size)
-{
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
-  GtkWidget *child;
-  const int spacing = get_spacing (box);
-  int nvis_children = 0;
-  int required_size = 0, required_natural = 0;
-  int largest_child = 0, largest_natural = 0;
-
-  for (child = _gtk_widget_get_first_child (GTK_WIDGET (box));
-       child != NULL;
-       child = _gtk_widget_get_next_sibling (child))
-    {
-      if (_gtk_widget_get_visible (child))
-        {
-          int child_size, child_natural;
-
-          gtk_widget_measure (child,
-                              priv->orientation,
-                              for_size,
-                              &child_size, &child_natural,
-                              NULL, NULL);
-
-          largest_child = MAX (largest_child, child_size);
-          largest_natural = MAX (largest_natural, child_natural);
-
-	  required_size    += child_size;
-	  required_natural += child_natural;
-
-          nvis_children += 1;
-        }
-    }
-
-  if (nvis_children > 0)
-    {
-      if (priv->homogeneous)
-	{
-	  required_size    = largest_child   * nvis_children;
-	  required_natural = largest_natural * nvis_children;
-	}
-
-      required_size     += (nvis_children - 1) * spacing;
-      required_natural  += (nvis_children - 1) * spacing;
-    }
-
-  *minimum_size = required_size;
-  *natural_size = required_natural;
-}
-
-
-static void
-gtk_box_measure (GtkWidget      *widget,
-                 GtkOrientation  orientation,
-                 int             for_size,
-                 int            *minimum,
-                 int            *natural,
-                 int            *minimum_baseline,
-                 int            *natural_baseline)
-{
-  GtkBox *box = GTK_BOX (widget);
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
-
-  if (priv->orientation != orientation)
-    gtk_box_compute_size_for_opposing_orientation (box, for_size, minimum, natural, minimum_baseline, natural_baseline);
-  else
-    gtk_box_compute_size_for_orientation (box, for_size, minimum, natural);
-}
-
 static void
 gtk_box_init (GtkBox *box)
 {
   GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkLayoutManager *box_layout = gtk_box_layout_new (GTK_ORIENTATION_HORIZONTAL);
 
   gtk_widget_set_has_surface (GTK_WIDGET (box), FALSE);
 
-  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
-  priv->homogeneous = FALSE;
-  priv->spacing = 0;
-  priv->baseline_pos = GTK_BASELINE_POSITION_CENTER;
+  gtk_widget_set_layout_manager (GTK_WIDGET (box), box_layout);
 
+  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
   _gtk_orientable_set_style_classes (GTK_ORIENTABLE (box));
 }
 
@@ -905,7 +369,7 @@ gtk_box_new (GtkOrientation orientation,
 {
   return g_object_new (GTK_TYPE_BOX,
                        "orientation", orientation,
-                       "spacing",     spacing,
+                       "spacing", spacing,
                        NULL);
 }
 
@@ -923,18 +387,18 @@ void
 gtk_box_set_homogeneous (GtkBox  *box,
 			 gboolean homogeneous)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkBoxLayout *box_layout;
 
   g_return_if_fail (GTK_IS_BOX (box));
 
-  homogeneous = homogeneous != FALSE;
+  homogeneous = !!homogeneous;
 
-  if (priv->homogeneous != homogeneous)
-    {
-      priv->homogeneous = homogeneous;
-      g_object_notify_by_pspec (G_OBJECT (box), props[PROP_HOMOGENEOUS]);
-      gtk_widget_queue_resize (GTK_WIDGET (box));
-    }
+  box_layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (box)));
+  if (homogeneous == gtk_box_layout_get_homogeneous (box_layout))
+    return;
+
+  gtk_box_layout_set_homogeneous (box_layout, homogeneous);
+  g_object_notify_by_pspec (G_OBJECT (box), props[PROP_HOMOGENEOUS]);
 }
 
 /**
@@ -949,11 +413,13 @@ gtk_box_set_homogeneous (GtkBox  *box,
 gboolean
 gtk_box_get_homogeneous (GtkBox *box)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkLayoutManager *box_layout;
 
   g_return_val_if_fail (GTK_IS_BOX (box), FALSE);
 
-  return priv->homogeneous;
+  box_layout = gtk_widget_get_layout_manager (GTK_WIDGET (box));
+
+  return gtk_box_layout_get_homogeneous (GTK_BOX_LAYOUT (box_layout));
 }
 
 /**
@@ -968,18 +434,16 @@ void
 gtk_box_set_spacing (GtkBox *box,
 		     gint    spacing)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkBoxLayout *box_layout;
 
   g_return_if_fail (GTK_IS_BOX (box));
 
-  if (priv->spacing != spacing)
-    {
-      priv->spacing = spacing;
+  box_layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (box)));
+  if (spacing == gtk_box_layout_get_spacing (box_layout))
+    return;
 
-      g_object_notify_by_pspec (G_OBJECT (box), props[PROP_SPACING]);
-
-      gtk_widget_queue_resize (GTK_WIDGET (box));
-    }
+  gtk_box_layout_set_spacing (box_layout, spacing);
+  g_object_notify_by_pspec (G_OBJECT (box), props[PROP_SPACING]);
 }
 
 /**
@@ -993,10 +457,13 @@ gtk_box_set_spacing (GtkBox *box,
 gint
 gtk_box_get_spacing (GtkBox *box)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkLayoutManager *box_layout;
+
   g_return_val_if_fail (GTK_IS_BOX (box), 0);
 
-  return priv->spacing;
+  box_layout = gtk_widget_get_layout_manager (GTK_WIDGET (box));
+
+  return gtk_box_layout_get_spacing (GTK_BOX_LAYOUT (box_layout));
 }
 
 /**
@@ -1015,18 +482,16 @@ void
 gtk_box_set_baseline_position (GtkBox             *box,
 			       GtkBaselinePosition position)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkBoxLayout *box_layout;
 
   g_return_if_fail (GTK_IS_BOX (box));
 
-  if (priv->baseline_pos != position)
-    {
-      priv->baseline_pos = position;
+  box_layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (box)));
+  if (position == gtk_box_layout_get_baseline_position (box_layout))
+    return;
 
-      g_object_notify_by_pspec (G_OBJECT (box), props[PROP_BASELINE_POSITION]);
-
-      gtk_widget_queue_resize (GTK_WIDGET (box));
-    }
+  gtk_box_layout_set_baseline_position (box_layout, position);
+  g_object_notify_by_pspec (G_OBJECT (box), props[PROP_BASELINE_POSITION]);
 }
 
 /**
@@ -1040,11 +505,13 @@ gtk_box_set_baseline_position (GtkBox             *box,
 GtkBaselinePosition
 gtk_box_get_baseline_position (GtkBox *box)
 {
-  GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
+  GtkLayoutManager *box_layout;
 
   g_return_val_if_fail (GTK_IS_BOX (box), GTK_BASELINE_POSITION_CENTER);
 
-  return priv->baseline_pos;
+  box_layout = gtk_widget_get_layout_manager (GTK_WIDGET (box));
+
+  return gtk_box_layout_get_baseline_position (GTK_BOX_LAYOUT (box_layout));
 }
 
 static void

gtk/gtkboxlayout.c

@@ -0,0 +1,879 @@
+/* gtkboxlayout.c: Box layout manager
+ *
+ * Copyright 2019  GNOME Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkboxlayout.h"
+
+#include "gtkcsspositionvalueprivate.h"
+#include "gtkintl.h"
+#include "gtkorientableprivate.h"
+#include "gtkprivate.h"
+#include "gtksizerequest.h"
+#include "gtkstylecontextprivate.h"
+#include "gtktypebuiltins.h"
+#include "gtkwidgetprivate.h"
+
+/**
+ * SECTION:gtkboxlayout
+ * @Title: GtkBoxLayout
+ * @Short_description: Layout manager for placing all children in a single row or column
+ *
+ * A GtkBoxLayout is a layout manager that arranges the children of any
+ * widget using it into a single row or column, depending on the value
+ * of its #GtkOrientable:orientation property. Within the other dimension
+ * all children all allocated the same size. The GtkBoxLayout will respect
+ * the #GtkWidget:halign and #GtkWidget:valign properties of each child
+ * widget.
+ *
+ * If you want all children to be assigned the same size, you can use
+ * the #GtkBoxLayout:homogeneous property.
+ *
+ * If you want to specify the amount of space placed between each child,
+ * you can use the #GtkBoxLayout:spacing property.
+ */
+
+struct _GtkBoxLayout
+{
+  GtkLayoutManager parent_instance;
+
+  gboolean homogeneous;
+  guint spacing;
+  GtkOrientation orientation;
+  GtkBaselinePosition baseline_position;
+};
+
+G_DEFINE_TYPE_WITH_CODE (GtkBoxLayout, gtk_box_layout, GTK_TYPE_LAYOUT_MANAGER,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
+
+enum {
+  PROP_HOMOGENEOUS = 1,
+  PROP_SPACING,
+  PROP_BASELINE_POSITION,
+
+  /* From GtkOrientable */
+  PROP_ORIENTATION,
+
+  N_PROPS = PROP_ORIENTATION
+};
+
+static GParamSpec *box_layout_props[N_PROPS];
+
+static void
+gtk_box_layout_set_orientation (GtkBoxLayout   *self,
+                                GtkOrientation  orientation)
+{
+  GtkLayoutManager *layout_manager = GTK_LAYOUT_MANAGER (self);
+  GtkWidget *widget;
+
+  if (self->orientation == orientation)
+    return;
+
+  self->orientation = orientation;
+
+  widget = gtk_layout_manager_get_widget (layout_manager);
+  if (widget != NULL && GTK_IS_ORIENTABLE (widget))
+    _gtk_orientable_set_style_classes (GTK_ORIENTABLE (widget));
+
+  gtk_layout_manager_layout_changed (layout_manager);
+
+  g_object_notify (G_OBJECT (self), "orientation");
+}
+
+static void
+gtk_box_layout_set_property (GObject      *gobject,
+                             guint         prop_id,
+                             const GValue *value,
+                             GParamSpec   *pspec)
+{
+  GtkBoxLayout *self = GTK_BOX_LAYOUT (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_HOMOGENEOUS:
+      gtk_box_layout_set_homogeneous (self, g_value_get_boolean (value));
+      break;
+
+    case PROP_SPACING:
+      gtk_box_layout_set_spacing (self, g_value_get_int (value));
+      break;
+
+    case PROP_BASELINE_POSITION:
+      gtk_box_layout_set_baseline_position (self, g_value_get_enum (value));
+      break;
+
+    case PROP_ORIENTATION:
+      gtk_box_layout_set_orientation (self, g_value_get_enum (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_box_layout_get_property (GObject    *gobject,
+                             guint       prop_id,
+                             GValue     *value,
+                             GParamSpec *pspec)
+{
+  GtkBoxLayout *box_layout = GTK_BOX_LAYOUT (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_HOMOGENEOUS:
+      g_value_set_boolean (value, box_layout->homogeneous);
+      break;
+
+    case PROP_SPACING:
+      g_value_set_int (value, box_layout->spacing);
+      break;
+
+    case PROP_BASELINE_POSITION:
+      g_value_set_enum (value, box_layout->baseline_position);
+      break;
+
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, box_layout->orientation);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+count_expand_children (GtkWidget *widget,
+                       GtkOrientation orientation,
+                       gint *visible_children,
+                       gint *expand_children)
+{
+  GtkWidget *child;
+
+  *visible_children = *expand_children = 0;
+
+  for (child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      if (_gtk_widget_get_visible (child))
+        {
+          *visible_children += 1;
+
+          if (gtk_widget_compute_expand (child, orientation))
+            *expand_children += 1;
+        }
+    }
+}
+
+static gint
+get_spacing (GtkBoxLayout *self,
+             GtkStyleContext *style_context)
+{
+  GtkCssValue *border_spacing;
+  gint css_spacing;
+
+  border_spacing = _gtk_style_context_peek_property (style_context, GTK_CSS_PROPERTY_BORDER_SPACING);
+  if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+    css_spacing = _gtk_css_position_value_get_x (border_spacing, 100);
+  else
+    css_spacing = _gtk_css_position_value_get_y (border_spacing, 100);
+
+  return css_spacing + self->spacing;
+}
+
+static GtkSizeRequestMode
+gtk_box_layout_get_request_mode (GtkLayoutManager *layout_manager,
+                                 GtkWidget        *widget)
+{
+  GtkBoxLayout *self = GTK_BOX_LAYOUT (layout_manager);
+
+  return self->orientation == GTK_ORIENTATION_HORIZONTAL
+    ? GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT
+    : GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
+}
+
+static void
+gtk_box_layout_compute_size (GtkBoxLayout *self,
+                             GtkWidget    *widget,
+                             int           for_size,
+                             int          *minimum,
+                             int          *natural)
+{
+  GtkWidget *child;
+  int n_visible_children = 0;
+  int required_min = 0, required_nat = 0;
+  int largest_min = 0, largest_nat = 0;
+  int spacing = get_spacing (self, _gtk_widget_get_style_context (widget));
+
+  for (child = gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      int child_min = 0;
+      int child_nat = 0;
+
+      if (!_gtk_widget_get_visible (child))
+        continue;
+
+      gtk_widget_measure (child, self->orientation,
+                          for_size,
+                          &child_min, &child_nat,
+                          NULL, NULL);
+
+      largest_min = MAX (largest_min, child_min);
+      largest_nat = MAX (largest_nat, child_nat);
+
+      required_min += child_min;
+      required_nat += child_nat;
+
+      n_visible_children += 1;
+    }
+
+  if (n_visible_children > 0)
+    {
+      if (self->homogeneous)
+        {
+          required_min = largest_min * n_visible_children;
+          required_nat = largest_nat * n_visible_children;
+        }
+
+      required_min += (n_visible_children - 1) * spacing;
+      required_nat += (n_visible_children - 1) * spacing;
+    }
+
+  if (minimum != NULL)
+    *minimum = required_min;
+  if (natural != NULL)
+    *natural = required_nat;
+}
+
+static void
+gtk_box_layout_compute_opposite_size (GtkBoxLayout *self,
+                                      GtkWidget    *widget,
+                                      int           for_size,
+                                      int          *minimum,
+                                      int          *natural,
+                                      int          *min_baseline,
+                                      int          *nat_baseline)
+{
+  GtkWidget *child;
+  int nvis_children;
+  int nexpand_children;
+  int computed_minimum = 0, computed_natural = 0;
+  int computed_minimum_above = 0, computed_natural_above = 0;
+  int computed_minimum_below = 0, computed_natural_below = 0;
+  int computed_minimum_baseline = -1, computed_natural_baseline = -1;
+  GtkRequestedSize *sizes;
+  int extra_space, size_given_to_child, i;
+  int children_minimum_size = 0;
+  int child_size, child_minimum, child_natural;
+  int child_minimum_baseline, child_natural_baseline;
+  int n_extra_widgets = 0;
+  int spacing;
+  gboolean have_baseline;
+
+  count_expand_children (widget, self->orientation, &nvis_children, &nexpand_children);
+
+  if (nvis_children <= 0)
+    return;
+
+  spacing = get_spacing (self, _gtk_widget_get_style_context (widget));
+  sizes = g_newa (GtkRequestedSize, nvis_children);
+  extra_space = MAX (0, for_size - (nvis_children - 1) * spacing);
+
+  /* Retrieve desired size for visible children */
+  for (i = 0, child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      if (_gtk_widget_get_visible (child))
+        {
+          gtk_widget_measure (child,
+                              self->orientation,
+                              -1,
+                              &sizes[i].minimum_size, &sizes[i].natural_size,
+                              NULL, NULL);
+
+          children_minimum_size += sizes[i].minimum_size;
+          i += 1;
+        }
+    }
+
+  if (self->homogeneous)
+    {
+      /* We still need to run the above loop to populate the minimum sizes for
+       * children that aren't going to fill.
+       */
+
+      size_given_to_child = extra_space / nvis_children;
+      n_extra_widgets = extra_space % nvis_children;
+    }
+  else
+    {
+      /* Bring children up to size first */
+      extra_space -= children_minimum_size;
+      extra_space = MAX (0, extra_space);
+      extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
+
+      /* Calculate space which hasn't distributed yet,
+       * and is available for expanding children.
+       */
+      if (nexpand_children > 0)
+        {
+          size_given_to_child = extra_space / nexpand_children;
+          n_extra_widgets = extra_space % nexpand_children;
+        }
+      else
+        {
+          size_given_to_child = 0;
+        }
+    }
+
+  have_baseline = FALSE;
+  for (i = 0, child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      /* If widget is not visible, skip it. */
+      if (!_gtk_widget_get_visible (child))
+        continue;
+
+      /* Assign the child's size. */
+      if (self->homogeneous)
+        {
+          child_size = size_given_to_child;
+
+          if (n_extra_widgets > 0)
+            {
+              child_size++;
+              n_extra_widgets--;
+            }
+        }
+      else
+        {
+          child_size = sizes[i].minimum_size;
+
+          if (gtk_widget_compute_expand (child, self->orientation))
+            {
+              child_size += size_given_to_child;
+
+              if (n_extra_widgets > 0)
+                {
+                  child_size++;
+                  n_extra_widgets--;
+                }
+            }
+        }
+
+      child_minimum_baseline = child_natural_baseline = -1;
+      /* Assign the child's position. */
+      gtk_widget_measure (child,
+                          OPPOSITE_ORIENTATION (self->orientation),
+                          child_size,
+                          &child_minimum, &child_natural,
+                          &child_minimum_baseline, &child_natural_baseline);
+
+      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 (self->baseline_position)
+        {
+        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;
+        default:
+          break;
+        }
+    }
+
+  if (minimum != NULL)
+    *minimum = computed_minimum;
+  if (natural != NULL)
+    *natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
+
+  if (min_baseline != NULL)
+    *min_baseline = computed_minimum_baseline;
+  if (nat_baseline != NULL)
+    *nat_baseline = computed_natural_baseline;
+}
+
+static void
+gtk_box_layout_measure (GtkLayoutManager *layout_manager,
+                        GtkWidget        *widget,
+                        GtkOrientation    orientation,
+                        int               for_size,
+                        int              *minimum,
+                        int              *natural,
+                        int              *min_baseline,
+                        int              *nat_baseline)
+{
+  GtkBoxLayout *self = GTK_BOX_LAYOUT (layout_manager);
+
+  if (self->orientation != orientation)
+    {
+      gtk_box_layout_compute_opposite_size (self, widget, for_size,
+                                            minimum, natural,
+                                            min_baseline, nat_baseline);
+    }
+  else
+    {
+      gtk_box_layout_compute_size (self, widget, for_size,
+                                   minimum, natural);
+    }
+}
+
+static void
+gtk_box_layout_allocate (GtkLayoutManager *layout_manager,
+                         GtkWidget        *widget,
+                         int               width,
+                         int               height,
+                         int               baseline)
+{
+  GtkBoxLayout *self = GTK_BOX_LAYOUT (layout_manager);
+  GtkWidget *child;
+  gint nvis_children;
+  gint nexpand_children;
+  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 extra_space;
+  gint children_minimum_size = 0;
+  gint size_given_to_child;
+  gint n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
+  gint x = 0, y = 0, i;
+  gint child_size;
+  gint spacing;
+
+  count_expand_children (widget, self->orientation, &nvis_children, &nexpand_children);
+
+  /* If there is no visible child, simply return. */
+  if (nvis_children <= 0)
+    return;
+
+  direction = _gtk_widget_get_direction (widget);
+  sizes = g_newa (GtkRequestedSize, nvis_children);
+  spacing = get_spacing (self, _gtk_widget_get_style_context (widget));
+
+  if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+    extra_space = width - (nvis_children - 1) * spacing;
+  else
+    extra_space = height - (nvis_children - 1) * spacing;
+
+  have_baseline = FALSE;
+  minimum_above = natural_above = 0;
+  minimum_below = natural_below = 0;
+
+  /* Retrieve desired size for visible children. */
+  for (i = 0, child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      if (!_gtk_widget_get_visible (child))
+        continue;
+
+      gtk_widget_measure (child,
+                          self->orientation,
+                          self->orientation == GTK_ORIENTATION_HORIZONTAL ? height : width,
+                          &sizes[i].minimum_size, &sizes[i].natural_size,
+                          NULL, NULL);
+
+      children_minimum_size += sizes[i].minimum_size;
+
+      sizes[i].data = child;
+
+      i++;
+    }
+
+  if (self->homogeneous)
+    {
+      /* We still need to run the above loop to populate the minimum sizes for
+       * children that aren't going to fill.
+       */
+
+      size_given_to_child = extra_space / nvis_children;
+      n_extra_widgets = extra_space % nvis_children;
+    }
+  else
+    {
+      /* Bring children up to size first */
+      extra_space -= children_minimum_size;
+      extra_space = MAX (0, extra_space);
+      extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
+
+      /* Calculate space which hasn't distributed yet,
+       * and is available for expanding children.
+       */
+      if (nexpand_children > 0)
+        {
+          size_given_to_child = extra_space / nexpand_children;
+          n_extra_widgets = extra_space % nexpand_children;
+        }
+      else
+        {
+          size_given_to_child = 0;
+        }
+    }
+
+  /* Allocate child sizes. */
+  for (i = 0, child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      /* If widget is not visible, skip it. */
+      if (!_gtk_widget_get_visible (child))
+        continue;
+
+      /* Assign the child's size. */
+      if (self->homogeneous)
+        {
+          child_size = size_given_to_child;
+
+          if (n_extra_widgets > 0)
+            {
+              child_size++;
+              n_extra_widgets--;
+            }
+        }
+      else
+        {
+          child_size = sizes[i].minimum_size;
+
+          if (gtk_widget_compute_expand (child, self->orientation))
+            {
+              child_size += size_given_to_child;
+
+              if (n_extra_widgets > 0)
+                {
+                  child_size++;
+                  n_extra_widgets--;
+                }
+            }
+        }
+
+      sizes[i].natural_size = child_size;
+
+      if (self->orientation == GTK_ORIENTATION_HORIZONTAL &&
+          gtk_widget_get_valign (child) == GTK_ALIGN_BASELINE)
+        {
+          int child_allocation_width;
+          int child_minimum_height, child_natural_height;
+
+          child_allocation_width = child_size;
+
+          child_minimum_baseline = -1;
+          child_natural_baseline = -1;
+          gtk_widget_measure (child, GTK_ORIENTATION_VERTICAL,
+                              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++;
+    }
+
+  if (self->orientation == GTK_ORIENTATION_VERTICAL)
+    baseline = -1;
+
+  /* we only calculate our own baseline if we don't get one passed from the parent
+   * and any of the child widgets explicitly request one */
+  if (baseline == -1 && have_baseline)
+    {
+      /* TODO: This is purely based on the minimum baseline, when things fit we should
+         use the natural one? */
+
+      switch (self->baseline_position)
+        {
+        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;
+        default:
+          break;
+        }
+    }
+
+  /* Allocate child positions. */
+  if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      child_allocation.y = 0;
+      child_allocation.height = height;
+      x = 0;
+    }
+  else
+    {
+      child_allocation.x = 0;
+      child_allocation.width = width;
+      y = 0;
+    }
+
+  for (i = 0, child = _gtk_widget_get_first_child (widget);
+       child != NULL;
+       child = _gtk_widget_get_next_sibling (child))
+    {
+      /* If widget is not visible, skip it. */
+      if (!_gtk_widget_get_visible (child))
+        continue;
+
+      child_size = sizes[i].natural_size;
+
+      /* Assign the child's position. */
+      if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+        {
+          child_allocation.width = child_size;
+          child_allocation.x = x;
+
+          x += child_size + spacing;
+
+          if (direction == GTK_TEXT_DIR_RTL)
+            child_allocation.x = width - child_allocation.x - child_allocation.width;
+
+        }
+      else /* (self->orientation == GTK_ORIENTATION_VERTICAL) */
+        {
+          child_allocation.height = child_size;
+          child_allocation.y = y;
+
+          y += child_size + spacing;
+        }
+
+      gtk_widget_size_allocate (child, &child_allocation, baseline);
+
+      i++;
+    }
+}
+
+static void
+gtk_box_layout_class_init (GtkBoxLayoutClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkLayoutManagerClass *layout_manager_class = GTK_LAYOUT_MANAGER_CLASS (klass);
+
+  gobject_class->set_property = gtk_box_layout_set_property;
+  gobject_class->get_property = gtk_box_layout_get_property;
+
+  layout_manager_class->get_request_mode = gtk_box_layout_get_request_mode;
+  layout_manager_class->measure = gtk_box_layout_measure;
+  layout_manager_class->allocate = gtk_box_layout_allocate;
+
+  /**
+   * GtkBoxLayout:homogeneous:
+   *
+   * Whether the box layout should distribute the available space
+   * homogeneously among the children of the widget using it as a
+   * layout manager.
+   */
+  box_layout_props[PROP_HOMOGENEOUS] =
+    g_param_spec_boolean ("homogeneous",
+                          P_("Homogeneous"),
+                          P_("Distribute space homogeneously"),
+                          FALSE,
+                          GTK_PARAM_READWRITE |
+                          G_PARAM_EXPLICIT_NOTIFY);
+
+  /**
+   * GtkBoxLayout:spacing:
+   *
+   * The space between each child of the widget using the box
+   * layout as its layout manager.
+   */
+  box_layout_props[PROP_SPACING] =
+    g_param_spec_int ("spacing",
+                      P_("Spacing"),
+                      P_("Spacing between widgets"),
+                      0, G_MAXINT, 0,
+                      GTK_PARAM_READWRITE |
+                      G_PARAM_EXPLICIT_NOTIFY);
+
+  /**
+   * GtkBoxLayout:baseline-position:
+   *
+   * The position of the allocated baseline within the extra space
+   * allocated to each child of the widget using a box layout
+   * manager.
+   *
+   * This property is only relevant for horizontal layouts containing
+   * at least one child with a baseline alignment.
+   */
+  box_layout_props[PROP_BASELINE_POSITION] =
+    g_param_spec_enum ("baseline-position",
+                       P_("Baseline position"),
+                       P_("The position of the baseline aligned widgets if extra space is available"),
+                       GTK_TYPE_BASELINE_POSITION,
+                       GTK_BASELINE_POSITION_CENTER,
+                       GTK_PARAM_READWRITE |
+                       G_PARAM_EXPLICIT_NOTIFY);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, box_layout_props);
+  g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
+}
+
+static void
+gtk_box_layout_init (GtkBoxLayout *self)
+{
+  self->homogeneous = FALSE;
+  self->spacing = 0;
+  self->orientation = GTK_ORIENTATION_HORIZONTAL;
+  self->baseline_position = GTK_BASELINE_POSITION_CENTER;
+}
+
+GtkLayoutManager *
+gtk_box_layout_new (GtkOrientation orientation)
+{
+  return g_object_new (GTK_TYPE_BOX_LAYOUT,
+                       "orientation", orientation,
+                       NULL);
+}
+
+void
+gtk_box_layout_set_homogeneous (GtkBoxLayout *box_layout,
+                                gboolean      homogeneous)
+{
+  g_return_if_fail (GTK_IS_BOX_LAYOUT (box_layout));
+
+  homogeneous = !!homogeneous;
+  if (box_layout->homogeneous == homogeneous)
+    return;
+
+  box_layout->homogeneous = homogeneous;
+
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (box_layout));
+  g_object_notify_by_pspec (G_OBJECT (box_layout), box_layout_props[PROP_HOMOGENEOUS]);
+}
+
+gboolean
+gtk_box_layout_get_homogeneous (GtkBoxLayout *box_layout)
+{
+  g_return_val_if_fail (GTK_IS_BOX_LAYOUT (box_layout), FALSE);
+
+  return box_layout->homogeneous;
+}
+
+void
+gtk_box_layout_set_spacing (GtkBoxLayout *box_layout,
+                            guint         spacing)
+{
+  g_return_if_fail (GTK_IS_BOX_LAYOUT (box_layout));
+
+  if (box_layout->spacing == spacing)
+    return;
+
+  box_layout->spacing = spacing;
+
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (box_layout));
+  g_object_notify_by_pspec (G_OBJECT (box_layout), box_layout_props[PROP_SPACING]);
+}
+
+guint
+gtk_box_layout_get_spacing (GtkBoxLayout *box_layout)
+{
+  g_return_val_if_fail (GTK_IS_BOX_LAYOUT (box_layout), 0);
+
+  return box_layout->spacing;
+}
+
+/**
+ * gtk_box_layout_set_baseline_position:
+ * @box_layout: a #GtkBoxLayout
+ * @position: a #GtkBaselinePosition
+ *
+ * Sets the baseline position of a box layout.
+ *
+ * The baseline position affects only horizontal boxes with at least one
+ * baseline aligned child. If there is more vertical space available than
+ * requested, and the baseline is not allocated by the parent then the
+ * given @position is used to allocate the baseline within the extra
+ * space available.
+ */
+void
+gtk_box_layout_set_baseline_position (GtkBoxLayout        *box_layout,
+                                      GtkBaselinePosition  position)
+{
+  g_return_if_fail (GTK_IS_BOX_LAYOUT (box_layout));
+
+  if (box_layout->baseline_position != position)
+    {
+      box_layout->baseline_position = position;
+
+      g_object_notify_by_pspec (G_OBJECT (box_layout), box_layout_props[PROP_BASELINE_POSITION]);
+
+      gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (box_layout));
+    }
+}
+
+/**
+ * gtk_box_layout_get_baseline_position:
+ * @box_layout: a #GtkBoxLayout
+ *
+ * Gets the value set by gtk_box_layout_set_baseline_position().
+ *
+ * Returns: the baseline position
+ */
+GtkBaselinePosition
+gtk_box_layout_get_baseline_position (GtkBoxLayout *box_layout)
+{
+  g_return_val_if_fail (GTK_IS_BOX_LAYOUT (box_layout), GTK_BASELINE_POSITION_CENTER);
+
+  return box_layout->baseline_position;
+}

gtk/gtkboxlayout.h

@@ -0,0 +1,54 @@
+/* gtkboxlayout.h: Box layout manager
+ *
+ * Copyright 2019  GNOME Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkenums.h>
+#include <gtk/gtklayoutmanager.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_BOX_LAYOUT (gtk_box_layout_get_type())
+
+GDK_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (GtkBoxLayout, gtk_box_layout, GTK, BOX_LAYOUT, GtkLayoutManager)
+
+GDK_AVAILABLE_IN_ALL
+GtkLayoutManager *      gtk_box_layout_new                      (GtkOrientation  orientation);
+
+GDK_AVAILABLE_IN_ALL
+void                    gtk_box_layout_set_homogeneous          (GtkBoxLayout        *box_layout,
+                                                                 gboolean             homogeneous);
+GDK_AVAILABLE_IN_ALL
+gboolean                gtk_box_layout_get_homogeneous          (GtkBoxLayout        *box_layout);
+GDK_AVAILABLE_IN_ALL
+void                    gtk_box_layout_set_spacing              (GtkBoxLayout        *box_layout,
+                                                                 guint                spacing);
+GDK_AVAILABLE_IN_ALL
+guint                   gtk_box_layout_get_spacing              (GtkBoxLayout        *box_layout);
+GDK_AVAILABLE_IN_ALL
+void                    gtk_box_layout_set_baseline_position    (GtkBoxLayout        *box_layout,
+                                                                 GtkBaselinePosition  position);
+GDK_AVAILABLE_IN_ALL
+GtkBaselinePosition     gtk_box_layout_get_baseline_position    (GtkBoxLayout        *box_layout);
+
+G_END_DECLS

gtk/gtkbutton.c

@@ -66,6 +66,7 @@
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
 #include "gtkprivate.h"
+#include "gtkstylecontext.h"
 #include "gtktypebuiltins.h"
 
 #include "a11y/gtkbuttonaccessible.h"

gtk/gtkcalendar.c

@@ -295,6 +295,8 @@ static gboolean gtk_calendar_key_controller_key_pressed (GtkEventControllerKey *
                                                          GdkModifierType        state,
                                                          GtkWidget             *widget);
 static void     gtk_calendar_key_controller_focus       (GtkEventControllerKey *controller,
+                                                         GdkCrossingMode        mode,
+                                                         GdkNotifyType          detail,
                                                          GtkWidget             *widget);
 static void     gtk_calendar_grab_notify    (GtkWidget        *widget,
                                              gboolean          was_grabbed);
@@ -2854,6 +2856,8 @@ gtk_calendar_key_controller_key_pressed (GtkEventControllerKey *controller,
 
 static void
 gtk_calendar_key_controller_focus (GtkEventControllerKey *key,
+                                   GdkCrossingMode        mode,
+                                   GdkNotifyType          detail,
                                    GtkWidget             *widget)
 {
   GtkCalendar *calendar = GTK_CALENDAR (widget);

gtk/gtkcellarea.c

@@ -352,6 +352,7 @@
 #include "gtkmarshalers.h"
 #include "gtkprivate.h"
 #include "gtksnapshot.h"
+#include "gtkstylecontext.h"
 
 #include <gobject/gvaluecollector.h>
 

gtk/gtkcellrenderer.c

@@ -23,6 +23,7 @@
 #include "gtkmarshalers.h"
 #include "gtkprivate.h"
 #include "gtksnapshot.h"
+#include "gtkstylecontext.h"
 #include "gtktreeprivate.h"
 #include "gtktypebuiltins.h"