path-tool: Show intersections

This function makes it possible to iterate
through the intersections of two paths.

.gitlab-ci/run-tests.sh

@@ -23,6 +23,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=gsk-compare-broadway
 
     # Store the exit code for the CI run, but always
@@ -45,6 +46,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=${backend}_failing \
                 --no-suite=gsk-compare-broadway
     exit_code=$?
@@ -67,6 +69,7 @@ case "${backend}" in
                 --suite=gtk \
                 --no-suite=failing \
                 --no-suite=flaky \
+                --no-suite=headless \
                 --no-suite=gsk-compare-opengl
 
     kill ${server}

CONTRIBUTING.md

@@ -35,8 +35,7 @@ The issue tracker is meant to be used for actionable issues only.
 
 You should not open a new issue for security related questions.
 
-When in doubt, send an email to the [security](mailto:security@gnome.org)
-mailing list.
+When in doubt, follow [security](https://security.gnome.org/).
 
 ### Bug reports
 
@@ -244,13 +243,11 @@ people committing to GTK to follow a few rules:
    code, you should always ask. If your change is minor and you've been
    working on GTK for a while it probably isn't necessary to ask. But when
    in doubt, ask. Even if your change is correct, somebody may know a
-   better way to do things. If you are making changes to GTK, you should
-   be subscribed to the [gtk-devel](https://mail.gnome.org/mailman/listinfo/gtk-devel-list)
-   mailing list; this is a good place to ask about intended changes.
-   The `#gtk` IRC channel on irc.gnome.org is also a good place to find GTK
-   developers to discuss changes, but if you live outside of the EU/US time
-   zones, an email to the gtk-devel mailing list is the most certain and
-   preferred method.
+   better way to do things.
+   The `gtk` [room on matrix](https://matrix.to/#/#gtk:gnome.org) is also a
+   good place to find GTK developers to discuss changes, but if you live
+   outside of the EU/US time zones, the [gtk tag on the GNOME Discourse instance](https://discourse.gnome.org/tag/gtk)
+   is the most certain and preferred method.
 
 0. Ask _first_.
 

NEWS

@@ -1,6 +1,64 @@
 Overview of Changes in 4.13.1, xx-xx-xxxx
 =========================================
 
+* GtkTooltip:
+ - Don't cross native boundaries when looking for tooltips
+
+* GtkCenterLayout, GtkEntry, GtkSearchEntry:
+ - Fix some issues with baseline handling
+
+* GtkFileChooser:
+ - Make "Visit file" scroll to the file
+
+* GtkSwitch:
+ - Respect text direction
+
+* Paths:
+ - GskPathMeasure performance has been improved
+ - Add custom contours for circles, rounded rectangles and rectangles
+ - Simplify GskPathPoint handling
+ - gsk_path_point_get_closest_point now returns the distance as well
+
+* Input:
+ - Handle (some) single-key compose sequences
+
+* GSK:
+ - Make the repeated gradients match between GL and cairo
+ - Make rounded rect shrinking match between Vulkan, GL and cairo
+ - Fix parsing of text nodes with color glyphs
+ - Restrict an optimization to the cases where it is crrect
+ - Fix rendering of shadows with opacity
+ - The Vulkan renderer now requires Vulkan 1.2
+
+* macOS:
+ - Clamp damage regions to the surface size
+
+* Tools:
+ - gtk4-path-tool gained restrict and reverse commands
+ - gtk4-path-tool show and render can show control points
+
+* Demos:
+ - Add a demo for hit testing with paths
+
+* Build:
+ - Fix build problems with C++ compilers
+
+* Translation updates
+ Brazilian Portuguese
+ British English
+ Catalan
+ Czech
+ Danish
+ Galician
+ Georgian
+ Italian
+ Korean
+ Lithuanian
+ Polish
+ Punjabi
+ Slovenian
+
+
 Overview of Changes in 4.13.0, 25-08-2023
 =========================================
 

demos/gtk-demo/application.c

@@ -223,7 +223,7 @@ delete_messages (gpointer data)
 static void
 pop_message (GtkWidget *status)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");
 
   if (messages)
     {
@@ -241,7 +241,7 @@ static void
 push_message (GtkWidget  *status,
               const char *message)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");
 
   gtk_label_set_label (GTK_LABEL (status), message);
   messages = g_list_prepend (messages, g_strdup (message));

demos/gtk-demo/demo.gresource.xml

@@ -339,6 +339,7 @@
     <file>path_fill.c</file>
     <file>path_maze.c</file>
     <file>path_spinner.c</file>
+    <file>path_sweep.c</file>
     <file>path_walk.c</file>
     <file>path_text.c</file>
     <file>peg_solitaire.c</file>
@@ -426,6 +427,10 @@
   <gresource prefix="/fontrendering">
     <file>fontrendering.ui</file>
   </gresource>
+  <gresource prefix="/path_sweep">
+    <file>path_sweep.ui</file>
+    <file compressed="true">path_world.txt</file>
+  </gresource>
   <gresource prefix="/path_walk">
     <file>path_walk.ui</file>
     <file compressed="true">path_world.txt</file>

demos/gtk-demo/fishbowl.c

@@ -74,14 +74,7 @@ create_blurred_button (void)
 static GtkWidget *
 create_font_button (void)
 {
-  GtkFontDialog *dialog;
-  GtkWidget *button;
-
-  dialog = gtk_font_dialog_new ();
-  button = gtk_font_dialog_button_new (dialog);
-  g_object_unref (dialog);
-
-  return button;
+  return gtk_font_dialog_button_new (gtk_font_dialog_new ());
 }
 
 static GtkWidget *

demos/gtk-demo/meson.build

@@ -75,6 +75,7 @@ demos = files([
   'path_fill.c',
   'path_maze.c',
   'path_spinner.c',
+  'path_sweep.c',
   'path_walk.c',
   'path_text.c',
   'peg_solitaire.c',

demos/gtk-demo/path_maze.c

@@ -8,6 +8,7 @@
  * is a rather complex path.
  */
 
+#include "config.h"
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
@@ -131,6 +132,24 @@ gtk_maze_class_init (GtkMazeClass *klass)
   widget_class->snapshot = gtk_maze_snapshot;
 }
 
+static void
+celebrate (gboolean win)
+{
+  char *path;
+  GtkMediaStream *stream;
+
+  if (win)
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "complete.oga", NULL);
+  else
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "suspend-error.oga", NULL);
+  stream = gtk_media_file_new_for_filename (path);
+  gtk_media_stream_set_volume (stream, 1.0);
+  gtk_media_stream_play (stream);
+
+  g_signal_connect (stream, "notify::ended", G_CALLBACK (g_object_unref), NULL);
+  g_free (path);
+}
+
 static void
 pointer_motion (GtkEventControllerMotion *controller,
                 double                    x,
@@ -153,6 +172,8 @@ pointer_motion (GtkEventControllerMotion *controller,
         return;
     }
 
+  celebrate (FALSE);
+
   self->active = FALSE;
   gtk_widget_queue_draw (GTK_WIDGET (self));
 }

demos/gtk-demo/path_spinner.c

@@ -9,6 +9,8 @@
 
 #include "paintable.h"
 
+#undef SHOW_CONTROLS
+
 #define GTK_TYPE_SPINNER_PAINTABLE (gtk_spinner_paintable_get_type ())
 G_DECLARE_FINAL_TYPE (GtkSpinnerPaintable, gtk_spinner_paintable, GTK, SPINNER_PAINTABLE, GObject)
 
@@ -150,6 +152,7 @@ static gboolean
 add_controls (GskPathOperation        op,
               const graphene_point_t *pts,
               gsize                   n_pts,
+              float                   weight,
               gpointer                data)
 {
   GskPathBuilder *builder = data;
@@ -166,7 +169,7 @@ add_controls (GskPathOperation        op,
       break;
 
     case GSK_PATH_QUAD:
-    case GSK_PATH_ARC:
+    case GSK_PATH_CONIC:
       gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
       gsk_path_builder_line_to (builder, pts[2].x, pts[2].y);
       break;

demos/gtk-demo/path_sweep.c

@@ -0,0 +1,319 @@
+/* Path/Sweep
+ *
+ * This demo shows how path intersections can be used.
+ *
+ * The world map that is used here is a path with 211 lines and 1569 cubic
+ * Bėzier segments in 121 contours.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_PATH_SWEEP (gtk_path_sweep_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathSweep, gtk_path_sweep, GTK, PATH_SWEEP, GtkWidget)
+
+#define POINT_SIZE 8
+
+enum {
+  PROP_0,
+  PROP_PATH,
+  N_PROPS
+};
+
+struct _GtkPathSweep
+{
+  GtkWidget parent_instance;
+
+  GskPath *path;
+  graphene_rect_t bounds;
+  float y_pos;
+  gboolean in;
+};
+
+struct _GtkPathSweepClass
+{
+  GtkWidgetClass parent_class;
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkPathSweep, gtk_path_sweep, GTK_TYPE_WIDGET)
+
+static gboolean
+intersection_cb (GskPath             *path1,
+                 const GskPathPoint  *point1,
+                 GskPath             *path2,
+                 const GskPathPoint  *point2,
+                 GskPathIntersection  kind,
+                 gpointer             data)
+{
+  GskPathBuilder *builder = data;
+  graphene_point_t p;
+
+  gsk_path_point_get_position (point1, path1, &p);
+  gsk_path_builder_add_circle (builder, &p, 4);
+
+  return TRUE;
+}
+
+static GskPath *
+get_intersection_path (GskPath *path1,
+                       GskPath *path2)
+{
+  GskPathBuilder *builder = gsk_path_builder_new ();
+
+  gsk_path_foreach_intersection (path1, path2, intersection_cb, builder);
+
+  return gsk_path_builder_to_path (builder);
+}
+
+static void
+gtk_path_sweep_snapshot (GtkWidget   *widget,
+                        GtkSnapshot *snapshot)
+{
+  GtkPathSweep *self = GTK_PATH_SWEEP (widget);
+  GskStroke *stroke;
+
+  if (self->path == NULL)
+    return;
+
+  gtk_snapshot_save (snapshot);
+
+  stroke = gsk_stroke_new (2.0);
+
+  gtk_snapshot_append_stroke (snapshot, self->path, stroke, &(GdkRGBA) { 0, 0, 0, 1 });
+
+  if (self->in)
+    {
+      graphene_rect_t bounds;
+      GskPathBuilder *builder;
+      GskPath *line, *isecs;
+
+      gsk_path_get_stroke_bounds (self->path, stroke, &bounds);
+
+      builder = gsk_path_builder_new ();
+      gsk_path_builder_move_to (builder, bounds.origin.x, bounds.origin.y + self->y_pos);
+      gsk_path_builder_line_to (builder, bounds.origin.x + bounds.size.width, bounds.origin.y + self->y_pos);
+      line = gsk_path_builder_free_to_path (builder);
+
+      gtk_snapshot_append_stroke (snapshot, line, stroke, &(GdkRGBA) { 0, 0, 0, 1 });
+
+      isecs = get_intersection_path (self->path, line);
+
+      gtk_snapshot_append_fill (snapshot, isecs, GSK_FILL_RULE_WINDING, &(GdkRGBA) { 1, 0, 0, 1 });
+      gtk_snapshot_append_stroke (snapshot, isecs, stroke, &(GdkRGBA) { 0, 0, 0, 1 });
+
+      gsk_path_unref (isecs);
+      gsk_path_unref (line);
+    }
+
+  gsk_stroke_free (stroke);
+
+  gtk_snapshot_restore (snapshot);
+}
+
+static void
+gtk_path_sweep_measure (GtkWidget      *widget,
+                        GtkOrientation  orientation,
+                        int             for_size,
+                        int            *minimum,
+                        int            *natural,
+                        int            *minimum_baseline,
+                        int            *natural_baseline)
+{
+  GtkPathSweep *self = GTK_PATH_SWEEP (widget);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = (int) ceilf (self->bounds.size.width);
+  else
+    *minimum = *natural = (int) ceilf (self->bounds.size.height);
+}
+
+static void
+gtk_path_sweep_set_path (GtkPathSweep *self,
+                        GskPath     *path)
+{
+  if (self->path == path)
+    return;
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  graphene_rect_init (&self->bounds, 0, 0, 0, 0);
+  if (path)
+    {
+      GskStroke *stroke;
+
+      self->path = gsk_path_ref (path);
+      stroke = gsk_stroke_new (2.0);
+      gsk_path_get_stroke_bounds (path, stroke, &self->bounds);
+      gsk_stroke_free (stroke);
+    }
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PATH]);
+}
+
+static void
+gtk_path_sweep_set_property (GObject      *object,
+                            guint         prop_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+
+{
+  GtkPathSweep *self = GTK_PATH_SWEEP (object);
+
+  switch (prop_id)
+    {
+    case PROP_PATH:
+      gtk_path_sweep_set_path (self, g_value_get_boxed (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_sweep_get_property (GObject    *object,
+                            guint       prop_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  GtkPathSweep *self = GTK_PATH_SWEEP (object);
+
+  switch (prop_id)
+    {
+    case PROP_PATH:
+      g_value_set_boxed (value, self->path);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_sweep_dispose (GObject *object)
+{
+  GtkPathSweep *self = GTK_PATH_SWEEP (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+
+  G_OBJECT_CLASS (gtk_path_sweep_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_sweep_class_init (GtkPathSweepClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_sweep_dispose;
+  object_class->set_property = gtk_path_sweep_set_property;
+  object_class->get_property = gtk_path_sweep_get_property;
+
+  widget_class->snapshot = gtk_path_sweep_snapshot;
+  widget_class->measure = gtk_path_sweep_measure;
+
+  properties[PROP_PATH] =
+    g_param_spec_boxed ("path", NULL, NULL,
+                        GSK_TYPE_PATH,
+                        G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+motion_cb (GtkEventControllerMotion *controller,
+           double                    x,
+           double                    y,
+           gpointer                  data)
+{
+  GtkPathSweep *self = data;
+
+  self->y_pos = y;
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+enter_cb (GtkEventControllerMotion *controller,
+          double                    x,
+          double                    y,
+          gpointer                  data)
+{
+  GtkPathSweep *self = data;
+
+  self->in = TRUE;
+  self->y_pos = y;
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+leave_cb (GtkEventControllerMotion *controller,
+          gpointer                  data)
+{
+  GtkPathSweep *self = data;
+
+  self->in = FALSE;
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+gtk_path_sweep_init (GtkPathSweep *self)
+{
+  GtkEventController *controller;
+
+  /* Data taken from
+   * https://commons.wikimedia.org/wiki/Maps_of_the_world#/media/File:Simplified_blank_world_map_without_Antartica_(no_borders).svg
+   */
+  GBytes *data = g_resources_lookup_data ("/path_sweep/path_world.txt", 0, NULL);
+  GskPath *path = gsk_path_parse (g_bytes_get_data (data, NULL));
+  g_bytes_unref (data);
+  gtk_path_sweep_set_path (self, path);
+  gsk_path_unref (path);
+
+  controller = gtk_event_controller_motion_new ();
+  g_signal_connect (controller, "motion", G_CALLBACK (motion_cb), self);
+  g_signal_connect (controller, "enter", G_CALLBACK (enter_cb), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (leave_cb), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+}
+
+GtkWidget *
+gtk_path_sweep_new (void)
+{
+  GtkPathSweep *self;
+
+  self = g_object_new (GTK_TYPE_PATH_SWEEP, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+GtkWidget *
+do_path_sweep (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_PATH_SWEEP);
+
+      builder = gtk_builder_new_from_resource ("/path_sweep/path_sweep.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/path_sweep.ui

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">World Map</property>
+    <property name="child">
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkPathSweep" id="view">
+            <property name="hexpand">true</property>
+            <property name="vexpand">true</property>
+          </object>
+        </child>
+      </object>
+    </property>
+  </object>
+</interface>

demos/gtk-demo/path_walk.ui

@@ -11,6 +11,8 @@
                 <property name="lower">0</property>
                 <property name="upper">5000</property>
                 <property name="value">500</property>
+                <property name="step-increment">1</property>
+                <property name="page-increment">10</property>
               </object>
             </property>
           </object>

docs/reference/gtk/gtk4-path-tool.rst

@@ -55,6 +55,22 @@ Showing
 The ``show`` command displays the given path in a window. The interior
 of the path is filled.
 
+``--fill``
+
+  Fill the path (this is the default).
+
+``--stroke``
+
+  Stroke the path instead of filling it.
+
+``--points``
+
+  Show points on the path.
+
+``--controls``
+
+  Show control points.
+
 ``--fill-rule=VALUE``
 
   The fill rule that is used to determine what areas are inside the path.
@@ -70,13 +86,10 @@ of the path is filled.
   The color that is used to render the background behind the path.
   If not specified, white is used.
 
-``--fill``
+``--point-color=COLOR``
 
-  Fill the path (this is the default).
-
-``--stroke``
-
-  Stroke the path instead of filling it.
+  The color that is used to render the points.
+  If not specified, red is used.
 
 ``--line-width=VALUE``
 
@@ -119,6 +132,22 @@ Rendering
 The ``render`` command renders the given path as a PNG image.
 The interior of the path is filled.
 
+``--fill``
+
+  Fill the path (this is the default).
+
+``--stroke``
+
+  Stroke the path instead of filling it.
+
+``--points``
+
+  Show points on the path.
+
+``--controls``
+
+  Show control points.
+
 ``--fill-rule=VALUE``
 
   The fill rule that is used to determine what areas are inside the path.
@@ -134,19 +163,16 @@ The interior of the path is filled.
   The color that is used to render the background behind the path.
   If not specified, white is used.
 
+``--point-color=COLOR``
+
+  The color that is used to render the points.
+  If not specified, red is used.
+
 ``--output-file=FILE``
 
   The file to save the PNG image to.
   If not specified, "path.png" is used.
 
-``--fill``
-
-  Fill the path (this is the default).
-
-``--stroke``
-
-  Stroke the path instead of filling it.
-
 ``--line-width=VALUE``
 
   The line width to use for the stroke. ``VALUE`` must be a positive number.

gdk/gdkarrayimpl.c

@@ -82,6 +82,18 @@ gdk_array(init) (GdkArray *self)
 #endif
 }
 
+G_GNUC_UNUSED static inline gsize
+gdk_array(get_capacity) (const GdkArray *self)
+{
+  return self->end_allocation - self->start;
+}
+
+G_GNUC_UNUSED static inline gsize
+gdk_array(get_size) (const GdkArray *self)
+{
+  return self->end - self->start;
+}
+
 static inline void
 gdk_array(free_elements) (_T_ *start,
                           _T_ *end)
@@ -110,6 +122,38 @@ gdk_array(clear) (GdkArray *self)
   gdk_array(init) (self);
 }
 
+/*
+ * gdk_array_steal:
+ * @self: the array
+ *
+ * Steals all data in the array and clears the array.
+ *
+ * If you need to know the size of the data, you should query it
+ * beforehand.
+ *
+ * Returns: The array's data
+ **/
+G_GNUC_UNUSED static inline _T_ *
+gdk_array(steal) (GdkArray *self)
+{
+  _T_ *result;
+
+#ifdef GDK_ARRAY_PREALLOC
+  if (self->start == self->preallocated)
+    {
+      gsize size = GDK_ARRAY_REAL_SIZE (gdk_array(get_size) (self));
+      result = g_new (_T_, size);
+      memcpy (result, self->preallocated, sizeof (_T_) * size);
+    }
+  else
+#endif
+    result = self->start;
+
+  gdk_array(init) (self);
+
+  return result;
+}
+
 G_GNUC_UNUSED static inline _T_ *
 gdk_array(get_data) (const GdkArray *self)
 {
@@ -123,18 +167,6 @@ gdk_array(index) (const GdkArray *self,
   return self->start + pos;
 }
 
-G_GNUC_UNUSED static inline gsize
-gdk_array(get_capacity) (const GdkArray *self)
-{
-  return self->end_allocation - self->start;
-}
-
-G_GNUC_UNUSED static inline gsize
-gdk_array(get_size) (const GdkArray *self)
-{
-  return self->end - self->start;
-}
-
 G_GNUC_UNUSED static inline gboolean
 gdk_array(is_empty) (const GdkArray *self)
 {

gdk/gdkdisplay.c

@@ -473,8 +473,7 @@ gdk_display_get_event (GdkDisplay *display)
  * @display: a `GdkDisplay`
  * @event: (transfer none): a `GdkEvent`
  *
- * Appends the given event onto the front of the event
- * queue for @display.
+ * Adds the given event to the event queue for @display.
  *
  * Deprecated: 4.10: This function is only useful in very
  * special situations and should not be used by applications.

gdk/gdkvulkancontext.c

@@ -1408,8 +1408,11 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
                                                     },
                                                     .enabledExtensionCount = device_extensions->len,
                                                     .ppEnabledExtensionNames = (const char * const *) device_extensions->pdata,
-                                                    .pNext = &(VkPhysicalDeviceDescriptorIndexingFeatures) {
-                                                      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+                                                    .pNext = &(VkPhysicalDeviceVulkan12Features) {
+                                                      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
+                                                      .shaderSampledImageArrayNonUniformIndexing = VK_TRUE,
+                                                      .shaderStorageBufferArrayNonUniformIndexing = VK_TRUE,
+                                                      .descriptorIndexing = VK_TRUE,
                                                       .descriptorBindingPartiallyBound = VK_TRUE,
                                                       .descriptorBindingVariableDescriptorCount = VK_TRUE,
                                                       .descriptorBindingSampledImageUpdateAfterBind = VK_TRUE,
@@ -1553,7 +1556,7 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
                                                  .applicationVersion = 0,
                                                  .pEngineName = "GTK",
                                                  .engineVersion = VK_MAKE_VERSION (GDK_MAJOR_VERSION, GDK_MINOR_VERSION, GDK_MICRO_VERSION),
-                                                 .apiVersion = VK_API_VERSION_1_0
+                                                 .apiVersion = VK_API_VERSION_1_2
                                              },
                                              .enabledLayerCount = used_layers->len,
                                              .ppEnabledLayerNames = (const char * const *) used_layers->pdata,

gdk/macos/gdkmacoscairocontext.c

@@ -188,6 +188,14 @@ copy_surface_data (GdkMacosBuffer       *from,
     }
 }
 
+static void
+clamp_region_to_surface (cairo_region_t *region,
+                         GdkSurface     *surface)
+{
+  cairo_rectangle_int_t rectangle = {0, 0, surface->width, surface->height};
+  cairo_region_intersect_rectangle (region, &rectangle);
+}
+
 static void
 _gdk_macos_cairo_context_begin_frame (GdkDrawContext *draw_context,
                                       GdkMemoryDepth  depth,
@@ -205,6 +213,8 @@ _gdk_macos_cairo_context_begin_frame (GdkDrawContext *draw_context,
   surface = GDK_MACOS_SURFACE (gdk_draw_context_get_surface (draw_context));
   buffer = _gdk_macos_surface_get_buffer (surface);
 
+  clamp_region_to_surface (region, GDK_SURFACE (surface));
+
   _gdk_macos_buffer_set_damage (buffer, region);
   _gdk_macos_buffer_set_flipped (buffer, FALSE);
 

gdk/macos/gdkmacosdisplay-private.h

@@ -90,7 +90,7 @@ struct _GdkMacosDisplay
   /* Note if we have a key window that is not a GdkMacosWindow
    * such as a NSPanel used for native dialogs.
    */
-  guint key_window_is_foregin : 1;
+  guint key_window_is_foreign : 1;
 };
 
 struct _GdkMacosDisplayClass

gdk/macos/gdkmacosdisplay.c

@@ -424,7 +424,7 @@ select_key_in_idle_cb (gpointer data)
   self->select_key_in_idle = 0;
 
   /* Don't steal focus from NSPanel, etc */
-  if (self->key_window_is_foregin)
+  if (self->key_window_is_foreign)
     return G_SOURCE_REMOVE;
 
   if (self->keyboard_surface == NULL)
@@ -941,7 +941,7 @@ _gdk_macos_display_get_surfaces (GdkMacosDisplay *self)
       NSArray *array = [NSApp orderedWindows];
       GQueue sorted = G_QUEUE_INIT;
 
-      self->key_window_is_foregin = FALSE;
+      self->key_window_is_foreign = FALSE;
 
       for (id obj in array)
         {
@@ -949,7 +949,7 @@ _gdk_macos_display_get_surfaces (GdkMacosDisplay *self)
           GdkMacosSurface *surface;
 
           if ([nswindow isKeyWindow])
-            self->key_window_is_foregin = !GDK_IS_MACOS_WINDOW (nswindow);
+            self->key_window_is_foreign = !GDK_IS_MACOS_WINDOW (nswindow);
 
           if (!GDK_IS_MACOS_WINDOW (nswindow))
             continue;

gdk/wayland/gdkapplaunchcontext-wayland.c

@@ -46,6 +46,21 @@ static const struct xdg_activation_token_v1_listener token_listener = {
   token_done,
 };
 
+static struct wl_surface *
+peek_launcher_toplevel (GdkSeat *seat)
+{
+  struct wl_surface *wl_surface = NULL;
+  GdkSurface *focus_surface;
+
+  focus_surface = gdk_wayland_device_get_focus (gdk_seat_get_keyboard (seat));
+  while (focus_surface && focus_surface->parent)
+    focus_surface = focus_surface->parent;
+  if (focus_surface)
+    wl_surface = gdk_wayland_surface_get_wl_surface (focus_surface);
+
+  return wl_surface;
+}
+
 static char *
 gdk_wayland_app_launch_context_get_startup_notify_id (GAppLaunchContext *context,
                                                       GAppInfo          *info,
@@ -62,7 +77,6 @@ gdk_wayland_app_launch_context_get_startup_notify_id (GAppLaunchContext *context
       struct wl_event_queue *event_queue;
       struct wl_surface *wl_surface = NULL;
       GdkWaylandSeat *seat;
-      GdkSurface *focus_surface;
       AppLaunchData app_launch_data = { 0 };
 
       event_queue = wl_display_create_queue (display->wl_display);
@@ -78,9 +92,7 @@ gdk_wayland_app_launch_context_get_startup_notify_id (GAppLaunchContext *context
                                           _gdk_wayland_seat_get_last_implicit_grab_serial (seat, NULL),
                                           gdk_wayland_seat_get_wl_seat (GDK_SEAT (seat)));
 
-      focus_surface = gdk_wayland_device_get_focus (gdk_seat_get_keyboard (GDK_SEAT (seat)));
-      if (focus_surface)
-        wl_surface = gdk_wayland_surface_get_wl_surface (focus_surface);
+      wl_surface = peek_launcher_toplevel (GDK_SEAT (seat));
       if (wl_surface)
         xdg_activation_token_v1_set_surface (token, wl_surface);
 

gdk/wayland/gdkdisplay-wayland.c

@@ -96,6 +96,12 @@
 #define XDG_ACTIVATION_VERSION   1
 #define OUTPUT_VERSION           3
 
+#ifdef HAVE_TOPLEVEL_STATE_SUSPENDED
+#define XDG_WM_BASE_VERSION      6
+#else
+#define XDG_WM_BASE_VERSION      5
+#endif
+
 static void _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *display_wayland);
 
 G_DEFINE_TYPE (GdkWaylandDisplay, gdk_wayland_display, GDK_TYPE_DISPLAY)
@@ -638,7 +644,8 @@ _gdk_wayland_display_open (const char *display_name)
         wl_registry_bind (display_wayland->wl_registry,
                           display_wayland->xdg_wm_base_id,
                           &xdg_wm_base_interface,
-                          MIN (display_wayland->xdg_wm_base_version, 4));
+                          MIN (display_wayland->xdg_wm_base_version,
+                               XDG_WM_BASE_VERSION));
       xdg_wm_base_add_listener (display_wayland->xdg_wm_base,
                                 &xdg_wm_base_listener,
                                 display_wayland);

gdk/wayland/gdktoplevel-wayland.c

@@ -672,10 +672,18 @@ xdg_toplevel_configure_bounds (void                *data,
   toplevel->pending.has_bounds = TRUE;
 }
 
+static void
+xdg_toplevel_wm_capabilities (void                *data,
+                              struct xdg_toplevel *xdg_toplevel,
+                              struct wl_array     *capabilities)
+{
+}
+
 static const struct xdg_toplevel_listener xdg_toplevel_listener = {
   xdg_toplevel_configure,
   xdg_toplevel_close,
   xdg_toplevel_configure_bounds,
+  xdg_toplevel_wm_capabilities,
 };
 
 static void

gdk/win32/gdkdisplay-win32.c

@@ -286,15 +286,16 @@ _gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
       GdkMonitor *ex_monitor;
 
       w32_ex_monitor = GDK_WIN32_MONITOR (g_list_model_get_item (win32_display->monitors, i));
-      g_object_unref (w32_ex_monitor);
       ex_monitor = GDK_MONITOR (w32_ex_monitor);
 
-      if (!w32_ex_monitor->remove)
-        continue;
+      if (w32_ex_monitor->remove)
+        {
+          w32_ex_monitor->hmonitor = NULL;
+          g_list_store_remove (G_LIST_STORE (win32_display->monitors), i);
+          gdk_monitor_invalidate (ex_monitor);
+        }
 
-      w32_ex_monitor->hmonitor = NULL;
-      g_list_store_remove (G_LIST_STORE (win32_display->monitors), i);
-      gdk_monitor_invalidate (ex_monitor);
+      g_object_unref (w32_ex_monitor);
     }
 
   for (i = 0; i < new_monitors->len; i++)

gsk/gl/gskglrenderer.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include <gsk/gskrenderer.h>
+#include <gsk/gsk.h>
 
 G_BEGIN_DECLS
 

gsk/gl/gskglrenderjob.c

@@ -142,6 +142,8 @@ struct _GskGLRenderJob
   const GskGLRenderModelview *current_modelview;
   GskGLProgram *current_program;
 
+  guint source_is_glyph_atlas : 1;
+
   /* If we should be rendering red zones over fallback nodes */
   guint debug_fallback : 1;
 
@@ -1260,6 +1262,7 @@ done:
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       texture_id);
+  job->source_is_glyph_atlas = FALSE;
   gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
 
@@ -1325,6 +1328,7 @@ blur_offscreen (GskGLRenderJob       *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen->texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform1f (job->current_program,
                                     UNIFORM_BLUR_RADIUS, 0,
                                     blur_radius_x);
@@ -1354,6 +1358,7 @@ blur_offscreen (GskGLRenderJob       *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           pass1->texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform1f (job->current_program,
                                     UNIFORM_BLUR_RADIUS, 0,
                                     blur_radius_y);
@@ -1461,7 +1466,8 @@ gsk_gl_render_job_visit_color_node (GskGLRenderJob      *job,
   batch = gsk_gl_command_queue_get_batch (job->command_queue);
 
   /* Limit the size, or we end up with a coordinate overflow somewhere. */
-  if (node->bounds.size.width < 300 &&
+  if (job->source_is_glyph_atlas &&
+      node->bounds.size.width < 300 &&
       node->bounds.size.height < 300 &&
       batch->any.kind == GSK_GL_COMMAND_KIND_DRAW &&
       batch->any.program == program->id)
@@ -1668,6 +1674,7 @@ gsk_gl_render_job_visit_clipped_child (GskGLRenderJob        *job,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               offscreen.texture_id);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_render_job_draw_offscreen_rect (job, clip);
           gsk_gl_render_job_end_draw (job);
         }
@@ -1758,6 +1765,7 @@ gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob      *job,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               offscreen.texture_id);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_render_job_draw_offscreen (job, &node->bounds, &offscreen);
           gsk_gl_render_job_end_draw (job);
         }
@@ -2123,6 +2131,7 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob      *job,
                                                                   offscreen.texture_id,
                                                                   linear_filter ? GL_LINEAR : GL_NEAREST,
                                                                   linear_filter ? GL_LINEAR : GL_NEAREST);
+                  job->source_is_glyph_atlas = FALSE;
                   gsk_gl_render_job_draw_offscreen (job, &child->bounds, &offscreen);
                   gsk_gl_render_job_end_draw (job);
                 }
@@ -2332,6 +2341,7 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob      *job,
                                             GL_TEXTURE_2D,
                                             GL_TEXTURE0,
                                             blurred_texture_id);
+        job->source_is_glyph_atlas = FALSE;
         gsk_gl_render_job_draw_offscreen (job, &node->bounds, &offscreen);
         gsk_gl_render_job_end_draw (job);
       }
@@ -2597,6 +2607,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               blurred_texture_id);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_program_set_uniform_rounded_rect (job->current_program,
                                                    UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
                                                    &transformed_outline);
@@ -2622,6 +2633,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           blurred_texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform_rounded_rect (job->current_program,
                                                UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
                                                &transformed_outline);
@@ -2859,6 +2871,7 @@ gsk_gl_render_job_visit_cross_fade_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE1,
                                           offscreen_end.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform1f (job->current_program,
                                     UNIFORM_CROSS_FADE_PROGRESS, 0,
                                     progress);
@@ -2905,6 +2918,7 @@ gsk_gl_render_job_visit_opacity_node (GskGLRenderJob      *job,
                                                   GL_TEXTURE_2D,
                                                   GL_TEXTURE0,
                                                   offscreen.texture_id);
+              job->source_is_glyph_atlas = FALSE;
               gsk_gl_render_job_draw_offscreen (job, &node->bounds, &offscreen);
               gsk_gl_render_job_end_draw (job);
             }
@@ -3046,6 +3060,7 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
                                                   GL_TEXTURE_2D,
                                                   GL_TEXTURE0,
                                                   texture_id);
+              job->source_is_glyph_atlas = TRUE;
               last_texture = texture_id;
             }
 
@@ -3142,10 +3157,6 @@ gsk_gl_render_job_visit_shadow_node (GskGLRenderJob      *job,
 
           offscreen.was_offscreen = TRUE;
         }
-      else if (dx == 0 && dy == 0)
-        {
-          continue; /* Invisible anyway */
-        }
       else
         {
           offscreen.bounds = &shadow_child->bounds;
@@ -3166,6 +3177,7 @@ gsk_gl_render_job_visit_shadow_node (GskGLRenderJob      *job,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               offscreen.texture_id);
+          job->source_is_glyph_atlas = FALSE;
           rgba_to_half (&shadow->color, color);
           gsk_gl_render_job_draw_offscreen_with_color (job, &bounds, &offscreen, color);
           gsk_gl_render_job_end_draw (job);
@@ -3222,6 +3234,7 @@ gsk_gl_render_job_visit_blur_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_render_job_draw_coords (job,
                                      min_x, min_y, max_x, max_y,
                                      0, 1, 1, 0,
@@ -3272,6 +3285,7 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob      *job,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               bottom_offscreen.texture_id);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_render_job_draw_offscreen (job, &node->bounds, &bottom_offscreen);
           gsk_gl_render_job_end_draw (job);
         }
@@ -3294,6 +3308,7 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE1,
                                           top_offscreen.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform1i (job->current_program,
                                     UNIFORM_BLEND_MODE, 0,
                                     gsk_blend_node_get_blend_mode (node));
@@ -3356,6 +3371,7 @@ gsk_gl_render_job_visit_mask_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE1,
                                           mask_offscreen.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform1i (job->current_program,
                                     UNIFORM_MASK_MODE, 0,
                                     gsk_mask_node_get_mask_mode (node));
@@ -3392,6 +3408,7 @@ gsk_gl_render_job_visit_color_matrix_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform_matrix (job->current_program,
                                          UNIFORM_COLOR_MATRIX_COLOR_MATRIX, 0,
                                          gsk_color_matrix_node_get_color_matrix (node));
@@ -3474,6 +3491,7 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob      *job,
                                                 GL_TEXTURE_2D,
                                                 GL_TEXTURE0 + i,
                                                 offscreens[i].texture_id);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_program_set_uniform2f (program,
                                         UNIFORM_CUSTOM_SIZE, 0,
                                         node->bounds.size.width,
@@ -3608,6 +3626,7 @@ gsk_gl_render_job_visit_texture (GskGLRenderJob        *job,
                                                         offscreen.has_mipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR,
                                                         GL_LINEAR,
                                                         offscreen.sync);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_render_job_draw_offscreen (job, bounds, &offscreen);
           gsk_gl_render_job_end_draw (job);
         }
