Make points stack-allocated

This does the necessary reshuffling to make GskPathPoint
a stack-allocated struct.

.gitlab-ci/test-msvc.bat

@@ -6,7 +6,7 @@ call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliar
 
 :: FIXME: make warnings fatal
 pip3 install --upgrade --user meson~=0.64 || goto :error
-meson setup -Dbackend_max_links=1 -Ddebug=false -Dmedia-gstreamer=disabled _build || goto :error
+meson -Ddebug=false -Dmedia-gstreamer=disabled _build || goto :error
 ninja -C _build || goto :error
 
 goto :EOF

NEWS

@@ -1,94 +1,6 @@
-Overview of Changes in 4.12.2, 20-09-2023
+Overview of Changes in 4.13.0, xx-xx-xxxx
 =========================================
 
-* GtkTooltip:
- - Don't cross native boundaries when looking for tooltips
-
-* GtkCenterLayout, GtkEntry, GtkSearchEntry:
- - Fix some issues with baseline handling
-
-* GtkSwitch:
- - Respect text direction
-
-* Theme:
- - Use relative font sizes
-
-* GSK:
- - Make 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 correct
- - Fix rendering of shadows with opacity
-
-* macOS:
- - Clamp damage regions to the surface size
-
-* Windows:
- - Fix missing minimize and maximize buttons
-
-* Translation updates
- Basque
- Brazilian Portuguese
- Catalan
- Chinese (China)
- Czech
- Danish
- Dutch
- Finnish
- Galician
- German
- Hungarian
- Italian
- Kazakh
- Latvian
- Lithuanian
- Slovenian
- Spanish
- Turkish
-
-
-Overview of Changes in 4.12.1, 25-08-2023
-=========================================
-
-* GtkGridView:
- - Fix a crash when scrolling
-
-* GtkColumnView:
- - Fix a refcounting issue in the new scroll_to api
-
-* GtkTreeView
- - Fix style classes for sort arrows
-
-* GtkEntry:
- - Improve tracking of user changes (for undo)
-
-* GtkNotebook:
- - Fix a critical when switching pages
-
-* GtkColor/FontDialogButton:
- - Make these widgets activatable
-
-* GtkMenuButton:
- - Fix problems with focus handling
- - Fix problems with DND
-
-* Printing
- - Fix the cpdb backend build
-
-* MacOS:
- - Make file filters work again
-
-* GSK:
- - Fix issues with color matrix nodes
-
-* Wayland:
- - Fix a crash with compositors other than gnome-shell
-
-* Translation updates:
- Polish
- Swedish
-
-
 Overview of Changes in 4.12.0, 05-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_steal_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_get_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_steal_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_get_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

@@ -335,6 +335,9 @@
     <file>paintable_symbolic.c</file>
     <file>panes.c</file>
     <file>password_entry.c</file>
+    <file>path_fill.c</file>
+    <file>path_maze.c</file>
+    <file>path_text.c</file>
     <file>peg_solitaire.c</file>
     <file>pickers.c</file>
     <file>printing.c</file>
@@ -420,6 +423,9 @@
   <gresource prefix="/fontrendering">
     <file>fontrendering.ui</file>
   </gresource>
+  <gresource prefix="/path_text">
+    <file>path_text.ui</file>
+  </gresource>
   <gresource prefix="/org/gtk/Demo4">
     <file>icons/16x16/actions/application-exit.png</file>
     <file>icons/16x16/actions/document-new.png</file>

demos/gtk-demo/gtkgears.c

@@ -840,24 +840,24 @@ gtk_gears_unrealize (GtkWidget *widget)
   GtkGearsPrivate *priv = gtk_gears_get_instance_private ((GtkGears *) widget);
 
   gtk_gl_area_make_current (glarea);
-  if (gtk_gl_area_get_error (glarea) == NULL)
-    {
-      /* Release the resources associated with OpenGL */
-      if (priv->gear_vbo[0] != 0)
-        glDeleteBuffers (1, &(priv->gear_vbo[0]));
+  if (gtk_gl_area_get_error (glarea) != NULL)
+    return;
 
-      if (priv->gear_vbo[1] != 0)
-        glDeleteBuffers (1, &(priv->gear_vbo[1]));
+  /* Release the resources associated with OpenGL */
+  if (priv->gear_vbo[0] != 0)
+    glDeleteBuffers (1, &(priv->gear_vbo[0]));
 
-      if (priv->gear_vbo[2] != 0)
-        glDeleteBuffers (1, &(priv->gear_vbo[2]));
+  if (priv->gear_vbo[1] != 0)
+    glDeleteBuffers (1, &(priv->gear_vbo[1]));
 
-      if (priv->vao != 0)
-        glDeleteVertexArrays (1, &priv->vao);
+  if (priv->gear_vbo[2] != 0)
+    glDeleteBuffers (1, &(priv->gear_vbo[2]));
 
-      if (priv->program != 0)
-        glDeleteProgram (priv->program);
-    }
+  if (priv->vao != 0)
+    glDeleteVertexArrays (1, &priv->vao);
+
+  if (priv->program != 0)
+    glDeleteProgram (priv->program);
 
   priv->ModelViewProjectionMatrix_location = 0;
   priv->NormalMatrix_location = 0;

demos/gtk-demo/meson.build