@@ -3645,6 +3664,7 @@ gsk_gl_render_job_visit_texture (GskGLRenderJob        *job,
                                                               slice->texture_id,
                                                               use_mipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR,
                                                               GL_LINEAR);
+              job->source_is_glyph_atlas = FALSE;
 
               gsk_gl_render_job_draw_coords (job,
                                              x1, y1, x2, y2,
@@ -3763,6 +3783,7 @@ gsk_gl_render_job_visit_texture_scale_node (GskGLRenderJob      *job,
                                                         min_filter,
                                                         mag_filter,
                                                         sync);
+          job->source_is_glyph_atlas = FALSE;
           gsk_gl_render_job_draw_coords (job,
                                          0, 0, clip_rect.size.width, clip_rect.size.height,
                                          u0, v0, u1, v1,
@@ -3804,6 +3825,7 @@ gsk_gl_render_job_visit_texture_scale_node (GskGLRenderJob      *job,
                                                               slice->texture_id,
                                                               min_filter,
                                                               mag_filter);
+              job->source_is_glyph_atlas = FALSE;
               gsk_gl_render_job_draw_coords (job,
                                              slice_bounds.origin.x,
                                              slice_bounds.origin.y,
@@ -3836,6 +3858,7 @@ render_texture:
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_render_job_draw_coords (job,
                                      job->offset_x + clip_rect.origin.x,
                                      job->offset_y + clip_rect.origin.y,
@@ -3888,6 +3911,7 @@ gsk_gl_render_job_visit_repeat_node (GskGLRenderJob      *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_program_set_uniform4f (job->current_program,
                                     UNIFORM_REPEAT_CHILD_BOUNDS, 0,
                                     (node->bounds.origin.x - child_bounds->origin.x) / child_bounds->size.width,
@@ -4382,6 +4406,7 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           texture_id);
+      job->source_is_glyph_atlas = FALSE;
       gsk_gl_render_job_draw_rect (job, &job->viewport);
       gsk_gl_render_job_end_draw (job);
     }

gsk/gl/resources/conic_gradient.glsl

@@ -75,10 +75,10 @@ void main() {
 
     if (offset < next_offset) {
       float f = (offset - curr_offset) / (next_offset - curr_offset);
-      vec4 curr_color = gsk_premultiply(get_color(i));
-      vec4 next_color = gsk_premultiply(get_color(i + 1));
+      vec4 curr_color = get_color(i);
+      vec4 next_color = get_color(i + 1);
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(color, u_alpha);
+      gskSetScaledOutputColor(gsk_premultiply(color), u_alpha);
       return;
     }
   }

gsk/gl/resources/linear_gradient.glsl

@@ -97,10 +97,10 @@ void main() {
 
     if (offset < next_offset) {
       float f = (offset - curr_offset) / (next_offset - curr_offset);
-      vec4 curr_color = gsk_premultiply(get_color(i));
-      vec4 next_color = gsk_premultiply(get_color(i + 1));
+      vec4 curr_color = get_color(i);
+      vec4 next_color = get_color(i + 1);
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(color, u_alpha);
+      gskSetScaledOutputColor(gsk_premultiply (color), u_alpha);
       return;
     }
   }

gsk/gl/resources/preamble.vs.glsl

@@ -28,6 +28,8 @@ gsk_rounded_rect_shrink (GskRoundedRect r, vec4 amount)
   if (r.corner_points1.zw == r.bounds.zy) new_corner_points1.zw = new_bounds.zy;
   if (r.corner_points2.xy == r.bounds.zw) new_corner_points2.xy = new_bounds.zw;
   if (r.corner_points2.zw == r.bounds.xw) new_corner_points2.zw = new_bounds.xw;
+  new_corner_points1 = clamp (new_corner_points1, new_bounds.xyxy, new_bounds.zwzw);
+  new_corner_points2 = clamp (new_corner_points2, new_bounds.xyxy, new_bounds.zwzw);
 
   return GskRoundedRect (new_bounds, new_corner_points1, new_corner_points2);
 }

gsk/gl/resources/radial_gradient.glsl

@@ -77,10 +77,10 @@ void main() {
 
     if (offset < next_offset) {
       float f = (offset - curr_offset) / (next_offset - curr_offset);
-      vec4 curr_color = gsk_premultiply(get_color(i));
-      vec4 next_color = gsk_premultiply(get_color(i + 1));
+      vec4 curr_color = get_color(i);
+      vec4 next_color = get_color(i + 1);
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(color, u_alpha);
+      gskSetScaledOutputColor(gsk_premultiply(color), u_alpha);
       return;
     }
   }

gsk/gskboundingboxprivate.h

@@ -112,4 +112,32 @@ gsk_bounding_box_union (const GskBoundingBox *a,
   gsk_bounding_box_init (res, &min, &max);
 }
 
-G_END_DECLS
+static inline void
+gsk_bounding_box_get_corner (const GskBoundingBox   *b,
+                             GskCorner               c,
+                             graphene_point_t       *p)
+{
+  switch (c)
+    {
+    case GSK_CORNER_TOP_LEFT:
+      *p = b->min;
+      break;
+
+    case GSK_CORNER_TOP_RIGHT:
+      p->x = b->max.x;
+      p->y = b->min.y;
+      break;
+
+    case GSK_CORNER_BOTTOM_RIGHT:
+      *p = b->max;
+      break;
+
+    case GSK_CORNER_BOTTOM_LEFT:
+      p->x = b->min.x;
+      p->y = b->max.y;
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+}