@@ -72,6 +72,9 @@ demos = files([
   'paintable_symbolic.c',
   'panes.c',
   'password_entry.c',
+  'path_fill.c',
+  'path_maze.c',
+  'path_text.c',
   'peg_solitaire.c',
   'pickers.c',
   'printing.c',

demos/gtk-demo/path_fill.c

@@ -0,0 +1,362 @@
+/* Path/Fill
+ *
+ * This demo shows how to use PangoCairo to draw text with more than
+ * just a single color.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#define GTK_TYPE_PATH_PAINTABLE (gtk_path_paintable_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathPaintable, gtk_path_paintable, GTK, PATH_PAINTABLE, GObject)
+
+struct _GtkPathPaintable
+{
+  GObject parent_instance;
+
+  int width;
+  int height;
+  GskPath *path;
+  GdkPaintable *background;
+};
+
+struct _GtkPathPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+static int
+gtk_path_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return MAX (gdk_paintable_get_intrinsic_width (self->background), self->width);
+  else
+    return self->width;
+}
+
+static int
+gtk_path_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return MAX (gdk_paintable_get_intrinsic_height (self->background), self->height);
+  else
+    return self->height;
+}
+
+static void
+gtk_path_paintable_snapshot (GdkPaintable *paintable,
+                             GdkSnapshot  *snapshot,
+                             double        width,
+                             double        height)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+#if 0
+  gtk_snapshot_push_fill (snapshot, self->path, GSK_FILL_RULE_WINDING);
+#else
+  GskStroke *stroke = gsk_stroke_new (2.0);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gsk_stroke_free (stroke);
+#endif
+
+  if (self->background)
+    {
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+    }
+  else
+    {
+      gtk_snapshot_append_linear_gradient (snapshot,
+                                           &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                           &GRAPHENE_POINT_INIT (0, 0),
+                                           &GRAPHENE_POINT_INIT (width, height),
+                                           (GskColorStop[8]) {
+                                             { 0.0, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.2, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.3, { 1.0, 1.0, 0.0, 1.0 } },
+                                             { 0.4, { 0.0, 1.0, 0.0, 1.0 } },
+                                             { 0.6, { 0.0, 1.0, 1.0, 1.0 } },
+                                             { 0.7, { 0.0, 0.0, 1.0, 1.0 } },
+                                             { 0.8, { 1.0, 0.0, 1.0, 1.0 } },
+                                             { 1.0, { 1.0, 0.0, 1.0, 1.0 } }
+                                           },
+                                           8);
+    }
+
+  gtk_snapshot_pop (snapshot);
+
+}
+
+static GdkPaintableFlags
+gtk_path_paintable_get_flags (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return gdk_paintable_get_flags (self->background);
+  else
+    return GDK_PAINTABLE_STATIC_CONTENTS | GDK_PAINTABLE_STATIC_SIZE;
+}
+
+static void
+gtk_path_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->get_intrinsic_width = gtk_path_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_path_paintable_get_intrinsic_height;
+  iface->snapshot = gtk_path_paintable_snapshot;
+  iface->get_flags = gtk_path_paintable_get_flags;
+}
+
+/* When defining the GType, we need to implement the GdkPaintable interface */
+G_DEFINE_TYPE_WITH_CODE (GtkPathPaintable, gtk_path_paintable, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_path_paintable_paintable_init))
+
+/* Here's the boilerplate for the GObject declaration.
+ * We need to disconnect the signals here that we set up elsewhere
+ */
+static void 
+gtk_path_paintable_dispose (GObject *object)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (object);
+
+  if (self->background)
+    {
+      g_signal_handlers_disconnect_by_func (self->background, gdk_paintable_invalidate_contents, self);
+      g_signal_handlers_disconnect_by_func (self->background, gdk_paintable_invalidate_size, self);
+      g_clear_object (&self->background);
+    }
+
+  G_OBJECT_CLASS (gtk_path_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_paintable_class_init (GtkPathPaintableClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_paintable_dispose;
+}
+
+static void
+gtk_path_paintable_init (GtkPathPaintable *self)
+{
+}
+
+/* And finally, we add a simple constructor.
+ * It is declared in the header so that the other examples
+ * can use it.
+ */
+GdkPaintable *
+gtk_path_paintable_new (GskPath      *path,
+                        GdkPaintable *background,
+                        int           width,
+                        int           height)
+{
+  GtkPathPaintable *self;
+
+  self = g_object_new (GTK_TYPE_PATH_PAINTABLE, NULL);
+  self->path = path;
+  self->background = background;
+  if (self->background)
+    {
+      g_object_ref (self->background);
+      g_signal_connect_swapped (self->background, "invalidate-contents", G_CALLBACK (gdk_paintable_invalidate_contents), self);
+      g_signal_connect_swapped (self->background, "invalidate-size", G_CALLBACK (gdk_paintable_invalidate_size), self);
+    }
+  self->width = width;
+  self->height = height;
+
+  return GDK_PAINTABLE (self);
+}
+
+void
+gtk_path_paintable_set_path (GtkPathPaintable *self,
+                             GskPath          *path)
+{
+  g_clear_pointer (&self->path, gsk_path_unref);
+  self->path = gsk_path_ref (path);
+
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+static GskPath *
+create_hexagon (GtkWidget *widget)
+{
+  GskPathBuilder *builder;
+
+  builder = gsk_path_builder_new ();
+
+  gsk_path_builder_move_to (builder, 120, 0);
+  gsk_path_builder_line_to (builder, 360, 0);
+  gsk_path_builder_line_to (builder, 480, 208);
+  gsk_path_builder_line_to (builder, 360, 416);
+  gsk_path_builder_line_to (builder, 120, 416);
+  gsk_path_builder_line_to (builder, 0, 208);
+  gsk_path_builder_close (builder);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+static GskPath *
+create_path_from_text (GtkWidget *widget)
+{
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+  GskPathBuilder *builder;
+
+  layout = gtk_widget_create_pango_layout (widget, "Pango power!\nPango power!\nPango power!");
+  desc = pango_font_description_from_string ("sans bold 36");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  builder = gsk_path_builder_new ();
+
+  gsk_path_builder_add_layout (builder, layout);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+static gboolean
+build_path (GskPathOperation        op,
+            const graphene_point_t *pts,
+            gsize                   n_pts,
+            float                   weight,
+            gpointer                user_data)
+{
+  GskPathBuilder *builder = user_data;
+
+  switch (op)
+  {
+    case GSK_PATH_MOVE:
+      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_close (builder);
+      break;
+
+    case GSK_PATH_LINE:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      break;
+
+    case GSK_PATH_QUAD:
+      gsk_path_builder_quad_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y);
+      break;
+
+    case GSK_PATH_CUBIC:
+      gsk_path_builder_cubic_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y, pts[3].x, pts[3].y);
+      break;
+
+    case GSK_PATH_CONIC:
+      gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y, weight);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+
+  return TRUE;
+}
+
+
+static gboolean
+update_path (GtkWidget     *widget,
+             GdkFrameClock *frame_clock,
+             gpointer       measure)
+{
+  float progress = gdk_frame_clock_get_frame_time (frame_clock) % (60 * G_USEC_PER_SEC) / (float) (30 * G_USEC_PER_SEC);
+  GskPathBuilder *builder;
+  GskPath *path;
+  GskPathPoint point;
+  graphene_point_t pos;
+  graphene_vec2_t tangent;
+  GskStroke *stroke;
+
+  path = gsk_path_measure_get_path (measure);
+
+  stroke = gsk_stroke_new (1);
+  gsk_stroke_set_dash (stroke, (float[2]) { 10, 5 }, 2);
+  gsk_stroke_set_dash_offset (stroke, - (gdk_frame_clock_get_frame_time (frame_clock) % G_USEC_PER_SEC) * 15. / G_USEC_PER_SEC);
+  builder = gsk_path_builder_new ();
+  gsk_path_dash (path, stroke, 0.2, build_path, builder);
+
+  if (gsk_path_measure_get_point (measure,
+                                   (progress > 1 ? (progress - 1) : progress) * gsk_path_measure_get_length (measure), &point))
+    {
+      gsk_path_point_get_position (&point, &pos);
+      gsk_path_point_get_tangent (&point, GSK_PATH_END, &tangent);
+
+      gsk_path_builder_move_to (builder, pos.x + 5 * graphene_vec2_get_x (&tangent), pos.y + 5 * graphene_vec2_get_y (&tangent));
+      gsk_path_builder_line_to (builder, pos.x + 3 * graphene_vec2_get_y (&tangent), pos.y + 3 * graphene_vec2_get_x (&tangent));
+      gsk_path_builder_line_to (builder, pos.x - 3 * graphene_vec2_get_y (&tangent), pos.y - 3 * graphene_vec2_get_x (&tangent));
+      gsk_path_builder_close (builder);
+
+      path = gsk_path_builder_free_to_path (builder);
+
+      gtk_path_paintable_set_path (GTK_PATH_PAINTABLE (gtk_picture_get_paintable (GTK_PICTURE (widget))),
+                                   path);
+      gsk_path_unref (path);
+    }
+
+  return G_SOURCE_CONTINUE;
+}
+
+GtkWidget *
+do_path_fill (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *picture;
+      GdkPaintable *paintable;
+      GtkMediaStream *stream;
+      GskPath *path;
+      graphene_rect_t bounds;
+      GskPathMeasure *measure;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Path Fill");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+#if 0
+      stream = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
+#else
+      stream = gtk_nuclear_media_stream_new ();
+#endif
+      gtk_media_stream_play (stream);
+      gtk_media_stream_set_loop (stream, TRUE);
+
+      path = create_hexagon (window);
+      path = create_path_from_text (window);
+      gsk_path_get_bounds (path, &bounds);
+
+      paintable = gtk_path_paintable_new (path,
+                                          GDK_PAINTABLE (stream),
+                                          bounds.origin.x + bounds.size.width,
+                                          bounds.origin.y + bounds.size.height);
+      picture = gtk_picture_new_for_paintable (paintable);
+      measure = gsk_path_measure_new (path);
+      gtk_widget_add_tick_callback (picture, update_path, measure, (GDestroyNotify) gsk_path_measure_unref);
+      gtk_picture_set_content_fit (GTK_PICTURE (picture), GTK_CONTENT_FIT_CONTAIN);
+      gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
+      g_object_unref (paintable);
+
+      gtk_window_set_child (GTK_WINDOW (window), picture);
+    }
+
+  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_maze.c

@@ -0,0 +1,346 @@
+/* Path/Maze
+ *
+ * This demo shows how to use a GskPath to create a maze and use
+ * gsk_path_measure_get_closest_point() to check the mouse stays
+ * on the path.
+ *
+ * It also shows off the performance of GskPath (or not) as this
+ * is a rather complex path.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#define MAZE_GRID_SIZE 20
+#define MAZE_STROKE_SIZE_ACTIVE (MAZE_GRID_SIZE - 4)
+#define MAZE_STROKE_SIZE_INACTIVE (MAZE_GRID_SIZE - 12)
+#define MAZE_WIDTH 31
+#define MAZE_HEIGHT 21
+
+#define GTK_TYPE_MAZE (gtk_maze_get_type ())
+G_DECLARE_FINAL_TYPE (GtkMaze, gtk_maze, GTK, MAZE, GtkWidget)
+
+struct _GtkMaze
+{
+  GtkWidget parent_instance;
+
+  int width;
+  int height;
+  GskPath *path;
+  GskPathMeasure *measure;
+  GdkPaintable *background;
+
+  gboolean active;
+};
+
+struct _GtkMazeClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkMaze, gtk_maze, GTK_TYPE_WIDGET)
+
+static void
+gtk_maze_measure (GtkWidget      *widget,
+                  GtkOrientation  orientation,
+                  int             for_size,
+                  int            *minimum,
+                  int            *natural,
+                  int            *minimum_baseline,
+                  int            *natural_baseline)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = self->width;
+  else
+    *minimum = *natural = self->height;
+}
+
+static void
+gtk_maze_snapshot (GtkWidget   *widget,
+                   GdkSnapshot *snapshot)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_new (MAZE_STROKE_SIZE_INACTIVE);
+  if (self->active)
+    gsk_stroke_set_line_width (stroke, MAZE_STROKE_SIZE_ACTIVE);
+  gsk_stroke_set_line_join (stroke, GSK_LINE_JOIN_ROUND);
+  gsk_stroke_set_line_cap (stroke, GSK_LINE_CAP_ROUND);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gsk_stroke_free (stroke);
+
+  if (self->background)
+    {
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+    }
+  else
+    {
+      gtk_snapshot_append_linear_gradient (snapshot,
+                                           &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                           &GRAPHENE_POINT_INIT (0, 0),
+                                           &GRAPHENE_POINT_INIT (width, height),
+                                           (GskColorStop[8]) {
+                                             { 0.0, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.2, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.3, { 1.0, 1.0, 0.0, 1.0 } },
+                                             { 0.4, { 0.0, 1.0, 0.0, 1.0 } },
+                                             { 0.6, { 0.0, 1.0, 1.0, 1.0 } },
+                                             { 0.7, { 0.0, 0.0, 1.0, 1.0 } },
+                                             { 0.8, { 1.0, 0.0, 1.0, 1.0 } },
+                                             { 1.0, { 1.0, 0.0, 1.0, 1.0 } }
+                                           },
+                                           8);
+    }
+
+  gtk_snapshot_pop (snapshot);
+
+}
+
+static void
+gtk_maze_dispose (GObject *object)
+{
+  GtkMaze *self = GTK_MAZE (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  if (self->background)
+    {
+      g_signal_handlers_disconnect_matched (self->background, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+      g_clear_object (&self->background);
+    }
+
+  G_OBJECT_CLASS (gtk_maze_parent_class)->dispose (object);
+}
+
+static void
+gtk_maze_class_init (GtkMazeClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_maze_dispose;
+
+  widget_class->measure = gtk_maze_measure;
+  widget_class->snapshot = gtk_maze_snapshot;
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkMaze                  *self)
+{
+  GskPathPoint point;
+  graphene_point_t pos;
+
+  if (!self->active)
+    return;
+
+  if (gsk_path_get_closest_point (self->path, &GRAPHENE_POINT_INIT (x, y), INFINITY, &point))
+    {
+      gsk_path_point_get_position (&point, &pos);
+
+      if (graphene_point_distance (&pos, &GRAPHENE_POINT_INIT (x, y), NULL, NULL) <= MAZE_STROKE_SIZE_ACTIVE / 2.0f)
+        return;
+
+      self->active = FALSE;
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkMaze                  *self)
+{
+  if (!self->active)
+    {
+      self->active = TRUE;
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+gtk_maze_init (GtkMaze *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->active = TRUE;
+}
+
+static void
+gtk_maze_set_path (GtkMaze *self,
+                   GskPath *path)
+{
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  self->path = gsk_path_ref (path);
+  self->measure = gsk_path_measure_new (path);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+GtkWidget *
+gtk_maze_new (GskPath      *path,
+              GdkPaintable *background,
+              int           width,
+              int           height)
+{
+  GtkMaze *self;
+
+  self = g_object_new (GTK_TYPE_MAZE, NULL);
+
+  gtk_maze_set_path (self, path);
+  gsk_path_unref (path);
+  self->background = background;
+  if (self->background)
+    {
+      g_signal_connect_swapped (self->background, "invalidate-contents", G_CALLBACK (gtk_widget_queue_draw), self);
+      g_signal_connect_swapped (self->background, "invalidate-size", G_CALLBACK (gtk_widget_queue_resize), self);
+    }
+  self->width = width;
+  self->height = height;
+
+  return GTK_WIDGET (self);
+}
+
+static void
+add_point_to_maze (GtkBitset      *maze,
+                   GskPathBuilder *builder,
+                   guint           x,
+                   guint           y)
+{
+  gboolean set[4] = { FALSE, FALSE, FALSE, FALSE };
+  guint dir;
+
+  gtk_bitset_add (maze, y * MAZE_WIDTH + x);
+
+  while (TRUE)
+    {
+      set[0] = set[0] || x == 0 || gtk_bitset_contains (maze, y * MAZE_WIDTH + x - 1);
+      set[1] = set[1] || y == 0 || gtk_bitset_contains (maze, (y - 1) * MAZE_WIDTH + x);
+      set[2] = set[2] || x + 1 == MAZE_WIDTH || gtk_bitset_contains (maze, y * MAZE_WIDTH + x + 1);
+      set[3] = set[3] || y + 1 == MAZE_HEIGHT || gtk_bitset_contains (maze, (y + 1) * MAZE_WIDTH + x);
+
+      if (set[0] && set[1] && set[2] && set[3])
+        return;
+      
+      do
+        {
+          dir = g_random_int_range (0, 4);
+        }
+      while (set[dir]);
+
+      switch (dir)
+        {
+          case 0:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x - 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x - 1, y);
+            break;
+
+          case 1:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y - 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y - 1);
+            break;
+
+          case 2:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 1.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x + 1, y);
+            break;
+
+          case 3:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 1.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y + 1);
+            break;
+
+          default:
+            g_assert_not_reached ();
+            break;
+        }
+    }
+}
+
+static GskPath *
+create_path_for_maze (GtkWidget *widget)
+{
+  GskPathBuilder *builder;
+  GtkBitset *maze;
+
+  builder = gsk_path_builder_new ();
+  maze = gtk_bitset_new_empty ();
+  /* make sure the outer lines are unreachable:
+   * Set the full range, then remove the center again. */
+  gtk_bitset_add_range (maze, 0, MAZE_WIDTH * MAZE_HEIGHT);
+  gtk_bitset_remove_rectangle (maze, MAZE_WIDTH + 1, MAZE_WIDTH - 2, MAZE_HEIGHT - 2, MAZE_WIDTH);
+
+  /* Fill the maze */
+  add_point_to_maze (maze, builder, MAZE_WIDTH / 2, MAZE_HEIGHT / 2);
+
+  /* Add start and stop lines */
+  gsk_path_builder_move_to (builder, 1.5 * MAZE_GRID_SIZE, -0.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, 1.5 * MAZE_GRID_SIZE, 1.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_move_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT - 1.5) * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT + 0.5) * MAZE_GRID_SIZE);
+
+
+  gtk_bitset_unref (maze);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+GtkWidget *
+do_path_maze (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *maze;
+      GtkMediaStream *stream;
+      GskPath *path;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Follow the maze with the mouse");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+#if 0
+      stream = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
+#else
+      stream = gtk_nuclear_media_stream_new ();
+#endif
+      gtk_media_stream_play (stream);
+      gtk_media_stream_set_loop (stream, TRUE);
+
+      path = create_path_for_maze (window);
+
+      maze = gtk_maze_new (path,
+                           GDK_PAINTABLE (stream),
+                           MAZE_WIDTH * MAZE_GRID_SIZE,
+                           MAZE_HEIGHT * MAZE_GRID_SIZE);
+
+      gtk_window_set_child (GTK_WINDOW (window), maze);
+    }
+
+  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_text.c

@@ -0,0 +1,612 @@
+/* Path/Text
+ *
+ * This demo shows how to use GskPath to animate a path along another path.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_PATH_WIDGET (gtk_path_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathWidget, gtk_path_widget, GTK, PATH_WIDGET, GtkWidget)
+
+#define POINT_SIZE 8
+
+enum {
+  PROP_0,
+  PROP_TEXT,
+  PROP_EDITABLE,
+  N_PROPS
+};
+
+struct _GtkPathWidget
+{
+  GtkWidget parent_instance;
+
+  char *text;
+  gboolean editable;
+
+  graphene_point_t points[4];
+
+  guint active_point;
+  float line_closest;
+
+  GskPath *line_path;
+  GskPathMeasure *line_measure;
+  GskPath *text_path;
+
+  GdkPaintable *background;
+};
+
+struct _GtkPathWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkPathWidget, gtk_path_widget, GTK_TYPE_WIDGET)
+
+static GskPath *
+create_path_from_text (GtkWidget  *widget,
+                       const char *text,
+                       graphene_point_t *out_offset)
+{
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+  GskPathBuilder *builder;
+  GskPath *result;
+
+  layout = gtk_widget_create_pango_layout (widget, text);
+  desc = pango_font_description_from_string ("sans bold 36");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_layout (builder, layout);
+  result = gsk_path_builder_free_to_path (builder);
+
+  if (out_offset)
+    graphene_point_init (out_offset, 0, - pango_layout_get_baseline (layout) / (double) PANGO_SCALE);
+  g_object_unref (layout);
+
+  return result;
+}
+
+typedef struct
+{
+  GskPathMeasure *measure;
+  GskPathBuilder *builder;
+  graphene_point_t offset;
+  double scale;
+} GtkPathTransform;
+
+static void
+gtk_path_transform_point (GskPathMeasure         *measure,
+                          const graphene_point_t *pt,
+                          const graphene_point_t *offset,
+                          float                   scale,
+                          graphene_point_t       *res)
+{
+  graphene_vec2_t tangent;
+  GskPathPoint point;
+
+  if (gsk_path_measure_get_point (measure, (pt->x + offset->x) * scale, &point))
+    {
+      gsk_path_point_get_position (&point, res);
+      gsk_path_point_get_tangent (&point, GSK_PATH_END, &tangent);
+
+      res->x -= (pt->y + offset->y) * scale * graphene_vec2_get_y (&tangent);
+      res->y += (pt->y + offset->y) * scale * graphene_vec2_get_x (&tangent);
+    }
+}
+
+static gboolean
+gtk_path_transform_op (GskPathOperation        op,
+                       const graphene_point_t *pts,
+                       gsize                   n_pts,
+                       float                   weight,
+                       gpointer                data)
+{
+  GtkPathTransform *transform = data;
+
+  switch (op)
+  {
+    case GSK_PATH_MOVE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[0], &transform->offset, transform->scale, &res);
+        gsk_path_builder_move_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_LINE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res);
+        gsk_path_builder_line_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_QUAD:
+      {
+        graphene_point_t res[2];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], &transform->offset, transform->scale, &res[1]);
+        gsk_path_builder_quad_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y);
+      }
+      break;
+
+    case GSK_PATH_CUBIC:
+      {
+        graphene_point_t res[3];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], &transform->offset, transform->scale, &res[1]);
+        gtk_path_transform_point (transform->measure, &pts[3], &transform->offset, transform->scale, &res[2]);
+        gsk_path_builder_cubic_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, res[2].x, res[2].y);
+      }
+      break;
+
+    case GSK_PATH_CONIC:
+      {
+        graphene_point_t res[2];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], &transform->offset, transform->scale, &res[1]);
+        gsk_path_builder_conic_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, weight);
+      }
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_close (transform->builder);
+      break;
+
+    default:
+      g_assert_not_reached();
+      return FALSE;
+  }
+
+  return TRUE;
+}
+
+static GskPath *
+gtk_path_transform (GskPathMeasure         *measure,
+                    GskPath                *path,
+                    const graphene_point_t *offset)
+{
+  GtkPathTransform transform = { measure, gsk_path_builder_new (), *offset };
+  graphene_rect_t bounds;
+
+  gsk_path_get_bounds (path, &bounds);
+  if (bounds.origin.x + bounds.size.width > 0)
+    transform.scale = gsk_path_measure_get_length (measure) / (bounds.origin.x + bounds.size.width);
+  else
+    transform.scale = 1.0f;
+
+  gsk_path_foreach (path, -1, gtk_path_transform_op, &transform);
+
+  return gsk_path_builder_free_to_path (transform.builder);
+}
+
+static void
+gtk_path_widget_clear_text_path (GtkPathWidget *self)
+{
+  g_clear_pointer (&self->text_path, gsk_path_unref);
+}
+
+static void
+gtk_path_widget_clear_paths (GtkPathWidget *self)
+{
+  gtk_path_widget_clear_text_path (self);
+
+  g_clear_pointer (&self->line_path, gsk_path_unref);
+  g_clear_pointer (&self->line_measure, gsk_path_measure_unref);
+}
+
+static void
+gtk_path_widget_create_text_path (GtkPathWidget *self)
+{
+  GskPath *path;
+  graphene_point_t offset;
+
+  gtk_path_widget_clear_text_path (self);
+
+  if (self->line_measure == NULL)
+    return;
+
+  path = create_path_from_text (GTK_WIDGET (self), self->text, &offset);
+  self->text_path = gtk_path_transform (self->line_measure, path, &offset);
+
+  gsk_path_unref (path);
+}
+
+static void
+gtk_path_widget_create_paths (GtkPathWidget *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  GskPathBuilder *builder;
+
+  gtk_path_widget_clear_paths (self);
+
+  if (width <= 0 || height <= 0)
+    return;
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder,
+                            self->points[0].x * width, self->points[0].y * height);
+  gsk_path_builder_cubic_to (builder,
+                             self->points[1].x * width, self->points[1].y * height,
+                             self->points[2].x * width, self->points[2].y * height,
+                             self->points[3].x * width, self->points[3].y * height);
+  self->line_path = gsk_path_builder_free_to_path (builder);
+
+  self->line_measure = gsk_path_measure_new (self->line_path);
+
+  gtk_path_widget_create_text_path (self);
+}
+
+static void
+gtk_path_widget_allocate (GtkWidget *widget,
+                          int        width,
+                          int        height,
+                          int        baseline)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+
+  GTK_WIDGET_CLASS (gtk_path_widget_parent_class)->size_allocate (widget, width, height, baseline);
+
+  gtk_path_widget_create_paths (self);
+}
+
+static void
+gtk_path_widget_snapshot (GtkWidget   *widget,
+                          GtkSnapshot *snapshot)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskPath *path;
+  GskStroke *stroke;
+  gsize i;
+
+  /* frosted glass the background */
+  gtk_snapshot_push_blur (snapshot, 100);
+  gdk_paintable_snapshot (self->background, snapshot, width, height);
+  gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 0.6 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+
+  /* draw the text */
+  if (self->text_path)
+    {
+      gtk_snapshot_push_fill (snapshot, self->text_path, GSK_FILL_RULE_WINDING);
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+
+      /* ... with an emboss effect */
+      stroke = gsk_stroke_new (2.0);
+      gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT(1, 1));
+      gtk_snapshot_push_stroke (snapshot, self->text_path, stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 0.2 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gsk_stroke_free (stroke);
+      gtk_snapshot_pop (snapshot);
+
+      gtk_snapshot_pop (snapshot);
+    }
+
+  if (self->editable && self->line_path)
+    {
+      GskPathBuilder *builder;
+
+      /* draw the control line */
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, self->line_path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      /* draw the points */
+      builder = gsk_path_builder_new ();
+      for (i = 0; i < 4; i++)
+        {
+          gsk_path_builder_add_circle (builder, &GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), POINT_SIZE);
+        }
+      path = gsk_path_builder_free_to_path (builder);
+
+      gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      gsk_path_unref (path);
+    }
+
+  if (self->line_closest >= 0)
+    {
+      GskPathBuilder *builder;
+      GskPathPoint point;
+      graphene_point_t closest;
+
+      builder = gsk_path_builder_new ();
+      if (gsk_path_measure_get_point (self->line_measure, self->line_closest, &point))
+        {
+          gsk_path_point_get_position (&point, &closest);
+          gsk_path_builder_add_circle (builder, &closest, POINT_SIZE);
+          path = gsk_path_builder_free_to_path (builder);
+
+          gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+          gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 1, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+          gtk_snapshot_pop (snapshot);
+
+          gsk_path_unref (path);
+        }
+    }
+}
+
+static void
+gtk_path_widget_set_text (GtkPathWidget *self,
+                          const char    *text)
+{
+  if (g_strcmp0 (self->text, text) == 0)
+    return;
+
+  g_free (self->text);
+  self->text = g_strdup (text);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT]);
+}
+
+static void
+gtk_path_widget_set_editable (GtkPathWidget *self,
+                              gboolean       editable)
+{
+  if (self->editable == editable)
+    return;
+
+  self->editable = editable;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EDITABLE]);
+}
+
+static void
+gtk_path_widget_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      gtk_path_widget_set_text (self, g_value_get_string (value));
+      break;
+
+    case PROP_EDITABLE:
+      gtk_path_widget_set_editable (self, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      g_value_set_string (value, self->text);
+      break;
+
+    case PROP_EDITABLE:
+      g_value_set_boolean (value, self->editable);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_dispose (GObject *object)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  gtk_path_widget_clear_paths (self);
+
+  G_OBJECT_CLASS (gtk_path_widget_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_widget_class_init (GtkPathWidgetClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_widget_dispose;
+  object_class->set_property = gtk_path_widget_set_property;
+  object_class->get_property = gtk_path_widget_get_property;
+
+  widget_class->size_allocate = gtk_path_widget_allocate;
+  widget_class->snapshot = gtk_path_widget_snapshot;
+
+  properties[PROP_TEXT] =
+    g_param_spec_string ("text",
+                         "text",
+                         "Text transformed along a path",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_EDITABLE] =
+    g_param_spec_boolean ("editable",
+                          "editable",
+                          "If the path can be edited by the user",
+                          FALSE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+drag_begin (GtkGestureDrag *gesture,
+            double          x,
+            double          y,
+            GtkPathWidget  *self)
+{
+  graphene_point_t mouse = GRAPHENE_POINT_INIT (x, y);
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  gsize i;
+
+  for (i = 0; i < 4; i++)
+    {
+      if (graphene_point_distance (&GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), &mouse, NULL, NULL) <= POINT_SIZE)
+        {
+          self->active_point = i;
+          break;
+        }
+    }
+  if (i == 4)
+    {
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
+      return;
+    }
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+drag_update (GtkGestureDrag *drag,
+             double          offset_x,
+             double          offset_y,
+             GtkPathWidget  *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  double start_x, start_y;
+
+  gtk_gesture_drag_get_start_point (drag, &start_x, &start_y);
+
+  self->points[self->active_point] = GRAPHENE_POINT_INIT ((start_x + offset_x) / width,
+                                                          (start_y + offset_y) / height);
+  self->points[self->active_point].x = CLAMP (self->points[self->active_point].x, 0, 1);
+  self->points[self->active_point].y = CLAMP (self->points[self->active_point].y, 0, 1);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkPathWidget            *self)
+{
+  GskPathPoint point;
+  graphene_point_t pos;
+
+  if (gsk_path_get_closest_point (gsk_path_measure_get_path (self->line_measure),
+                                  &GRAPHENE_POINT_INIT (x, y),
+                                  INFINITY,
+                                  &point))
+    {
+      gsk_path_point_get_position (&point, &pos);
+      self->line_closest = graphene_point_distance (&pos, &GRAPHENE_POINT_INIT (x, y), NULL, NULL);
+    
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkPathWidget            *self)
+{
+  self->line_closest = -1;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+gtk_path_widget_init (GtkPathWidget *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (gtk_gesture_drag_new ());
+  g_signal_connect (controller, "drag-begin", G_CALLBACK (drag_begin), self);
+  g_signal_connect (controller, "drag-update", G_CALLBACK (drag_update), self);
+  g_signal_connect (controller, "drag-end", G_CALLBACK (drag_update), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "enter", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->line_closest = -1;
+
+  self->points[0] = GRAPHENE_POINT_INIT (0.1, 0.9);
+  self->points[1] = GRAPHENE_POINT_INIT (0.3, 0.1);
+  self->points[2] = GRAPHENE_POINT_INIT (0.7, 0.1);
+  self->points[3] = GRAPHENE_POINT_INIT (0.9, 0.9);
+
+  self->background = GDK_PAINTABLE (gdk_texture_new_from_resource ("/sliding_puzzle/portland-rose.jpg"));
+
+  gtk_path_widget_set_text (self, "It's almost working");
+}
+
+GtkWidget *
+gtk_path_widget_new (void)
+{
+  GtkPathWidget *self;
+
+  self = g_object_new (GTK_TYPE_PATH_WIDGET, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+GtkWidget *
+do_path_text (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_PATH_WIDGET);
+
+      builder = gtk_builder_new_from_resource ("/path_text/path_text.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_text.ui

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Text along a Path</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <child type="end">
+          <object class="GtkToggleButton" id="edit-toggle">
+            <property name="icon-name">document-edit-symbolic</property>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkRevealer">
+            <property name="reveal-child" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <child>
+              <object class="GtkEntry" id="text">
+                <property name="text">Through the looking glass</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkPathWidget" id="view">
+            <property name="editable" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <property name="text" bind-source="text" bind-property="text" bind-flags="sync-create"></property>
+            <property name="hexpand">true</property>
+            <property name="vexpand">true</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

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

@@ -0,0 +1,121 @@
+.. _gtk4-path-tool(1):
+
+=================
+gtk4-path-tool
+=================
+
+-----------------------
+GskPath Utility
+-----------------------
+
+SYNOPSIS
+--------
+|   **gtk4-path-tool** <COMMAND> [OPTIONS...] <PATH>
+|
+|   **gtk4-path-tool** decompose [OPTIONS...] <PATH>
+|   **gtk4-path-tool** restrict [OPTIONS...] <PATH>
+|   **gtk4-path-tool** show [OPTIONS...] <PATH>
+|   **gtk4-path-tool** render [OPTIONS...] <PATH>
+|   **gtk4-path-tool** info [OPTIONS...] <PATH>
+
+DESCRIPTION
+-----------
+
+``gtk4-path-tool`` can perform various tasks on paths. Paths are specified
+in SVG syntax, as strings like "M 100 100 C 100 200 200 200 200 100 Z".
+
+To read a path from a file, use a filename that starts with a '.' or a '/'.
+To read a path from stdin, use '-'.
+
+COMMANDS
+--------
+
+Decomposing
+^^^^^^^^^^^
+
+The ``decompose`` command approximates the path by one with simpler elements.
+When used without options, the curves of the path are approximated by line
+segments.
+
+``--allow-curves``
+
+  Allow cubic Bézier curves to be used in the generated path.
+
+``--allow-conics``
+
+  Allow rational quadratic Bézier curves to be used in the generated path.
+
+Restricting
+^^^^^^^^^^^
+
+The ``restrict`` command creates a path that traces a segment of the original
+path. Note that the start and the end of the segment are specified as
+path length from the beginning of the path.
+
+``--start=LENGTH``
+
+  The distance from the beginning of the path where the segment begins. The
+  default values is 0.
+
+``--end=LENGTH``
+
+  The distance from the beginning of the path where the segment ends. The
+  default value is the length of path.
+
+Showing
+^^^^^^^
+
+The ``show`` command displays the given path in a window. The interior
+of the path is filled.
+
+``--fill-rule=VALUE``
+
+  The fill rule that is used to determine what areas are inside the path.
+  The possible values are ``winding`` or ``even-odd``. The default is ``winding``.
+
+``--fg-color=COLOR``
+
+  The color that is used to fill the interior of the path.
+  If not specified, black is used.
+
+``--bg-color=COLOR``
+
+  The color that is used to render the background behind the path.
+  If not specified, white is used.
+
+Rendering
+^^^^^^^^^
+
+The ``render`` command renders the given path as a PNG image.
+The interior of the path is filled.
+
+``--fill-rule=VALUE``
+
+  The fill rule that is used to determine what areas are inside the path.
+  The possible values are ``winding`` or ``even-odd``. The default is ``winding``.
+
+``--fg-color=COLOR``
+
+  The color that is used to fill the interior of the path.
+  If not specified, black is used.
+
+``--bg-color=COLOR``
+
+  The color that is used to render the background behind the path.
+  If not specified, white is used.
+
+``--output-file=FILE``
+
+  The file to save the PNG image to.
+  If not specified, "path.png" is used.
+
+Info
+^^^^
+
+The ``info`` command shows various information about the given path,
+such as its bounding box and and its length.
+
+REFERENCES
+----------
+
+- SVG Path Specification, https://www.w3.org/TR/SVG2/paths.html

docs/reference/gtk/meson.build

@@ -77,6 +77,7 @@ if get_option('man-pages') and rst2man.found()
     [ 'gtk4-query-settings', '1', ],
     [ 'gtk4-rendernode-tool', '1' ],
     [ 'gtk4-update-icon-cache', '1', ],
+    [ 'gtk4-path-tool', '1', ],
   ]
 
   if get_option('demos')

docs/reference/gtk/section-accessibility.md

@@ -222,7 +222,7 @@ It is possible to set accessible attributes in UI files as well:
   <accessibility>
     <property name="label">Download</property>
     <relation name="labelled-by">label1</relation>
-  </accessibility>
+  /accessibility>
 </object>
 ```
 

gdk/gdkdisplay.c

@@ -473,7 +473,8 @@ gdk_display_get_event (GdkDisplay *display)
  * @display: a `GdkDisplay`
  * @event: (transfer none): a `GdkEvent`
  *
- * Adds the given event to the event queue for @display.
+ * Appends the given event onto the front of 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/gdkglcontext.c

@@ -1528,8 +1528,7 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
 
   if (gdk_gl_context_get_use_es (context))
     {
-      priv->has_unpack_subimage = gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)) ||
-                                  epoxy_has_gl_extension ("GL_EXT_unpack_subimage");
+      priv->has_unpack_subimage = epoxy_has_gl_extension ("GL_EXT_unpack_subimage");
       priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
     }
   else

gdk/gdkgltexture.c

@@ -153,7 +153,7 @@ gdk_gl_texture_find_format (gboolean         use_es,
       if (gdk_memory_format_alpha (format) != alpha)
         continue;
 
-      if (!gdk_memory_format_gl_format (format, use_es, gl_major, gl_minor, &q_internal_format, &q_format, &q_type, q_swizzle))
+      if (!gdk_memory_format_gl_format (format, use_es, gl_major, gl_minor, &q_internal_format, &q_format, &q_type, &q_swizzle))
         continue;
 
       if (q_format != gl_format || q_type != gl_type)
@@ -188,7 +188,7 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
                                    FALSE,
                                    major, minor,
                                    &gl_internal_format,
-                                   &gl_format, &gl_type, gl_swizzle))
+                                   &gl_format, &gl_type, &gl_swizzle))
     {
       if (download->stride == expected_stride &&
           download->format == format)

gdk/gdkmemoryformat.c

@@ -739,12 +739,12 @@ gdk_memory_format_gl_format (GdkMemoryFormat  format,
                              guint           *out_internal_format,
                              guint           *out_format,
                              guint           *out_type,
-                             GLint            out_swizzle[4])
+                             GLint          (*out_swizzle)[4])
 {
   *out_internal_format = memory_formats[format].gl.internal_format;
   *out_format = memory_formats[format].gl.format;
   *out_type = memory_formats[format].gl.type;
-  memcpy (out_swizzle, memory_formats[format].gl.swizzle, sizeof(GLint) * 4);
+  memcpy (out_swizzle, &memory_formats[format].gl.swizzle, sizeof(GLint) * 4);
 
   if (gles)
     {

gdk/gdkmemoryformatprivate.h

@@ -52,7 +52,7 @@ gboolean                gdk_memory_format_gl_format         (GdkMemoryFormat
                                                              guint                      *out_internal_format,
                                                              guint                      *out_format,
                                                              guint                      *out_type,
-                                                             GLint                       out_gizzle[4]);
+                                                             GLint                     (*out_gizzle)[4]);
 
 void                    gdk_memory_convert                  (guchar                     *dest_data,
                                                              gsize                       dest_stride,

gdk/gdkpaintable.c

@@ -25,12 +25,10 @@
 #include "gdkprivate.h"
 
 /* HACK: So we don't need to include any (not-yet-created) GSK or GTK headers */
-GdkSnapshot *   gtk_snapshot_new                        (void);
 void            gtk_snapshot_push_debug                 (GdkSnapshot            *snapshot,
                                                          const char             *message,
                                                          ...) G_GNUC_PRINTF (2, 3);
 void            gtk_snapshot_pop                        (GdkSnapshot            *snapshot);
-GdkPaintable *  gtk_snapshot_free_to_paintable          (GdkSnapshot            *snapshot);
 
 /**
  * GdkPaintable:
@@ -104,21 +102,9 @@ gdk_paintable_default_snapshot (GdkPaintable *paintable,
 static GdkPaintable *
 gdk_paintable_default_get_current_image (GdkPaintable *paintable)
 {
-  int width, height;
-  GdkSnapshot *snapshot;
+  g_warning ("FIXME: implement by snapshotting at default size and returning a GskRendererNodePaintable");
 
-  /* No need to check whether the paintable is static, as
-   * gdk_paintable_get_current_image () takes care of that already.  */
-
-  width = gdk_paintable_get_intrinsic_width (paintable);
-  height = gdk_paintable_get_intrinsic_height (paintable);
-
-  if (width <= 0 || height <= 0)
-    return gdk_paintable_new_empty (width, height);
-
-  snapshot = gtk_snapshot_new ();
-  gdk_paintable_snapshot (paintable, snapshot, width, height);
-  return gtk_snapshot_free_to_paintable (snapshot);
+  return paintable;
 }
 
 static GdkPaintableFlags

gdk/macos/gdkmacoscairocontext.c

@@ -188,14 +188,6 @@ 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,
@@ -213,8 +205,6 @@ _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_foreign : 1;
+  guint key_window_is_foregin : 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_foreign)
+  if (self->key_window_is_foregin)
     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_foreign = FALSE;
+      self->key_window_is_foregin = 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_foreign = !GDK_IS_MACOS_WINDOW (nswindow);
+            self->key_window_is_foregin = !GDK_IS_MACOS_WINDOW (nswindow);
 
           if (!GDK_IS_MACOS_WINDOW (nswindow))
             continue;

gdk/wayland/gdkapplaunchcontext-wayland.c

@@ -46,21 +46,6 @@ 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,
@@ -77,6 +62,7 @@ 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);
@@ -92,7 +78,9 @@ 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)));
 
-      wl_surface = peek_launcher_toplevel (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);
       if (wl_surface)
         xdg_activation_token_v1_set_surface (token, wl_surface);
 
@@ -105,8 +93,7 @@ gdk_wayland_app_launch_context_get_startup_notify_id (GAppLaunchContext *context
       id = app_launch_data.token;
       wl_event_queue_destroy (event_queue);
     }
-  else if (display->gtk_shell &&
-           gtk_shell1_get_version (display->gtk_shell) >= GTK_SHELL1_NOTIFY_LAUNCH_SINCE_VERSION)
+  else if (gtk_shell1_get_version (display->gtk_shell) >= GTK_SHELL1_NOTIFY_LAUNCH_SINCE_VERSION)
     {
       id = g_uuid_string_random ();
       gtk_shell1_notify_launch (display->gtk_shell, id);

gdk/wayland/gdkdisplay-wayland.c

@@ -96,12 +96,6 @@
 #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)
@@ -644,8 +638,7 @@ _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,
-                               XDG_WM_BASE_VERSION));
+                          MIN (display_wayland->xdg_wm_base_version, 4));
       xdg_wm_base_add_listener (display_wayland->xdg_wm_base,
                                 &xdg_wm_base_listener,
                                 display_wayland);

gdk/wayland/gdktoplevel-wayland.c

@@ -672,18 +672,10 @@ 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/wayland/meson.build

@@ -127,6 +127,3 @@ libgdk_wayland = static_library('gdk-wayland',
   link_with: [ libwayland_cursor, ],
   dependencies: [ gdk_deps, gdk_wayland_deps ],
 )
-
-# Used to generate pkg-config Requires
-wayland_public_deps = [wlclientdep]

gdk/win32/gdkevents-win32.c

@@ -2857,10 +2857,7 @@ gdk_event_translate (MSG *msg,
       break;
 
     case WM_SYSCOMMAND:
-      /* From: https://learn.microsoft.com/en-us/windows/win32/menurc/wm-syscommand?redirectedfrom=MSDN
-       * To obtain the correct result when testing the value of wParam,
-       * an application must combine the value 0xFFF0 with the wParam value by using the bitwise AND operator. */
-      switch (msg->wParam & 0xFFF0)
+      switch (msg->wParam)
 	{
 	case SC_MINIMIZE:
 	case SC_RESTORE:
@@ -2967,14 +2964,6 @@ gdk_event_translate (MSG *msg,
                   windowpos = (WINDOWPOS *) msg->lParam;
                   windowpos->cx = our_mmi.ptMaxSize.x;
                   windowpos->cy = our_mmi.ptMaxSize.y;
-
-                  if (!_gdk_win32_surface_lacks_wm_decorations (window) &&
-                      !(windowpos->flags & SWP_NOCLIENTSIZE) &&
-                      window->width == impl->next_layout.configured_width &&
-                      window->height == impl->next_layout.configured_height)
-                    {
-                      impl->inhibit_configure = TRUE;
-                    }
                 }
 
               impl->maximizing = FALSE;

gdk/win32/gdksurface-win32.c

@@ -1230,11 +1230,18 @@ get_effective_window_decorations (GdkSurface       *window,
 
       *decoration |= GDK_DECOR_MINIMIZE;
 
+      return TRUE;
+    }
+  else if (impl->hint_flags & GDK_HINT_MAX_SIZE)
+    {
+      *decoration = GDK_DECOR_ALL | GDK_DECOR_MAXIMIZE;
+      *decoration |= GDK_DECOR_MINIMIZE;
+
       return TRUE;
     }
   else
     {
-      *decoration = GDK_DECOR_ALL;
+      *decoration = (GDK_DECOR_ALL | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE);
       return TRUE;
     }
 

gdk/x11/gdkclipboard-x11.c

@@ -201,7 +201,7 @@ gdk_x11_clipboard_formats_to_targets (GdkContentFormats *formats)
             continue;
 
           if (g_str_equal (mime_types[i], special_targets[j].mime_type))
-            targets = g_slist_prepend (targets, (gpointer) g_intern_static_string (special_targets[j].x_target));
+            targets = g_slist_prepend (targets, (gpointer) g_intern_string (special_targets[j].x_target));
         }
       targets = g_slist_prepend (targets, (gpointer) mime_types[i]);
     }
@@ -238,8 +238,6 @@ gdk_x11_clipboard_formats_to_atoms (GdkDisplay        *display,
   for (l = targets; l; l = l->next)
     atoms[i++] = gdk_x11_get_xatom_by_name_for_display (display, l->data);
 
-  g_slist_free (targets);
-
   return atoms;
 }
 

gdk/x11/meson.build

@@ -86,5 +86,3 @@ libgdk_x11 = static_library('gdk-x11',
   ] + common_cflags,
   dependencies: [ gdk_deps, gdk_x11_deps, ],
 )
-
-x11_public_deps = [x11_dep]

gsk/broadway/gskbroadwayrenderer.c

@@ -271,6 +271,8 @@ collect_reused_child_nodes (GskRenderer *renderer,
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
 
     default:
 
@@ -859,6 +861,8 @@ gsk_broadway_renderer_add_node (GskRenderer *renderer,
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
     case GSK_GL_SHADER_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
     default:
       break; /* Fallback */
     }

gsk/gl/gskglcommandqueue.c

@@ -1456,7 +1456,7 @@ memory_format_gl_format (GdkMemoryFormat  data_format,
                          guint           *gl_internalformat,
                          guint           *gl_format,
                          guint           *gl_type,
-                         GLint            gl_swizzle[4])
+                         GLint          (*gl_swizzle)[4])
 {
   GdkMemoryDepth depth;
 
@@ -1577,7 +1577,7 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
                                          &gl_internalformat,
                                          &gl_format,
                                          &gl_type,
-                                         gl_swizzle);
+                                         &gl_swizzle);
 
   gdk_texture_downloader_init (&downloader, texture);
   gdk_texture_downloader_set_format (&downloader, data_format);
@@ -1595,7 +1595,8 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
     {
       glTexSubImage2D (GL_TEXTURE_2D, 0, x, y, width, height, gl_format, gl_type, data);
     }
-  else if (stride % bpp == 0 && gdk_gl_context_has_unpack_subimage (self->context))
+  else if (stride % bpp == 0 &&
+           (gdk_gl_context_check_version (self->context, NULL, "3.0") || gdk_gl_context_has_unpack_subimage (self->context)))
     {
       glPixelStorei (GL_UNPACK_ROW_LENGTH, stride / bpp);
 
@@ -1683,7 +1684,7 @@ gsk_gl_command_queue_upload_texture_chunks (GskGLCommandQueue    *self,
                                          &gl_internalformat,
                                          &gl_format,
                                          &gl_type,
-                                         gl_swizzle);
+                                         &gl_swizzle);
 
   glTexImage2D (GL_TEXTURE_2D, 0, gl_internalformat, width, height, 0, gl_format, gl_type, NULL);
 

gsk/gl/gskglrenderer.h

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

gsk/gl/gskglrenderjob.c

@@ -142,8 +142,6 @@ 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;
 
@@ -257,6 +255,8 @@ node_supports_2d_transform (const GskRenderNode *node)
     case GSK_BLEND_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
       return TRUE;
 
     case GSK_SHADOW_NODE:
@@ -311,6 +311,8 @@ node_supports_transform (const GskRenderNode *node)
     case GSK_BLEND_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
       return TRUE;
 
     case GSK_SHADOW_NODE:
@@ -1258,7 +1260,6 @@ 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);
 
@@ -1324,7 +1325,6 @@ 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,7 +1354,6 @@ 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);
@@ -1462,8 +1461,7 @@ 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 (job->source_is_glyph_atlas &&
-      node->bounds.size.width < 300 &&
+  if (node->bounds.size.width < 300 &&
       node->bounds.size.height < 300 &&
       batch->any.kind == GSK_GL_COMMAND_KIND_DRAW &&
       batch->any.program == program->id)
@@ -1670,7 +1668,6 @@ 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);
         }
@@ -1761,7 +1758,6 @@ 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);
         }
@@ -2127,7 +2123,6 @@ 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);
                 }
@@ -2337,7 +2332,6 @@ 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);
       }
@@ -2603,7 +2597,6 @@ 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);
@@ -2629,7 +2622,6 @@ 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);
@@ -2867,7 +2859,6 @@ 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);
@@ -2914,7 +2905,6 @@ 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);
             }
@@ -3056,7 +3046,6 @@ 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;
             }
 
@@ -3153,6 +3142,10 @@ 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;
@@ -3173,7 +3166,6 @@ 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);
@@ -3230,7 +3222,6 @@ 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,
@@ -3281,7 +3272,6 @@ 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);
         }
@@ -3304,7 +3294,6 @@ 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));
@@ -3367,7 +3356,6 @@ 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));
@@ -3404,7 +3392,6 @@ 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));
@@ -3487,7 +3474,6 @@ 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,
@@ -3622,7 +3608,6 @@ 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);
         }
@@ -3660,7 +3645,6 @@ 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,
@@ -3779,7 +3763,6 @@ 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,
@@ -3821,7 +3804,6 @@ 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,
@@ -3854,7 +3836,6 @@ 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,
@@ -3907,7 +3888,6 @@ 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,
@@ -4113,6 +4093,14 @@ gsk_gl_render_job_visit_node (GskGLRenderJob      *job,
       gsk_gl_render_job_visit_as_fallback (job, node);
     break;
 
+    case GSK_FILL_NODE:
+      gsk_gl_render_job_visit_as_fallback (job, node);
+    break;
+
+    case GSK_STROKE_NODE:
+      gsk_gl_render_job_visit_as_fallback (job, node);
+    break;
+
     case GSK_NOT_A_RENDER_NODE:
     default:
       g_assert_not_reached ();
@@ -4394,7 +4382,6 @@ 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 = get_color(i);
-      vec4 next_color = get_color(i + 1);
+      vec4 curr_color = gsk_premultiply(get_color(i));
+      vec4 next_color = gsk_premultiply(get_color(i + 1));
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(gsk_premultiply(color), u_alpha);
+      gskSetScaledOutputColor(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 = get_color(i);
-      vec4 next_color = get_color(i + 1);
+      vec4 curr_color = gsk_premultiply(get_color(i));
+      vec4 next_color = gsk_premultiply(get_color(i + 1));
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(gsk_premultiply (color), u_alpha);
+      gskSetScaledOutputColor(color, u_alpha);
       return;
     }
   }

gsk/gl/resources/preamble.vs.glsl

@@ -28,8 +28,6 @@ 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 = get_color(i);
-      vec4 next_color = get_color(i + 1);
+      vec4 curr_color = gsk_premultiply(get_color(i));
+      vec4 next_color = gsk_premultiply(get_color(i + 1));
       vec4 color = mix(curr_color, next_color, f);
-      gskSetScaledOutputColor(gsk_premultiply(color), u_alpha);
+      gskSetScaledOutputColor(color, u_alpha);
       return;
     }
   }

gsk/gsk.h

@@ -20,9 +20,14 @@
 #define __GSK_H_INSIDE__
 
 #include <gsk/gskenums.h>
+#include <gsk/gskpath.h>
+#include <gsk/gskpathbuilder.h>
+#include <gsk/gskpathmeasure.h>
+#include <gsk/gskpathpoint.h>
 #include <gsk/gskrenderer.h>
 #include <gsk/gskrendernode.h>
 #include <gsk/gskroundedrect.h>
+#include <gsk/gskstroke.h>
 #include <gsk/gsktransform.h>
 #include <gsk/gskglshader.h>
 

gsk/gskboundingboxprivate.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GskBoundingBox GskBoundingBox;
+
+struct _GskBoundingBox {
+  graphene_point_t min;
+  graphene_point_t max;
+};
+
+static inline GskBoundingBox *
+gsk_bounding_box_init (GskBoundingBox         *self,
+                       const graphene_point_t *a,
+                       const graphene_point_t *b)
+{
+  self->min.x = MIN (a->x, b->x);
+  self->min.y = MIN (a->y, b->y);
+  self->max.x = MAX (a->x, b->x);
+  self->max.y = MAX (a->y, b->y);
+  return self;
+}
+
+static inline GskBoundingBox *
+gsk_bounding_box_init_copy (GskBoundingBox       *self,
+                            const GskBoundingBox *src)
+{
+  self->min = src->min;
+  self->max = src->max;
+  return self;
+}
+
+static inline GskBoundingBox *
+gsk_bounding_box_init_from_rect (GskBoundingBox        *self,
+                                 const graphene_rect_t *bounds)
+{
+  self->min = bounds->origin;
+  self->max.x = bounds->origin.x + bounds->size.width;
+  self->max.y = bounds->origin.y + bounds->size.height;
+  return self;
+}
+
+static inline void
+gsk_bounding_box_expand (GskBoundingBox         *self,
+                         const graphene_point_t *p)
+{
+  self->min.x = MIN (self->min.x, p->x);
+  self->min.y = MIN (self->min.y, p->y);
+  self->max.x = MAX (self->max.x, p->x);
+  self->max.y = MAX (self->max.y, p->y);
+}
+
+static inline graphene_rect_t *
+gsk_bounding_box_to_rect (const GskBoundingBox  *self,
+                          graphene_rect_t       *rect)
+{
+  rect->origin = self->min;
+  rect->size.width = self->max.x - self->min.x;
+  rect->size.height = self->max.y - self->min.y;
+  return rect;
+}
+
+static inline gboolean
+gsk_bounding_box_contains_point (const GskBoundingBox   *self,
+                                 const graphene_point_t *p)
+{
+  return self->min.x <= p->x && p->x <= self->max.x &&
+         self->min.y <= p->y && p->y <= self->max.y;
+}
+
+static inline gboolean
+gsk_bounding_box_contains_point_with_epsilon (const GskBoundingBox   *self,
+                                              const graphene_point_t *p,
+                                              float                   epsilon)
+{
+  return self->min.x - epsilon <= p->x && p->x <= self->max.x + epsilon &&
+         self->min.y - epsilon <= p->y && p->y <= self->max.y + epsilon;
+}
+
+static inline gboolean
+gsk_bounding_box_intersection (const GskBoundingBox *a,
+                               const GskBoundingBox *b,
+                               GskBoundingBox       *res)
+{
+  graphene_point_t min, max;
+
+  min.x = MAX (a->min.x, b->min.x);
+  min.y = MAX (a->min.y, b->min.y);
+  max.x = MIN (a->max.x, b->max.x);
+  max.y = MIN (a->max.y, b->max.y);
+
+  if (res)
+    gsk_bounding_box_init (res, &min, &max);
+
+  return min.x <= max.x && min.y <= max.y;
+}
+
+G_END_DECLS

gsk/gskcontourprivate.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#pragma once
+
+#include "gskpathprivate.h"
+#include "gskpathpointprivate.h"
+#include "gskpathopprivate.h"
+
+G_BEGIN_DECLS
+
+GskContour *            gsk_rect_contour_new                    (const graphene_rect_t  *rect);
+GskContour *            gsk_rounded_rect_contour_new            (const GskRoundedRect   *rounded_rect);
+GskContour *            gsk_circle_contour_new                  (const graphene_point_t *center,
+                                                                 float                   radius,
+                                                                 float                   start_angle,
+                                                                 float                   end_angle);
+GskContour *            gsk_standard_contour_new                (GskPathFlags            flags,
+                                                                 const graphene_point_t *points,
+                                                                 gsize                   n_points,
+                                                                 const gskpathop        *ops,
+                                                                 gsize                   n_ops,
+                                                                 gssize                  offset);
+
+void                    gsk_contour_copy                        (GskContour *            dest,
+                                                                 const GskContour       *src);
+GskContour *            gsk_contour_dup                         (const GskContour       *src);
+GskContour *            gsk_contour_reverse                     (const GskContour       *src);
+
+gsize                   gsk_contour_get_size                    (const GskContour       *self);
+GskPathFlags            gsk_contour_get_flags                   (const GskContour       *self);
+void                    gsk_contour_print                       (const GskContour       *self,
+                                                                 GString                *string);
+gboolean                gsk_contour_get_bounds                  (const GskContour       *self,
+                                                                 graphene_rect_t        *bounds);
+gboolean                gsk_contour_get_stroke_bounds           (const GskContour       *self,
+                                                                 const GskStroke        *stroke,
+                                                                 graphene_rect_t        *bounds);
+gboolean                gsk_contour_foreach                     (const GskContour       *self,
+                                                                 float                   tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+void                    gsk_contour_get_start_end               (const GskContour       *self,
+                                                                 graphene_point_t       *start,
+                                                                 graphene_point_t       *end);
+int                     gsk_contour_get_winding                 (const GskContour       *self,
+                                                                 const graphene_point_t *point);
+
+gboolean                gsk_contour_get_closest_point           (const GskContour       *self,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 GskRealPathPoint       *result,
+                                                                 float                  *out_dist);
+
+void                    gsk_contour_get_position                (const GskContour       *self,
+                                                                 GskRealPathPoint       *point,
+                                                                 graphene_point_t       *pos);
+
+void                    gsk_contour_get_tangent                 (const GskContour       *self,
+                                                                 GskRealPathPoint       *point,
+                                                                 GskPathDirection        direction,
+                                                                 graphene_vec2_t        *tangent);
+float                   gsk_contour_get_curvature               (const GskContour       *self,
+                                                                 GskRealPathPoint       *point,
+                                                                 graphene_point_t       *center);
+gpointer                gsk_contour_init_measure                (const GskContour       *self,
+                                                                 float                   tolerance,
+                                                                 float                  *out_length);
+void                    gsk_contour_free_measure                (const GskContour       *self,
+                                                                 gpointer                data);
+void                    gsk_contour_add_segment                 (const GskContour       *self,
+                                                                 GskPathBuilder         *builder,
+                                                                 gpointer                measure_data,
+                                                                 gboolean                emit_move_to,
+                                                                 float                   start,
+                                                                 float                   end);
+void                    gsk_contour_get_point                   (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 float                   offset,
+                                                                 GskRealPathPoint       *result);
+float                   gsk_contour_get_distance                (const GskContour       *self,
+                                                                 GskRealPathPoint       *point,
+                                                                 gpointer                measure_data);
+gboolean                gsk_contour_dash                        (const GskContour       *contour,
+                                                                 GskStroke              *stroke,
+                                                                 float                   tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+G_END_DECLS

gsk/gskcurveprivate.h

@@ -0,0 +1,176 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#pragma once
+
+#include "gskpathopprivate.h"
+#include "gskpath.h"
+#include "gskboundingboxprivate.h"
+
+G_BEGIN_DECLS
+
+typedef gpointer gskpathop;
+
+typedef union _GskCurve GskCurve;
+
+typedef struct _GskLineCurve GskLineCurve;
+typedef struct _GskQuadCurve GskQuadCurve;
+typedef struct _GskCubicCurve GskCubicCurve;
+typedef struct _GskConicCurve GskConicCurve;
+
+struct _GskLineCurve
+{
+  GskPathOperation op;
+
+  gboolean padding;
+
+  graphene_point_t points[2];
+};
+
+struct _GskQuadCurve
+{
+  GskPathOperation op;
+
+  gboolean has_coefficients;
+
+  graphene_point_t points[3];
+
+  graphene_point_t coeffs[3];
+};
+
+struct _GskCubicCurve
+{
+  GskPathOperation op;
+
+  gboolean has_coefficients;
+
+  graphene_point_t points[4];
+
+  graphene_point_t coeffs[4];
+};
+
+struct _GskConicCurve
+{
+  GskPathOperation op;
+
+  gboolean has_coefficients;
+
+  /* points[0], points[1], points[3] are the control points,
+   * points[2].x is the weight
+   */
+  graphene_point_t points[4];
+
+  graphene_point_t num[3];
+  graphene_point_t denom[3];
+};
+
+union _GskCurve
+{
+  GskPathOperation op;
+  GskLineCurve line;
+  GskQuadCurve quad;
+  GskCubicCurve cubic;
+  GskConicCurve conic;
+};
+
+typedef enum {
+  GSK_CURVE_LINE_REASON_STRAIGHT,
+  GSK_CURVE_LINE_REASON_SHORT
+} GskCurveLineReason;
+
+typedef gboolean (* GskCurveAddLineFunc) (const graphene_point_t *from,
+                                          const graphene_point_t *to,
+                                          float                   from_progress,
+                                          float                   to_progress,
+                                          GskCurveLineReason      reason,
+                                          gpointer                user_data);
+
+typedef gboolean (* GskCurveAddCurveFunc) (GskPathOperation        op,
+                                           const graphene_point_t *pts,
+                                           gsize                   n_pts,
+                                           float                   weight,
+                                           gpointer                user_data);
+
+void                    gsk_curve_init                          (GskCurve               *curve,
+                                                                 gskpathop               op);
+void                    gsk_curve_init_foreach                  (GskCurve               *curve,
+                                                                 GskPathOperation        op,
+                                                                 const graphene_point_t *pts,
+                                                                 gsize                   n_pts,
+                                                                 float                   weight);
+
+void                    gsk_curve_print                         (const GskCurve         *curve,
+                                                                 GString                *string);
+
+char *                  gsk_curve_to_string                     (const GskCurve         *curve);
+
+gskpathop               gsk_curve_pathop                        (const GskCurve         *curve);
+const graphene_point_t *gsk_curve_get_start_point               (const GskCurve         *curve);
+const graphene_point_t *gsk_curve_get_end_point                 (const GskCurve         *curve);
+void                    gsk_curve_get_start_tangent             (const GskCurve         *curve,
+                                                                 graphene_vec2_t        *tangent);
+void                    gsk_curve_get_end_tangent               (const GskCurve         *curve,
+                                                                 graphene_vec2_t        *tangent);
+void                    gsk_curve_get_point                     (const GskCurve         *curve,
+                                                                 float                   progress,
+                                                                 graphene_point_t       *pos);
+void                    gsk_curve_get_tangent                   (const GskCurve         *curve,
+                                                                 float                   progress,
+                                                                 graphene_vec2_t        *tangent);
+void                    gsk_curve_reverse                       (const GskCurve         *curve,
+                                                                 GskCurve               *reverse);
+void                    gsk_curve_split                         (const GskCurve         *curve,
+                                                                 float                   progress,
+                                                                 GskCurve               *start,
+                                                                 GskCurve               *end);
+void                    gsk_curve_segment                       (const GskCurve         *curve,
+                                                                 float                   start,
+                                                                 float                   end,
+                                                                 GskCurve               *segment);
+gboolean                gsk_curve_decompose                     (const GskCurve         *curve,
+                                                                 float                   tolerance,
+                                                                 GskCurveAddLineFunc     add_line_func,
+                                                                 gpointer                user_data);
+gboolean                gsk_curve_decompose_curve               (const GskCurve         *curve,
+                                                                 GskPathForeachFlags     flags,
+                                                                 float                   tolerance,
+                                                                 GskCurveAddCurveFunc    add_curve_func,
+                                                                 gpointer                user_data);
+
+#define gsk_curve_builder_to(curve, builder) gsk_path_builder_pathop_to ((builder), gsk_curve_pathop (curve))
+
+float                   gsk_curve_get_curvature                 (const GskCurve         *curve,
+                                                                 float                   t,
+                                                                 graphene_point_t       *center);
+void                    gsk_curve_get_bounds                    (const GskCurve         *curve,
+                                                                 GskBoundingBox         *bounds);
+void                    gsk_curve_get_tight_bounds              (const GskCurve         *curve,
+                                                                 GskBoundingBox         *bounds);
+
+int                     gsk_curve_get_crossing                  (const GskCurve         *curve,
+                                                                 const graphene_point_t *point);
+gboolean                gsk_curve_get_closest_point             (const GskCurve         *curve,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 float                  *out_dist,
+                                                                 float                  *out_t);
+
+G_END_DECLS
+

gsk/gskenums.h

@@ -42,6 +42,8 @@
  * @GSK_REPEAT_NODE: A node that repeats the child's contents
  * @GSK_CLIP_NODE: A node that clips its child to a rectangular area
  * @GSK_ROUNDED_CLIP_NODE: A node that clips its child to a rounded rectangle
+ * @GSK_FILL_NODE: A node that fills a path
+ * @GSK_STROKE_NODE: A node that strokes a path
  * @GSK_SHADOW_NODE: A node that draws a shadow below its child
  * @GSK_BLEND_NODE: A node that blends two children together
  * @GSK_CROSS_FADE_NODE: A node that cross-fades between two children
@@ -74,6 +76,8 @@ typedef enum {
   GSK_REPEAT_NODE,
   GSK_CLIP_NODE,
   GSK_ROUNDED_CLIP_NODE,
+  GSK_FILL_NODE,
+  GSK_STROKE_NODE,
   GSK_SHADOW_NODE,
   GSK_BLEND_NODE,
   GSK_CROSS_FADE_NODE,
@@ -170,6 +174,136 @@ typedef enum {
   GSK_CORNER_BOTTOM_LEFT
 } GskCorner;
 
+/**
+ * GskFillRule:
+ * @GSK_FILL_RULE_WINDING: If the path crosses the ray from
+ *   left-to-right, counts +1. If the path crosses the ray
+ *   from right to left, counts -1. (Left and right are determined
+ *   from the perspective of looking along the ray from the starting
+ *   point.) If the total count is non-zero, the point will be filled.
+ * @GSK_FILL_RULE_EVEN_ODD: Counts the total number of
+ *   intersections, without regard to the orientation of the contour. If
+ *   the total number of intersections is odd, the point will be
+ *   filled.
+ *
+ * `GskFillRule` is used to select how paths are filled.
+ *
+ * Whether or not a point is included in the fill is determined by taking
+ * a ray from that point to infinity and looking at intersections with the
+ * path. The ray can be in any direction, as long as it doesn't pass through
+ * the end point of a segment or have a tricky intersection such as
+ * intersecting tangent to the path.
+ *
+ * (Note that filling is not actually implemented in this way. This
+ * is just a description of the rule that is applied.)
+ *
+ * New entries may be added in future versions.
+ *
+ * Since: 4.14
+ */
+typedef enum {
+  GSK_FILL_RULE_WINDING,
+  GSK_FILL_RULE_EVEN_ODD
+} GskFillRule;
+
+/**
+ * GskLineCap:
+ * @GSK_LINE_CAP_BUTT: Start and stop the line exactly at the start
+ *   and end point
+ * @GSK_LINE_CAP_ROUND: Use a round ending, the center of the circle
+ *   is the start or end point
+ * @GSK_LINE_CAP_SQUARE: use squared ending, the center of the square
+ *   is the start or end point
+ *
+ * Specifies how to render the start and end points of contours or
+ * dashes when stroking.
+ *
+ * The default line cap style is `GSK_LINE_CAP_BUTT`.
+ *
+ * New entries may be added in future versions.
+ *
+ * Since: 4.14
+ */
+typedef enum {
+  GSK_LINE_CAP_BUTT,
+  GSK_LINE_CAP_ROUND,
+  GSK_LINE_CAP_SQUARE
+} GskLineCap;
+
+/**
+ * GskLineJoin:
+ * @GSK_LINE_JOIN_MITER: Use a sharp angled corner
+ * @GSK_LINE_JOIN_MITER_CLIP: Use a sharp, angled corner, at a distance
+ * @GSK_LINE_JOIN_ROUND: Use a round join, the center of the circle is
+ *   the join point
+ * @GSK_LINE_JOIN_BEVEL: use a cut-off join, the join is cut off at half
+ *   the line width from the joint point
+ *
+ * Specifies how to render the junction of two lines when stroking.
+ *
+ * See [method@Gsk.Stroke.set_miter_limit] for details on the difference
+ * between `GSK_LINE_JOIN_MITER` and `GSK_LINE_JOIN_MITER_CLIP`.
+ *
+ * The default line join style is `GSK_LINE_JOIN_MITER`.
+ *
+ * New entries may be added in future versions.
+ *
+ * Since: 4.14
+ */
+typedef enum {
+  GSK_LINE_JOIN_MITER,
+  GSK_LINE_JOIN_MITER_CLIP,
+  GSK_LINE_JOIN_ROUND,
+  GSK_LINE_JOIN_BEVEL,
+} GskLineJoin;
+
+/**
+ * GskPathOperation:
+ * @GSK_PATH_MOVE: A move-to operation, with 1 point describing the target point.
+ * @GSK_PATH_CLOSE: A close operation ending the current contour with a line back
+ *   to the starting point. Two points describe the start and end of the line.
+ * @GSK_PATH_LINE: A line-to operation, with 2 points describing the start and
+ *   end point of a straight line.
+ * @GSK_PATH_QUAD: A curve-to operation describing a quadratic Bézier curve
+ *   with 3 points describing the start point, the control point and the end
+ *   point of the curve.
+ * @GSK_PATH_CUBIC: A curve-to operation describing a cubic Bézier curve with 4
+ *   points describing the start point, the two control points and the end point
+ *   of the curve.
+ * @GSK_PATH_CONIC: A weighted quadratic Bézier curve with 3 points describing
+ *   the start point, control point and end point of the curve. A weight for the
+ *   curve will be passed, too.
+ *
+ * Path operations are used to described segments of a `GskPath`.
+ *
+ * More values may be added in the future.
+ *
+ * Since: 4.14
+ */
+typedef enum {
+  GSK_PATH_MOVE,
+  GSK_PATH_CLOSE,
+  GSK_PATH_LINE,
+  GSK_PATH_QUAD,
+  GSK_PATH_CUBIC,
+  GSK_PATH_CONIC,
+} GskPathOperation;
+
+/**
+ * GskPathDirection:
+ * @GSK_PATH_START: The side that leads to the start of the path
+ * @GSK_PATH_END: The side that leads to the end of the path
+ *
+ * The values of the `GskPathDirection` enum are used to pick one
+ * of the two sides of the path that at a given point on the path.
+ *
+ * Since: 4.14
+ */
+typedef enum {
+  GSK_PATH_START,
+  GSK_PATH_END
+} GskPathDirection;
+
 /**
  * GskSerializationError:
  * @GSK_SERIALIZATION_UNSUPPORTED_FORMAT: The format can not be identified
@@ -274,4 +408,3 @@ typedef enum
   GSK_MASK_MODE_LUMINANCE,
   GSK_MASK_MODE_INVERTED_LUMINANCE
 } GskMaskMode;
-

gsk/gskpath.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GskPathForeachFlags:
+ * @GSK_PATH_FOREACH_ALLOW_QUAD: Allow emission of `GSK_PATH_QUAD` operations
+ * @GSK_PATH_FOREACH_ALLOW_CUBIC: Allow emission of `GSK_PATH_CUBIC` operations.
+ * @GSK_PATH_FOREACH_ALLOW_CONIC: Allow emission of `GSK_PATH_CONIC` operations.
+ *
+ * Flags that can be passed to gsk_path_foreach() to enable additional
+ * features.
+ *
+ * By default, [method@Gsk.Path.foreach] will only emit a path with all operations
+ * flattened to straight lines to allow for maximum compatibility. The only
+ * operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and `GSK_PATH_CLOSE`.
+ */
+typedef enum
+{
+  GSK_PATH_FOREACH_ALLOW_QUAD  = (1 << 0),
+  GSK_PATH_FOREACH_ALLOW_CUBIC = (1 << 1),
+  GSK_PATH_FOREACH_ALLOW_CONIC = (1 << 2),
+} GskPathForeachFlags;
+
+/**
+ * GskPathForeachFunc:
+ * @op: The operation to perform
+ * @pts: The points of the operation
+ * @n_pts: The number of points
+ * @weight: The weight for conic curves, or unused if not a conic curve.
+ * @user_data: The user data provided with the function
+ *
+ * Prototype of the callback to iterate throught the operations of
+ * a path.
+ *
+ * Returns: %TRUE to continue evaluating the path, %FALSE to
+ *     immediately abort and not call the function again.
+ */
+typedef gboolean (* GskPathForeachFunc) (GskPathOperation        op,
+                                         const graphene_point_t *pts,
+                                         gsize                   n_pts,
+                                         float                   weight,
+                                         gpointer                user_data);
+
+#define GSK_TYPE_PATH (gsk_path_get_type ())
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_path_get_type                       (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_path_ref                            (GskPath                *self);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_unref                          (GskPath                *self);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_print                          (GskPath                *self,
+                                                                 GString                *string);
+GDK_AVAILABLE_IN_4_14
+char *                  gsk_path_to_string                      (GskPath                *self);
+
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_path_parse                          (const char             *string);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_to_cairo                       (GskPath                *self,
+                                                                 cairo_t                *cr);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_is_empty                       (GskPath                *self);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_is_closed                      (GskPath                *self);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_get_bounds                     (GskPath                *self,
+                                                                 graphene_rect_t        *bounds);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_in_fill                        (GskPath                *self,
+                                                                 const graphene_point_t *point,
+                                                                 GskFillRule             fill_rule);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_get_closest_point              (GskPath                *self,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 GskPathPoint           *result);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_foreach                        (GskPath                *self,
+                                                                 GskPathForeachFlags     flags,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_dash                           (GskPath                *self,
+                                                                 GskStroke              *stroke,
+                                                                 float                   tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPath, gsk_path_unref)
+
+G_END_DECLS

gsk/gskpathbuilder.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gskroundedrect.h>
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_PATH_BUILDER (gsk_path_builder_get_type ())
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_path_builder_get_type               (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_4_14
+GskPathBuilder *        gsk_path_builder_new                    (void);
+GDK_AVAILABLE_IN_4_14
+GskPathBuilder *        gsk_path_builder_ref                    (GskPathBuilder         *self);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_unref                  (GskPathBuilder         *self);
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_path_builder_free_to_path           (GskPathBuilder         *self) G_GNUC_WARN_UNUSED_RESULT;
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_path_builder_to_path                (GskPathBuilder         *self) G_GNUC_WARN_UNUSED_RESULT;
+
+GDK_AVAILABLE_IN_4_14
+const graphene_point_t *gsk_path_builder_get_current_point      (GskPathBuilder         *self);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_path               (GskPathBuilder         *self,
+                                                                 GskPath                *path);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_reverse_path       (GskPathBuilder         *self,
+                                                                 GskPath                *path);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_cairo_path         (GskPathBuilder         *self,
+                                                                 const cairo_path_t     *path);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_layout             (GskPathBuilder         *self,
+                                                                 PangoLayout            *layout);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_rect               (GskPathBuilder         *self,
+                                                                 const graphene_rect_t  *rect);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_rounded_rect       (GskPathBuilder         *self,
+                                                                 const GskRoundedRect   *rect);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_circle             (GskPathBuilder         *self,
+                                                                 const graphene_point_t *center,
+                                                                 float                   radius);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_ellipse            (GskPathBuilder         *self,
+                                                                 const graphene_point_t *center,
+                                                                 const graphene_size_t  *radius);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_add_segment            (GskPathBuilder         *self,
+                                                                 GskPathMeasure         *measure,
+                                                                 float                   start,
+                                                                 float                   end);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_move_to                (GskPathBuilder         *self,
+                                                                 float                   x,
+                                                                 float                   y);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_rel_move_to            (GskPathBuilder         *self,
+                                                                 float                   x,
+                                                                 float                   y);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_line_to                (GskPathBuilder         *self,
+                                                                 float                   x,
+                                                                 float                   y);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_rel_line_to            (GskPathBuilder         *self,
+                                                                 float                   x,
+                                                                 float                   y);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_quad_to                (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_rel_quad_to            (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_cubic_to               (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   x3,
+                                                                 float                   y3);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_rel_cubic_to           (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   x3,
+                                                                 float                   y3);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_conic_to               (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   weight);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_rel_conic_to           (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   weight);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_builder_close                  (GskPathBuilder         *self);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathBuilder, gsk_path_builder_unref)
+
+G_END_DECLS

gsk/gskpathdash.c

@@ -0,0 +1,306 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gskcontourprivate.h"
+#include "gskcurveprivate.h"
+#include "gskpathprivate.h"
+#include "gskstrokeprivate.h"
+
+typedef struct
+{
+  float offset;                 /* how much of the current dash we've spent */
+  gsize dash_index;             /* goes from 0 to n_dash * 2, so we don't have to care about on/off
+                                   for uneven dashes */
+  gboolean on;                  /* If we're currently dashing or not */
+  gboolean may_close;           /* TRUE if we haven't turned the dash off in this contour */
+  gboolean needs_move_to;       /* If we have emitted the initial move_to() yet */
+  enum {
+    NORMAL, /* no special behavior required */
+    SKIP,   /* skip the next dash */
+    ONLY,   /* only do the first dash */
+    DONE    /* done with the first dash */
+  } first_dash_behavior;        /* How to handle the first dash in the loop. We loop closed contours
+                                   twice to make sure the first dash and the last dash can get joined */
+
+  GskCurve curve;               /* Curve we are currently processing */
+
+  float collect_start;          /* We're collecting multiple line segments when decomposing. */
+  float collect_length;         /* No need to emit a curve for every line segment when the dash is long enough. */
+
+  /* from the stroke */
+  float *dash;
+  gsize n_dash;
+  float dash_length;
+  float dash_offset;
+
+  float tolerance;
+  GskPathForeachFunc func;
+  gpointer user_data;
+} GskPathDash;
+
+static void
+gsk_path_dash_setup (GskPathDash *self)
+{
+  self->offset = fmodf (self->dash_offset, 2 * self->dash_length);
+
+  self->dash_index = 0;
+  self->on = TRUE;
+  self->may_close = TRUE;
+  while (self->offset > self->dash[self->dash_index % self->n_dash])
+    {
+      self->offset -= self->dash[self->dash_index % self->n_dash];
+      self->dash_index++;
+      self->on = !self->on;
+    }
+  if (self->first_dash_behavior != ONLY)
+    self->needs_move_to = TRUE;
+}
+
+static gboolean
+gsk_path_dash_ensure_move_to (GskPathDash            *self,
+                              const graphene_point_t *pt)
+{
+  if (!self->needs_move_to)
+    return TRUE;
+
+  if (!self->func (GSK_PATH_MOVE, pt, 1, 0, self->user_data))
+    return FALSE;
+
+  self->needs_move_to = FALSE;
+  return TRUE;
+}
+
+static gboolean
+gsk_path_dash_add_line_segment (const graphene_point_t *start,
+                                const graphene_point_t *end,
+                                float                   t_start,
+                                float                   t_end,
+                                GskCurveLineReason      reason,
+                                gpointer                user_data)
+{
+  GskPathDash *self = user_data;
+  float remaining, length, t_step;
+
+  length = graphene_point_distance (start, end, NULL, NULL);
+  if (self->collect_length)
+    {
+      t_start = self->collect_start;
+      length += self->collect_length;
+      self->collect_length = 0;
+    }
+
+  t_step = t_end - t_start;
+  remaining = length;
+
+  while (remaining)
+    {
+      float piece;
+
+      if (self->offset + remaining <= self->dash[self->dash_index % self->n_dash])
+        {
+          /* try collecting multiple line segments */
+          if (t_end < 1.0)
+            {
+              self->collect_start = t_start + t_step * (length - remaining) / length;
+              self->collect_length = remaining;
+              return TRUE;
+            }
+
+          piece = remaining;
+        }
+      else
+        piece = self->dash[self->dash_index % self->n_dash] - self->offset;
+
+      if (self->on)
+        {
+          if (self->first_dash_behavior != SKIP)
+            {
+              GskCurve segment;
+
+              if (piece)
+                {
+                  gsk_curve_segment (&self->curve,
+                                     t_start + t_step * (length - remaining) / length,
+                                     t_start + t_step * (length - (remaining - piece)) / length,
+                                     &segment);
+                  if (!gsk_path_dash_ensure_move_to (self, gsk_curve_get_start_point (&segment)))
+                    return FALSE;
+
+                  if (!gsk_pathop_foreach (gsk_curve_pathop (&segment), self->func, self->user_data))
+                    return FALSE;
+                }
+              else
+                {
+                  graphene_point_t p;
+
+                  gsk_curve_get_point (&self->curve, t_start + t_step * (length - remaining) / length, &p);
+                  if (!gsk_path_dash_ensure_move_to (self, &p))
+                    return FALSE;
+                }
+            }
+        }
+      else
+        {
+          self->may_close = FALSE;
+          if (self->first_dash_behavior == ONLY)
+            {
+              self->first_dash_behavior = DONE;
+              return FALSE;
+            }
+          self->first_dash_behavior = NORMAL;
+        }
+
+      if (self->offset + remaining <= self->dash[self->dash_index % self->n_dash])
+        {
+          self->offset += remaining;
+          remaining = 0;
+        }
+      else
+        {
+          remaining -= piece;
+          self->offset = 0;
+          self->dash_index++;
+          self->dash_index %= 2 * self->n_dash;
+          self->on = !self->on;
+          self->needs_move_to = TRUE;
+        }
+    }
+
+  return TRUE;
+}
+
+static gboolean
+gsk_path_dash_foreach (GskPathOperation        op,
+                       const graphene_point_t *pts,
+                       gsize                   n_pts,
+                       float                   weight,
+                       gpointer                user_data)
+{
+  GskPathDash *self = user_data;
+
+  switch (op)
+  {
+    case GSK_PATH_MOVE:
+      gsk_path_dash_setup (self);
+      break;
+
+    case GSK_PATH_CLOSE:
+      if (self->may_close)
+        {
+          if (graphene_point_equal (&pts[0], &pts[1]))
+            return self->func (GSK_PATH_CLOSE, pts, 2, 0, self->user_data);
+        }
+      else
+        op = GSK_PATH_LINE;
+      G_GNUC_FALLTHROUGH;
+
+    case GSK_PATH_LINE:
+    case GSK_PATH_QUAD:
+    case GSK_PATH_CUBIC:
+    case GSK_PATH_CONIC:
+      gsk_curve_init_foreach (&self->curve, op, pts, n_pts, weight);
+      if (!gsk_curve_decompose (&self->curve, self->tolerance, gsk_path_dash_add_line_segment, self))
+        return FALSE;
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+
+  return TRUE;
+}
+
+gboolean
+gsk_contour_dash (const GskContour   *contour,
+                  GskStroke          *stroke,
+                  float               tolerance,
+                  GskPathForeachFunc  func,
+                  gpointer            user_data)
+{
+  GskPathDash self = {
+    .offset = 0,
+    .dash = stroke->dash,
+    .n_dash = stroke->n_dash,
+    .dash_length = stroke->dash_length,
+    .dash_offset = stroke->dash_offset,
+    .tolerance = tolerance,
+    .func = func,
+    .user_data = user_data
+  };
+  gboolean is_closed = gsk_contour_get_flags (contour) & GSK_PATH_CLOSED ? TRUE : FALSE;
+
+  self.first_dash_behavior = is_closed ? SKIP : NORMAL;
+  if (!gsk_contour_foreach (contour, tolerance, gsk_path_dash_foreach, &self))
+    return FALSE;
+
+  if (is_closed)
+    {
+      if (self.first_dash_behavior == NORMAL)
+        self.first_dash_behavior = ONLY;
+      else
+        self.first_dash_behavior = NORMAL;
+      self.needs_move_to = !self.on;
+      if (!gsk_contour_foreach (contour, tolerance, gsk_path_dash_foreach, &self) &&
+          self.first_dash_behavior != DONE)
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+/**
+ * gsk_path_dash:
+ * @self: the `GskPath` to dash
+ * @stroke: the stroke containing the dash parameters
+ * @tolerance: tolerance to use while dashing
+ * @func: (scope call) (closure user_data): the function to call for operations
+ * @user_data: (nullable): user data passed to @func
+ *
+ * Calls @func for every operation of the path that is the result
+ * of dashing @self with the dash pattern from @stroke.
+ *
+ * Returns: `FALSE` if @func returned FALSE`, `TRUE` otherwise.
+ *
+ * Since: 4.14
+ */
+gboolean
+gsk_path_dash (GskPath            *self,
+               GskStroke          *stroke,
+               float               tolerance,
+               GskPathForeachFunc  func,
+               gpointer            user_data)
+{
+  gsize i;
+
+  /* Dashing disabled, no need to do any work */
+  if (stroke->dash_length <= 0)
+    return gsk_path_foreach (self, -1, func, user_data);
+
+  for (i = 0; i < gsk_path_get_n_contours (self); i++)
+    {
+      if (!gsk_contour_dash (gsk_path_get_contour (self, i), stroke, tolerance, func, user_data))
+        return FALSE;
+    }
+
+  return TRUE;
+}
+

gsk/gskpathmeasure.c

@@ -0,0 +1,411 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gskpathmeasure.h"
+
+#include "gskpathbuilder.h"
+#include "gskpathpointprivate.h"
+#include "gskpathprivate.h"
+
+/**
+ * GskPathMeasure:
+ *
+ * `GskPathMeasure` is an object that allows measurements
+ * on `GskPath`s such as determining the length of the path.
+ *
+ * Many measuring operations require approximating the path
+ * with simpler shapes. Therefore, a `GskPathMeasure` has
+ * a tolerance that determines what precision is required
+ * for such approximations.
+ *
+ * A `GskPathMeasure` struct is a reference counted struct
+ * and should be treated as opaque.
+ */
+
+typedef struct _GskContourMeasure GskContourMeasure;
+
+struct _GskContourMeasure
+{
+  float length;
+  gpointer contour_data;
+};
+
+struct _GskPathMeasure
+{
+  /*< private >*/
+  guint ref_count;
+
+  GskPath *path;
+  float tolerance;
+
+  float length;
+  gsize n_contours;
+  GskContourMeasure measures[];
+};
+
+G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
+                     gsk_path_measure_ref,
+                     gsk_path_measure_unref)
+
+/**
+ * gsk_path_measure_new:
+ * @path: the path to measure
+ *
+ * Creates a measure object for the given @path.
+ *
+ * Returns: a new `GskPathMeasure` representing @path
+ *
+ * Since: 4.14
+ */
+GskPathMeasure *
+gsk_path_measure_new (GskPath *path)
+{
+  return gsk_path_measure_new_with_tolerance (path, GSK_PATH_TOLERANCE_DEFAULT);
+}
+
+/**
+ * gsk_path_measure_new_with_tolerance:
+ * @path: the path to measure
+ * @tolerance: the tolerance for measuring operations
+ *
+ * Creates a measure object for the given @path and @tolerance.
+ *
+ * Returns: a new `GskPathMeasure` representing @path
+ *
+ * Since: 4.14
+ */
+GskPathMeasure *
+gsk_path_measure_new_with_tolerance (GskPath *path,
+                                     float    tolerance)
+{
+  GskPathMeasure *self;
+  gsize i, n_contours;
+
+  g_return_val_if_fail (path != NULL, NULL);
+  g_return_val_if_fail (tolerance > 0, NULL);
+
+  n_contours = gsk_path_get_n_contours (path);
+
+  self = g_malloc0 (sizeof (GskPathMeasure) + n_contours * sizeof (GskContourMeasure));
+
+  self->ref_count = 1;
+  self->path = gsk_path_ref (path);
+  self->tolerance = tolerance;
+  self->n_contours = n_contours;
+
+  for (i = 0; i < n_contours; i++)
+    {
+      self->measures[i].contour_data = gsk_contour_init_measure (gsk_path_get_contour (path, i),
+                                                                 self->tolerance,
+                                                                 &self->measures[i].length);
+      self->length += self->measures[i].length;
+    }
+
+  return self;
+}
+
+/**
+ * gsk_path_measure_ref:
+ * @self: a `GskPathMeasure`
+ *
+ * Increases the reference count of a `GskPathMeasure` by one.
+ *
+ * Returns: the passed in `GskPathMeasure`.
+ *
+ * Since: 4.14
+ */
+GskPathMeasure *
+gsk_path_measure_ref (GskPathMeasure *self)
+{
+  g_return_val_if_fail (self != NULL, NULL);
+
+  self->ref_count++;
+
+  return self;
+}
+
+/**
+ * gsk_path_measure_unref:
+ * @self: a `GskPathMeasure`
+ *
+ * Decreases the reference count of a `GskPathMeasure` by one.
+ *
+ * If the resulting reference count is zero, frees the object.
+ *
+ * Since: 4.14
+ */
+void
+gsk_path_measure_unref (GskPathMeasure *self)
+{
+  gsize i;
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (self->ref_count > 0);
+
+  self->ref_count--;
+  if (self->ref_count > 0)
+    return;
+
+  for (i = 0; i < self->n_contours; i++)
+    {
+      gsk_contour_free_measure (gsk_path_get_contour (self->path, i),
+                                self->measures[i].contour_data);
+    }
+
+  gsk_path_unref (self->path);
+  g_free (self);
+}
+
+/**
+ * gsk_path_measure_get_path:
+ * @self: a `GskPathMeasure`
+ *
+ * Returns the path that the measure was created for.
+ *
+ * Returns: (transfer none): the path of @self
+ *
+ * Since: 4.14
+ */
+GskPath *
+gsk_path_measure_get_path (GskPathMeasure *self)
+{
+  return self->path;
+}
+
+/**
+ * gsk_path_measure_get_tolerance:
+ * @self: a `GskPathMeasure`
+ *
+ * Returns the tolerance that the measure was created with.
+ *
+ * Returns: the tolerance of @self
+ *
+ * Since: 4.14
+ */
+float
+gsk_path_measure_get_tolerance (GskPathMeasure *self)
+{
+  return self->tolerance;
+}
+
+/**
+ * gsk_path_measure_get_length:
+ * @self: a `GskPathMeasure`
+ *
+ * Gets the length of the path being measured.
+ *
+ * The length is cached, so this function does not do any work.
+ *
+ * Returns: The length of the path measured by @self
+ *
+ * Since: 4.14
+ */
+float
+gsk_path_measure_get_length (GskPathMeasure *self)
+{
+  g_return_val_if_fail (self != NULL, 0);
+
+  return self->length;
+}
+
+static float
+gsk_path_measure_clamp_distance (GskPathMeasure *self,
+                                 float           distance)
+{
+  if (isnan (distance))
+    return 0;
+
+  return CLAMP (distance, 0, self->length);
+}
+
+static void
+gsk_path_builder_add_segment_chunk (GskPathBuilder *self,
+                                    GskPathMeasure *measure,
+                                    gboolean        emit_move_to,
+                                    float           start,
+                                    float           end)
+{
+  g_assert (start < end);
+
+  for (gsize i = 0; i < measure->n_contours; i++)
+    {
+      if (measure->measures[i].length < start)
+        {
+          start -= measure->measures[i].length;
+          end -= measure->measures[i].length;
+        }
+      else if (start > 0 || end < measure->measures[i].length)
+        {
+          float len = MIN (end, measure->measures[i].length);
+          gsk_contour_add_segment (gsk_path_get_contour (measure->path, i),
+                                   self,
+                                   measure->measures[i].contour_data,
+                                   emit_move_to,
+                                   start,
+                                   len);
+          end -= len;
+          start = 0;
+          if (end <= 0)
+            break;
+        }
+      else
+        {
+          end -= measure->measures[i].length;
+          gsk_path_builder_add_contour (self, gsk_contour_dup (gsk_path_get_contour (measure->path, i)));
+        }
+      emit_move_to = TRUE;
+    }
+}
+
+/**
+ * gsk_path_builder_add_segment:
+ * @self: a `GskPathBuilder`
+ * @measure: the `GskPathMeasure` to take the segment to
+ * @start: start distance into the path
+ * @end: end distance into the path
+ *
+ * Adds to @self the segment of @measure from @start to @end.
+ *
+ * The distances are given relative to the length of @measure's path,
+ * from 0 for the beginning of the path to its length for the end
+ * of the path. The values will be clamped to that range. The length
+ * can be obtained with [method@Gsk.PathMeasure.get_length].
+ *
+ * If @start >= @end after clamping, the path will first add the segment
+ * from @start to the end of the path, and then add the segment from
+ * the beginning to @end. If the path is closed, these segments will
+ * be connected.
+ *
+ * Since: 4.14
+ */
+void
+gsk_path_builder_add_segment (GskPathBuilder *self,
+                              GskPathMeasure *measure,
+                              float           start,
+                              float           end)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (measure != NULL);
+
+  start = gsk_path_measure_clamp_distance (measure, start);
+  end = gsk_path_measure_clamp_distance (measure, end);
+
+  if (start < end)
+    {
+      gsk_path_builder_add_segment_chunk (self, measure, TRUE, start, end);
+    }
+  else
+    {
+      /* If the path is closed, we can connect the 2 subpaths. */
+      gboolean closed = gsk_path_is_closed (measure->path);
+      gboolean need_move_to = !closed;
+
+      if (start < measure->length)
+        gsk_path_builder_add_segment_chunk (self, measure,
+                                            TRUE,
+                                            start, measure->length);
+      else
+        need_move_to = TRUE;
+
+      if (end > 0)
+        gsk_path_builder_add_segment_chunk (self, measure,
+                                            need_move_to,
+                                            0, end);
+      if (start == end && closed)
+        gsk_path_builder_close (self);
+    }
+}
+
+/**
+ * gsk_path_measure_get_point:
+ * @self: a `GskPathMeasure`
+ * @distance: the distance
+ * @result: (out caller-allocates): return location for the result
+ *
+ * Sets @result to the point at the given distance into the path.
+ *
+ * An empty path has no points, so `FALSE` is returned in that case.
+ *
+ * Returns: `TRUE` if @result was set
+ *
+ * Since: 4.14
+ */
+gboolean
+gsk_path_measure_get_point (GskPathMeasure *self,
+                            float           distance,
+                            GskPathPoint   *result)
+{
+  GskRealPathPoint *res = (GskRealPathPoint *) result;
+  gsize i;
+  float offset;
+  const GskContour *contour;
+
+  g_return_val_if_fail (self != NULL, FALSE);
+  g_return_val_if_fail (result != NULL, FALSE);
+
+  if (self->n_contours == 0)
+    return FALSE;
+
+  offset = gsk_path_measure_clamp_distance (self, distance);
+
+  for (i = 0; i < self->n_contours - 1; i++)
+    {
+      if (offset < self->measures[i].length)
+        break;
+
+      offset -= self->measures[i].length;
+    }
+
+  g_assert (0 <= i && i < self->n_contours);
+
+  offset = CLAMP (offset, 0, self->measures[i].length);
+
+  contour = gsk_path_get_contour (self->path, i);
+
+  gsk_contour_get_point (contour, self->measures[i].contour_data, offset, res);
+
+  return TRUE;
+}
+
+float
+gsk_path_measure_get_distance (GskPathMeasure *self,
+                               GskPathPoint   *point)
+{
+  GskRealPathPoint *p = (GskRealPathPoint *)point;
+  const GskContour *contour = p->contour;
+  float contour_offset = 0;
+
+  g_return_val_if_fail (self != NULL, 0);
+  g_return_val_if_fail (point != NULL, 0);
+  g_return_val_if_fail (self->path == p->path, 0);
+
+  for (gsize i = 0; i < self->n_contours; i++)
+    {
+      if (contour == gsk_path_get_contour (self->path, i))
+        return contour_offset + gsk_contour_get_distance (contour,
+                                                          p,
+                                                          self->measures[i].contour_data);
+
+      contour_offset += self->measures[i].length;
+    }
+
+  g_return_val_if_reached (0);
+}

gsk/gskpathmeasure.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gskpath.h>
+#include <gsk/gskpathpoint.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_PATH_MEASURE (gsk_path_measure_get_type ())
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_path_measure_get_type               (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_4_14
+GskPathMeasure *        gsk_path_measure_new                    (GskPath                *path);
+GDK_AVAILABLE_IN_4_14
+GskPathMeasure *        gsk_path_measure_new_with_tolerance     (GskPath                *path,
+                                                                 float                   tolerance);
+
+GDK_AVAILABLE_IN_4_14
+GskPathMeasure *        gsk_path_measure_ref                    (GskPathMeasure         *self);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_measure_unref                  (GskPathMeasure         *self);
+
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_path_measure_get_path               (GskPathMeasure         *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+float                   gsk_path_measure_get_tolerance          (GskPathMeasure         *self) G_GNUC_PURE;
+
+GDK_AVAILABLE_IN_4_14
+float                   gsk_path_measure_get_length             (GskPathMeasure         *self);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_path_measure_get_point              (GskPathMeasure         *self,
+                                                                 float                   distance,
+                                                                 GskPathPoint           *point);
+
+GDK_AVAILABLE_IN_4_14
+float                   gsk_path_measure_get_distance           (GskPathMeasure         *self,
+                                                                 GskPathPoint           *point);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathMeasure, gsk_path_measure_unref)
+
+G_END_DECLS

gsk/gskpathopprivate.h

@@ -0,0 +1,186 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#pragma once
+
+#include "gskpath.h"
+#include "gskpathbuilder.h"
+
+G_BEGIN_DECLS
+
+typedef gpointer gskpathop;
+
+static inline
+gskpathop               gsk_pathop_encode                       (GskPathOperation        op,
+                                                                 const graphene_point_t *pts);
+static inline
+const graphene_point_t *gsk_pathop_points                       (gskpathop               pop);
+static inline
+GskPathOperation        gsk_pathop_op                           (gskpathop               pop);
+
+static inline
+gboolean                gsk_pathop_foreach                      (gskpathop               pop,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+/* included inline so tests can use them */
+static inline
+void                    gsk_path_builder_pathop_to              (GskPathBuilder         *builder,
+                                                                 gskpathop               op);
+static inline
+void                    gsk_path_builder_pathop_reverse_to      (GskPathBuilder         *builder,
+                                                                 gskpathop               op);
+
+/* IMPLEMENTATION */
+
+#define GSK_PATHOP_OPERATION_MASK (0x7)
+
+static inline gskpathop
+gsk_pathop_encode (GskPathOperation        op,
+                   const graphene_point_t *pts)
+{
+  /* g_assert (op & GSK_PATHOP_OPERATION_MASK == op); */
+  g_assert ((GPOINTER_TO_SIZE (pts) & GSK_PATHOP_OPERATION_MASK) == 0);
+
+  return GSIZE_TO_POINTER (GPOINTER_TO_SIZE (pts) | op);
+}
+
+static inline const graphene_point_t *
+gsk_pathop_points (gskpathop pop)
+{
+  return GSIZE_TO_POINTER (GPOINTER_TO_SIZE (pop) & ~GSK_PATHOP_OPERATION_MASK);
+}
+
+static inline
+GskPathOperation gsk_pathop_op (gskpathop pop)
+{
+  return GPOINTER_TO_SIZE (pop) & GSK_PATHOP_OPERATION_MASK;
+}
+
+static inline gboolean
+gsk_pathop_foreach (gskpathop          pop,
+                    GskPathForeachFunc func,
+                    gpointer           user_data)
+{
+  switch (gsk_pathop_op (pop))
+  {
+    case GSK_PATH_MOVE:
+      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 1, 0, user_data);
+
+    case GSK_PATH_CLOSE:
+    case GSK_PATH_LINE:
+      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 2, 0, user_data);
+
+    case GSK_PATH_QUAD:
+      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 3, 0, user_data);
+
+    case GSK_PATH_CUBIC:
+      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 4, 0, user_data);
+
+    case GSK_PATH_CONIC:
+      {
+        const graphene_point_t *pts = gsk_pathop_points (pop);
+        return func (gsk_pathop_op (pop), (graphene_point_t[3]) { pts[0], pts[1], pts[3] }, 3, pts[2].x, user_data);
+      }
+
+    default:
+      g_assert_not_reached ();
+      return TRUE;
+    }
+}
+
+static inline void
+gsk_path_builder_pathop_to (GskPathBuilder *builder,
+                            gskpathop       op)
+{
+  const graphene_point_t *pts = gsk_pathop_points (op);
+
+  switch (gsk_pathop_op (op))
+  {
+    case GSK_PATH_MOVE:
+      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_close (builder);
+      break;
+
+    case GSK_PATH_LINE:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      break;
+
+    case GSK_PATH_QUAD:
+      gsk_path_builder_quad_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y);
+      break;
+
+    case GSK_PATH_CUBIC:
+      gsk_path_builder_cubic_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y, pts[3].x, pts[3].y);
+      break;
+
+    case GSK_PATH_CONIC:
+      gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[3].x, pts[3].y, pts[2].x);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+}
+
+static inline void
+gsk_path_builder_pathop_reverse_to (GskPathBuilder *builder,
+                                    gskpathop       op)
+{
+  const graphene_point_t *pts = gsk_pathop_points (op);
+
+  switch (gsk_pathop_op (op))
+  {
+    case GSK_PATH_MOVE:
+      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_line_to (builder, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_LINE:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      break;
+
+    case GSK_PATH_QUAD:
+      gsk_path_builder_quad_to (builder, pts[1].x, pts[1].y, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CUBIC:
+      gsk_path_builder_cubic_to (builder, pts[2].x, pts[2].y, pts[1].x, pts[1].y, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CONIC:
+      gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[0].x, pts[0].y, pts[2].x);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+}
+
+
+G_END_DECLS

gsk/gskpathpoint.c

@@ -0,0 +1,165 @@
+/*
+ * Copyright © 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.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/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include "gskpathpointprivate.h"
+
+#include "gskcontourprivate.h"
+#include "gskpathmeasure.h"
+
+#include "gdk/gdkprivate.h"
+
+
+/**
+ * GskPathPoint:
+ *
+ * `GskPathPoint` is an opaque type representing a point on a path.
+ *
+ * It can be queried for properties of the path at that point, such as its
+ * tangent or its curvature.
+ *
+ * To obtain a `GskPathPoint`, use [method@Gsk.Path.get_closest_point]
+ * or [method@Gsk.PathMeasure.get_point].
+ *
+ * Note that `GskPathPoint` structs are meant to be stack-allocated, and
+ * don't a reference to the path object they are obtained from. It is the
+ * callers responsibility to keep a reference to the path as long as the
+ * `GskPathPoint` is used.
+ */
+
+G_DEFINE_BOXED_TYPE (GskPathPoint, gsk_path_point,
+                     gsk_path_point_copy,
+                     gsk_path_point_free)
+
+
+GskPathPoint *
+gsk_path_point_copy (GskPathPoint *point)
+{
+  GskPathPoint *copy;
+
+  copy = g_new0 (GskPathPoint, 1);
+
+  memcpy (copy, point, sizeof (GskRealPathPoint));
+
+  return copy;
+}
+
+void
+gsk_path_point_free (GskPathPoint *point)
+{
+  g_free (point);
+}
+
+GskPath *
+gsk_path_point_get_path (GskPathPoint *point)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  return self->path;
+}
+
+const GskContour *
+gsk_path_point_get_contour (GskPathPoint *point)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  return self->contour;
+}
+
+/**
+ * gsk_path_point_get_position:
+ * @point: a `GskPathPoint`
+ * @position: (out caller-allocates): Return location for
+ *   the coordinates of the point
+ *
+ * Gets the position of the point.
+ *
+ * Since: 4.14
+ */
+void
+gsk_path_point_get_position (GskPathPoint     *point,
+                             graphene_point_t *position)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  gsk_contour_get_position (self->contour, self, position);
+}
+
+/**
+ * gsk_path_point_get_tangent:
+ * @point: a `GskPathPoint`
+ * @direction: the direction for which to return the tangent
+ * @tangent: (out caller-allocates): Return location for
+ *   the tangent at the point
+ *
+ * Gets the tangent of the path at the point.
+ *
+ * Note that certain points on a path may not have a single
+ * tangent, such as sharp turns. At such points, there are
+ * two tangents -- the direction of the path going into the
+ * point, and the direction coming out of it. The @direction
+ * argument lets you choose which one to get.
+ *
+ * Since: 4.14
+ */
+void
+gsk_path_point_get_tangent (GskPathPoint     *point,
+                            GskPathDirection  direction,
+                            graphene_vec2_t  *tangent)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  gsk_contour_get_tangent (self->contour, self, direction, tangent);
+}
+
+/**
+ * gsk_path_point_get_curvature:
+ * @point: a `GskPathPoint`
+ * @center: (out caller-allocates): Return location for
+ *   the center of the osculating circle
+ *
+ * Calculates the curvature of the path at the point.
+ *
+ * Optionally, returns the center of the osculating circle as well.
+ *
+ * If the curvature is infinite (at line segments), zero is returned,
+ * and @center is not modified.
+ *
+ * Returns: The curvature of the path at the given point
+ *
+ * Since: 4.14
+ */
+float
+gsk_path_point_get_curvature (GskPathPoint     *point,
+                              graphene_point_t *center)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  return gsk_contour_get_curvature (self->contour, self, center);
+}
+
+float
+gsk_path_point_get_distance (GskPathPoint *point,
+                             gpointer      measure_data)
+{
+  GskRealPathPoint *self = (GskRealPathPoint *) point;
+
+  return gsk_contour_get_distance (self->contour, self, measure_data);
+}

gsk/gskpathpoint.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.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/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#pragma once
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_PATH_POINT (gsk_path_point_get_type ())
+
+typedef struct _GskPathPoint GskPathPoint;
+struct _GskPathPoint {
+  /*< private >*/
+  union {
+    float f[8];
+    gpointer p[8];
+  } data;
+};
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_path_point_get_type        (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_4_14
+GskPathPoint *          gsk_path_point_copy            (GskPathPoint     *point);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_point_free            (GskPathPoint     *point);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_point_get_position    (GskPathPoint     *point,
+                                                        graphene_point_t *position);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_path_point_get_tangent     (GskPathPoint     *point,
+                                                        GskPathDirection  direction,
+                                                        graphene_vec2_t  *tangent);
+
+GDK_AVAILABLE_IN_4_14
+float                   gsk_path_point_get_curvature   (GskPathPoint     *point,
+                                                        graphene_point_t *center);
+
+G_END_DECLS

gsk/gskpathpointprivate.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "gskpathpoint.h"
+#include "gskcontourprivate.h"
+
+G_BEGIN_DECLS
+
+struct _GskRealPathPoint
+{
+  GskPath *path;
+  const GskContour *contour;
+
+  union {
+    struct {
+      unsigned int idx;
+      float t;
+    } std;
+    struct {
+      float distance;
+    } rect;
+    struct {
+      float angle;
+    } circle;
+  } data;
+};
+
+GskPath          * gsk_path_point_get_path     (GskPathPoint     *self);
+const GskContour * gsk_path_point_get_contour  (GskPathPoint     *self);
+float              gsk_path_point_get_distance (GskPathPoint     *self,
+                                                gpointer          measure_data);
+
+G_END_DECLS
+

gsk/gskpathprivate.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#pragma once
+
+#include "gskpath.h"
+
+#include "gskpathopprivate.h"
+
+G_BEGIN_DECLS
+
+typedef enum
+{
+  GSK_PATH_FLAT,
+  GSK_PATH_CLOSED
+} GskPathFlags;
+
+typedef struct _GskContour GskContour;
+typedef struct _GskRealPathPoint GskRealPathPoint;
+
+/* Same as Skia, so looks like a good value. ¯\_(ツ)_/¯ */
+#define GSK_PATH_TOLERANCE_DEFAULT (0.5)
+
+GskPath *               gsk_path_new_from_contours              (const GSList           *contours);
+
+gsize                   gsk_path_get_n_contours                 (GskPath                *path);
+const GskContour *      gsk_path_get_contour                    (GskPath                *path,
+                                                                 gsize                   i);
+
+GskPathFlags            gsk_path_get_flags                      (GskPath                *self);
+
+gboolean                gsk_path_foreach_with_tolerance         (GskPath                *self,
+                                                                 GskPathForeachFlags     flags,
+                                                                 double                  tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+
+void                    gsk_path_builder_add_contour            (GskPathBuilder         *builder,
+                                                                 GskContour             *contour);
+
+void                    gsk_path_builder_svg_arc_to             (GskPathBuilder         *builder,
+                                                                 float                   rx,
+                                                                 float                   ry,
+                                                                 float                   x_axis_rotation,
+                                                                 gboolean                large_arc,
+                                                                 gboolean                positive_sweep,
+                                                                 float                   x,
+                                                                 float                   y);
+
+gboolean                gsk_path_get_stroke_bounds              (GskPath                *self,
+                                                                 const GskStroke        *stroke,
+                                                                 graphene_rect_t        *bounds);
+
+G_END_DECLS
+

gsk/gskpointprivate.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <graphene.h>
+
+static inline void G_GNUC_PURE
+gsk_point_interpolate (const graphene_point_t *p1,
+                       const graphene_point_t *p2,
+                       float t,
+                       graphene_point_t *p)
+{
+  p->x = p1->x * (1 - t) + p2->x * t;
+  p->Y = p1->y * (1 - t) + p2->y * t;
+}
+
+static inline float G_GNUC_PURE
+gsk_point_distance (const graphene_point_t *p1,
+                    const graphene_point_t *p2)
+{
+  return sqrtf ((p1->x - p2->x)*(p1->x - p2->x) + (p1->y - p2->y)*(p1->y - p2->y));
+}

gsk/gskrendernode.h

@@ -158,6 +158,8 @@ GskRenderNode *         gsk_render_node_deserialize             (GBytes
 #define GSK_TYPE_REPEAT_NODE                    (gsk_repeat_node_get_type())
 #define GSK_TYPE_CLIP_NODE                      (gsk_clip_node_get_type())
 #define GSK_TYPE_ROUNDED_CLIP_NODE              (gsk_rounded_clip_node_get_type())
+#define GSK_TYPE_FILL_NODE                      (gsk_fill_node_get_type())
+#define GSK_TYPE_STROKE_NODE                    (gsk_stroke_node_get_type())
 #define GSK_TYPE_SHADOW_NODE                    (gsk_shadow_node_get_type())
 #define GSK_TYPE_BLEND_NODE                     (gsk_blend_node_get_type())
 #define GSK_TYPE_CROSS_FADE_NODE                (gsk_cross_fade_node_get_type())
@@ -186,6 +188,8 @@ typedef struct _GskColorMatrixNode              GskColorMatrixNode;
 typedef struct _GskRepeatNode                   GskRepeatNode;
 typedef struct _GskClipNode                     GskClipNode;
 typedef struct _GskRoundedClipNode              GskRoundedClipNode;
+typedef struct _GskFillNode                     GskFillNode;
+typedef struct _GskStrokeNode                   GskStrokeNode;
 typedef struct _GskShadowNode                   GskShadowNode;
 typedef struct _GskBlendNode                    GskBlendNode;
 typedef struct _GskCrossFadeNode                GskCrossFadeNode;
@@ -459,6 +463,32 @@ GskRenderNode *         gsk_rounded_clip_node_get_child         (const GskRender
 GDK_AVAILABLE_IN_ALL
 const GskRoundedRect *  gsk_rounded_clip_node_get_clip          (const GskRenderNode      *node) G_GNUC_PURE;
 
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_fill_node_get_type                  (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_4_14
+GskRenderNode *         gsk_fill_node_new                       (GskRenderNode            *child,
+                                                                 GskPath                  *path,
+                                                                 GskFillRule               fill_rule);
+GDK_AVAILABLE_IN_4_14
+GskRenderNode *         gsk_fill_node_get_child                 (const GskRenderNode      *node);
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_fill_node_get_path                  (const GskRenderNode      *node);
+GDK_AVAILABLE_IN_4_14
+GskFillRule             gsk_fill_node_get_fill_rule             (const GskRenderNode      *node);
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_stroke_node_get_type                (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_4_14
+GskRenderNode *         gsk_stroke_node_new                     (GskRenderNode            *child,
+                                                                 GskPath                  *path,
+                                                                 const GskStroke          *stroke);
+GDK_AVAILABLE_IN_4_14
+GskRenderNode *         gsk_stroke_node_get_child               (const GskRenderNode      *node);
+GDK_AVAILABLE_IN_4_14
+GskPath *               gsk_stroke_node_get_path                (const GskRenderNode      *node);
+GDK_AVAILABLE_IN_4_14
+const GskStroke *       gsk_stroke_node_get_stroke              (const GskRenderNode      *node);
+
 GDK_AVAILABLE_IN_ALL
 GType                   gsk_shadow_node_get_type                (void) G_GNUC_CONST;
 GDK_AVAILABLE_IN_ALL

gsk/gskrendernodeimpl.c

@@ -25,8 +25,10 @@
 #include "gskdebugprivate.h"
 #include "gskdiffprivate.h"
 #include "gl/gskglrenderer.h"
+#include "gskpathprivate.h"
 #include "gskrendererprivate.h"
 #include "gskroundedrectprivate.h"
+#include "gskstrokeprivate.h"
 #include "gsktransformprivate.h"
 
 #include "gdk/gdktextureprivate.h"
@@ -245,13 +247,6 @@ gsk_linear_gradient_node_draw (GskRenderNode *node,
   if (gsk_render_node_get_node_type (node) == GSK_REPEATING_LINEAR_GRADIENT_NODE)
     cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
 
-  if (self->stops[0].offset > 0.0)
-    cairo_pattern_add_color_stop_rgba (pattern,
-                                       0.0,
-                                       self->stops[0].color.red,
-                                       self->stops[0].color.green,
-                                       self->stops[0].color.blue,
-                                       self->stops[0].color.alpha);
   for (i = 0; i < self->n_stops; i++)
     {
       cairo_pattern_add_color_stop_rgba (pattern,
@@ -261,13 +256,6 @@ gsk_linear_gradient_node_draw (GskRenderNode *node,
                                          self->stops[i].color.blue,
                                          self->stops[i].color.alpha);
     }
-  if (self->stops[self->n_stops-1].offset < 1.0)
-    cairo_pattern_add_color_stop_rgba (pattern,
-                                       1.0,
-                                       self->stops[self->n_stops-1].color.red,
-                                       self->stops[self->n_stops-1].color.green,
-                                       self->stops[self->n_stops-1].color.blue,
-                                       self->stops[self->n_stops-1].color.alpha);
 
   cairo_set_source (cr, pattern);
   cairo_pattern_destroy (pattern);
@@ -573,29 +561,13 @@ gsk_radial_gradient_node_draw (GskRenderNode *node,
   else
     cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
 
-  if (self->stops[0].offset > 0.0)
-    cairo_pattern_add_color_stop_rgba (pattern,
-                                       0.0,
-                                       self->stops[0].color.red,
-                                       self->stops[0].color.green,
-                                       self->stops[0].color.blue,
-                                       self->stops[0].color.alpha);
   for (i = 0; i < self->n_stops; i++)
-    {
-      cairo_pattern_add_color_stop_rgba (pattern,
-                                         self->stops[i].offset,
-                                         self->stops[i].color.red,
-                                         self->stops[i].color.green,
-                                         self->stops[i].color.blue,
-                                         self->stops[i].color.alpha);
-    }
-  if (self->stops[self->n_stops-1].offset < 1.0)
     cairo_pattern_add_color_stop_rgba (pattern,
-                                       1.0,
-                                       self->stops[self->n_stops-1].color.red,
-                                       self->stops[self->n_stops-1].color.green,
-                                       self->stops[self->n_stops-1].color.blue,
-                                       self->stops[self->n_stops-1].color.alpha);
+                                       self->stops[i].offset,
+                                       self->stops[i].color.red,
+                                       self->stops[i].color.green,
+                                       self->stops[i].color.blue,
+                                       self->stops[i].color.alpha);
 
   gsk_cairo_rectangle (cr, &node->bounds);
   cairo_translate (cr, self->center.x, self->center.y);
@@ -3868,12 +3840,11 @@ gsk_color_matrix_node_class_init (gpointer g_class,
  * Creates a `GskRenderNode` that will drawn the @child with
  * @color_matrix.
  *
- * In particular, the node will transform colors by applying
+ * In particular, the node will transform the operation
  *
- *     pixel = transpose(color_matrix) * pixel + color_offset
+ *     pixel = color_matrix * pixel + color_offset
  *
- * for every pixel. The transformation operates on unpremultiplied
- * colors, with color components ordered R, G, B, A.
+ * for every pixel.
  *
  * Returns: (transfer full) (type GskColorMatrixNode): A new `GskRenderNode`
  */
@@ -4397,6 +4368,387 @@ gsk_rounded_clip_node_get_clip (const GskRenderNode *node)
   return &self->clip;
 }
 
+/* }}} */
+/* {{{ GSK_FILL_NODE */
+
+struct _GskFillNode
+{
+  GskRenderNode render_node;
+
+  GskRenderNode *child;
+  GskPath *path;
+  GskFillRule fill_rule;
+};
+
+static void
+gsk_fill_node_finalize (GskRenderNode *node)
+{
+  GskFillNode *self = (GskFillNode *) node;
+  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_FILL_NODE));
+
+  gsk_render_node_unref (self->child);
+  gsk_path_unref (self->path);
+
+  parent_class->finalize (node);
+}
+
+static void
+gsk_fill_node_draw (GskRenderNode *node,
+                    cairo_t       *cr)
+{
+  GskFillNode *self = (GskFillNode *) node;
+
+  cairo_save (cr);
+
+  switch (self->fill_rule)
+  {
+    case GSK_FILL_RULE_WINDING:
+      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);
+      break;
+    case GSK_FILL_RULE_EVEN_ODD:
+      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+  gsk_path_to_cairo (self->path, cr);
+  cairo_clip (cr);
+
+  gsk_render_node_draw (self->child, cr);
+
+  cairo_restore (cr);
+}
+
+static void
+gsk_fill_node_diff (GskRenderNode  *node1,
+                    GskRenderNode  *node2,
+                    cairo_region_t *region)
+{
+  GskFillNode *self1 = (GskFillNode *) node1;
+  GskFillNode *self2 = (GskFillNode *) node2;
+
+  if (self1->path == self2->path)
+    {
+      cairo_region_t *sub;
+      cairo_rectangle_int_t clip_rect;
+      graphene_rect_t rect;
+
+      sub = cairo_region_create();
+      gsk_render_node_diff (self1->child, self2->child, sub);
+      graphene_rect_union (&node1->bounds, &node2->bounds, &rect);
+      rectangle_init_from_graphene (&clip_rect, &rect);
+      cairo_region_intersect_rectangle (sub, &clip_rect);
+      cairo_region_union (region, sub);
+      cairo_region_destroy (sub);
+    }
+  else
+    {
+      gsk_render_node_diff_impossible (node1, node2, region);
+    }
+}
+
+static void
+gsk_fill_node_class_init (gpointer g_class,
+                          gpointer class_data)
+{
+  GskRenderNodeClass *node_class = g_class;
+
+  node_class->node_type = GSK_FILL_NODE;
+
+  node_class->finalize = gsk_fill_node_finalize;
+  node_class->draw = gsk_fill_node_draw;
+  node_class->diff = gsk_fill_node_diff;
+}
+
+/**
+ * gsk_fill_node_new:
+ * @child: The node to fill the area with
+ * @path: The path describing the area to fill
+ * @fill_rule: The fill rule to use
+ *
+ * Creates a `GskRenderNode` that will fill the @child in the area
+ * given by @path and @fill_rule.
+ *
+ * Returns: (transfer none) (type GskFillNode): A new `GskRenderNode`
+ *
+ * Since: 4.14
+ */
+GskRenderNode *
+gsk_fill_node_new (GskRenderNode *child,
+                   GskPath       *path,
+                   GskFillRule    fill_rule)
+{
+  GskFillNode *self;
+  GskRenderNode *node;
+  graphene_rect_t path_bounds;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
+  g_return_val_if_fail (path != NULL, NULL);
+
+  self = gsk_render_node_alloc (GSK_FILL_NODE);
+  node = (GskRenderNode *) self;
+
+  self->child = gsk_render_node_ref (child);
+  self->path = gsk_path_ref (path);
+  self->fill_rule = fill_rule;
+
+  if (gsk_path_get_bounds (path, &path_bounds))
+    graphene_rect_intersection (&path_bounds, &child->bounds, &node->bounds);
+  else
+    graphene_rect_init_from_rect (&node->bounds, graphene_rect_zero ());
+
+  return node;
+}
+
+/**
+ * gsk_fill_node_get_child:
+ * @node: (type GskFillNode): a fill `GskRenderNode`
+ *
+ * Gets the child node that is getting drawn by the given @node.
+ *
+ * Returns: (transfer none): The child that is getting drawn
+ *
+ * Since: 4.14
+ */
+GskRenderNode *
+gsk_fill_node_get_child (const GskRenderNode *node)
+{
+  const GskFillNode *self = (const GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
+
+  return self->child;
+}
+
+/**
+ * gsk_fill_node_get_path:
+ * @node: (type GskFillNode): a fill `GskRenderNode`
+ *
+ * Retrieves the path used to describe the area filled with the contents of
+ * the @node.
+ *
+ * Returns: (transfer none): a `GskPath`
+ *
+ * Since: 4.14
+ */
+GskPath *
+gsk_fill_node_get_path (const GskRenderNode *node)
+{
+  const GskFillNode *self = (const GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
+
+  return self->path;
+}
+
+/**
+ * gsk_fill_node_get_fill_rule:
+ * @node: (type GskFillNode): a fill `GskRenderNode`
+ *
+ * Retrieves the fill rule used to determine how the path is filled.
+ *
+ * Returns: a `GskFillRule`
+ *
+ * Since: 4.14
+ */
+GskFillRule
+gsk_fill_node_get_fill_rule (const GskRenderNode *node)
+{
+  const GskFillNode *self = (const GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), GSK_FILL_RULE_WINDING);
+
+  return self->fill_rule;
+}
+
+/* }}} */
+/* {{{ GSK_STROKE_NODE */
+
+struct _GskStrokeNode
+{
+  GskRenderNode render_node;
+
+  GskRenderNode *child;
+  GskPath *path;
+  GskStroke stroke;
+};
+
+static void
+gsk_stroke_node_finalize (GskRenderNode *node)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_STROKE_NODE));
+
+  gsk_render_node_unref (self->child);
+  gsk_path_unref (self->path);
+  gsk_stroke_clear (&self->stroke);
+
+  parent_class->finalize (node);
+}
+
+static void
+gsk_stroke_node_draw (GskRenderNode *node,
+                      cairo_t       *cr)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+
+  cairo_save (cr);
+
+  gsk_cairo_rectangle (cr, &self->child->bounds);
+  cairo_clip (cr);
+
+  cairo_push_group (cr);
+  gsk_render_node_draw (self->child, cr);
+  cairo_pop_group_to_source (cr);
+
+  gsk_stroke_to_cairo (&self->stroke, cr);
+
+  gsk_path_to_cairo (self->path, cr);
+  cairo_stroke (cr);
+
+  cairo_restore (cr);
+}
+
+static void
+gsk_stroke_node_diff (GskRenderNode  *node1,
+                      GskRenderNode  *node2,
+                      cairo_region_t *region)
+{
+  GskStrokeNode *self1 = (GskStrokeNode *) node1;
+  GskStrokeNode *self2 = (GskStrokeNode *) node2;
+
+  if (self1->path == self2->path &&
+      gsk_stroke_equal (&self1->stroke, &self2->stroke))
+    {
+      cairo_region_t *sub;
+
+      sub = cairo_region_create();
+      gsk_render_node_diff (self1->child, self2->child, sub);
+      cairo_region_union (region, sub);
+      cairo_region_destroy (sub);
+    }
+  else
+    {
+      gsk_render_node_diff_impossible (node1, node2, region);
+    }
+}
+
+static void
+gsk_stroke_node_class_init (gpointer g_class,
+                            gpointer class_data)
+{
+  GskRenderNodeClass *node_class = g_class;
+
+  node_class->node_type = GSK_STROKE_NODE;
+
+  node_class->finalize = gsk_stroke_node_finalize;
+  node_class->draw = gsk_stroke_node_draw;
+  node_class->diff = gsk_stroke_node_diff;
+}
+
+/**
+ * gsk_stroke_node_new:
+ * @child: The node to stroke the area with
+ * @path: (transfer none): The path describing the area to stroke
+ * @stroke: (transfer none): The stroke attributes to use
+ *
+ * Creates a #GskRenderNode that will stroke the @child along the given
+ * @path using the attributes defined in @stroke.
+ *
+ * Returns: (transfer none) (type GskStrokeNode): A new #GskRenderNode
+ *
+ * Since: 4.14
+ */
+GskRenderNode *
+gsk_stroke_node_new (GskRenderNode   *child,
+                     GskPath         *path,
+                     const GskStroke *stroke)
+{
+  GskStrokeNode *self;
+  GskRenderNode *node;
+  graphene_rect_t stroke_bounds;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
+  g_return_val_if_fail (path != NULL, NULL);
+  g_return_val_if_fail (stroke != NULL, NULL);
+
+  self = gsk_render_node_alloc (GSK_STROKE_NODE);
+  node = (GskRenderNode *) self;
+
+  self->child = gsk_render_node_ref (child);
+  self->path = gsk_path_ref (path);
+  gsk_stroke_init_copy (&self->stroke, stroke);
+
+  if (gsk_path_get_stroke_bounds (self->path, &self->stroke, &stroke_bounds))
+    graphene_rect_intersection (&stroke_bounds, &child->bounds, &node->bounds);
+  else
+    graphene_rect_init_from_rect (&node->bounds, graphene_rect_zero ());
+
+  return node;
+}
+
+/**
+ * gsk_stroke_node_get_child:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Gets the child node that is getting drawn by the given @node.
+ *
+ * Returns: (transfer none): The child that is getting drawn
+ *
+ * Since: 4.14
+ */
+GskRenderNode *
+gsk_stroke_node_get_child (const GskRenderNode *node)
+{
+  const GskStrokeNode *self = (const GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return self->child;
+}
+
+/**
+ * gsk_stroke_node_get_path:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Retrieves the path that will be stroked with the contents of
+ * the @node.
+ *
+ * Returns: (transfer none): a #GskPath
+ *
+ * Since: 4.14
+ */
+GskPath *
+gsk_stroke_node_get_path (const GskRenderNode *node)
+{
+  const GskStrokeNode *self = (const GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return self->path;
+}
+
+/**
+ * gsk_stroke_node_get_stroke:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Retrieves the stroke attributes used in this @node.
+ *
+ * Returns: a #GskStroke
+ *
+ * Since: 4.14
+ */
+const GskStroke *
+gsk_stroke_node_get_stroke (const GskRenderNode *node)
+{
+  const GskStrokeNode *self = (const GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return &self->stroke;
+}
+
 /* }}} */
 /* {{{ GSK_SHADOW_NODE */
 
@@ -4432,8 +4784,18 @@ gsk_shadow_node_draw (GskRenderNode *node,
                       cairo_t       *cr)
 {
   GskShadowNode *self = (GskShadowNode *) node;
+  cairo_pattern_t *pattern;
   gsize i;
 
+  cairo_save (cr);
+  /* clip so the push_group() creates a small surface */
+  gsk_cairo_rectangle (cr, &self->child->bounds);
+  cairo_clip (cr);
+  cairo_push_group (cr);
+  gsk_render_node_draw (self->child, cr);
+  pattern = cairo_pop_group (cr);
+  cairo_restore (cr);
+
   cairo_save (cr);
   /* clip so the blur area stays small */
   gsk_cairo_rectangle (cr, &node->bounds);
@@ -4442,31 +4804,27 @@ gsk_shadow_node_draw (GskRenderNode *node,
   for (i = 0; i < self->n_shadows; i++)
     {
       GskShadow *shadow = &self->shadows[i];
-      cairo_pattern_t *pattern;
 
       /* We don't need to draw invisible shadows */
       if (gdk_rgba_is_clear (&shadow->color))
         continue;
 
       cairo_save (cr);
+      gdk_cairo_set_source_rgba (cr, &shadow->color);
       cr = gsk_cairo_blur_start_drawing (cr, shadow->radius, GSK_BLUR_X | GSK_BLUR_Y);
 
-      cairo_save (cr);
       cairo_translate (cr, shadow->dx, shadow->dy);
-      cairo_push_group (cr);
-      gsk_render_node_draw (self->child, cr);
-      pattern = cairo_pop_group (cr);
-      gdk_cairo_set_source_rgba (cr, &shadow->color);
       cairo_mask (cr, pattern);
-      cairo_restore (cr);
 
       cr = gsk_cairo_blur_finish_drawing (cr, shadow->radius, &shadow->color, GSK_BLUR_X | GSK_BLUR_Y);
       cairo_restore (cr);
     }
 
-  gsk_render_node_draw (self->child, cr);
-
+  cairo_set_source (cr, pattern);
+  cairo_paint (cr);
   cairo_restore (cr);
+
+  cairo_pattern_destroy (pattern);
 }
 
 static void
@@ -4587,7 +4945,7 @@ gsk_shadow_node_new (GskRenderNode   *child,
 
   self = gsk_render_node_alloc (GSK_SHADOW_NODE);
   node = (GskRenderNode *) self;
-  node->offscreen_for_opacity = TRUE;
+  node->offscreen_for_opacity = child->offscreen_for_opacity;
 
   self->child = gsk_render_node_ref (child);
   self->n_shadows = n_shadows;
@@ -6284,6 +6642,8 @@ GSK_DEFINE_RENDER_NODE_TYPE (gsk_color_matrix_node, GSK_COLOR_MATRIX_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_repeat_node, GSK_REPEAT_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_clip_node, GSK_CLIP_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_rounded_clip_node, GSK_ROUNDED_CLIP_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_fill_node, GSK_FILL_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_stroke_node, GSK_STROKE_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_shadow_node, GSK_SHADOW_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_blend_node, GSK_BLEND_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_cross_fade_node, GSK_CROSS_FADE_NODE)
@@ -6432,6 +6792,16 @@ gsk_render_node_init_types_once (void)
                                                     sizeof (GskDebugNode),
                                                     gsk_debug_node_class_init);
   gsk_render_node_types[GSK_DEBUG_NODE] = node_type;
+
+  node_type = gsk_render_node_type_register_static (I_("GskFillNode"),
+                                                    sizeof (GskFillNode),
+                                                    gsk_fill_node_class_init);
+  gsk_render_node_types[GSK_FILL_NODE] = node_type;
+
+  node_type = gsk_render_node_type_register_static (I_("GskStrokeNode"),
+                                                    sizeof (GskStrokeNode),
+                                                    gsk_stroke_node_class_init);
+  gsk_render_node_types[GSK_STROKE_NODE] = node_type;
 }
 
 static void

gsk/gskrendernodeparser.c

@@ -23,8 +23,10 @@
 
 #include "gskrendernodeparserprivate.h"
 
+#include "gskpath.h"
 #include "gskroundedrectprivate.h"
 #include "gskrendernodeprivate.h"
+#include "gskstroke.h"
 #include "gsktransformprivate.h"
 
 #include "gdk/gdkrgbaprivate.h"
@@ -2433,6 +2435,14 @@ printer_init_duplicates_for_node (Printer       *printer,
       printer_init_duplicates_for_node (printer, gsk_debug_node_get_child (node));
       break;
 
+    case GSK_FILL_NODE:
+      printer_init_duplicates_for_node (printer, gsk_fill_node_get_child (node));
+      break;
+
+    case GSK_STROKE_NODE:
+      printer_init_duplicates_for_node (printer, gsk_stroke_node_get_child (node));
+      break;
+
     case GSK_BLEND_NODE:
       printer_init_duplicates_for_node (printer, gsk_blend_node_get_bottom_child (node));
       printer_init_duplicates_for_node (printer, gsk_blend_node_get_top_child (node));
@@ -2658,7 +2668,7 @@ append_float_param (Printer    *p,
                     float       value,
                     float       default_value)
 {
-  /* Don't approximate-compare here, better be topo verbose */
+  /* Don't approximate-compare here, better be too verbose */
   if (value == default_value)
     return;
 
@@ -3019,7 +3029,7 @@ gsk_text_node_serialize_glyphs (GskRenderNode *node,
           string_append_double (p, (double) glyphs[i].geometry.y_offset / PANGO_SCALE);
           if (!glyphs[i].attr.is_cluster_start)
             g_string_append (p, " same-cluster");
-          if (glyphs[i].attr.is_color)
+          if (!glyphs[i].attr.is_color)
             g_string_append (p, " color");
         }
 
@@ -3204,6 +3214,39 @@ render_node_print (Printer       *p,
         append_rounded_rect_param (p, "clip", gsk_rounded_clip_node_get_clip (node));
         append_node_param (p, "child", gsk_rounded_clip_node_get_child (node));
 
+        end_node (p);
+      }
+      break;
+
+    case GSK_FILL_NODE:
+      {
+        char *path_str;
+
+        start_node (p, "fill", node_name);
+
+        append_node_param (p, "child", gsk_fill_node_get_child (node));
+        path_str = gsk_path_to_string (gsk_fill_node_get_path (node));
+        append_string_param (p, "path", path_str);
+        g_free (path_str);
+
+        end_node (p);
+      }
+      break;
+
+    case GSK_STROKE_NODE:
+      {
+        const GskStroke *stroke;
+        char *path_str;
+
+        start_node (p, "stroke", node_name);
+
+        append_node_param (p, "child", gsk_stroke_node_get_child (node));
+        path_str = gsk_path_to_string (gsk_stroke_node_get_path (node));
+        append_string_param (p, "path", path_str);
+        g_free (path_str);
+
+        stroke = gsk_stroke_node_get_stroke (node);
+        append_float_param (p, "line-width", gsk_stroke_get_line_width (stroke), 0.0);
 
         end_node (p);
       }

gsk/gskspline.c

@@ -0,0 +1,208 @@
+/*
+ * Copyright © 2002 University of Southern California
+ *             2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ *          Carl D. Worth <cworth@cworth.org>
+ */
+
+#include "config.h"
+
+#include "gsksplineprivate.h"
+
+#include <math.h>
+
+/* Spline deviation from the circle in radius would be given by:
+
+        error = sqrt (x**2 + y**2) - 1
+
+   A simpler error function to work with is:
+
+        e = x**2 + y**2 - 1
+
+   From "Good approximation of circles by curvature-continuous Bezier
+   curves", Tor Dokken and Morten Daehlen, Computer Aided Geometric
+   Design 8 (1990) 22-41, we learn:
+
+        abs (max(e)) = 4/27 * sin**6(angle/4) / cos**2(angle/4)
+
+   and
+        abs (error) =~ 1/2 * e
+
+   Of course, this error value applies only for the particular spline
+   approximation that is used in _cairo_gstate_arc_segment.
+*/
+static float
+arc_error_normalized (float angle)
+{
+  return 2.0/27.0 * pow (sin (angle / 4), 6) / pow (cos (angle / 4), 2);
+}
+
+static float
+arc_max_angle_for_tolerance_normalized (float tolerance)
+{
+  float angle, error;
+  guint i;
+
+  /* Use table lookup to reduce search time in most cases. */
+  struct {
+    float angle;
+    float error;
+  } table[] = {
+    { G_PI / 1.0,   0.0185185185185185036127 },
+    { G_PI / 2.0,   0.000272567143730179811158 },
+    { G_PI / 3.0,   2.38647043651461047433e-05 },
+    { G_PI / 4.0,   4.2455377443222443279e-06 },
+    { G_PI / 5.0,   1.11281001494389081528e-06 },
+    { G_PI / 6.0,   3.72662000942734705475e-07 },
+    { G_PI / 7.0,   1.47783685574284411325e-07 },
+    { G_PI / 8.0,   6.63240432022601149057e-08 },
+    { G_PI / 9.0,   3.2715520137536980553e-08 },
+    { G_PI / 10.0,  1.73863223499021216974e-08 },
+    { G_PI / 11.0,  9.81410988043554039085e-09 },
+  };
+
+  for (i = 0; i < G_N_ELEMENTS (table); i++)
+    {
+      if (table[i].error < tolerance)
+        return table[i].angle;
+    }
+
+  i++;
+  do {
+    angle = G_PI / i++;
+    error = arc_error_normalized (angle);
+  } while (error > tolerance);
+
+  return angle;
+}
+
+static guint
+arc_segments_needed (float angle,
+                     float radius,
+                     float tolerance)
+{
+  float max_angle;
+
+  /* the error is amplified by at most the length of the
+   * major axis of the circle; see cairo-pen.c for a more detailed analysis
+   * of this. */
+  max_angle = arc_max_angle_for_tolerance_normalized (tolerance / radius);
+
+  return ceil (fabs (angle) / max_angle);
+}
+
+/* We want to draw a single spline approximating a circular arc radius
+   R from angle A to angle B. Since we want a symmetric spline that
+   matches the endpoints of the arc in position and slope, we know
+   that the spline control points must be:
+
+        (R * cos(A), R * sin(A))
+        (R * cos(A) - h * sin(A), R * sin(A) + h * cos (A))
+        (R * cos(B) + h * sin(B), R * sin(B) - h * cos (B))
+        (R * cos(B), R * sin(B))
+
+   for some value of h.
+
+   "Approximation of circular arcs by cubic polynomials", Michael
+   Goldapp, Computer Aided Geometric Design 8 (1991) 227-238, provides
+   various values of h along with error analysis for each.
+
+   From that paper, a very practical value of h is:
+
+        h = 4/3 * R * tan(angle/4)
+
+   This value does not give the spline with minimal error, but it does
+   provide a very good approximation, (6th-order convergence), and the
+   error expression is quite simple, (see the comment for
+   _arc_error_normalized).
+*/
+static gboolean
+gsk_spline_decompose_arc_segment (const graphene_point_t *center,
+                                  float                   radius,
+                                  float                   angle_A,
+                                  float                   angle_B,
+                                  GskSplineAddCurveFunc   curve_func,
+                                  gpointer                user_data)
+{
+  float r_sin_A, r_cos_A;
+  float r_sin_B, r_cos_B;
+  float h;
+
+  r_sin_A = radius * sin (angle_A);
+  r_cos_A = radius * cos (angle_A);
+  r_sin_B = radius * sin (angle_B);
+  r_cos_B = radius * cos (angle_B);
+
+  h = 4.0/3.0 * tan ((angle_B - angle_A) / 4.0);
+
+  return curve_func ((graphene_point_t[4]) {
+                       GRAPHENE_POINT_INIT (
+                         center->x + r_cos_A,
+                         center->y + r_sin_A
+                       ),
+                       GRAPHENE_POINT_INIT (
+                         center->x + r_cos_A - h * r_sin_A,
+                         center->y + r_sin_A + h * r_cos_A
+                       ),
+                       GRAPHENE_POINT_INIT (
+                         center->x + r_cos_B + h * r_sin_B,
+                         center->y + r_sin_B - h * r_cos_B
+                       ),
+                       GRAPHENE_POINT_INIT (
+                         center->x + r_cos_B,
+                         center->y + r_sin_B
+                       )
+                     },
+                     user_data);
+}
+
+gboolean
+gsk_spline_decompose_arc (const graphene_point_t *center,
+                          float                   radius,
+                          float                   tolerance,
+                          float                   start_angle,
+                          float                   end_angle,
+                          GskSplineAddCurveFunc   curve_func,
+                          gpointer                user_data)
+{
+  float step = start_angle - end_angle;
+  guint i, n_segments;
+
+  /* Recurse if drawing arc larger than pi */
+  if (ABS (step) > G_PI)
+    {
+      float mid_angle = (start_angle + end_angle) / 2.0;
+
+      return gsk_spline_decompose_arc (center, radius, tolerance, start_angle, mid_angle, curve_func, user_data)
+          && gsk_spline_decompose_arc (center, radius, tolerance, mid_angle, end_angle, curve_func, user_data);
+    }
+  else if (ABS (step) < tolerance)
+    {
+      return gsk_spline_decompose_arc_segment (center, radius, start_angle, end_angle, curve_func, user_data);
+    }
+
+  n_segments = arc_segments_needed (ABS (step), radius, tolerance);
+  step = (end_angle - start_angle) / n_segments;
+
+  for (i = 0; i < n_segments - 1; i++, start_angle += step)
+    {
+      if (!gsk_spline_decompose_arc_segment (center, radius, start_angle, start_angle + step, curve_func, user_data))
+        return FALSE;
+    }
+  return gsk_spline_decompose_arc_segment (center, radius, start_angle, end_angle, curve_func, user_data);
+}
+

gsk/gsksplineprivate.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#ifndef __GSK_SPLINE_PRIVATE_H__
+#define __GSK_SPLINE_PRIVATE_H__
+
+#include "gskpath.h"
+
+G_BEGIN_DECLS
+
+typedef gboolean (* GskSplineAddCurveFunc) (const graphene_point_t curve[4],
+                                            gpointer               user_data);
+gboolean                gsk_spline_decompose_arc                (const graphene_point_t *center,
+                                                                 float                   radius,
+                                                                 float                   tolerance,
+                                                                 float                   start_angle,
+                                                                 float                   end_angle,
+                                                                 GskSplineAddCurveFunc   curve_func,
+                                                                 gpointer                user_data);
+
+G_END_DECLS
+
+#endif /* __GSK_SPLINE_PRIVATE_H__ */
+

gsk/gskstroke.c

@@ -0,0 +1,479 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gskstrokeprivate.h"
+
+/**
+ * GskStroke:
+ *
+ * A `GskStroke` struct collects the parameters that influence
+ * the operation of stroking a path.
+ */
+
+G_DEFINE_BOXED_TYPE (GskStroke, gsk_stroke, gsk_stroke_copy, gsk_stroke_free)
+
+
+/**
+ * gsk_stroke_new:
+ * @line_width: line width of the stroke. Must be > 0
+ *
+ * Creates a new `GskStroke` with the given @line_width.
+ *
+ * Returns: a new `GskStroke`
+ *
+ * Since: 4.14
+ */
+GskStroke *
+gsk_stroke_new (float line_width)
+{
+  GskStroke *self;
+
+  g_return_val_if_fail (line_width > 0, NULL);
+
+  self = g_new0 (GskStroke, 1);
+
+  self->line_width = line_width;
+  self->line_cap = GSK_LINE_CAP_BUTT;
+  self->line_join = GSK_LINE_JOIN_MITER;
+  self->miter_limit = 4.f; /* following svg */
+
+  return self;
+}
+
+/**
+ * gsk_stroke_copy:
+ * @other: `GskStroke` to copy
+ *
+ * Creates a copy of the given @other stroke.
+ *
+ * Returns: a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it
+ *
+ * Since: 4.14
+ */
+GskStroke *
+gsk_stroke_copy (const GskStroke *other)
+{
+  GskStroke *self;
+
+  g_return_val_if_fail (other != NULL, NULL);
+
+  self = g_new (GskStroke, 1);
+
+  gsk_stroke_init_copy (self, other);
+
+  return self;
+}
+
+/**
+ * gsk_stroke_free:
+ * @self: a `GskStroke`
+ *
+ * Frees a `GskStroke`.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_free (GskStroke *self)
+{
+  if (self == NULL)
+    return;
+
+  gsk_stroke_clear (self);
+
+  g_free (self);
+}
+
+/**
+ * gsk_stroke_to_cairo:
+ * @self: a `GskStroke`
+ * @cr: the cairo context to configure
+ *
+ * A helper function that sets the stroke parameters
+ * of @cr from the values found in @self.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_to_cairo (const GskStroke *self,
+                     cairo_t         *cr)
+{
+  cairo_set_line_width (cr, self->line_width);
+
+  /* gcc can optimize that to a direct case. This catches later additions to the enum */
+  switch (self->line_cap)
+    {
+      case GSK_LINE_CAP_BUTT:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+        break;
+      case GSK_LINE_CAP_ROUND:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+        break;
+      case GSK_LINE_CAP_SQUARE:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+        break;
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  /* gcc can optimize that to a direct case. This catches later additions to the enum */
+  switch (self->line_join)
+    {
+      case GSK_LINE_JOIN_MITER:
+      case GSK_LINE_JOIN_MITER_CLIP:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
+        break;
+      case GSK_LINE_JOIN_ROUND:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+        break;
+      case GSK_LINE_JOIN_BEVEL:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL);
+        break;
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  cairo_set_miter_limit (cr, self->miter_limit);
+
+  if (self->dash_length)
+    {
+      gsize i;
+      double *dash = g_newa (double, self->n_dash);
+
+      for (i = 0; i < self->n_dash; i++)
+        {
+          dash[i] = self->dash[i];
+        }
+      cairo_set_dash (cr, dash, self->n_dash, self->dash_offset);
+    }
+  else
+    cairo_set_dash (cr, NULL, 0, 0.0);
+}
+
+/**
+ * gsk_stroke_equal:
+ * @stroke1: the first `GskStroke`
+ * @stroke2: the second `GskStroke`
+ *
+ * Checks if 2 strokes are identical.
+ *
+ * Returns: `TRUE` if the 2 strokes are equal, `FALSE` otherwise
+ *
+ * Since: 4.14
+ */
+gboolean
+gsk_stroke_equal (gconstpointer stroke1,
+                  gconstpointer stroke2)
+{
+  const GskStroke *self1 = stroke1;
+  const GskStroke *self2 = stroke2;
+
+  return self1->line_width == self2->line_width;
+}
+
+/**
+ * gsk_stroke_set_line_width:
+ * @self: a `GskStroke`
+ * @line_width: width of the line in pixels
+ *
+ * Sets the line width to be used when stroking.
+ *
+ * The line width must be > 0.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_line_width (GskStroke *self,
+                           float      line_width)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (line_width > 0);
+
+  self->line_width = line_width;
+}
+
+/**
+ * gsk_stroke_get_line_width:
+ * @self: a `GskStroke`
+ *
+ * Gets the line width used.
+ *
+ * Returns: The line width
+ *
+ * Since: 4.14
+ */
+float
+gsk_stroke_get_line_width (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_width;
+}
+
+/**
+ * gsk_stroke_set_line_cap:
+ * @self: a`GskStroke`
+ * @line_cap: the `GskLineCap`
+ *
+ * Sets the line cap to be used when stroking.
+ *
+ * See [enum@Gsk.LineCap] for details.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_line_cap (GskStroke  *self,
+                         GskLineCap  line_cap)
+{
+  g_return_if_fail (self != NULL);
+
+  self->line_cap = line_cap;
+}
+
+/**
+ * gsk_stroke_get_line_cap:
+ * @self: a `GskStroke`
+ *
+ * Gets the line cap used.
+ *
+ * See [enum@Gsk.LineCap] for details.
+ *
+ * Returns: The line cap
+ *
+ * Since: 4.14
+ */
+GskLineCap
+gsk_stroke_get_line_cap (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_cap;
+}
+
+/**
+ * gsk_stroke_set_line_join:
+ * @self: a `GskStroke`
+ * @line_join: The line join to use
+ *
+ * Sets the line join to be used when stroking.
+ *
+ * See [enum@Gsk.LineJoin] for details.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_line_join (GskStroke   *self,
+                          GskLineJoin  line_join)
+{
+  g_return_if_fail (self != NULL);
+
+  self->line_join = line_join;
+}
+
+/**
+ * gsk_stroke_get_line_join:
+ * @self: a `GskStroke`
+ *
+ * Gets the line join used.
+ *
+ * See [enum@Gsk.LineJoin] for details.
+ *
+ * Returns: The line join
+ *
+ * Since: 4.14
+ */
+GskLineJoin
+gsk_stroke_get_line_join (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_join;
+}
+
+/**
+ * gsk_stroke_set_miter_limit:
+ * @self: a `GskStroke`
+ * @limit: the miter limit
+ *
+ * Sets the limit for the distance from the corner where sharp
+ * turns of joins get cut off.
+ *
+ * The miter limit is in units of line width and must be non-negative.
+ *
+ * For joins of type `GSK_LINE_JOIN_MITER` that exceed the miter
+ * limit, the join gets rendered as if it was of type
+ * `GSK_LINE_JOIN_BEVEL`. For joins of type `GSK_LINE_JOIN_MITER_CLIP`,
+ * the miter is clipped at a distance of half the miter limit.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_miter_limit (GskStroke  *self,
+                            float       limit)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (limit >= 0);
+
+  self->miter_limit = limit;
+}
+
+/**
+ * gsk_stroke_get_miter_limit:
+ * @self: a `GskStroke`
+ *
+ * Returns the miter limit of a `GskStroke`.
+ *
+ * Since: 4.14
+ */
+float
+gsk_stroke_get_miter_limit (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 4.f);
+
+  return self->miter_limit;
+}
+
+/**
+ * gsk_stroke_set_dash:
+ * @self: a `GskStroke`
+ * @dash: (array length=n_dash) (transfer none) (nullable):
+ *     the array of dashes
+ * @n_dash: number of elements in @dash
+ *
+ * Sets the dash pattern to use by this stroke.
+ *
+ * A dash pattern is specified by an array of alternating non-negative
+ * values. Each value provides the length of alternate "on" and "off"
+ * portions of the stroke.
+ *
+ * Each "on" segment will have caps applied as if the segment were a
+ * separate contour. In particular, it is valid to use an "on" length
+ * of 0 with `GSK_LINE_CAP_ROUND` or `GSK_LINE_CAP_SQUARE` to draw dots
+ * or squares along a path.
+ *
+ * If @n_dash is 0, if all elements in @dash are 0, or if there are
+ * negative values in @dash, then dashing is disabled.
+ *
+ * If @n_dash is 1, an alternating "on" and "off" pattern with the
+ * single dash length provided is assumed.
+ *
+ * If @n_dash is uneven, the dash array will be used with the first
+ * element in @dash defining an "on" or "off" in alternating passes
+ * through the array.
+ *
+ * You can specify a starting offset into the dash with
+ * [method@Gsk.Stroke.set_dash_offset].
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_dash (GskStroke   *self,
+                     const float *dash,
+                     gsize        n_dash)
+{
+  float dash_length;
+  gsize i;
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (dash != NULL || n_dash == 0);
+
+  dash_length = 0;
+  for (i = 0; i < n_dash; i++)
+    {
+      if (!(dash[i] >= 0)) /* should catch NaN */
+        {
+          g_critical ("invalid value in dash array at position %zu", i);
+          return;
+        }
+      dash_length += dash[i];
+    }
+
+  self->dash_length = dash_length;
+  g_free (self->dash);
+  self->dash = g_memdup (dash, sizeof (gfloat) * n_dash);
+  self->n_dash = n_dash;
+
+}
+
+/**
+ * gsk_stroke_get_dash:
+ * @self: a `GskStroke`
+ * @n_dash: (out caller-allocates): number of elements
+ *     in the array returned
+ *
+ * Gets the dash array in use or `NULL` if dashing is disabled.
+ *
+ * Returns: (array length=n_dash) (transfer none) (nullable):
+ *   The dash array or `NULL` if the dash array is empty.
+ *
+ * Since: 4.14
+ */
+const float *
+gsk_stroke_get_dash (const GskStroke *self,
+                     gsize           *n_dash)
+{
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (n_dash != NULL, NULL);
+
+  *n_dash = self->n_dash;
+
+  return self->dash;
+}
+
+/**
+ * gsk_stroke_set_dash_offset:
+ * @self: a `GskStroke`
+ * @offset: offset into the dash pattern
+ *
+ * Sets the offset into the dash pattern where dashing should begin.
+ *
+ * This is an offset into the length of the path, not an index into
+ * the array values of the dash array.
+ *
+ * See [method@Gsk.Stroke.set_dash] for more details on dashing.
+ *
+ * Since: 4.14
+ */
+void
+gsk_stroke_set_dash_offset (GskStroke *self,
+                            float      offset)
+{
+  g_return_if_fail (self != NULL);
+
+  self->dash_offset = offset;
+}
+
+/**
+ * gsk_stroke_get_dash_offset:
+ * @self: a `GskStroke`
+ *
+ * Returns the dash_offset of a `GskStroke`.
+ *
+ * Since: 4.14
+ */
+float
+gsk_stroke_get_dash_offset (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 4.f);
+
+  return self->dash_offset;
+}

gsk/gskstroke.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_STROKE (gsk_stroke_get_type ())
+
+GDK_AVAILABLE_IN_4_14
+GType                   gsk_stroke_get_type                     (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_4_14
+GskStroke *             gsk_stroke_new                          (float                   line_width);
+GDK_AVAILABLE_IN_4_14
+GskStroke *             gsk_stroke_copy                         (const GskStroke        *other);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_free                         (GskStroke              *self);
+
+GDK_AVAILABLE_IN_4_14
+gboolean                gsk_stroke_equal                        (gconstpointer           stroke1,
+                                                                 gconstpointer           stroke2);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_line_width               (GskStroke              *self,
+                                                                 float                   line_width);
+GDK_AVAILABLE_IN_4_14
+float                   gsk_stroke_get_line_width               (const GskStroke        *self);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_line_cap                 (GskStroke              *self,
+                                                                 GskLineCap              line_cap);
+GDK_AVAILABLE_IN_4_14
+GskLineCap              gsk_stroke_get_line_cap                 (const GskStroke        *self);
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_line_join                (GskStroke              *self,
+                                                                 GskLineJoin             line_join);
+GDK_AVAILABLE_IN_4_14
+GskLineJoin             gsk_stroke_get_line_join                (const GskStroke        *self);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_miter_limit              (GskStroke              *self,
+                                                                 float                   limit);
+GDK_AVAILABLE_IN_4_14
+float                   gsk_stroke_get_miter_limit              (const GskStroke        *self);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_dash                     (GskStroke              *self,
+                                                                 const float            *dash,
+                                                                 gsize                   n_dash);
+GDK_AVAILABLE_IN_4_14
+const float *           gsk_stroke_get_dash                     (const GskStroke        *self,
+                                                                 gsize                  *n_dash);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_set_dash_offset              (GskStroke              *self,
+                                                                 float                   offset);
+GDK_AVAILABLE_IN_4_14
+float                   gsk_stroke_get_dash_offset              (const GskStroke        *self);
+
+GDK_AVAILABLE_IN_4_14
+void                    gsk_stroke_to_cairo                     (const GskStroke        *self,
+                                                                 cairo_t                *cr);
+
+
+G_END_DECLS

gsk/gskstrokeprivate.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * 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/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#pragma once
+
+#include "gskstroke.h"
+
+G_BEGIN_DECLS
+
+struct _GskStroke
+{
+  float line_width;
+  GskLineCap line_cap;
+  GskLineJoin line_join;
+  float miter_limit;
+
+  float *dash;
+  gsize n_dash;
+  float dash_length; /* sum of all dashes in the array */
+  float dash_offset;
+};
+
+static inline void
+gsk_stroke_init_copy (GskStroke       *stroke,
+                      const GskStroke *other)
+{
+  *stroke = *other;
+
+  stroke->dash = g_memdup (other->dash, stroke->n_dash * sizeof (float));
+}
+
+static inline void
+gsk_stroke_clear (GskStroke *stroke)
+{
+  g_clear_pointer (&stroke->dash, g_free);
+  stroke->n_dash = 0; /* better safe than sorry */
+}
+
+G_END_DECLS

gsk/gsktransform.c

@@ -857,8 +857,7 @@ normalize_angle (float angle)
  * @next: (nullable) (transfer full): the next transform
  * @angle: the rotation angle, in degrees (clockwise)
  *
- * Rotates @next @angle degrees in 2D - or in 3D-speak, around the Z axis.
- * The rotation happens around the origin point of (0, 0).
+ * Rotates @next @angle degrees in 2D - or in 3D-speak, around the z axis.
  *
  * Returns: (nullable): The new transform
  */

gsk/gsktypes.h

@@ -25,6 +25,11 @@
 #include <gdk/gdk.h>
 #include <gsk/gskenums.h>
 
+typedef struct _GskPath                 GskPath;
+typedef struct _GskPathBuilder          GskPathBuilder;
+typedef struct _GskPathMeasure          GskPathMeasure;
+typedef struct _GskPathPoint            GskPathPoint;
 typedef struct _GskRenderer             GskRenderer;
+typedef struct _GskStroke               GskStroke;
 typedef struct _GskTransform            GskTransform;
 

gsk/meson.build

@@ -23,23 +23,32 @@ gsk_private_gl_shaders = [
 ]
 
 gsk_public_sources = files([
-  'gskdiff.c',
   'gskcairorenderer.c',
+  'gskdiff.c',
   'gskglshader.c',
+  'gskpath.c',
+  'gskpathdash.c',
+  'gskpathbuilder.c',
+  'gskpathmeasure.c',
+  'gskpathpoint.c',
   'gskrenderer.c',
   'gskrendernode.c',
   'gskrendernodeimpl.c',
   'gskrendernodeparser.c',
   'gskroundedrect.c',
+  'gskstroke.c',
   'gsktransform.c',
   'gl/gskglrenderer.c',
 ])
 
 gsk_private_sources = files([
   'gskcairoblur.c',
+  'gskcontour.c',
+  'gskcurve.c',
   'gskdebug.c',
   'gskprivate.c',
   'gskprofiler.c',
+  'gskspline.c',
   'gl/gskglattachmentstate.c',
   'gl/gskglbuffer.c',
   'gl/gskglcommandqueue.c',
@@ -66,9 +75,14 @@ gsk_public_headers = files([
   'gskcairorenderer.h',
   'gskenums.h',
   'gskglshader.h',
+  'gskpath.h',
+  'gskpathbuilder.h',
+  'gskpathmeasure.h',
+  'gskpathpoint.h',
   'gskrenderer.h',
   'gskrendernode.h',
   'gskroundedrect.h',
+  'gskstroke.h',
   'gsktransform.h',
   'gsktypes.h',
 ])
@@ -97,6 +111,10 @@ if have_vulkan
 endif
 
 gsk_private_vulkan_shaders = []
+# This is an odd split because we use configure_file() below to workaround
+# a limitation in meson preventing using custom_target() with gnome.compile_resources()
+# and that requires file paths, but we also need to have dependencies during development
+# on constantly regenerated files.
 gsk_private_vulkan_compiled_shaders = []
 gsk_private_vulkan_compiled_shaders_deps = []
 gsk_private_vulkan_shader_headers = []
@@ -144,7 +162,7 @@ if get_variable('broadway_enabled')
   ])
 endif
 
-gsk_resources_xml = custom_target(output: 'gsk.resources.xml',
+gsk_resources_xml = configure_file(output: 'gsk.resources.xml',
   input: 'gen-gsk-gresources-xml.py',
   command: [
     find_program('gen-gsk-gresources-xml.py'),
@@ -180,6 +198,7 @@ gsk_deps = [
   pango_dep,
   cairo_dep,
   cairo_csi_dep,
+  pixbuf_dep,
   libgdk_dep,
 ]
 

gsk/vulkan/gskvulkanrenderer.h

@@ -18,7 +18,7 @@
 #pragma once
 
 #include <gdk/gdk.h>
-#include <gsk/gsk.h>
+#include <gsk/gskrenderer.h>
 
 #ifdef GDK_RENDERING_VULKAN
 

gsk/vulkan/gskvulkanrenderpass.c

@@ -1260,6 +1260,8 @@ static const GskVulkanRenderPassNodeFunc nodes_vtable[] = {
   [GSK_GL_SHADER_NODE] = NULL,
   [GSK_TEXTURE_SCALE_NODE] = gsk_vulkan_render_pass_add_texture_scale_node,
   [GSK_MASK_NODE] = gsk_vulkan_render_pass_add_mask_node,
+  [GSK_FILL_NODE] = NULL,
+  [GSK_STROKE_NODE] = NULL,
 };
 
 static void

gsk/vulkan/resources/meson.build

@@ -93,12 +93,12 @@ foreach shader: gsk_private_vulkan_shaders
 endforeach
 
 foreach shader: gsk_private_vulkan_vertex_shaders
-  shader_header = custom_target(output: '@0@.h'.format(shader),
-                                input: shader,
-                                command: [
-                                  find_program('generate-header.py'),
-                                  '@INPUT@',
-                                ],
-                                capture: true)
+  shader_header = configure_file(output: '@0@.h'.format(shader),
+                                 input: shader,
+                                 command: [
+                                   find_program('generate-header.py'),
+                                   '@INPUT@',
+                                 ],
+                                 capture: true)
   gsk_private_vulkan_shader_headers += shader_header
 endforeach

gtk/deprecated/gtkcolorbutton.c

@@ -290,9 +290,6 @@ gtk_color_button_init (GtkColorButton *button)
 
   button->button = gtk_button_new ();
   g_signal_connect (button->button, "clicked", G_CALLBACK (gtk_color_button_clicked), button);
-  g_object_bind_property (button, "focus-on-click",
-                          button->button, "focus-on-click",
-                          0);
   gtk_widget_set_parent (button->button, GTK_WIDGET (button));
 
   button->swatch = g_object_new (GTK_TYPE_COLOR_SWATCH,

gtk/deprecated/gtkfontbutton.c

@@ -594,9 +594,6 @@ gtk_font_button_init (GtkFontButton *font_button)
 
   font_button->button = gtk_button_new ();
   g_signal_connect (font_button->button, "clicked", G_CALLBACK (gtk_font_button_clicked), font_button);
-  g_object_bind_property (font_button, "focus-on-click",
-                          font_button->button, "focus-on-click",
-                          0);
   font_button->font_label = gtk_label_new (_("Font"));
   gtk_widget_set_hexpand (font_button->font_label, TRUE);
   font_button->size_label = gtk_label_new ("14");

gtk/deprecated/gtktreemodel.c

@@ -257,6 +257,8 @@ static guint tree_model_signals[LAST_SIGNAL] = { 0 };
  * GtkTreePath:
  *
  * An opaque structure representing a path to a row in a model.
+ *
+ * Deprecated: 4.10
  */
 struct _GtkTreePath
 {

gtk/deprecated/gtktreemodel.h

@@ -69,6 +69,8 @@ typedef gboolean (* GtkTreeModelForeachFunc) (GtkTreeModel *model, GtkTreePath *
  * static for the lifetime of the object. A more complete description
  * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
  * this section.
+ *
+ * Deprecated: 4.10
  */
 typedef enum
 {
@@ -88,6 +90,8 @@ typedef enum
  * integer in the @stamp member, and put
  * model-specific data in the three @user_data
  * members.
+ *
+ * Deprecated: 4.10
  */
 struct _GtkTreeIter
 {
@@ -251,6 +255,8 @@ gboolean     gtk_tree_path_is_descendant    (GtkTreePath       *path,
  * A GtkTreeRowReference tracks model changes so that it always refers to the
  * same row (a `GtkTreePath` refers to a position, not a fixed row). Create a
  * new GtkTreeRowReference with gtk_tree_row_reference_new().
+ *
+ * Deprecated: 4.10: Use [iface@Gio.ListModel] instead
  */
 
 GDK_AVAILABLE_IN_ALL

gtk/deprecated/gtktreemodelfilter.c

@@ -734,12 +734,10 @@ gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,
   g_assert (filter->priv->child_model != NULL);
 
   /* Avoid building a level that already exists */
-#ifndef G_DISABLE_ASSERT
   if (parent_level)
     g_assert (parent_elt->children == NULL);
   else
     g_assert (filter->priv->root == NULL);
-#endif
 
   if (filter->priv->in_row_deleted)
     return;

gtk/deprecated/gtktreeview.c

@@ -12833,10 +12833,7 @@ gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
     *column = real_column;
 
   gtk_tree_model_get_iter (priv->model, &iter, real_path);
-  if (!_gtk_tree_view_find_node (tree_view, real_path, &tree, &node))
-    {
-      g_assert_not_reached ();
-    }
+  _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
 
   /* Check if there's an expander arrow at (x, y) */
   if (real_column == priv->expander_column

gtk/deprecated/gtktreeviewcolumn.c

@@ -937,13 +937,13 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column)
       if ((!alternative && priv->sort_order == GTK_SORT_ASCENDING) ||
           (alternative && priv->sort_order == GTK_SORT_DESCENDING))
         {
-          gtk_widget_remove_css_class (arrow, "ascending");
-          gtk_widget_add_css_class (arrow, "descending");
+          gtk_widget_remove_css_class (arrow, "descending");
+          gtk_widget_add_css_class (arrow, "ascending");
         }
       else
         {
-          gtk_widget_remove_css_class (arrow, "descending");
-          gtk_widget_add_css_class (arrow, "ascending");
+          gtk_widget_remove_css_class (arrow, "ascending");
+          gtk_widget_add_css_class (arrow, "descending");
         }
     }
 

gtk/gskpango.c

@@ -459,8 +459,7 @@ gsk_pango_renderer_release (GskPangoRenderer *renderer)
  *
  * Creates render nodes for rendering @layout in the given foregound @color
  * and appends them to the current node of @snapshot without changing the
- * current node. The current theme's foreground color for a widget can be
- * obtained with [method@Gtk.Widget.get_color].
+ * current node.
  *
  * Note that if the layout does not produce any visible output, then nodes
  * may not be added to the @snapshot.

gtk/gtkactionable.c

@@ -26,7 +26,7 @@
 /**
  * GtkActionable:
  *
- * The `GtkActionable` interface provides a convenient way of associating
+ * The `GtkActionable` interface provides a convenient way of asscociating
  * widgets with actions.
  *
  * It primarily consists of two properties: [property@Gtk.Actionable:action-name]

gtk/gtkcenterlayout.c

@@ -282,8 +282,6 @@ gtk_center_layout_measure_opposite (GtkCenterLayout *self,
   int total_nat, above_nat, below_nat;
   GtkWidget *child[3];
   GtkRequestedSize sizes[3];
-  gboolean have_baseline = FALSE;
-  gboolean align_baseline = FALSE;
   int i;
 
   child[0] = self->start_widget;
@@ -307,33 +305,27 @@ gtk_center_layout_measure_opposite (GtkCenterLayout *self,
                           &child_min, &child_nat,
                           &child_min_baseline, &child_nat_baseline);
 
-      total_min = MAX (total_min, child_min);
-      total_nat = MAX (total_nat, child_nat);
-
-      if (orientation == GTK_ORIENTATION_VERTICAL && child_min_baseline >= 0)
+      if (child_min_baseline >= 0)
         {
-          have_baseline = TRUE;
-          if (gtk_widget_get_valign (child[i]) == GTK_ALIGN_BASELINE_FILL ||
-              gtk_widget_get_valign (child[i]) == GTK_ALIGN_BASELINE_CENTER)
-            align_baseline = TRUE;
-
           below_min = MAX (below_min, child_min - child_min_baseline);
           above_min = MAX (above_min, child_min_baseline);
           below_nat = MAX (below_nat, child_nat - child_nat_baseline);
           above_nat = MAX (above_nat, child_nat_baseline);
         }
+      else
+        {
+          total_min = MAX (total_min, child_min);
+          total_nat = MAX (total_nat, child_nat);
+        }
    }
 
-  if (have_baseline)
+  if (above_min >= 0)
     {
       int min_baseline = -1;
       int nat_baseline = -1;
 
-      if (align_baseline)
-        {
-          total_min = MAX (total_min, above_min + below_min);
-          total_nat = MAX (total_nat, above_nat + below_nat);
-        }
+      total_min = MAX (total_min, above_min + below_min);
+      total_nat = MAX (total_nat, above_nat + below_nat);
 
       switch (self->baseline_pos)
         {

gtk/gtkcolordialogbutton.c

@@ -45,7 +45,6 @@ static GdkContentProvider *
                                 double                x,
                                 double                y,
                                 GtkColorDialogButton *self);
-static void     activated      (GtkColorDialogButton *self);
 static void     button_clicked (GtkColorDialogButton *self);
 static void     update_button_sensitivity
                                (GtkColorDialogButton *self);
@@ -97,17 +96,8 @@ enum
   NUM_PROPERTIES
 };
 
-/* Signals */
-enum
-{
-  SIGNAL_ACTIVATE = 1,
-  NUM_SIGNALS
-};
-
 static GParamSpec *properties[NUM_PROPERTIES];
 
-static unsigned int color_dialog_button_signals[NUM_SIGNALS] = { 0 };
-
 G_DEFINE_TYPE (GtkColorDialogButton, gtk_color_dialog_button, GTK_TYPE_WIDGET)
 
 static void
@@ -118,8 +108,6 @@ gtk_color_dialog_button_init (GtkColorDialogButton *self)
   GtkDragSource *source;
   GtkDropTarget *dest;
 
-  g_signal_connect_swapped (self, "activate", G_CALLBACK (activated), self);
-
   self->color = GDK_RGBA ("00000000");
 
   self->button = gtk_button_new ();
@@ -290,27 +278,6 @@ gtk_color_dialog_button_class_init (GtkColorDialogButtonClass *class)
 
   g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
 
-  /**
-   * GtkColorDialogButton::activate:
-   * @widget: the object which received the signal
-   *
-   * Emitted when the color dialog button is activated.
-   *
-   * The `::activate` signal on `GtkColorDialogButton` is an action signal
-   * and emitting it causes the button to pop up its dialog.
-   *
-   * Since: 4.14
-   */
-  color_dialog_button_signals[SIGNAL_ACTIVATE] =
-    g_signal_new (I_ ("activate"),
-                  G_TYPE_FROM_CLASS (class),
-                  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
-                  0,
-                  NULL, NULL,
-                  NULL,
-                  G_TYPE_NONE, 0);
-
-  gtk_widget_class_set_activate_signal (widget_class, color_dialog_button_signals[SIGNAL_ACTIVATE]);
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
   gtk_widget_class_set_css_name (widget_class, "colorbutton");
   gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_GROUP);
@@ -399,12 +366,6 @@ color_chosen (GObject      *source,
   update_button_sensitivity (self);
 }
 
-static void
-activated (GtkColorDialogButton *self)
-{
-  gtk_widget_activate (self->button);
-}
-
 static void
 button_clicked (GtkColorDialogButton *self)
 {

gtk/gtkcolumnview.c

@@ -1798,8 +1798,6 @@ gtk_column_view_scroll_to_column (GtkColumnView       *self,
                                                        gtk_adjustment_get_page_size (self->hadjustment));
 
   gtk_adjustment_set_value (self->hadjustment, new_value);
-
-  g_clear_pointer (&scroll_info, gtk_scroll_info_unref);
 }
 
 void
@@ -2216,14 +2214,9 @@ gtk_column_view_scroll_to (GtkColumnView       *self,
   if (column && (flags & GTK_LIST_SCROLL_FOCUS))
     gtk_column_view_set_focus_column (self, column, FALSE);
 
-  gtk_list_view_scroll_to (self->listview,
-                           pos,
-                           flags,
-                           scroll ? gtk_scroll_info_ref (scroll) : NULL);
+  gtk_list_view_scroll_to (self->listview, pos, flags, scroll);
 
   if (column)
     gtk_column_view_scroll_to_column (self, column, scroll);
-  else
-    g_clear_pointer (&scroll, gtk_scroll_info_unref);
 }
 

gtk/gtkcomposetable.c

@@ -231,7 +231,7 @@ parse_compose_sequence (const char *seq,
       char *start = words[i];
       char *end = strchr (words[i], '>');
       char *match;
-      guint keyval;
+      gunichar codepoint;
 
       if (words[i][0] == '\0')
              continue;
@@ -248,24 +248,18 @@ parse_compose_sequence (const char *seq,
 
       if (is_codepoint (match))
         {
-          keyval = gdk_unicode_to_keyval ((gunichar) g_ascii_strtoll (match + 1, NULL, 16));
-          if (keyval > 0xffff)
-            g_warning ("Can't handle >16bit keyvals");
-
-          sequence[n] = (guint16) keyval;
+          codepoint = (gunichar) g_ascii_strtoll (match + 1, NULL, 16);
+          sequence[n] = codepoint;
           sequence[n + 1] = 0;
         }
       else
         {
-          keyval = gdk_keyval_from_name (match);
-          if (keyval > 0xffff)
-            g_warning ("Can't handle >16bit keyvals");
-
-          sequence[n] = (guint16) keyval;
+          codepoint = (gunichar) gdk_keyval_from_name (match);
+          sequence[n] = codepoint;
           sequence[n + 1] = 0;
         }
 
-      if (keyval == GDK_KEY_VoidSymbol)
+      if (codepoint == GDK_KEY_VoidSymbol)
         g_warning ("Could not get code point of keysym %s", match);
       g_free (match);
       n++;
@@ -1337,27 +1331,10 @@ gtk_compose_table_check (const GtkComposeTable *table,
   if (!seq_index)
     return FALSE;
 
-  match = FALSE;
-
   if (n_compose == 1)
-    {
-      if (seq_index[2] - seq_index[1] > 0)
-        {
-          seq = table->data + seq_index[1];
+    return TRUE;
 
-          value = seq[0];
-
-          if ((value & (1 << 15)) != 0)
-            g_string_append (output, &table->char_data[value & ~(1 << 15)]);
-          else
-            g_string_append_unichar (output, value);
-
-          if (compose_match)
-            *compose_match = TRUE;
-        }
-
-      return TRUE;
-    }
+  match = FALSE;
 
   for (i = n_compose - 1; i < table->max_seq_len; i++)
     {

gtk/gtkcomposetable.h

@@ -30,13 +30,12 @@ typedef struct _GtkComposeTableCompact GtkComposeTableCompact;
  * The first part of the data contains rows of length max_seq_len + 1,
  * where the first element is the item of the sequence, and the
  * following elements are offsets to the data for sequences that
- * start with the first item of length 1, ..., max_seq_len.
+ * start with the first item of length 2, ..., max_seq_len.
  *
  * The second part of the data contains the rest of the sequence
  * data. It does not have a fixed stride. For each sequence, we
  * put seq[2], ..., seq[len - 1], followed by the encoded value
- * for this sequence. In particular for a sequence of length 1,
- * the offset points directly to the value.
+ * for this sequence.
  *
  * The values are encoded as follows:
  *

gtk/gtkcssfiltervalue.c

@@ -266,8 +266,7 @@ static int
 gtk_css_filter_value_compute_matrix (const GtkCssValue *value,
                                      int                first,
                                      graphene_matrix_t *matrix,
-                                     graphene_vec4_t   *offset,
-                                     gboolean          *all_opacity)
+                                     graphene_vec4_t   *offset)
 {
   graphene_matrix_t m, m2;
   graphene_vec4_t o, o2;
@@ -276,14 +275,11 @@ gtk_css_filter_value_compute_matrix (const GtkCssValue *value,
   if (!gtk_css_filter_get_matrix (&value->filters[first], matrix, offset))
     return first;
 
-  *all_opacity = value->filters[first].type == GTK_CSS_FILTER_OPACITY;
-
   for (i = first + 1; i < value->n_filters; i++)
     {
       if (!gtk_css_filter_get_matrix (&value->filters[i], &m, &o))
         return i;
 
-      *all_opacity &= value->filters[i].type == GTK_CSS_FILTER_OPACITY;
       graphene_matrix_multiply (matrix, &m, &m2);
       graphene_matrix_transform_vec4 (&m, offset, &o2);
 
@@ -940,7 +936,6 @@ gtk_css_filter_value_push_snapshot (const GtkCssValue *filter,
 {
   graphene_matrix_t matrix;
   graphene_vec4_t offset;
-  gboolean all_opacity;
   int i, j;
 
   if (gtk_css_filter_value_is_none (filter))
@@ -949,15 +944,9 @@ gtk_css_filter_value_push_snapshot (const GtkCssValue *filter,
   i = 0;
   while (i < filter->n_filters)
     {
-      j = gtk_css_filter_value_compute_matrix (filter, i, &matrix, &offset, &all_opacity);
+      j = gtk_css_filter_value_compute_matrix (filter, i, &matrix, &offset);
       if (i < j)
-        {
-          if (all_opacity)
-            gtk_snapshot_push_opacity (snapshot, graphene_matrix_get_value (&matrix, 3, 3));
-          else
-            gtk_snapshot_push_color_matrix (snapshot, &matrix, &offset);
-        }
-
+        gtk_snapshot_push_color_matrix (snapshot, &matrix, &offset);
 
       if (j < filter->n_filters)
         {

gtk/gtkentry.c

@@ -1646,18 +1646,14 @@ gtk_entry_measure (GtkWidget      *widget,
 {
   GtkEntry *entry = GTK_ENTRY (widget);
   GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
-  int text_min, text_nat;
   int i;
 
   gtk_widget_measure (priv->text,
                       orientation,
                       for_size,
-                      &text_min, &text_nat,
+                      minimum, natural,
                       minimum_baseline, natural_baseline);
 
-  *minimum = text_min;
-  *natural = text_nat;
-
   for (i = 0; i < MAX_ICONS; i++)
     {
       EntryIconInfo *icon_info = priv->icons[i];
@@ -1695,14 +1691,6 @@ gtk_entry_measure (GtkWidget      *widget,
       *minimum = MAX (*minimum, prog_min);
       *natural = MAX (*natural, prog_nat);
     }
-
-  if (orientation == GTK_ORIENTATION_VERTICAL)
-    {
-      if (G_LIKELY (*minimum_baseline >= 0))
-        *minimum_baseline += (*minimum - text_min) / 2;
-      if (G_LIKELY (*natural_baseline >= 0))
-        *natural_baseline += (*natural - text_nat) / 2;
-    }
 }
 
 static void

gtk/gtkfilechoosernativequartz.c

@@ -43,8 +43,6 @@
 
 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 
-@class FilterComboBox;
-
 typedef struct {
   GtkFileChooserNative *self;
 
@@ -70,33 +68,31 @@ typedef struct {
 
   NSMutableArray *filters;
   NSMutableArray *filter_names;
-  FilterComboBox *filter_popup_button;
+  NSComboBox *filter_combo_box;
 
   GSList *files;
   int response;
 } FileChooserQuartzData;
 
-@interface FilterComboBox : NSPopUpButton
+@interface FilterComboBox : NSObject<NSComboBoxDelegate>
 {
   FileChooserQuartzData *data;
 }
 - (id) initWithData:(FileChooserQuartzData *) quartz_data;
-- (void) popUpButtonSelectionChanged:(id) sender;
+- (void)comboBoxSelectionDidChange:(NSNotification *)notification;
 @end
 
 @implementation FilterComboBox
 
 - (id) initWithData:(FileChooserQuartzData *) quartz_data
 {
-  [super initWithFrame:NSMakeRect(0, 0, 200, 24)];
-  [self setTarget:self];
-  [self setAction:@selector(popUpButtonSelectionChanged:)];
+  [super init];
   data = quartz_data;
   return self;
 }
-- (void)popUpButtonSelectionChanged:(id)sender
+- (void)comboBoxSelectionDidChange:(NSNotification *)notification
 {
-  NSInteger selected_index = [data->filter_popup_button indexOfSelectedItem];
+  NSInteger selected_index = [data->filter_combo_box indexOfSelectedItem];
   NSArray *filter = [data->filters objectAtIndex:selected_index];
   // check for empty strings in filter -> indicates all filetypes should be allowed!
   if ([filter containsObject:@""])
@@ -306,8 +302,10 @@ filechooser_quartz_launch (FileChooserQuartzData *data)
   if (data->filters)
     {
       // when filters have been provided, a combobox needs to be added
-      data->filter_popup_button = [[FilterComboBox alloc] initWithData:data];
-      [data->filter_popup_button addItemsWithTitles:data->filter_names];
+      data->filter_combo_box = [[NSComboBox alloc] initWithFrame:NSMakeRect(0, 0, 200, 24)];
+      [data->filter_combo_box addItemsWithObjectValues:data->filter_names];
+      [data->filter_combo_box setEditable:NO];
+      [data->filter_combo_box setDelegate:[[FilterComboBox alloc] initWithData:data]];
 
       if (data->self->current_filter)
         {
@@ -331,18 +329,16 @@ filechooser_quartz_launch (FileChooserQuartzData *data)
           g_object_unref (filters);
 
           if (current_filter_index != GTK_INVALID_LIST_POSITION)
-            [data->filter_popup_button selectItemAtIndex:current_filter_index];
+            [data->filter_combo_box selectItemAtIndex:current_filter_index];
           else
-            [data->filter_popup_button selectItemAtIndex:0];
+            [data->filter_combo_box selectItemAtIndex:0];
         }
       else
         {
-          [data->filter_popup_button selectItemAtIndex:0];
+          [data->filter_combo_box selectItemAtIndex:0];
         }
-
-      [data->filter_popup_button popUpButtonSelectionChanged:NULL];
-      [data->filter_popup_button setToolTip:[NSString stringWithUTF8String:_("Select which types of files are shown")]];
-      [data->panel setAccessoryView:data->filter_popup_button];
+      [data->filter_combo_box setToolTip:[NSString stringWithUTF8String:_("Select which types of files are shown")]];
+      [data->panel setAccessoryView:data->filter_combo_box];
       if ([data->panel isKindOfClass:[NSOpenPanel class]] && [data->panel respondsToSelector:@selector(setAccessoryViewDisclosed:)])
         {
           [(id<CanSetAccessoryViewDisclosed>) data->panel setAccessoryViewDisclosed:YES];
@@ -582,3 +578,4 @@ gtk_file_chooser_native_quartz_hide (GtkFileChooserNative *self)
     }
   data->panel = NULL;
 }
+

gtk/gtkfilefilter.c

@@ -758,6 +758,8 @@ gtk_file_filter_get_attributes (GtkFileFilter *filter)
 
 #ifdef GDK_WINDOWING_MACOS
 
+#import <Foundation/Foundation.h>
+
 NSArray * _gtk_file_filter_get_as_pattern_nsstrings (GtkFileFilter *filter)
 {
   NSMutableArray *array = [[NSMutableArray alloc] init];
@@ -771,8 +773,9 @@ NSArray * _gtk_file_filter_get_as_pattern_nsstrings (GtkFileFilter *filter)
         {
         case FILTER_RULE_MIME_TYPE:
           {
-            // GContentType from GIO use UTI on macOS since glib version 2.51
-            NSString *uti_nsstring = [NSString stringWithUTF8String: rule->u.content_types[0]];
+            // convert mime-types to UTI
+            NSString *mime_type_nsstring = [NSString stringWithUTF8String: rule->u.content_types[0]];
+            NSString *uti_nsstring = (NSString *) UTTypeCreatePreferredIdentifierForTag (kUTTagClassMIMEType, (CFStringRef) mime_type_nsstring, NULL);
             if (uti_nsstring == NULL)
               {
                 [array release];

gtk/gtkfontdialogbutton.c

@@ -32,7 +32,7 @@
 #include "gtkwidgetprivate.h"
 #include "gtktypebuiltins.h"
 
-static void     activated      (GtkFontDialogButton *self);
+
 static void     button_clicked (GtkFontDialogButton *self);
 static void     update_button_sensitivity
                                (GtkFontDialogButton *self);
@@ -100,17 +100,8 @@ enum
   NUM_PROPERTIES
 };
 
-/* Signals */
-enum
-{
-  SIGNAL_ACTIVATE = 1,
-  NUM_SIGNALS
-};
-
 static GParamSpec *properties[NUM_PROPERTIES];
 
-static unsigned int font_dialog_button_signals[NUM_SIGNALS] = { 0 };
-
 G_DEFINE_TYPE (GtkFontDialogButton, gtk_font_dialog_button, GTK_TYPE_WIDGET)
 
 static void
@@ -119,8 +110,6 @@ gtk_font_dialog_button_init (GtkFontDialogButton *self)
   GtkWidget *box;
   PangoFontDescription *font_desc;
 
-  g_signal_connect_swapped (self, "activate", G_CALLBACK (activated), self);
-
   self->button = gtk_button_new ();
   g_signal_connect_swapped (self->button, "clicked", G_CALLBACK (button_clicked), self);
   self->font_label = gtk_label_new (_("Font"));
@@ -394,27 +383,6 @@ gtk_font_dialog_button_class_init (GtkFontDialogButtonClass *class)
 
   g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
 
-  /**
-   * GtkFontDialogButton::activate:
-   * @widget: The object which received the signal
-   *
-   * Emitted when the font dialog button is activated.
-   *
-   * The `::activate` signal on `GtkFontDialogButton` is an action signal
-   * and emitting it causes the button to pop up its dialog.
-   *
-   * Since: 4.14
-   */
-  font_dialog_button_signals[SIGNAL_ACTIVATE] =
-    g_signal_new (I_ ("activate"),
-                  G_TYPE_FROM_CLASS (class),
-                  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
-                  0,
-                  NULL, NULL,
-                  NULL,
-                  G_TYPE_NONE, 0);
-
-  gtk_widget_class_set_activate_signal (widget_class, font_dialog_button_signals[SIGNAL_ACTIVATE]);
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
   gtk_widget_class_set_css_name (widget_class, "fontbutton");
   gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_GROUP);
@@ -531,12 +499,6 @@ font_and_features_chosen (GObject      *source,
   update_button_sensitivity (self);
 }
 
-static void
-activated (GtkFontDialogButton *self)
-{
-  gtk_widget_activate (self->button);
-}
-
 static void
 button_clicked (GtkFontDialogButton *self)
 {

gtk/gtkgridview.c

@@ -411,7 +411,7 @@ gtk_grid_view_get_position_from_allocation (GtkListBase           *base,
     }
 
   pos = gtk_list_tile_get_position (self->item_manager, tile);
-  if (tile->n_items > 1 && tile->area.width > 0 && tile->area.height > 0)
+  if (tile->n_items > 1)
     {
       int xspacing, yspacing;
 

gtk/gtklistbase.c

@@ -121,7 +121,7 @@ static GParamSpec *properties[N_PROPS] = { NULL, };
  * @self: a `GtkListBase`
  * @across: position in pixels in the direction cross to the list
  * @along:  position in pixels in the direction of the list
- * @pos: (out): set to the looked up position
+ * @pos: (out caller-allocates): set to the looked up position
  * @area: (out caller-allocates) (optional): set to the area occupied
  *   by the returned position
  *
@@ -1519,7 +1519,7 @@ gtk_list_base_allocate_children (GtkListBase *self,
   GtkListBasePrivate *priv = gtk_list_base_get_instance_private (self);
   GtkListTile *tile;
   int dx, dy;
-
+  
   gtk_list_base_get_adjustment_values (self, OPPOSITE_ORIENTATION (priv->orientation), &dx, NULL, NULL);
   gtk_list_base_get_adjustment_values (self, priv->orientation, &dy, NULL, NULL);
 

gtk/gtklistheader.c

@@ -27,9 +27,9 @@
  * `GtkListHeader` is used by list widgets to represent the headers they
  * display.
  *
- * `GtkListHeader` objects are managed just like [class@Gtk.ListItem]
- * objects via their factory, but provide a different set of properties suitable
- * for managing the header instead of individual items.
+ * The `GtkListHeader`s are managed just like [class@gtk.ListItem]s via
+ * their factory, but provide a different set of properties suitable for
+ * managing the header instead of individual items.
  *
  * Since: 4.12
  */

gtk/gtklistitem.c

@@ -27,14 +27,13 @@
 /**
  * GtkListItem:
  *
- * `GtkListItem` is used by list widgets to represent items in a
- * [iface@Gio.ListModel].
+ * `GtkListItem` is used by list widgets to represent items in a `GListModel`.
  *
- * `GtkListItem` objects are managed by the list widget (with its factory)
+ * The `GtkListItem`s are managed by the list widget (with its factory)
  * and cannot be created by applications, but they need to be populated
  * by application code. This is done by calling [method@Gtk.ListItem.set_child].
  *
- * `GtkListItem` objects exist in 2 stages:
+ * `GtkListItem`s exist in 2 stages:
  *
  * 1. The unbound stage where the listitem is not currently connected to
  *    an item in the list. In that case, the [property@Gtk.ListItem:item]

gtk/gtkmain.c

@@ -1191,6 +1191,11 @@ gtk_synthesize_crossing_events (GtkRoot         *toplevel,
   for (widget = new_target; widget; widget = _gtk_widget_get_parent (widget))
     gtk_widget_stack_append (&target_array, g_object_ref (widget));
 
+  if (old_target && new_target)
+    ancestor = gtk_widget_common_ancestor (old_target, new_target);
+  else
+    ancestor = NULL;
+
   crossing.direction = GTK_CROSSING_IN;
 
   seen_ancestor = FALSE;

gtk/gtkmenubutton.c

@@ -1353,35 +1353,35 @@ gtk_menu_button_get_use_underline (GtkMenuButton *menu_button)
 }
 
 static GList *
-get_menu_bars (GtkWidget *toplevel)
+get_menu_bars (GtkWindow *window)
 {
-  return g_object_get_data (G_OBJECT (toplevel), "gtk-menu-bar-list");
+  return g_object_get_data (G_OBJECT (window), "gtk-menu-bar-list");
 }
 
 static void
-set_menu_bars (GtkWidget *toplevel,
+set_menu_bars (GtkWindow *window,
                GList     *menubars)
 {
-  g_object_set_data (G_OBJECT (toplevel), I_("gtk-menu-bar-list"), menubars);
+  g_object_set_data (G_OBJECT (window), I_("gtk-menu-bar-list"), menubars);
 }
 
 static void
-add_to_toplevel (GtkWidget     *toplevel,
-                 GtkMenuButton *button)
+add_to_window (GtkWindow     *window,
+               GtkMenuButton *button)
 {
-  GList *menubars = get_menu_bars (toplevel);
+  GList *menubars = get_menu_bars (window);
 
-  set_menu_bars (toplevel, g_list_prepend (menubars, button));
+  set_menu_bars (window, g_list_prepend (menubars, button));
 }
 
 static void
-remove_from_toplevel (GtkWidget     *toplevel,
-                      GtkMenuButton *button)
+remove_from_window (GtkWindow     *window,
+                    GtkMenuButton *button)
 {
-  GList *menubars = get_menu_bars (toplevel);
+  GList *menubars = get_menu_bars (window);
 
   menubars = g_list_remove (menubars, button);
-  set_menu_bars (toplevel, menubars);
+  set_menu_bars (window, menubars);
 }
 
 static void
@@ -1394,7 +1394,7 @@ gtk_menu_button_root (GtkWidget *widget)
   if (button->primary)
     {
       GtkWidget *toplevel = GTK_WIDGET (gtk_widget_get_root (widget));
-      add_to_toplevel (toplevel, button);
+      add_to_window (GTK_WINDOW (toplevel), button);
     }
 }
 
@@ -1404,7 +1404,7 @@ gtk_menu_button_unroot (GtkWidget *widget)
   GtkWidget *toplevel;
 
   toplevel = GTK_WIDGET (gtk_widget_get_root (widget));
-  remove_from_toplevel (toplevel, GTK_MENU_BUTTON (widget));
+  remove_from_window (GTK_WINDOW (toplevel), GTK_MENU_BUTTON (widget));
 
   GTK_WIDGET_CLASS (gtk_menu_button_parent_class)->unroot (widget);
 }
@@ -1437,9 +1437,9 @@ gtk_menu_button_set_primary (GtkMenuButton *menu_button,
   if (toplevel)
     {
       if (menu_button->primary)
-        add_to_toplevel (GTK_WIDGET (toplevel), menu_button);
+        add_to_window (GTK_WINDOW (toplevel), menu_button);
       else
-        remove_from_toplevel (GTK_WIDGET (toplevel), menu_button);
+        remove_from_window (GTK_WINDOW (toplevel), menu_button);
     }
 
   g_object_notify_by_pspec (G_OBJECT (menu_button), menu_button_props[PROP_PRIMARY]);
@@ -1510,8 +1510,8 @@ gtk_menu_button_set_child (GtkMenuButton *menu_button,
                                           NULL,
                                           NULL,
                                           NULL,
-                                          (GtkGizmoFocusFunc)gtk_widget_focus_child,
-                                          NULL);
+                                          (GtkGizmoFocusFunc)gtk_widget_focus_self,
+                                          (GtkGizmoGrabFocusFunc)gtk_widget_grab_focus_self);
 
   gtk_widget_set_layout_manager (inner_widget, gtk_bin_layout_new ());
   gtk_widget_set_hexpand (inner_widget, TRUE);

gtk/gtknotebook.c

@@ -5409,9 +5409,7 @@ gtk_notebook_real_switch_page (GtkNotebook     *notebook,
   if (notebook->cur_page)
     {
       GtkRoot *root = gtk_widget_get_root (GTK_WIDGET (notebook));
-      GtkWidget *focus = NULL;
-      if (root)
-        focus = gtk_root_get_focus (root);
+      GtkWidget *focus = gtk_root_get_focus (root);
       if (focus)
         child_has_focus = gtk_widget_is_ancestor (focus, notebook->cur_page->child);
       gtk_widget_unset_state_flags (notebook->cur_page->tab_widget, GTK_STATE_FLAG_CHECKED);

gtk/gtkoverlaylayout.c

@@ -33,12 +33,12 @@
 /**
  * GtkOverlayLayout:
  *
- * `GtkOverlayLayout` is the layout manager used by [class@Gtk.Overlay].
+ * `GtkOverlayLayout` is the layout manager used by `GtkOverlay`.
  *
  * It places widgets as overlays on top of the main child.
  *
  * This is not a reusable layout manager, since it expects its widget
- * to be a `GtkOverlay`. It is only listed here so that its layout
+ * to be a `GtkOverlay`. It only listed here so that its layout
  * properties get documented.
  */
 

gtk/gtkpopover.c

@@ -70,31 +70,30 @@
  * # CSS nodes
  *
  * ```
- * popover.background[.menu]
+ * popover[.menu]
  * ├── arrow
- * ╰── contents
+ * ╰── contents.background
  *     ╰── <child>
  * ```
  *
- * `GtkPopover` has a main node with name `popover`, an arrow with name `arrow`,
- * and another node for the content named `contents`. The `popover` node always
- * gets the `.background` style class. It also gets the `.menu` style class
- * if the popover is menu-like, e.g. is a [class@Gtk.PopoverMenu].
+ * The contents child node always gets the .background style class
+ * and the popover itself gets the .menu style class if the popover
+ * is menu-like (i.e. `GtkPopoverMenu`).
  *
  * Particular uses of `GtkPopover`, such as touch selection popups or
  * magnifiers in `GtkEntry` or `GtkTextView` get style classes like
- * `.touch-selection` or `.magnifier` to differentiate from plain popovers.
+ * .touch-selection or .magnifier to differentiate from plain popovers.
  *
- * When styling a popover directly, the `popover` node should usually
+ * When styling a popover directly, the popover node should usually
  * not have any background. The visible part of the popover can have
- * a shadow. To specify it in CSS, set the box-shadow of the `contents` node.
+ * a shadow. To specify it in CSS, set the box-shadow of the contents node.
  *
  * Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
- * uses custom drawing for the `arrow` node. This makes it possible for the
+ * uses custom drawing for the arrow node. This makes it possible for the
  * arrow to change its shape dynamically, but it also limits the possibilities
- * of styling it using CSS. In particular, the `arrow` gets drawn over the
- * `content` node's border and shadow, so they look like one shape, which
- * means that the border width of the `content` node and the `arrow` node should
+ * of styling it using CSS. In particular, the arrow gets drawn over the
+ * content node's border and shadow, so they look like one shape, which
+ * means that the border width of the content node and the arrow node should
  * be the same. The arrow also does not support any border shape other than
  * solid, no border-radius, only one border width (border-bottom-width is
  * used) and no box-shadow.