wip: port curve-editor to GtkContour

Not quite done.

.gitlab-ci/flatpak-build.sh

@@ -23,8 +23,8 @@ flatpak build ${builddir} meson \
                 -Dbuild-testsuite=false \
                 -Dbuild-examples=false \
                 -Dintrospection=disabled \
-                -Dbuild-demos=true \
-                -Ddemo-profile=devel \
+                -Ddemos=true \
+                -Dprofile=devel \
                 _flatpak_build
 
 flatpak build ${builddir} ninja -C _flatpak_build install

NEWS

@@ -1,85 +1,6 @@
 Overview of Changes in 4.11.4, xx-xx-xxxx
 =========================================
 
-* GtkFileChooser:
- - Default to sorting folders first
- - Fix a crash when visiting recent files
-
-* GtkTextView:
- - Fix corner cases in word navigation
-
-* GtkMenuButton:
- - Normalize label layout
-
-* GtkDropDown:
- - Add support for sections
-
-* GtkVideo:
- - Make the overlay icon clickable
-
-* GtkWindow:
- - Clear the resize cursors to avoid artifacts
-
-* GtkFileDialog:
- - Always set initial-folder
-
-* GtkDropDown:
- - Update on expression changes
-
-* Accessibility:
- - Improvements all over the place: GtkButton, GtkPasswordEntry,
-   GtkFontChooserDialog, GtkColorChooserDialog, GtkShortcutsWindow,
-   GtkMenuButton, GtkAboutDialog, GtkFileChooserDialog, GtkStackSidebar,
-   GtkStackSwitcher, GtkMediaControls, GtkColorDialogButton, GtkDropDown,
-   GtkInfoBar, GtkNotebook, GtkPrintUnixDialog, GtkModelButton
- - Make name computation follow the ARIA spec more closely
- - Adapt name computation for the common 'nested button' scenario
- - Change many containers to use `generic` instead of `group`
- - Use `generic` as the default role
- - Use `application` instead of `window` for windows
- - Add properties for accessible names of not directly exposed
-   widgets in GtkListView, GtkGridView and GtkColumnView
-
-* DND:
- - Fix criticals when drops are rejected
-
-* X11:
- - Fix regressions in GLX setup
-
-* Windows:
- - Center newly created transient windows
-
-* Vulkan:
- - Add antialising for gradients
- - Do less work on clipped away nodes
- - Redo image uploading
- - Support different image depths and formats
- - Add a pipeline cache
-
-* Demos:
- - gtk4-demo: Improve window sizing
- - gtk4-demo: Improve focus behavior
- - gtk4-demo: Add many missing a11y properties
-
-* Tools:
- - gtk4-builder-tool: Make render an alias screenshot
-
-* Inspector:
- - Show more information in the a11y tab
- - Add an accessibility overlay with warnings and recommendations
- - Limit the width of the a11y tab
-
-* Build:
- - Require GLib 2.76
- - Make asan builds work again
-
-* Translation updates:
- Brazilian Portuguese
- Catalan
- Czech
- Georgian
-
-
 Overview of Changes in 4.11.3, 05-06-2023
 =========================================
 

demos/gtk-demo/cepath.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define CE_TYPE_PATH (ce_path_get_type ())
+G_DECLARE_FINAL_TYPE (CEPath, ce_path, CE, PATH, GObject)
+
+typedef struct _CEPathCurve CEPathCurve;
+
+typedef enum
+{
+  CE_PATH_CUSP,
+  CE_PATH_SMOOTH,
+  CE_PATH_SYMMETRIC,
+  CE_PATH_AUTOMATIC
+} CEPathConstraint;
+
+CEPath *        ce_path_new                  (void);
+
+int             ce_path_get_n_curves         (CEPath                 *self);
+
+CEPathCurve *   ce_path_get_curve            (CEPath                 *self,
+                                              int                     idx);
+
+CEPathCurve *   ce_path_previous_curve       (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+CEPathCurve *   ce_path_next_curve           (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+void            ce_path_set_gsk_path         (CEPath                 *self,
+                                              GskPath                *path);
+
+GskPath *       ce_path_get_gsk_path         (CEPath                 *self);
+
+void            ce_path_split_curve          (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              float                   pos);
+
+void            ce_path_remove_curve         (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+void            ce_path_drag_curve           (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              const graphene_point_t *pos);
+
+CEPathCurve *   ce_path_find_closest_curve   (CEPath                 *self,
+                                              graphene_point_t       *point,
+                                              float                   threshold,
+                                              graphene_point_t       *p,
+                                              float                  *pos);
+
+void            ce_path_get_point            (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              int                     c,
+                                              graphene_point_t       *point);
+
+void            ce_path_set_point            (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              int                     point,
+                                              const graphene_point_t *pos);
+
+GskPathOperation
+                ce_path_get_operation        (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+void            ce_path_set_operation        (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              GskPathOperation        op);
+
+float           ce_path_get_weight           (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+void            ce_path_set_weight           (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              float                   weight);
+
+CEPathConstraint
+                ce_path_get_constraint       (CEPath                 *self,
+                                              CEPathCurve            *seg);
+
+void            ce_path_set_constraint       (CEPath                 *self,
+                                              CEPathCurve            *seg,
+                                              CEPathConstraint        constraint);
+
+
+
+G_END_DECLS

demos/gtk-demo/curve-editor.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define CURVE_TYPE_EDITOR (curve_editor_get_type ())
+G_DECLARE_FINAL_TYPE (CurveEditor, curve_editor, CURVE, EDITOR, GtkWidget)
+
+GtkWidget *       curve_editor_new              (void);
+
+void              curve_editor_set_edit         (CurveEditor *self,
+                                                 gboolean     edit);
+
+void              curve_editor_set_path         (CurveEditor *self,
+                                                 GskPath     *path);
+
+GskPath *         curve_editor_get_path         (CurveEditor *self);
+
+void              curve_editor_set_stroke       (CurveEditor *self,
+                                                 GskStroke   *stroke);
+
+const GskStroke * curve_editor_get_stroke       (CurveEditor *self);
+
+
+void              curve_editor_set_color        (CurveEditor   *self,
+                                                 const GdkRGBA *color);
+
+const GdkRGBA *   curve_editor_get_color        (CurveEditor *self);
+
+gboolean          curve_editor_get_show_outline (CurveEditor *self);
+
+void              curve_editor_set_show_outline (CurveEditor *self,
+                                                 gboolean     show_outline);
+
+G_END_DECLS

demos/gtk-demo/curve.c

@@ -0,0 +1,288 @@
+/* Path/Curve Editor
+ *
+ * This demo shows an elaborate curve editor that you would expect to find
+ * in a vector graphics editor. It is built on top of GTK's path APIs.
+ */
+
+#include <gtk/gtk.h>
+#include "curve-editor.h"
+
+
+static GskPath *
+make_circle_path (void)
+{
+  float w = 310;
+  float h = 310;
+  float cx = w / 2;
+  float cy = h / 2;
+  float pad = 20;
+  float r = (w - 2 * pad) / 2;
+  float k = 0.55228;
+  float kr = k  * r;
+  GskPathBuilder *builder;
+
+  builder = gsk_path_builder_new ();
+
+  gsk_path_builder_move_to (builder,  cx, pad);
+  gsk_path_builder_cubic_to (builder, cx + kr, pad,
+                                      w - pad, cy - kr,
+                                      w - pad, cy);
+  gsk_path_builder_cubic_to (builder, w - pad, cy + kr,
+                                      cx + kr, h - pad,
+                                      cx, h - pad);
+  gsk_path_builder_cubic_to (builder, cx - kr, h - pad,
+                                      pad, cy + kr,
+                                      pad, cy);
+#if 0
+  gsk_path_builder_cubic_to (builder, pad, cy - kr,
+                                      cx - kr, pad,
+                                      cx, pad);
+  gsk_path_builder_close (builder);
+#endif
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+static GskPath *
+make_fancy_path (void)
+{
+  GskPathBuilder *builder;
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, &GRAPHENE_POINT_INIT (150, 150), 100);
+  gsk_path_builder_add_rect (builder, &GRAPHENE_RECT_INIT (100, 100, 100, 100));
+  gsk_path_builder_move_to (builder, 300, 150);
+  gsk_path_builder_cubic_to (builder, 300, 50, 400, 50, 400, 150);
+  gsk_path_builder_cubic_to (builder, 400, 250, 500, 250, 500, 150);
+  gsk_path_builder_line_to (builder, 600, 150);
+  gsk_path_builder_line_to (builder, 530, 190);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+static void
+edit_changed (GtkToggleButton *button,
+              GParamSpec      *pspec,
+              CurveEditor     *editor)
+{
+  curve_editor_set_edit (editor, gtk_toggle_button_get_active (button));
+}
+
+static void
+reset (GtkButton   *button,
+       CurveEditor *editor)
+{
+  GskPath *path;
+
+  path = make_fancy_path ();
+  curve_editor_set_path (editor, path);
+  gsk_path_unref (path);
+}
+
+static void
+line_width_changed (GtkSpinButton *spin,
+                    CurveEditor   *editor)
+{
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_copy (curve_editor_get_stroke (editor));
+  gsk_stroke_set_line_width (stroke, gtk_spin_button_get_value (spin));
+  curve_editor_set_stroke (editor, stroke);
+  gsk_stroke_free (stroke);
+}
+
+static void
+cap_changed (GtkDropDown *combo,
+             GParamSpec  *pspec,
+             CurveEditor *editor)
+{
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_copy (curve_editor_get_stroke (editor));
+  gsk_stroke_set_line_cap (stroke, (GskLineCap)gtk_drop_down_get_selected (combo));
+  curve_editor_set_stroke (editor, stroke);
+  gsk_stroke_free (stroke);
+}
+
+static void
+join_changed (GtkDropDown *combo,
+              GParamSpec  *pspec,
+              CurveEditor *editor)
+{
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_copy (curve_editor_get_stroke (editor));
+  gsk_stroke_set_line_join (stroke, (GskLineJoin)gtk_drop_down_get_selected (combo));
+  curve_editor_set_stroke (editor, stroke);
+  gsk_stroke_free (stroke);
+}
+
+static void
+color_changed (GtkColorDialogButton *button,
+               GParamSpec           *pspec,
+               CurveEditor          *editor)
+{
+  curve_editor_set_color (editor, gtk_color_dialog_button_get_rgba (button));
+}
+
+static void
+stroke_toggled (GtkCheckButton *button,
+                CurveEditor    *editor)
+{
+  curve_editor_set_show_outline (editor, gtk_check_button_get_active (button));
+  gtk_widget_queue_draw (GTK_WIDGET (editor));
+}
+
+static void
+limit_changed (GtkSpinButton *spin,
+               CurveEditor   *editor)
+{
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_copy (curve_editor_get_stroke (editor));
+  gsk_stroke_set_miter_limit (stroke, gtk_spin_button_get_value (spin));
+  curve_editor_set_stroke (editor, stroke);
+  gsk_stroke_free (stroke);
+}
+
+static void
+dashes_changed (GtkEntry    *entry,
+                GParamSpec  *spec,
+                CurveEditor *editor)
+{
+  const char *text;
+  char **split;
+  GArray *dash;
+  GskStroke *stroke;
+
+  text = gtk_editable_get_text (GTK_EDITABLE (entry));
+  split = g_strsplit (text, " ", 0);
+
+  dash = g_array_new (FALSE, FALSE, sizeof (float));
+  for (int i = 0; split[i] != NULL; i++)
+    {
+      double d;
+      char *endp = 0;
+
+      d = g_strtod (split[i], &endp);
+      if (*endp == '\0')
+        g_array_append_vals (dash, (float[1]) { d }, 1);
+    }
+
+  g_strfreev (split);
+
+  stroke = gsk_stroke_copy (curve_editor_get_stroke (editor));
+  gsk_stroke_set_dash (stroke, (const float *)dash->data, dash->len);
+  curve_editor_set_stroke (editor, stroke);
+  gsk_stroke_free (stroke);
+
+  g_array_free (dash, TRUE);
+}
+
+GtkWidget *
+do_curve (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *demo;
+  GtkWidget *edit_toggle;
+  GtkWidget *reset_button;
+  GtkWidget *titlebar;
+  GtkWidget *stroke_toggle;
+  GtkWidget *line_width_spin;
+  GtkWidget *stroke_button;
+  GtkWidget *popover;
+  GtkWidget *grid;
+  GtkWidget *cap_combo;
+  GtkWidget *join_combo;
+  GtkWidget *color_button;
+  GtkWidget *limit_spin;
+  GtkWidget *dash_entry;
+
+  if (!window)
+    {
+      window = gtk_window_new ();
+      gtk_window_set_title (GTK_WINDOW (window), "Curve Editor");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_window_set_default_size (GTK_WINDOW (window), 315, 350);
+
+      edit_toggle = gtk_toggle_button_new ();
+      gtk_button_set_icon_name (GTK_BUTTON (edit_toggle), "document-edit-symbolic");
+
+      reset_button = gtk_button_new_from_icon_name ("edit-undo-symbolic");
+
+      stroke_button = gtk_menu_button_new ();
+      gtk_menu_button_set_icon_name (GTK_MENU_BUTTON (stroke_button), "open-menu-symbolic");
+      popover = gtk_popover_new ();
+      gtk_menu_button_set_popover (GTK_MENU_BUTTON (stroke_button), popover);
+
+      grid = gtk_grid_new ();
+      gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
+      gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
+      gtk_popover_set_child (GTK_POPOVER (popover), grid);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Color:"), 0, 0, 1, 1);
+      color_button = gtk_color_dialog_button_new (gtk_color_dialog_new ());
+      gtk_grid_attach (GTK_GRID (grid), color_button, 1, 0, 1, 1);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Line width:"), 0, 1, 1, 1);
+      line_width_spin = gtk_spin_button_new_with_range (1, 20, 1);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (line_width_spin), 1);
+      gtk_grid_attach (GTK_GRID (grid), line_width_spin, 1, 1, 1, 1);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Line cap:"), 0, 2, 1, 1);
+      cap_combo = gtk_drop_down_new_from_strings ((const char *[]){"Butt", "Round", "Square", NULL});
+      gtk_grid_attach (GTK_GRID (grid), cap_combo, 1, 2, 1, 1);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Line join:"), 0, 3, 1, 1);
+      join_combo = gtk_drop_down_new_from_strings ((const char *[]){"Miter", "Miter-clip", "Round", "Bevel", "Arcs", NULL});
+      gtk_grid_attach (GTK_GRID (grid), join_combo, 1, 3, 1, 1);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Miter limit:"), 0, 4, 1, 1);
+      limit_spin = gtk_spin_button_new_with_range (0, 10, 1);
+      gtk_spin_button_set_digits (GTK_SPIN_BUTTON (limit_spin), 1);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (limit_spin), 4);
+      gtk_grid_attach (GTK_GRID (grid), limit_spin, 1, 4, 1, 1);
+
+      gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Dashes:"), 0, 5, 1, 1);
+      dash_entry = gtk_entry_new ();
+      gtk_grid_attach (GTK_GRID (grid), dash_entry, 1, 5, 1, 1);
+
+      stroke_toggle = gtk_check_button_new_with_label ("Show outline");
+      gtk_grid_attach (GTK_GRID (grid), stroke_toggle, 1, 6, 1, 1);
+
+      titlebar = gtk_header_bar_new ();
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (titlebar), edit_toggle);
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (titlebar), reset_button);
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (titlebar), stroke_button);
+
+      gtk_window_set_titlebar (GTK_WINDOW (window), titlebar);
+
+      demo = curve_editor_new ();
+
+      g_signal_connect (stroke_toggle, "toggled", G_CALLBACK (stroke_toggled), demo);
+      g_signal_connect (edit_toggle, "notify::active", G_CALLBACK (edit_changed), demo);
+      g_signal_connect (reset_button, "clicked", G_CALLBACK (reset), demo);
+      g_signal_connect (cap_combo, "notify::selected", G_CALLBACK (cap_changed), demo);
+      g_signal_connect (join_combo, "notify::selected", G_CALLBACK (join_changed), demo);
+      g_signal_connect (color_button, "notify::rgba", G_CALLBACK (color_changed), demo);
+      g_signal_connect (line_width_spin, "value-changed", G_CALLBACK (line_width_changed), demo);
+      g_signal_connect (limit_spin, "value-changed", G_CALLBACK (limit_changed), demo);
+      g_signal_connect (dash_entry, "notify::text", G_CALLBACK (dashes_changed), demo);
+
+      reset (NULL, CURVE_EDITOR (demo));
+
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (line_width_spin), 6);
+      gtk_color_dialog_button_set_rgba (GTK_COLOR_DIALOG_BUTTON (color_button), &(GdkRGBA) { 1, 0, 0, 1 });
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (cap_combo), GSK_LINE_CAP_ROUND);
+      //gtk_editable_set_text (GTK_EDITABLE (dash_entry), "0 8");
+
+      gtk_window_set_child (GTK_WINDOW (window), demo);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/demo.gresource.xml

@@ -127,6 +127,7 @@
     <file>fishbowl.ui</file>
     <file>gtkfishbowl.c</file>
     <file>gtkfishbowl.h</file>
+    <file>tiger.node</file>
   </gresource>
   <gresource prefix="/frames">
     <file>frames.ui</file>
@@ -258,6 +259,10 @@
   <gresource prefix="/video-player">
     <file>bbb.png</file>
   </gresource>
+  <gresource prefix="/curve">
+    <file>curve-editor.c</file>
+    <file>curve-editor.h</file>
+  </gresource>
   <gresource prefix="/sources">
     <file>application_demo.c</file>
     <file>assistant.c</file>
@@ -275,6 +280,7 @@
     <file>css_pixbufs.c</file>
     <file>css_shadows.c</file>
     <file>cursors.c</file>
+    <file>curve.c</file>
     <file>dialog.c</file>
     <file>drawingarea.c</file>
     <file>dnd.c</file>
@@ -294,6 +300,7 @@
     <file>gears.c</file>
     <file>gestures.c</file>
     <file>glarea.c</file>
+    <file>glyphs.c</file>
     <file>gltransition.c</file>
     <file>headerbar.c</file>
     <file>hypertext.c</file>

demos/gtk-demo/dnd.c

@@ -162,39 +162,27 @@ click_done (GtkGesture *gesture)
     gtk_widget_insert_after (item, canvas, last_child);
 }
 
-/* GtkSettings treats `GTK_THEME=foo:dark` as theme name `foo`, variant `dark`,
- * and our embedded CSS files let `foo-dark` work as an alias for `foo:dark`. */
-static gboolean
-has_dark_suffix (const char *theme)
-{
-  return g_str_has_suffix (theme, ":dark") ||
-         g_str_has_suffix (theme, "-dark");
-}
-
-/* So we can make a good guess whether the current theme is dark by checking for
- * either: it is suffixed `[:-]dark`, or Settings:…prefer-dark-theme is TRUE. */
 static gboolean
 theme_is_dark (void)
 {
-  const char *env_theme;
   GtkSettings *settings;
   char *theme;
   gboolean prefer_dark;
   gboolean dark;
 
-  /* Like GtkSettings, 1st see if theme is overridden by environment variable */
-  env_theme = g_getenv ("GTK_THEME");
-  if (env_theme != NULL)
-    return has_dark_suffix (env_theme);
-
-  /* If not, test Settings:…theme-name in the same way OR :…prefer-dark-theme */
   settings = gtk_settings_get_default ();
   g_object_get (settings,
                 "gtk-theme-name", &theme,
                 "gtk-application-prefer-dark-theme", &prefer_dark,
                 NULL);
-  dark = prefer_dark || has_dark_suffix (theme);
+
+  if ((strcmp (theme, "Adwaita") == 0 && prefer_dark) || strcmp (theme, "HighContrastInverse") == 0)
+    dark = TRUE;
+  else
+    dark = FALSE;
+
   g_free (theme);
+
   return dark;
 }
 

demos/gtk-demo/fishbowl.c

@@ -11,6 +11,9 @@
 #include "gtkgears.h"
 #include "gskshaderpaintable.h"
 
+#include "nodewidget.h"
+#include "graphwidget.h"
+
 const char *const css =
 ".blurred-button {"
 "  box-shadow: 0px 0px 5px 10px rgba(0, 0, 0, 0.5);"
@@ -203,6 +206,18 @@ create_menu_button (void)
   return w;
 }
 
+static GtkWidget *
+create_tiger (void)
+{
+  return node_widget_new ("/fishbowl/tiger.node");
+}
+
+static GtkWidget *
+create_graph (void)
+{
+  return graph_widget_new ();
+}
+
 static const struct {
   const char *name;
   GtkWidget * (*create_func) (void);
@@ -220,6 +235,8 @@ static const struct {
   { "Switch",     create_switch         },
   { "Menubutton", create_menu_button    },
   { "Shader",     create_cogs           },
+  { "Tiger",      create_tiger          },
+  { "Graph",      create_graph          },
 };
 
 static int selected_widget_type = -1;

demos/gtk-demo/graphwidget.c

@@ -0,0 +1,164 @@
+#include "graphwidget.h"
+
+struct _GraphWidget
+{
+  GtkWidget parent_instance;
+
+  GskPath *path;
+  GskStroke *stroke;
+  GdkRGBA color;
+  GskPath *stroke_path;
+
+  guint tick_cb;
+  guint64 start_time;
+
+  double period;
+  double amplitude;
+};
+
+struct _GraphWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GraphWidget, graph_widget, GTK_TYPE_WIDGET)
+
+static void
+update_path (GraphWidget *self,
+             float        amplitude)
+{
+  graphene_point_t p[20];
+  GskPathBuilder *builder;
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->stroke_path, gsk_path_unref);
+
+  for (int i = 0; i < 20; i++)
+    {
+      p[i].x = 10 * i;
+      p[i].y = 50;
+
+      if (i % 4 == 1 || i % 4 == 2)
+        {
+          if (i % 8 < 4)
+            p[i].y += amplitude;
+          else
+            p[i].y -= amplitude;
+        }
+    }
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder, p[0].x, p[0].y);
+
+  for (int i = 0; i < 20; i += 4)
+    gsk_path_builder_cubic_to (builder,
+                               p[i+1].x, p[i+1].y,
+                               p[i+2].x, p[i+2].y,
+                               p[i+3].x, p[i+3].y);
+
+  self->path = gsk_path_builder_free_to_path (builder);
+  self->stroke_path = gsk_path_stroke (self->path, self->stroke);
+}
+
+static gboolean
+tick_cb (GtkWidget     *widget,
+         GdkFrameClock *frame_clock,
+         gpointer       user_data)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+  guint64 now;
+  double angle;
+
+  now = gdk_frame_clock_get_frame_time (frame_clock);
+
+  if (self->start_time == 0)
+    self->start_time = now;
+
+  angle = 360 * (now - self->start_time) / (double)(self->period * G_TIME_SPAN_MINUTE);
+  update_path (self, sin (angle) * self->amplitude);
+
+  gtk_widget_queue_draw (widget);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+graph_widget_init (GraphWidget *self)
+{
+  self->color.red = g_random_double_range (0, 1);
+  self->color.green = g_random_double_range (0, 1);
+  self->color.blue = g_random_double_range (0, 1);
+  self->color.alpha = 1;
+
+  self->period = g_random_double_range (0.5, 1);
+  self->amplitude = g_random_double_range (10, 25);
+
+  self->stroke = gsk_stroke_new (2);
+
+  update_path (self, 0);
+
+  self->start_time = 0;
+  self->tick_cb = gtk_widget_add_tick_callback (GTK_WIDGET (self), tick_cb, NULL, NULL);
+}
+
+static void
+graph_widget_dispose (GObject *object)
+{
+  GraphWidget *self = GRAPH_WIDGET (object);
+
+  gsk_path_unref (self->path);
+  gsk_stroke_free (self->stroke);
+
+  G_OBJECT_CLASS (graph_widget_parent_class)->dispose (object);
+}
+
+static void
+graph_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+  int width, height;
+
+  width = gtk_widget_get_width (widget);
+  height = gtk_widget_get_height (widget);
+
+  gtk_snapshot_push_fill (snapshot, self->stroke_path, GSK_FILL_RULE_WINDING);
+  gtk_snapshot_append_color (snapshot,
+                             &self->color,
+                             &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+}
+
+static void
+graph_widget_measure (GtkWidget      *widget,
+                      GtkOrientation  orientation,
+                      int             for_size,
+                      int            *minimum,
+                      int            *natural,
+                      int            *minimum_baseline,
+                      int            *natural_baseline)
+{
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = 200;
+  else
+    *minimum = *natural = 100;
+}
+
+
+static void
+graph_widget_class_init (GraphWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = graph_widget_dispose;
+
+  widget_class->snapshot = graph_widget_snapshot;
+  widget_class->measure = graph_widget_measure;
+}
+
+GtkWidget *
+graph_widget_new (void)
+{
+  return g_object_new (GRAPH_TYPE_WIDGET, NULL);
+}

demos/gtk-demo/graphwidget.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define GRAPH_TYPE_WIDGET (graph_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GraphWidget, graph_widget, GRAPH, WIDGET, GtkWidget)
+
+GtkWidget * graph_widget_new       (void);

demos/gtk-demo/listview_applauncher.c

@@ -52,10 +52,6 @@ setup_listitem_cb (GtkListItemFactory *factory,
 
   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
   image = gtk_image_new ();
-  gtk_accessible_update_property (GTK_ACCESSIBLE (image),
-                                  GTK_ACCESSIBLE_PROPERTY_LABEL,
-                                  "App icon",
-                                  -1);
   gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
   gtk_box_append (GTK_BOX (box), image);
   label = gtk_label_new ("");
@@ -83,7 +79,6 @@ bind_listitem_cb (GtkListItemFactory *factory,
 
   gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
   gtk_label_set_label (GTK_LABEL (label), g_app_info_get_display_name (app_info));
-  gtk_list_item_set_accessible_label (list_item, g_app_info_get_display_name (app_info));
 }
 
 /* In more complex code, we would also need functions to unbind and teardown

demos/gtk-demo/listview_clocks.c

@@ -431,9 +431,6 @@ setup_listitem_cb (GtkListItemFactory *factory,
   picture = gtk_picture_new ();
   gtk_expression_bind (expression, picture, "paintable", picture);
   gtk_box_append (GTK_BOX (box), picture);
-  gtk_accessible_update_relation (GTK_ACCESSIBLE (picture),
-                                  GTK_ACCESSIBLE_RELATION_LABELLED_BY, location_label, NULL,
-                                  -1);
 
 
   /* And finally, everything comes together.
@@ -490,9 +487,6 @@ do_listview_clocks (GtkWidget *do_widget)
 
       model = GTK_SELECTION_MODEL (gtk_no_selection_new (create_clocks_model ()));
       gridview = gtk_grid_view_new (model, factory);
-      gtk_accessible_update_property (GTK_ACCESSIBLE (gridview),
-                                      GTK_ACCESSIBLE_PROPERTY_LABEL, "Clocks",
-                                      -1);
       gtk_scrollable_set_hscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
       gtk_scrollable_set_vscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
 

demos/gtk-demo/meson.build

@@ -17,6 +17,7 @@ demos = files([
   'css_pixbufs.c',
   'css_shadows.c',
   'cursors.c',
+  'curve.c',
   'dialog.c',
   'drawingarea.c',
   'dnd.c',
@@ -34,6 +35,7 @@ demos = files([
   'gestures.c',
   'glarea.c',
   'gltransition.c',
+  'glyphs.c',
   'headerbar.c',
   'hypertext.c',
   'iconscroll.c',
@@ -139,6 +141,10 @@ extra_demo_sources = files([
   'unicode-names.c',
   'suggestionentry.c',
   'language-names.c',
+  'nodewidget.c',
+  'graphwidget.c',
+  'curve-editor.c',
+  'cepath.c',
 ])
 
 if os_unix
@@ -161,7 +167,17 @@ demos_h = custom_target('gtk4 demo header',
   command: [ find_program('geninclude.py'), '@OUTPUT@', '@INPUT@' ],
 )
 
-if can_use_objcopy_for_resources
+objcopy_supports_add_symbol = false
+objcopy = find_program('objcopy', required : false)
+if objcopy.found()
+  objcopy_supports_add_symbol = run_command(objcopy, '--help', check: false).stdout().contains('--add-symbol')
+endif
+
+ld = find_program('ld', required : false)
+
+if not meson.is_cross_build() and build_machine.cpu_family() != 'arm' and build_machine.system() == 'linux' and objcopy.found() and objcopy_supports_add_symbol and ld.found()
+  glib_compile_resources = find_program('glib-compile-resources')
+
   # Create the resource blob
   gtkdemo_gresource = custom_target('gtkdemo.gresource',
       input : 'demo.gresource.xml',

demos/gtk-demo/nodewidget.c

@@ -0,0 +1,76 @@
+#include "nodewidget.h"
+
+struct _NodeWidget
+{
+  GtkWidget parent_instance;
+
+  GskRenderNode *node;
+};
+
+struct _NodeWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (NodeWidget, node_widget, GTK_TYPE_WIDGET)
+
+static void
+node_widget_init (NodeWidget *self)
+{
+}
+
+static void
+node_widget_dispose (GObject *object)
+{
+  NodeWidget *self = NODE_WIDGET (object);
+
+  gsk_render_node_unref (self->node);
+
+  G_OBJECT_CLASS (node_widget_parent_class)->dispose (object);
+}
+
+static void
+node_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  NodeWidget *self = NODE_WIDGET (widget);
+
+  gtk_snapshot_append_node (snapshot, self->node);
+}
+
+static void
+node_widget_class_init (NodeWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = node_widget_dispose;
+
+  widget_class->snapshot = node_widget_snapshot;
+}
+
+GtkWidget *
+node_widget_new (const char *resource)
+{
+  NodeWidget *self;
+  GBytes *bytes;
+  GskRenderNode *node;
+  graphene_rect_t bounds;
+  float scale;
+  GskTransform *transform;
+
+  self = g_object_new (NODE_TYPE_WIDGET, NULL);
+
+  bytes = g_resources_lookup_data (resource, 0, NULL);
+  node = gsk_render_node_deserialize (bytes, NULL, NULL);
+  g_bytes_unref (bytes);
+
+  gsk_render_node_get_bounds (node, &bounds);
+  scale = MIN (100.0/bounds.size.width, 100.0/bounds.size.height);
+  transform = gsk_transform_scale (NULL, scale, scale);
+  self->node = gsk_transform_node_new (node, transform);
+  gsk_transform_unref (transform);
+  gsk_render_node_unref (node);
+
+  return GTK_WIDGET (self);
+}

demos/gtk-demo/nodewidget.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define NODE_TYPE_WIDGET (node_widget_get_type ())
+G_DECLARE_FINAL_TYPE (NodeWidget, node_widget, NODE, WIDGET, GtkWidget)
+
+GtkWidget * node_widget_new       (const char *file);

demos/gtk-demo/path_fill.c

@@ -60,7 +60,7 @@ gtk_path_paintable_snapshot (GdkPaintable *paintable,
 #if 0
   gtk_snapshot_push_fill (snapshot, self->path, GSK_FILL_RULE_WINDING);
 #else
-  GskStroke *stroke = gsk_stroke_new (4.0);
+  GskStroke *stroke = gsk_stroke_new (2.0);
   gtk_snapshot_push_stroke (snapshot, self->path, stroke);
   gsk_stroke_free (stroke);
 #endif
@@ -206,33 +206,66 @@ create_hexagon (GtkWidget *widget)
 static GskPath *
 create_path_from_text (GtkWidget *widget)
 {
-  cairo_surface_t *surface;
-  cairo_t *cr;
-  cairo_path_t *path;
   PangoLayout *layout;
   PangoFontDescription *desc;
-  GskPath *result;
-
-  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
-  cr = cairo_create (surface);
+  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);
 
-  pango_cairo_layout_path (cr, layout);
-  path = cairo_copy_path_flat (cr);
-  result = gsk_path_new_from_cairo (path);
+  builder = gsk_path_builder_new ();
 
-  cairo_path_destroy (path);
-  g_object_unref (layout);
-  cairo_destroy (cr);
-  cairo_surface_destroy (surface);
+  gsk_path_builder_add_layout (builder, layout);
 
-  return result;
+  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,
@@ -241,23 +274,30 @@ update_path (GtkWidget     *widget,
   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_measure_add_segment (measure,
-                                builder,
-                                progress > 1 ? (progress - 1) * gsk_path_measure_get_length (measure) : 0.0,
-                                (progress < 1 ? progress : 1.0) * gsk_path_measure_get_length (measure));
+  gsk_path_dash (path, stroke, 0.2, build_path, builder);
+
+  point = gsk_path_measure_get_point (measure,
+                                      (progress > 1 ? (progress - 1) : progress) * gsk_path_measure_get_length (measure));
+  gsk_path_point_get_position (point, &pos);
+  gsk_path_point_get_tangent (point, GSK_PATH_END, &tangent);
+  gsk_path_point_unref (point);
 
-  gsk_path_measure_get_point (measure,
-                              (progress > 1 ? (progress - 1) : progress) * gsk_path_measure_get_length (measure),
-                              &pos,
-                              &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))),

demos/gtk-demo/path_maze.c

@@ -137,10 +137,17 @@ pointer_motion (GtkEventControllerMotion *controller,
                 double                    y,
                 GtkMaze                  *self)
 {
+  GskPathPoint *point;
+  graphene_point_t pos;
+
   if (!self->active)
     return;
 
-  if (gsk_path_measure_get_closest_point (self->measure, &GRAPHENE_POINT_INIT (x, y), NULL) <= MAZE_STROKE_SIZE_ACTIVE / 2.0f)
+  point = gsk_path_measure_get_closest_point (self->measure, &GRAPHENE_POINT_INIT (x, y), INFINITY);
+  gsk_path_point_get_position (point, &pos);
+  gsk_path_point_unref (point);
+
+  if (graphene_point_distance (&pos, &GRAPHENE_POINT_INIT (x, y), NULL, NULL) <= MAZE_STROKE_SIZE_ACTIVE / 2.0f)
     return;
 
   self->active = FALSE;

demos/gtk-demo/path_text.c

@@ -48,32 +48,26 @@ G_DEFINE_TYPE (GtkPathWidget, gtk_path_widget, GTK_TYPE_WIDGET)
 
 static GskPath *
 create_path_from_text (GtkWidget  *widget,
-                       const char *text)
+                       const char *text,
+                       graphene_point_t *out_offset)
 {
-  cairo_surface_t *surface;
-  cairo_t *cr;
-  cairo_path_t *path;
   PangoLayout *layout;
   PangoFontDescription *desc;
+  GskPathBuilder *builder;
   GskPath *result;
 
-  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
-  cr = cairo_create (surface);
-
   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);
 
-  cairo_move_to (cr, 0, - pango_layout_get_baseline (layout) / (double) PANGO_SCALE);
-  pango_cairo_layout_path (cr, layout);
-  path = cairo_copy_path_flat (cr);
-  result = gsk_path_new_from_cairo (path);
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_layout (builder, layout);
+  result = gsk_path_builder_free_to_path (builder);
 
-  cairo_path_destroy (path);
+  if (out_offset)
+    graphene_point_init (out_offset, 0, - pango_layout_get_baseline (layout) / (double) PANGO_SCALE);
   g_object_unref (layout);
-  cairo_destroy (cr);
-  cairo_surface_destroy (surface);
 
   return result;
 }
@@ -82,27 +76,34 @@ 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;
 
-  gsk_path_measure_get_point (measure, pt->x * scale, res, &tangent);
+  point = gsk_path_measure_get_point (measure, (pt->x + offset->x) * scale);
+  gsk_path_point_get_position (point, res);
+  gsk_path_point_get_tangent (point, GSK_PATH_END, &tangent);
+  gsk_path_point_unref (point);
 
-  res->x -= pt->y * scale * graphene_vec2_get_y (&tangent);
-  res->y += pt->y * scale * graphene_vec2_get_x (&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;
@@ -112,7 +113,7 @@ gtk_path_transform_op (GskPathOperation        op,
     case GSK_PATH_MOVE:
       {
         graphene_point_t res;
-        gtk_path_transform_point (transform->measure, &pts[0], transform->scale, &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;
@@ -120,18 +121,36 @@ gtk_path_transform_op (GskPathOperation        op,
     case GSK_PATH_LINE:
       {
         graphene_point_t res;
-        gtk_path_transform_point (transform->measure, &pts[1], transform->scale, &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_CURVE:
+    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->scale, &res[0]);
-        gtk_path_transform_point (transform->measure, &pts[2], transform->scale, &res[1]);
-        gtk_path_transform_point (transform->measure, &pts[3], transform->scale, &res[2]);
-        gsk_path_builder_curve_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, res[2].x, res[2].y);
+        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;
 
@@ -148,10 +167,11 @@ gtk_path_transform_op (GskPathOperation        op,
 }
 
 static GskPath *
-gtk_path_transform (GskPathMeasure *measure,
-                    GskPath        *path)
+gtk_path_transform (GskPathMeasure         *measure,
+                    GskPath                *path,
+                    const graphene_point_t *offset)
 {
-  GtkPathTransform transform = { measure, gsk_path_builder_new () };
+  GtkPathTransform transform = { measure, gsk_path_builder_new (), *offset };
   graphene_rect_t bounds;
 
   gsk_path_get_bounds (path, &bounds);
@@ -160,7 +180,7 @@ gtk_path_transform (GskPathMeasure *measure,
   else
     transform.scale = 1.0f;
 
-  gsk_path_foreach (path, GSK_PATH_FOREACH_ALLOW_CURVES, gtk_path_transform_op, &transform);
+  gsk_path_foreach (path, -1, gtk_path_transform_op, &transform);
 
   return gsk_path_builder_free_to_path (transform.builder);
 }
@@ -184,14 +204,15 @@ 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);
-  self->text_path = gtk_path_transform (self->line_measure, path);
+  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);
 }
@@ -211,7 +232,7 @@ gtk_path_widget_create_paths (GtkPathWidget *self)
   builder = gsk_path_builder_new ();
   gsk_path_builder_move_to (builder,
                             self->points[0].x * width, self->points[0].y * height);
-  gsk_path_builder_curve_to (builder,
+  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);
@@ -304,10 +325,13 @@ gtk_path_widget_snapshot (GtkWidget   *widget,
   if (self->line_closest >= 0)
     {
       GskPathBuilder *builder;
+      GskPathPoint *point;
       graphene_point_t closest;
 
       builder = gsk_path_builder_new ();
-      gsk_path_measure_get_point (self->line_measure, self->line_closest, &closest, NULL);
+      point = gsk_path_measure_get_point (self->line_measure, self->line_closest);
+      gsk_path_point_get_position (point, &closest);
+      gsk_path_point_unref (point);
       gsk_path_builder_add_circle (builder, &closest, POINT_SIZE);
       path = gsk_path_builder_free_to_path (builder);
 
@@ -495,11 +519,15 @@ pointer_motion (GtkEventControllerMotion *controller,
                 double                    y,
                 GtkPathWidget            *self)
 {
-  gsk_path_measure_get_closest_point_full (self->line_measure,
-                                           &GRAPHENE_POINT_INIT (x, y),
-                                           INFINITY,
-                                           &self->line_closest,
-                                           NULL, NULL, NULL);
+  GskPathPoint *point;
+  graphene_point_t pos;
+
+  point = gsk_path_measure_get_closest_point (self->line_measure,
+                                              &GRAPHENE_POINT_INIT (x, y),
+                                              INFINITY);
+  gsk_path_point_get_position (point, &pos);
+  self->line_closest = graphene_point_distance (&pos, &GRAPHENE_POINT_INIT (x, y), NULL, NULL);
+  gsk_path_point_unref (point);
 
   gtk_widget_queue_draw (GTK_WIDGET (self));
 }

demos/widget-factory/meson.build

@@ -1,6 +1,16 @@
 # demos/widget-factory
 
-if can_use_objcopy_for_resources
+objcopy_supports_add_symbol = false
+objcopy = find_program('objcopy', required : false)
+if objcopy.found()
+  objcopy_supports_add_symbol = run_command(objcopy, '--help', check: false).stdout().contains('--add-symbol')
+endif
+
+ld = find_program('ld', required : false)
+
+if not meson.is_cross_build() and build_machine.cpu_family() != 'arm' and build_machine.system() == 'linux' and objcopy.found() and objcopy_supports_add_symbol and ld.found()
+  glib_compile_resources = find_program('glib-compile-resources')
+
   # Create the resource blob
   widgetfactory_gresource = custom_target('widgetfactory.gresource',
       input : 'widget-factory.gresource.xml',

demos/widget-factory/widget-factory.ui

@@ -1572,9 +1572,6 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
                                     <property name="valign">3</property>
                                     <child>
                                       <object class="GtkVolumeButton">
-                                        <accessibility>
-                                          <property name="label" translatable="1">Volume</property>
-                                        </accessibility>
                                         <property name="orientation">1</property>
                                         <property name="valign">3</property>
                                         <property name="value">.5</property>
@@ -1587,9 +1584,6 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
                                     </child>
                                     <child>
                                       <object class="GtkScaleButton" id="mic-button">
-                                        <accessibility>
-                                          <property name="label" translatable="1">Microphone gain</property>
-                                        </accessibility>
                                         <property name="has-tooltip">1</property>
                                         <property name="icons">microphone-sensitivity-muted-symbolic
 microphone-sensitivity-high-symbolic

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

@@ -16,7 +16,6 @@ SYNOPSIS
 |   **gtk4-builder-tool** enumerate [OPTIONS...] <FILE>
 |   **gtk4-builder-tool** simplify [OPTIONS...] <FILE>
 |   **gtk4-builder-tool** preview [OPTIONS...] <FILE>
-|   **gtk4-builder-tool** render [OPTIONS...] <FILE>
 |   **gtk4-builder-tool** screenshot [OPTIONS...] <FILE>
 
 DESCRIPTION
@@ -70,11 +69,12 @@ file to use.
 
   Load style information from the given CSS file.
 
-Render
-^^^^^^
+Screenshot
+^^^^^^^^^^
 
-The ``render`` command saves a rendering of the UI definition file as a png image
-or node file. The name of the file to write can be specified as a second FILE argument.
+The ``screenshot`` command saves a rendering of the UI definition file
+as a png image or node file. The name of the file to write can be specified as
+a second FILE argument.
 
 This command accepts options to specify the ID of the toplevel object and a CSS
 file to use.
@@ -96,11 +96,6 @@ file to use.
 
   Overwrite an existing file.
 
-Screenshot
-^^^^^^^^^^
-
-The ``screenshot`` command is an alias for ``render``.
-
 Simplification
 ^^^^^^^^^^^^^^
 

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

@@ -0,0 +1,207 @@
+.. _gtk4-path-tool(1):
+
+=================
+gtk4-path-tool
+=================
+
+-----------------------
+GskPath Utility
+-----------------------
+
+SYNOPSIS
+--------
+|   **gtk4-path-tool** <COMMAND> [OPTIONS...] <PATH>
+|
+|   **gtk4-path-tool** stroke [OPTIONS...] <PATH>
+|   **gtk4-path-tool** offset [OPTIONS...] <PATH>
+|   **gtk4-path-tool** simplify [OPTIONS...] <PATH>
+|   **gtk4-path-tool** intersection [OPTIONS...] <PATH> <PATH>
+|   **gtk4-path-tool** union [OPTIONS...] <PATH> <PATH>
+|   **gtk4-path-tool** difference [OPTIONS...] <PATH> <PATH>
+|   **gtk4-path-tool** symmetric-difference [OPTIONS...] <PATH> <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
+--------
+
+Stroking
+^^^^^^^^
+
+The ``stroke`` command performs a stroke operation along the path according to
+the parameters specified via options.
+
+``--line-width=VALUE``
+
+  The line width to use for the stroke. ``VALUE`` must be a positive number.
+  The default line width is 1.
+
+``--line-cap=VALUE``
+
+  The cap style to use at line ends. The possible values are ``butt``, ``round``
+  or ``square``. See the SVG specification for details on these styles.
+  The default cap style is ``butt``.
+
+``--line-join=VALUE``
+
+  The join style to use at line joins. The possible values are ``miter``,
+  ``miter-clip``, ``round``, ``bevel`` or ``arcs``. See the SVG specification
+  for details on these styles.
+  The default join style is ``miter``.
+
+``--miter-limit=VALUE``
+
+  The limit at which to clip miters at line joins. The default value is 4.
+
+``--dashes=VALUE``
+
+  The dash pattern to use for this stroke. A dash pattern is specified by
+  a comma-separated list of alternating non-negative numbers. Each number
+  provides the length of alternate "on" and "off" portions of the stroke.
+  If the dash pattern is empty, dashing is disabled, which is the default.
+  See the SVG specification for details on dashing.
+
+``--dash-offset=VALUE``
+
+  The offset into the dash pattern where dashing should begin.
+  The default value is 0.
+
+Offsetting
+^^^^^^^^^^
+
+The ``offset`` command applies a lateral offset to the path. Note that this
+is different from applying a translation transformation.
+
+``--distance=VALUE``
+
+  The distance by which to offset the path. Positive values offset to the right,
+  negative values to the left (wrt to the direction of the path). The default
+  value is 0.
+
+``--line-join=VALUE``
+
+  The join style to use at line joins. The possible values are ``miter``,
+  ``miter-clip``, ``round``, ``bevel`` or ``arcs``. See the SVG specification
+  for details on these styles.
+  The default join style is ``miter``.
+
+``--miter-limit=VALUE``
+
+  The limit at which to clip miters at line joins. The default value is 4.
+
+Boolean Operations
+^^^^^^^^^^^^^^^^^^
+
+The ``intersection``, ``union``, ``difference`` and ``symmetric-difference`` commands
+perform boolean operations on paths. Given two paths, they create a new path which
+encircles the area that is the intersection, union, difference or symmetric difference
+of the areas encircled by the paths.
+
+Simplification
+^^^^^^^^^^^^^^
+
+The ``simplify`` command removes areas of overlap from a path such that the resulting
+path encircles the same area, but every edge in the resulting path is a boundary between
+the inside and the outside.
+
+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 the number of contours, its bounding box and and its length.
+
+REFERENCES
+----------
+
+- SVG Path Specification, https://www.w3.org/TR/SVG2/paths.html

docs/reference/gtk/meson.build

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

docs/reference/gtk/running.md

@@ -211,9 +211,6 @@ A number of options affect behavior instead of logging:
 `portals`
 : Force the use of [portals](https://docs.flatpak.org/en/latest/portals.html)
 
-`no-portals`
-: Disable use of [portals](https://docs.flatpak.org/en/latest/portals.html)
-
 `gl-disable`
 : Disable OpenGL support
 

docs/reference/gtk/section-accessibility.md

@@ -31,7 +31,7 @@ described by a set of *attributes*.
 Roles define the taxonomy and semantics of a UI control to any assistive
 technology application; for instance, a button will have a role of
 `GTK_ACCESSIBLE_ROLE_BUTTON`; an entry will have a role of
-`GTK_ACCESSIBLE_ROLE_TEXTBOX`; a check button will have a role of
+`GTK_ACCESSIBLE_ROLE_TEXTBOX`; a toggle button will have a role of
 `GTK_ACCESSIBLE_ROLE_CHECKBOX`; etc.
 
 Each role is part of the widget's instance, and **cannot** be changed over
@@ -46,7 +46,6 @@ Each role name is part of the #GtkAccessibleRole enumeration.
 
 | Role name | Description | Related GTK widget |
 |-----------|-------------|--------------------|
-| `APPLICATION` | An application window | [class@Gtk.Window] |
 | `BUTTON` | A control that performs an action when pressed | [class@Gtk.Button], [class@Gtk.LinkButton], [class@Gtk.Expander] |
 | `CHECKBOX` | A control that has three possible value: `true`, `false`, or `undefined` | [class@Gtk.CheckButton] |
 | `COMBOBOX` | A control that can be expanded to show a list of possible values to select | [class@Gtk.ComboBox] |
@@ -79,6 +78,7 @@ Each role name is part of the #GtkAccessibleRole enumeration.
 | `TAB_PANEL` | A page in a notebook or stack | [class@Gtk.Stack] |
 | `TEXT_BOX` | A type of input that allows free-form text as its value. | [class@Gtk.Entry], [class@Gtk.PasswordEntry], [class@Gtk.TextView] |
 | `TREE_GRID` | A treeview-like columned list | [class@Gtk.ColumnView] |
+| `WINDOW` | An application window | [class@Gtk.Window] |
 | `...` | … |
 
 See the [WAI-ARIA](https://www.w3.org/WAI/PF/aria/appendices#quickref) list
@@ -216,16 +216,6 @@ are accessible as part of the development process. The GTK Inspector shows
 the accessible attributes of each widget, and also provides an overlay that
 can highlight accessibility issues.
 
-It is possible to set accessible attributes in UI files as well:
-```xml
-<object class="GtkButton" id="button1">
-  <accessibility>
-    <property name="label">Download</property>
-    <relation name="labelled-by">label1</relation>
-  /accessibility>
-</object>
-```
-
 ## Implementations
 
 Each UI control implements the `GtkAccessible` interface to allow widget and
@@ -267,13 +257,6 @@ turn automatically any widget into a `GtkButton`; but if your widget behaves
 like a button, using the %GTK_ACCESSIBLE_ROLE_BUTTON will allow any
 assistive technology to handle it like they would a `GtkButton`.
 
-For widgets that act as containers of other widgets, you should use
-%GTK_ACCESSIBLE_ROLE_GROUP if the grouping of the children is semantic
-in nature; for instance, the children of a [class@Gtk.HeaderBar] are
-grouped together on the header of a window. For generic containers that
-only impose a layout on their children, you should use
-%GTK_ACCESSIBLE_ROLE_GENERIC instead.
-
 ### Attributes can both hide and enhance
 
 Accessible attributes can be used to override the content of a UI element,
@@ -382,6 +365,3 @@ To allow changing the value via accessible technologies, you can export
 actions.  Since the accessibility interfaces only support actions
 without parameters, you should provide actions such as `increase-value`
 and `decrease-value`.
-
-Since GTK 4.10, the best way to suppose changing the value is by implementing
-the [iface@Gtk.AccessibleRange] interface.

gdk/gdkdisplayprivate.h

@@ -100,10 +100,6 @@ struct _GdkDisplay
   VkDevice vk_device;
   VkQueue vk_queue;
   uint32_t vk_queue_family_index;
-  VkPipelineCache vk_pipeline_cache;
-  gsize vk_pipeline_cache_size;
-  char *vk_pipeline_cache_etag;
-  guint vk_save_pipeline_cache_source;
 
   guint vulkan_refcount;
 #endif /* GDK_RENDERING_VULKAN */

gdk/gdkvulkancontext.c

@@ -52,7 +52,6 @@ struct _GdkVulkanContextPrivate {
     GdkMemoryFormat gdk_format;
   } formats[4];
   GdkMemoryDepth current_format;
-  GdkMemoryFormat offscreen_formats[4];
 
   VkSwapchainKHR swapchain;
   VkSemaphore draw_semaphore;
@@ -694,11 +693,6 @@ gdk_vulkan_context_real_init (GInitable     *initable,
   if (!priv->vulkan_ref)
     return FALSE;
 
-  priv->offscreen_formats[GDK_MEMORY_U8] = GDK_MEMORY_B8G8R8A8_PREMULTIPLIED;
-  priv->offscreen_formats[GDK_MEMORY_U16] = GDK_MEMORY_R16G16B16A16_PREMULTIPLIED;
-  priv->offscreen_formats[GDK_MEMORY_FLOAT16] = GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED;
-  priv->offscreen_formats[GDK_MEMORY_FLOAT32] = GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED;
-
   if (surface == NULL)
     {
       for (i = 0; i < G_N_ELEMENTS (priv->formats); i++)
@@ -754,7 +748,6 @@ gdk_vulkan_context_real_init (GInitable     *initable,
                   {
                     priv->formats[GDK_MEMORY_U8].vk_format = formats[i];
                     priv->formats[GDK_MEMORY_U8].gdk_format = GDK_MEMORY_B8G8R8A8_PREMULTIPLIED;
-                    priv->offscreen_formats[GDK_MEMORY_U8] = GDK_MEMORY_B8G8R8A8_PREMULTIPLIED;
                   };
                 break;
 
@@ -834,15 +827,6 @@ out_surface:
   return FALSE;
 }
 
-GdkMemoryFormat
-gdk_vulkan_context_get_offscreen_format (GdkVulkanContext *context,
-                                         GdkMemoryDepth    depth)
-{
-  GdkVulkanContextPrivate *priv = gdk_vulkan_context_get_instance_private (context);
-
-  return priv->offscreen_formats[depth];
-}
-
 static void
 gdk_vulkan_context_initable_init (GInitableIface *iface)
 {
@@ -931,216 +915,6 @@ gdk_vulkan_context_get_queue_family_index (GdkVulkanContext *context)
   return gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context))->vk_queue_family_index;
 }
 
-static char *
-gdk_vulkan_get_pipeline_cache_dirname (void)
-{
-  return g_build_filename (g_get_user_cache_dir (), "gtk-4.0", "vulkan-pipeline-cache", NULL);
-}
-
-static GFile *
-gdk_vulkan_get_pipeline_cache_file (GdkDisplay *display)
-{
-  VkPhysicalDeviceProperties props;
-  char *dirname, *basename, *path;
-  GFile *result;
-
-  vkGetPhysicalDeviceProperties (display->vk_physical_device, &props);
-
-  dirname = gdk_vulkan_get_pipeline_cache_dirname ();
-  basename = g_strdup_printf ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x"
-                              "-%02x%02x%02x%02x%02x%02x.%u",
-                              props.pipelineCacheUUID[0], props.pipelineCacheUUID[1],
-                              props.pipelineCacheUUID[2], props.pipelineCacheUUID[3],
-                              props.pipelineCacheUUID[4], props.pipelineCacheUUID[5],
-                              props.pipelineCacheUUID[6], props.pipelineCacheUUID[7],
-                              props.pipelineCacheUUID[8], props.pipelineCacheUUID[9],
-                              props.pipelineCacheUUID[10], props.pipelineCacheUUID[11],
-                              props.pipelineCacheUUID[12], props.pipelineCacheUUID[13],
-                              props.pipelineCacheUUID[14], props.pipelineCacheUUID[15],
-                              props.driverVersion);
-
-  path = g_build_filename (dirname, basename, NULL);
-  result = g_file_new_for_path (path);
-
-  g_free (path);
-  g_free (basename);
-  g_free (dirname);
-
-  return result;
-}
-
-static VkPipelineCache
-gdk_display_load_pipeline_cache (GdkDisplay *display)
-{
-  GError *error = NULL;
-  VkPipelineCache result;
-  GFile *cache_file;
-  char *etag, *data;
-  gsize size;
-
-  cache_file = gdk_vulkan_get_pipeline_cache_file (display);
-  if (!g_file_load_contents (cache_file, NULL, &data, &size, &etag, &error))
-    {
-      GDK_DEBUG (VULKAN, "failed to load Vulkan pipeline cache file '%s': %s\n",
-                 g_file_peek_path (cache_file), error->message);
-      g_object_unref (cache_file);
-      g_clear_error (&error);
-      return VK_NULL_HANDLE;
-    }
-
-  if (GDK_VK_CHECK (vkCreatePipelineCache, display->vk_device,
-                                           &(VkPipelineCacheCreateInfo) {
-                                             .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
-                                             .initialDataSize = size,
-                                             .pInitialData = data,
-                                           },
-                                           NULL,
-                                           &result) != VK_SUCCESS)
-    result = VK_NULL_HANDLE;
-
-  g_free (data);
-  g_free (display->vk_pipeline_cache_etag);
-  display->vk_pipeline_cache_etag = etag;
-  display->vk_pipeline_cache_size = size;
-
-  return result;
-}
-
-static gboolean
-gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
-{
-  GError *error = NULL;
-  VkDevice device;
-  VkPipelineCache cache;
-  GFile *file;
-  char *path;
-  size_t size;
-  char *data, *etag;
-
-  device = display->vk_device;
-  cache = display->vk_pipeline_cache;
-
-  GDK_VK_CHECK (vkGetPipelineCacheData, device, cache, &size, NULL);
-  if (size == 0)
-    return TRUE;
-  
-  if (size == display->vk_pipeline_cache_size)
-    {
-      GDK_DEBUG (VULKAN, "pipeline cache size (%zu bytes) unchanged, skipping save", size);
-      return TRUE;
-    }
-
-
-  data = g_malloc (size);
-  if (GDK_VK_CHECK (vkGetPipelineCacheData, device, cache, &size, data) != VK_SUCCESS)
-    {
-      g_free (data);
-      return FALSE;
-    }
-
-  path = gdk_vulkan_get_pipeline_cache_dirname ();
-  if (g_mkdir_with_parents (path, 0755) != 0)
-    {
-      g_warning_once ("Failed to create pipeline cache directory");
-      g_free (path);
-      return FALSE;
-    }
-  g_free (path);
-
-  file = gdk_vulkan_get_pipeline_cache_file (display);
-
-  GDK_DEBUG (VULKAN, "Saving pipeline cache to %s", g_file_peek_path (file));
-
-  if (!g_file_replace_contents (file,
-                                data,
-                                size,
-                                display->vk_pipeline_cache_etag,
-                                FALSE,
-                                0,
-                                &etag,
-                                NULL,
-                                &error))
-    {
-      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WRONG_ETAG))
-        {
-          VkPipelineCache new_cache;
-          
-          GDK_DEBUG (VULKAN, "Pipeline cache file modified, merging into current");
-          new_cache = gdk_display_load_pipeline_cache (display);
-          if (new_cache)
-            {
-              GDK_VK_CHECK (vkMergePipelineCaches, device, cache, 1, &new_cache);
-              vkDestroyPipelineCache (device, new_cache, NULL);
-            }
-          else
-            {
-              g_clear_pointer (&display->vk_pipeline_cache_etag, g_free);
-            }
-          g_clear_error (&error);
-          g_object_unref (file);
-
-          /* try again */
-          return gdk_vulkan_save_pipeline_cache (display);
-        }
-
-      g_warning ("Failed to save pipeline cache: %s", error->message);
-      g_clear_error (&error);
-      g_object_unref (file);
-      return FALSE;
-    }
-
-  g_object_unref (file);
-  g_free (display->vk_pipeline_cache_etag);
-  display->vk_pipeline_cache_etag = etag;
-
-  return TRUE;
-}
-
-static gboolean
-gdk_vulkan_save_pipeline_cache_cb (gpointer data)
-{
-  GdkDisplay *display = data;
-
-  gdk_vulkan_save_pipeline_cache (display);
-
-  display->vk_save_pipeline_cache_source = 0;
-  return G_SOURCE_REMOVE;
-}
-
-void
-gdk_vulkan_context_pipeline_cache_updated (GdkVulkanContext *self)
-{
-  GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (self));
-
-  g_clear_handle_id (&display->vk_save_pipeline_cache_source, g_source_remove);
-  display->vk_save_pipeline_cache_source = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT_IDLE - 10,
-                                                                       10, /* random choice that is not now */
-                                                                       gdk_vulkan_save_pipeline_cache_cb,
-                                                                       display,
-                                                                       NULL);
-}
-
-static void
-gdk_display_create_pipeline_cache (GdkDisplay *display)
-{
-  display->vk_pipeline_cache = gdk_display_load_pipeline_cache (display);
-
-  GDK_VK_CHECK (vkCreatePipelineCache, display->vk_device,
-                                       &(VkPipelineCacheCreateInfo) {
-                                         .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
-                                       },
-                                       NULL,
-                                       &display->vk_pipeline_cache);
-}
-
-VkPipelineCache
-gdk_vulkan_context_get_pipeline_cache (GdkVulkanContext *self)
-{
-  g_return_val_if_fail (GDK_IS_VULKAN_CONTEXT (self), NULL);
-
-  return gdk_draw_context_get_display (GDK_DRAW_CONTEXT (self))->vk_pipeline_cache;
-}
-
 /**
  * gdk_vulkan_context_get_image_format:
  * @context: a `GdkVulkanContext`
@@ -1394,7 +1168,6 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
                                                       .descriptorBindingPartiallyBound = VK_TRUE,
                                                       .descriptorBindingVariableDescriptorCount = VK_TRUE,
                                                       .descriptorBindingSampledImageUpdateAfterBind = VK_TRUE,
-                                                      .descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE,
                                                     }
                                                 },
                                                 NULL,
@@ -1591,8 +1364,6 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
       return FALSE;
     }
 
-  gdk_display_create_pipeline_cache (display);
-
   return TRUE;
 }
 
@@ -1621,16 +1392,6 @@ gdk_display_unref_vulkan (GdkDisplay *display)
   if (display->vulkan_refcount > 0)
     return;
 
-  if (display->vk_save_pipeline_cache_source)
-    {
-      gdk_vulkan_save_pipeline_cache_cb (display);
-      g_assert (display->vk_save_pipeline_cache_source == 0);
-    }
-  vkDestroyPipelineCache (display->vk_device, display->vk_pipeline_cache, NULL);
-  display->vk_device = VK_NULL_HANDLE;
-  g_clear_pointer (&display->vk_pipeline_cache_etag, g_free);
-  display->vk_pipeline_cache_size = 0;
-
   vkDestroyDevice (display->vk_device, NULL);
   display->vk_device = VK_NULL_HANDLE;
   if (display->vk_debug_callback != VK_NULL_HANDLE)

gdk/gdkvulkancontextprivate.h

@@ -69,15 +69,9 @@ gdk_vulkan_handle_result (VkResult    res,
 
 #define GDK_VK_CHECK(func, ...) gdk_vulkan_handle_result (func (__VA_ARGS__), G_STRINGIFY (func))
 
-gboolean                gdk_display_ref_vulkan                          (GdkDisplay            *display,
-                                                                         GError               **error);
-void                    gdk_display_unref_vulkan                        (GdkDisplay            *display);
-
-VkPipelineCache         gdk_vulkan_context_get_pipeline_cache           (GdkVulkanContext      *self);
-void                    gdk_vulkan_context_pipeline_cache_updated       (GdkVulkanContext      *self);
-
-GdkMemoryFormat         gdk_vulkan_context_get_offscreen_format         (GdkVulkanContext      *context,
-                                                                         GdkMemoryDepth         depth);
+gboolean        gdk_display_ref_vulkan                          (GdkDisplay      *display,
+                                                                 GError         **error);
+void            gdk_display_unref_vulkan                        (GdkDisplay      *display);
 
 #else /* !GDK_RENDERING_VULKAN */
 

gsk/gl/fp16.c

@@ -165,7 +165,7 @@ void half_to_float4 (const guint16 h[4], float f[4]) __attribute__((ifunc ("reso
 void float_to_half (const float *f, guint16 *h, int n) __attribute__((ifunc ("resolve_float_to_half")));
 void half_to_float (const guint16 *h, float *f, int n) __attribute__((ifunc ("resolve_half_to_float")));
 
-static void * __attribute__ ((no_sanitize_address))
+static void *
 resolve_float_to_half4 (void)
 {
   __builtin_cpu_init ();
@@ -175,7 +175,7 @@ resolve_float_to_half4 (void)
     return float_to_half4_c;
 }
 
-static void * __attribute__ ((no_sanitize_address))
+static void *
 resolve_half_to_float4 (void)
 {
   __builtin_cpu_init ();
@@ -185,7 +185,7 @@ resolve_half_to_float4 (void)
     return half_to_float4_c;
 }
 
-static void * __attribute__ ((no_sanitize_address))
+static void *
 resolve_float_to_half (void)
 {
   __builtin_cpu_init ();
@@ -195,7 +195,7 @@ resolve_float_to_half (void)
     return float_to_half_c;
 }
 
-static void * __attribute__ ((no_sanitize_address))
+static void *
 resolve_half_to_float (void)
 {
   __builtin_cpu_init ();

gsk/gl/gskgldriver.c

@@ -686,21 +686,17 @@ gsk_gl_driver_cache_texture (GskGLDriver         *self,
                              const GskTextureKey *key,
                              guint                texture_id)
 {
+  GskTextureKey *k;
+
   g_assert (GSK_IS_GL_DRIVER (self));
   g_assert (key != NULL);
   g_assert (texture_id > 0);
   g_assert (g_hash_table_contains (self->textures, GUINT_TO_POINTER (texture_id)));
 
-  if (!g_hash_table_contains (self->key_to_texture_id, key))
-    {
-      GskTextureKey *k;
+  k = g_memdup (key, sizeof *key);
 
-      k = g_memdup (key, sizeof *key);
-
-      g_assert (!g_hash_table_contains (self->texture_id_to_key, GUINT_TO_POINTER (texture_id)));
-      g_hash_table_insert (self->key_to_texture_id, k, GUINT_TO_POINTER (texture_id));
-      g_hash_table_insert (self->texture_id_to_key, GUINT_TO_POINTER (texture_id), k);
-    }
+  g_hash_table_insert (self->key_to_texture_id, k, GUINT_TO_POINTER (texture_id));
+  g_hash_table_insert (self->texture_id_to_key, GUINT_TO_POINTER (texture_id), k);
 }
 
 /**

gsk/gl/gskglrenderjob.c

@@ -807,8 +807,6 @@ gsk_gl_render_job_untransform_bounds (GskGLRenderJob        *job,
 
   out_rect->origin.x -= job->offset_x;
   out_rect->origin.y -= job->offset_y;
-
-  gsk_transform_unref (transform);
 }
 
 static inline void

gsk/gsk.h

@@ -20,15 +20,16 @@
 #define __GSK_H_INSIDE__
 
 #include <gsk/gskenums.h>
-#include <gsk/gskglshader.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>
 
 #include <gsk/gskcairorenderer.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,128 @@
+/*
+ * 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;
+
+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);
+gpointer                gsk_contour_init_measure                (const GskContour       *self,
+                                                                 float                   tolerance,
+                                                                 float                  *out_length);
+void                    gsk_contour_free_measure                (const GskContour       *self,
+                                                                 gpointer                data);
+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);
+void                    gsk_contour_get_point                   (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 float                   distance,
+                                                                 GskPathDirection        direction,
+                                                                 graphene_point_t       *pos,
+                                                                 graphene_vec2_t        *tangent);
+gboolean                gsk_contour_get_closest_point           (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 float                   tolerance,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 float                  *out_distance,
+                                                                 graphene_point_t       *out_pos,
+                                                                 float                  *out_offset,
+                                                                 graphene_vec2_t        *out_tangent);
+int                     gsk_contour_get_winding                 (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 const graphene_point_t *point);
+void                    gsk_contour_add_segment                 (const GskContour       *self,
+                                                                 GskPathBuilder         *builder,
+                                                                 gpointer                measure_data,
+                                                                 gboolean                emit_move_to,
+                                                                 float                   start,
+                                                                 float                   end);
+float                   gsk_contour_get_curvature               (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 float                   distance,
+                                                                 graphene_point_t       *center);
+gboolean                gsk_contour_dash                        (const GskContour       *contour,
+                                                                 GskStroke              *stroke,
+                                                                 float                   tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+void                    gsk_contour_add_stroke                  (const GskContour       *contour,
+                                                                 GskPathBuilder         *builder,
+                                                                 GskStroke              *stroke);
+
+void                    gsk_contour_default_add_stroke          (const GskContour       *contour,
+                                                                 GskPathBuilder         *builder,
+                                                                 GskStroke              *stroke);
+
+void                    gsk_contour_offset                      (const GskContour       *contour,
+                                                                 GskPathBuilder         *builder,
+                                                                 float                   distance,
+                                                                 GskStroke              *stroke);
+
+void                    gsk_contour_default_offset              (const GskContour       *contour,
+                                                                 GskPathBuilder         *builder,
+                                                                 float                   distance,
+                                                                 GskStroke              *stroke);
+
+G_END_DECLS

gsk/gskcurveintersect.c

@@ -0,0 +1,879 @@
+/*
+ * Copyright © 2020 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 <math.h>
+
+#include "gskcurveprivate.h"
+
+/* {{{ Utilities */
+
+static void
+get_tangent (const graphene_point_t *p0,
+             const graphene_point_t *p1,
+             graphene_vec2_t        *t)
+{
+  graphene_vec2_init (t, p1->x - p0->x, p1->y - p0->y);
+  graphene_vec2_normalize (t, t);
+}
+
+static inline gboolean
+acceptable (float t)
+{
+  return 0 - FLT_EPSILON <= t && t <= 1 + FLT_EPSILON;
+}
+
+static inline void
+_sincosf (float  angle,
+          float *out_s,
+          float *out_c)
+{
+#ifdef HAVE_SINCOSF
+      sincosf (angle, out_s, out_c);
+#else
+      *out_s = sinf (angle);
+      *out_c = cosf (angle);
+#endif
+}
+
+static void
+align_points (const graphene_point_t *p,
+              const graphene_point_t *a,
+              const graphene_point_t *b,
+              graphene_point_t       *q,
+              int                     n)
+{
+  graphene_vec2_t n1;
+  float angle;
+  float s, c;
+
+  get_tangent (a, b, &n1);
+  angle = - atan2 (graphene_vec2_get_y (&n1), graphene_vec2_get_x (&n1));
+  _sincosf (angle, &s, &c);
+
+  for (int i = 0; i < n; i++)
+    {
+      q[i].x = (p[i].x - a->x) * c - (p[i].y - a->y) * s;
+      q[i].y = (p[i].x - a->x) * s + (p[i].y - a->y) * c;
+    }
+}
+
+static void
+find_point_on_line (const graphene_point_t *p1,
+                    const graphene_point_t *p2,
+                    const graphene_point_t *q,
+                    float                  *t)
+{
+  if (p2->x != p1->x)
+    *t = (q->x - p1->x) / (p2->x - p1->x);
+  else
+    *t = (q->y - p1->y) / (p2->y - p1->y);
+}
+
+/* find solutions for at^2 + bt + c = 0 */
+static int
+solve_quadratic (float a, float b, float c, float t[2])
+{
+  float d;
+  int n = 0;
+
+  if (fabs (a) > 0.0001)
+    {
+      if (b*b > 4*a*c)
+        {
+          d = sqrt (b*b - 4*a*c);
+          t[n++] = (-b + d)/(2*a);
+          t[n++] = (-b - d)/(2*a);
+        }
+      else
+        {
+          t[n++] = -b / (2*a);
+        }
+    }
+  else if (fabs (b) > 0.0001)
+    {
+      t[n++] = -c / b;
+    }
+
+  return n;
+}
+
+static int
+filter_allowable (float t[3],
+                  int   n)
+{
+  float g[3];
+  int j = 0;
+
+  for (int i = 0; i < n; i++)
+    if (0 < t[i] && t[i] < 1)
+      g[j++] = t[i];
+  for (int i = 0; i < j; i++)
+    t[i] = g[i];
+  return j;
+}
+
+/* Solve P = 0 where P is
+ * P = (1-t)^2*pa + 2*t*(1-t)*pb + t^2*pc
+ */
+static int
+get_quadratic_roots (float pa, float pb, float pc, float roots[2])
+{
+  float a, b, c, d;
+  int n_roots = 0;
+
+  a = pa - 2 * pb + pc;
+  b = 2 * (pb - pa);
+  c = pa;
+
+  d = b*b - 4*a*c;
+
+  if (d > 0.0001)
+    {
+      float q = sqrt (d);
+      roots[n_roots] = (-b + q) / (2 * a);
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+      roots[n_roots] = (-b - q) / (2 * a);
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+    }
+  else if (fabs (d) < 0.0001)
+    {
+      roots[n_roots] = -b / (2 * a);
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+    }
+
+  return n_roots;
+}
+
+static float
+cuberoot (float v)
+{
+  if (v < 0)
+    return -pow (-v, 1.f / 3);
+  return pow (v, 1.f / 3);
+}
+
+/* Solve P = 0 where P is
+ * P = (1-t)^3*pa + 3*t*(1-t)^2*pb + 3*t^2*(1-t)*pc + t^3*pd
+ */
+static int
+get_cubic_roots (float pa, float pb, float pc, float pd, float roots[3])
+{
+  float a, b, c, d;
+  float q, q2;
+  float p, p3;
+  float discriminant;
+  float u1, v1, sd;
+  int n_roots = 0;
+
+  d = -pa + 3*pb - 3*pc + pd;
+  a = 3*pa - 6*pb + 3*pc;
+  b = -3*pa + 3*pb;
+  c = pa;
+
+  if (fabs (d) < 0.0001)
+    {
+      if (fabs (a) < 0.0001)
+        {
+          if (fabs (b) < 0.0001)
+            return 0;
+
+          if (acceptable (-c / b))
+            {
+              roots[0] = -c / b;
+
+              return 1;
+            }
+
+          return 0;
+        }
+      q = sqrt (b*b - 4*a*c);
+      roots[n_roots] = (-b + q) / (2 * a);
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+
+      roots[n_roots] = (-b - q) / (2 * a);
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+
+      return n_roots;
+    }
+
+  a /= d;
+  b /= d;
+  c /= d;
+
+  p = (3*b - a*a)/3;
+  p3 = p/3;
+  q = (2*a*a*a - 9*a*b + 27*c)/27;
+  q2 = q/2;
+  discriminant = q2*q2 + p3*p3*p3;
+
+  if (discriminant < 0)
+    {
+      float mp3 = -p/3;
+      float mp33 = mp3*mp3*mp3;
+      float r = sqrt (mp33);
+      float t = -q / (2*r);
+      float cosphi = t < -1 ? -1 : (t > 1 ? 1 : t);
+      float phi = acos (cosphi);
+      float crtr = cuberoot (r);
+      float t1 = 2*crtr;
+
+      roots[n_roots] = t1 * cos (phi/3) - a/3;
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+      roots[n_roots] = t1 * cos ((phi + 2*M_PI) / 3) - a/3;
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+      roots[n_roots] = t1 * cos ((phi + 4*M_PI) / 3) - a/3;
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+
+    return n_roots;
+  }
+
+  if (discriminant == 0)
+    {
+      u1 = q2 < 0 ? cuberoot (-q2) : -cuberoot (q2);
+      roots[n_roots] = 2*u1 - a/3;
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+      roots[n_roots] = -u1 - a/3;
+      if (acceptable (roots[n_roots]))
+        n_roots++;
+
+      return n_roots;
+    }
+
+  sd = sqrt (discriminant);
+  u1 = cuberoot (sd - q2);
+  v1 = cuberoot (sd + q2);
+  roots[n_roots] = u1 - v1 - a/3;
+  if (acceptable (roots[n_roots]))
+    n_roots++;
+
+  return n_roots;
+}
+
+/* }}} */
+/* {{{ Cusps and inflections */
+
+/* Get the points where the curvature of curve is
+ * zero, or a maximum or minimum, inside the open
+ * interval from 0 to 1.
+ */
+int
+gsk_curve_get_curvature_points (const GskCurve *curve,
+                                float           t[3])
+{
+  const graphene_point_t *pts = curve->cubic.points;
+  graphene_point_t p[4];
+  float a, b, c, d;
+  float x, y, z;
+  int n;
+
+  if (curve->op != GSK_PATH_CUBIC)
+    return 0;
+
+  align_points (pts, &pts[0], &pts[3], p, 4);
+
+  a = p[2].x * p[1].y;
+  b = p[3].x * p[1].y;
+  c = p[1].x * p[2].y;
+  d = p[3].x * p[2].y;
+
+  x = - 3*a + 2*b + 3*c - d;
+  y = 3*a - b - 3*c;
+  z = c - a;
+
+  n = solve_quadratic (x, y, z, t);
+  return filter_allowable (t, n);
+}
+
+/* Find cusps inside the open interval from 0 to 1.
+ *
+ * According to Stone & deRose, A Geometric Characterization
+ * of Parametric Cubic curves, a necessary and sufficient
+ * condition is that the first derivative vanishes.
+ */
+int
+gsk_curve_get_cusps (const GskCurve *curve,
+                     float           t[2])
+{
+  const graphene_point_t *pts = curve->cubic.points;
+  graphene_point_t p[3];
+  float ax, bx, cx;
+  float ay, by, cy;
+  float tx[3];
+  int nx;
+  int n = 0;
+
+  if (curve->op != GSK_PATH_CUBIC)
+    return 0;
+
+  p[0].x = 3 * (pts[1].x - pts[0].x);
+  p[0].y = 3 * (pts[1].y - pts[0].y);
+  p[1].x = 3 * (pts[2].x - pts[1].x);
+  p[1].y = 3 * (pts[2].y - pts[1].y);
+  p[2].x = 3 * (pts[3].x - pts[2].x);
+  p[2].y = 3 * (pts[3].y - pts[2].y);
+
+  ax = p[0].x - 2 * p[1].x + p[2].x;
+  bx = - 2 * p[0].x + 2 * p[1].x;
+  cx = p[0].x;
+
+  nx = solve_quadratic (ax, bx, cx, tx);
+  nx = filter_allowable (tx, nx);
+
+  ay = p[0].y - 2 * p[1].y + p[2].y;
+  by = - 2 * p[0].y + 2 * p[1].y;
+  cy = p[0].y;
+
+  for (int i = 0; i < nx; i++)
+    {
+      float ti = tx[i];
+
+      if (0 < ti && ti < 1 &&
+          fabs (ay * ti * ti + by * ti + cy) < 0.001)
+        t[n++] = ti;
+    }
+
+  return n;
+}
+
+/* }}} */
+/* {{{ Intersection */
+
+static int
+line_intersect (const GskCurve   *curve1,
+                const GskCurve   *curve2,
+                float            *t1,
+                float            *t2,
+                graphene_point_t *p,
+                int               n)
+{
+  const graphene_point_t *pts1 = curve1->line.points;
+  const graphene_point_t *pts2 = curve2->line.points;
+  float a1 = pts1[0].x - pts1[1].x;
+  float b1 = pts1[0].y - pts1[1].y;
+  float a2 = pts2[0].x - pts2[1].x;
+  float b2 = pts2[0].y - pts2[1].y;
+  float det = a1 * b2 - b1 * a2;
+
+  if (fabs(det) > 0.01)
+    {
+      float tt =   ((pts1[0].x - pts2[0].x) * b2 - (pts1[0].y - pts2[0].y) * a2) / det;
+      float ss = - ((pts1[0].y - pts2[0].y) * a1 - (pts1[0].x - pts2[0].x) * b1) / det;
+
+      if (acceptable (tt) && acceptable (ss))
+        {
+          p[0].x = pts1[0].x + tt * (pts1[1].x - pts1[0].x);
+          p[0].y = pts1[0].y + tt * (pts1[1].y - pts1[0].y);
+
+          t1[0] = tt;
+          t2[0] = ss;
+
+          return 1;
+        }
+    }
+  else /* parallel lines */
+    {
+      float r = a1 * (pts1[1].y - pts2[0].y) - (pts1[1].x - pts2[0].x) * b1;
+      float dist = (r * r) / (a1 * a1 + b1 * b1);
+      float t, s, tt, ss;
+
+      if (dist > 0.01)
+        return 0;
+
+      if (pts1[1].x != pts1[0].x)
+        {
+          t = (pts2[0].x - pts1[0].x) / (pts1[1].x - pts1[0].x);
+          s = (pts2[1].x - pts1[0].x) / (pts1[1].x - pts1[0].x);
+        }
+      else
+        {
+          t = (pts2[0].y - pts1[0].y) / (pts1[1].y - pts1[0].y);
+          s = (pts2[1].y - pts1[0].y) / (pts1[1].y - pts1[0].y);
+        }
+
+      if ((t < 0 && s < 0) || (t > 1 && s > 1))
+        return 0;
+
+      if (acceptable (t))
+        {
+          t1[0] = t;
+          t2[0] = 0;
+          p[0] = pts2[0];
+        }
+      else if (t < 0)
+        {
+          if (pts2[1].x != pts2[0].x)
+            tt = (pts1[0].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
+          else
+            tt = (pts1[0].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
+
+          t1[0] = 0;
+          t2[0] = tt;
+          p[0] = pts1[0];
+        }
+      else
+        {
+          if (pts2[1].x != pts2[0].x)
+            tt = (pts1[1].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
+          else
+            tt = (pts1[1].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
+
+          t1[0] = 1;
+          t2[0] = tt;
+          p[0] = pts1[1];
+        }
+
+      if (acceptable (s))
+        {
+          if (t2[0] == 1)
+            return 1;
+
+          t1[1] = s;
+          t2[1] = 1;
+          p[1] = pts2[1];
+        }
+      else if (s < 0)
+        {
+          if (t1[0] == 0)
+            return 1;
+
+          if (pts2[1].x != pts2[0].x)
+            ss = (pts1[0].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
+          else
+            ss = (pts1[0].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
+
+          t1[1] = 0;
+          t2[1] = ss;
+          p[1] = pts1[0];
+        }
+      else
+        {
+          if (t1[0] == 1)
+            return 1;
+
+          if (pts2[1].x != pts2[0].x)
+            ss = (pts1[1].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
+          else
+            ss = (pts1[1].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
+
+          t1[1] = 1;
+          t2[1] = ss;
+          p[1] = pts1[1];
+        }
+
+      return 2;
+    }
+
+  return 0;
+}
+
+static int
+line_quad_intersect (const GskCurve   *curve1,
+                     const GskCurve   *curve2,
+                     float            *t1,
+                     float            *t2,
+                     graphene_point_t *p,
+                     int               n)
+{
+  const graphene_point_t *a = &curve1->line.points[0];
+  const graphene_point_t *b = &curve1->line.points[1];
+  graphene_point_t pts[4];
+  float t[2];
+  int m, i, j;
+
+  /* Rotate things to place curve1 on the x axis,
+   * then solve curve2 for y == 0.
+   */
+  align_points (curve2->quad.points, a, b, pts, 3);
+
+  m = get_quadratic_roots (pts[0].y, pts[1].y, pts[2].y, t);
+
+  j = 0;
+  for (i = 0; i < m; i++)
+    {
+      t2[j] = t[i];
+      gsk_curve_get_point (curve2, t2[j], &p[j]);
+      find_point_on_line (a, b, &p[j], &t1[j]);
+      if (acceptable (t1[j]))
+        j++;
+      if (j == n)
+        break;
+    }
+
+  return j;
+}
+
+static int
+line_cubic_intersect (const GskCurve   *curve1,
+                      const GskCurve   *curve2,
+                      float            *t1,
+                      float            *t2,
+                      graphene_point_t *p,
+                      int               n)
+{
+  const graphene_point_t *a = &curve1->line.points[0];
+  const graphene_point_t *b = &curve1->line.points[1];
+  graphene_point_t pts[4];
+  float t[3];
+  int m, i, j;
+
+  /* Rotate things to place curve1 on the x axis,
+   * then solve curve2 for y == 0.
+   */
+  align_points (curve2->cubic.points, a, b, pts, 4);
+
+  m = get_cubic_roots (pts[0].y, pts[1].y, pts[2].y, pts[3].y, t);
+
+  j = 0;
+  for (i = 0; i < m; i++)
+    {
+      t2[j] = t[i];
+      gsk_curve_get_point (curve2, t2[j], &p[j]);
+      find_point_on_line (a, b, &p[j], &t1[j]);
+      if (acceptable (t1[j]))
+        j++;
+      if (j == n)
+        break;
+    }
+
+  return j;
+}
+
+#define MAX_LEVEL 25
+#define TOLERANCE 0.001
+
+static void
+cubic_intersect_recurse (const GskCurve   *curve1,
+                         const GskCurve   *curve2,
+                         float             t1l,
+                         float             t1r,
+                         float             t2l,
+                         float             t2r,
+                         float            *t1,
+                         float            *t2,
+                         graphene_point_t *p,
+                         int               n,
+                         int              *pos,
+                         int               level)
+{
+  GskCurve p11, p12, p21, p22;
+  GskBoundingBox b1, b2;
+  float d1, d2;
+
+  if (*pos == n)
+    return;
+
+  if (level == MAX_LEVEL)
+    return;
+
+  gsk_curve_get_bounds (curve1, &b1);
+  gsk_curve_get_bounds (curve2, &b2);
+  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
+    return;
+
+  gsk_curve_get_tight_bounds (curve1, &b1);
+  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
+    return;
+
+  gsk_curve_get_tight_bounds (curve2, &b2);
+  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
+    return;
+
+  d1 = (t1r - t1l) / 2;
+  d2 = (t2r - t2l) / 2;
+
+  if (b1.max.x - b1.min.x < TOLERANCE && b1.max.y - b1.min.y < TOLERANCE &&
+      b2.max.x - b2.min.x < TOLERANCE && b2.max.y - b2.min.y < TOLERANCE)
+    {
+      graphene_point_t c;
+      t1[*pos] = t1l + d1;
+      t2[*pos] = t2l + d2;
+      gsk_curve_get_point (curve1, 0.5, &c);
+
+      for (int i = 0; i < *pos; i++)
+        {
+          if (graphene_point_near (&c, &p[i], 0.1))
+            return;
+        }
+
+      p[*pos] = c;
+      (*pos)++;
+
+      return;
+    }
+
+  gsk_curve_split (curve1, 0.5, &p11, &p12);
+  gsk_curve_split (curve2, 0.5, &p21, &p22);
+
+  cubic_intersect_recurse (&p11, &p21, t1l,      t1l + d1, t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
+  cubic_intersect_recurse (&p11, &p22, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
+  cubic_intersect_recurse (&p12, &p21, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
+  cubic_intersect_recurse (&p12, &p22, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
+}
+
+static int
+cubic_intersect (const GskCurve   *curve1,
+                 const GskCurve   *curve2,
+                 float            *t1,
+                 float            *t2,
+                 graphene_point_t *p,
+                 int               n)
+{
+  int pos = 0;
+
+  cubic_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, 0);
+
+  return pos;
+}
+
+static void
+get_bounds (const GskCurve  *curve,
+            float            tl,
+            float            tr,
+            GskBoundingBox  *bounds)
+{
+  GskCurve c;
+
+  gsk_curve_segment (curve, tl, tr, &c);
+  gsk_curve_get_tight_bounds (&c, bounds);
+}
+
+static void
+general_intersect_recurse (const GskCurve   *curve1,
+                           const GskCurve   *curve2,
+                           float             t1l,
+                           float             t1r,
+                           float             t2l,
+                           float             t2r,
+                           float            *t1,
+                           float            *t2,
+                           graphene_point_t *p,
+                           int               n,
+                           int              *pos,
+                           int               level)
+{
+  GskBoundingBox b1, b2;
+  float d1, d2;
+
+  if (*pos == n)
+    return;
+
+  if (level == MAX_LEVEL)
+    return;
+
+  get_bounds (curve1, t1l, t1r, &b1);
+  get_bounds (curve2, t2l, t2r, &b2);
+
+  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
+    return;
+
+  d1 = (t1r - t1l) / 2;
+  d2 = (t2r - t2l) / 2;
+
+  if (b1.max.x - b1.min.x < TOLERANCE && b1.max.y - b1.min.y < TOLERANCE &&
+      b2.max.x - b2.min.x < TOLERANCE && b2.max.y - b2.min.y < TOLERANCE)
+    {
+      graphene_point_t c;
+      t1[*pos] = t1l + d1;
+      t2[*pos] = t2l + d2;
+      gsk_curve_get_point (curve1, t1[*pos], &c);
+
+      for (int i = 0; i < *pos; i++)
+        {
+          if (graphene_point_near (&c, &p[i], 0.1))
+            return;
+        }
+
+      p[*pos] = c;
+      (*pos)++;
+
+      return;
+    }
+
+  /* Note that in the conic case, we cannot just split the curves and
+   * pass the two halves down, since splitting changes the parametrization,
+   * and we need the t's to be valid parameters wrt to the original curve.
+   *
+   * So, instead, we determine the bounding boxes above by always starting
+   * from the original curve. That is a bit less efficient, but also works
+   * for conics.
+   */
+  general_intersect_recurse (curve1, curve2, t1l,      t1l + d1, t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
+  general_intersect_recurse (curve1, curve2, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
+  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
+  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
+}
+
+static int
+general_intersect (const GskCurve   *curve1,
+                   const GskCurve   *curve2,
+                   float            *t1,
+                   float            *t2,
+                   graphene_point_t *p,
+                   int               n)
+{
+  int pos = 0;
+
+  general_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, 0);
+
+  return pos;
+}
+
+static int
+curve_self_intersect (const GskCurve   *curve,
+                      float            *t1,
+                      float            *t2,
+                      graphene_point_t *p,
+                      int               n)
+{
+  float tt[3], ss[3], s;
+  graphene_point_t pp[3];
+  int m;
+  GskCurve cs, ce;
+
+  if (curve->op != GSK_PATH_CUBIC)
+    return 0;
+
+  s = 0.5;
+  m = gsk_curve_get_curvature_points (curve, tt);
+  for (int i = 0; i < m; i++)
+    {
+      if (gsk_curve_get_curvature (curve, tt[i], NULL) == 0)
+        {
+          s = tt[i];
+          break;
+        }
+    }
+
+  gsk_curve_split (curve, s, &cs, &ce);
+
+  m = cubic_intersect (&cs, &ce, tt, ss, pp, 3);
+
+  if (m > 1)
+    {
+      /* One of the (at most 2) intersections we found
+       * must be the common point where we split the curve.
+       * It will have a t value of 1 and an s value of 0.
+       */
+      if (fabs (tt[0] - 1) > 1e-3)
+        {
+          t1[0] = t2[0] = tt[0] * s;
+          p[0] = pp[0];
+        }
+      else if (fabs (tt[1] - 1) > 1e-3)
+        {
+          t1[0] = t2[0] = tt[1] * s;
+          p[0] = pp[1];
+        }
+
+      if (n == 1)
+        return 1;
+
+      if (fabs (ss[0]) > 1e-3)
+        {
+          t1[1] = t2[1] = s + ss[0] * (1 - s);
+          p[1] = pp[0];
+        }
+      else if (fabs (ss[1]) > 1e-3)
+        {
+          t1[1] = t2[1] = s + ss[1] * (1 - s);
+          p[1] = pp[1];
+        }
+
+      return 2;
+    }
+
+  return 0;
+}
+
+static inline gboolean
+curve_equal (const GskCurve *c1,
+             const GskCurve *c2)
+{
+  gsize curve_size[] = {
+    sizeof (GskLineCurve),
+    sizeof (GskLineCurve),
+    sizeof (GskLineCurve),
+    sizeof (GskQuadCurve),
+    sizeof (GskCubicCurve),
+    sizeof (GskConicCurve)
+  };
+
+  return c1->op == c2->op && memcmp (c1, c2, curve_size[c1->op]) == 0;
+}
+
+/* Place intersections between the curves in p, and their Bezier positions
+ * in t1 and t2, up to n. Return the number of intersections found.
+ *
+ * Note that two cubic Beziers can have up to 9 intersections.
+ */
+int
+gsk_curve_intersect (const GskCurve   *curve1,
+                     const GskCurve   *curve2,
+                     float            *t1,
+                     float            *t2,
+                     graphene_point_t *p,
+                     int               n)
+{
+  GskPathOperation op1 = curve1->op;
+  GskPathOperation op2 = curve2->op;
+
+  if (op1 == GSK_PATH_CLOSE)
+    op1 = GSK_PATH_LINE;
+
+  if (op2 == GSK_PATH_CLOSE)
+    op2 = GSK_PATH_LINE;
+
+  if (curve_equal (curve1, curve2))
+    return curve_self_intersect (curve1, t1, t2, p, n);
+
+  /* We special-case line-line and line-cubic intersections,
+   * since we can solve them directly.
+   * Everything else is done via bisection.
+   */
+  if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_LINE)
+    return line_intersect (curve1, curve2, t1, t2, p, n);
+  else if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_QUAD)
+    return line_quad_intersect (curve1, curve2, t1, t2, p, n);
+  else if (op1 == GSK_PATH_QUAD && op2 == GSK_PATH_LINE)
+    return line_quad_intersect (curve2, curve1, t2, t1, p, n);
+  else if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_CUBIC)
+    return line_cubic_intersect (curve1, curve2, t1, t2, p, n);
+  else if (op1 == GSK_PATH_CUBIC && op2 == GSK_PATH_LINE)
+    return line_cubic_intersect (curve2, curve1, t2, t1, p, n);
+  else if ((op1 == GSK_PATH_QUAD || op1 == GSK_PATH_CUBIC) &&
+           (op2 == GSK_PATH_QUAD || op2 == GSK_PATH_CUBIC))
+    return cubic_intersect (curve1, curve2, t1, t2, p, n);
+  else
+    return general_intersect (curve1, curve2, t1, t2, p, n);
+}
+
+/* }}} */
+
+/* vim:set foldmethod=marker expandtab: */

gsk/gskcurveprivate.h

@@ -0,0 +1,184 @@
+/*
+ * 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);
+void                    gsk_curve_offset                        (const GskCurve         *curve,
+                                                                 float                   distance,
+                                                                 GskCurve               *offset_curve);
+
+int                     gsk_curve_get_curvature_points          (const GskCurve         *curve,
+                                                                 float                   t[3]);
+
+int                     gsk_curve_get_cusps                     (const GskCurve         *curve,
+                                                                 float                   t[2]);
+
+int                     gsk_curve_intersect                     (const GskCurve         *curve1,
+                                                                 const GskCurve         *curve2,
+                                                                 float                  *t1,
+                                                                 float                  *t2,
+                                                                 graphene_point_t       *p,
+                                                                 int                     n);
+
+G_END_DECLS
+

gsk/gskenums.h

@@ -186,17 +186,19 @@ typedef enum {
  *   the total number of intersections is odd, the point will be
  *   filled.
  *
- * #GskFillRule is used to select how paths are filled, for example in
- * gsk_fill_node_new(). 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.
+ * `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.
- **/
+ */
 typedef enum {
   GSK_FILL_RULE_WINDING,
   GSK_FILL_RULE_EVEN_ODD
@@ -205,16 +207,16 @@ typedef enum {
 /**
  * GskLineCap:
  * @GSK_LINE_CAP_BUTT: Start and stop the line exactly at the start
- *     and end point
+ *   and end point
  * @GSK_LINE_CAP_ROUND: Use a round ending, the center of the circle
- *     is the start or end point.
+ *   is the start or end point
  * @GSK_LINE_CAP_SQUARE: use squared ending, the center of the square
- *     is the start or end point.
+ *   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.
+ * The default line cap style is `GSK_LINE_CAP_BUTT`.
  */
 typedef enum {
   GSK_LINE_CAP_BUTT,
@@ -224,41 +226,47 @@ typedef enum {
 
 /**
  * GskLineJoin:
- * @GSK_LINE_JOIN_MITER: Use a sharp, angled corner
+ * @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 joint point
- * @GSK_LINE_JOIN_BEVEL: Use a cut-off join, the join is cut off at half
- *     the line width from the joint point
+ *   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
+ * @GSK_LINE_JOIN_ARCS: Use a sharp angled corner made from circles
  *
  * Specifies how to render the junction of two lines when stroking.
  *
- * See gsk_stroke_set_miter_limit() for details on the difference between
- * @GSK_LINE_JOIN_MITER and @GSK_LINE_JOIN_MITER_CLIP.
+ * 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.
+ * The default line join style is `GSK_LINE_JOIN_MITER`.
  **/
 typedef enum {
   GSK_LINE_JOIN_MITER,
   GSK_LINE_JOIN_MITER_CLIP,
   GSK_LINE_JOIN_ROUND,
-  GSK_LINE_JOIN_BEVEL
+  GSK_LINE_JOIN_BEVEL,
+  GSK_LINE_JOIN_ARCS
 } GskLineJoin;
 
 /**
  * GskPathOperation:
- * @GSK_PATH_MOVE: A move-to operation, with 1 point describing the
- *     target point.
- * @GSK_PATH_LINE: A line-to operation, with 2 points describing the
- *     start and end point of a straight line.
- * @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_CURVE: 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_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 can be used to approximate a #GskPath.
+ * Path operations can be used to approximate a `GskPath`.
  *
  * More values may be added in the future.
  **/
@@ -266,9 +274,24 @@ typedef enum {
   GSK_PATH_MOVE,
   GSK_PATH_CLOSE,
   GSK_PATH_LINE,
-  GSK_PATH_CURVE,
+  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.
+ */
+typedef enum {
+  GSK_PATH_START,
+  GSK_PATH_END
+} GskPathDirection;
+
 /**
  * GskSerializationError:
  * @GSK_SERIALIZATION_UNSUPPORTED_FORMAT: The format can not be identified
@@ -373,4 +396,3 @@ typedef enum
   GSK_MASK_MODE_LUMINANCE,
   GSK_MASK_MODE_INVERTED_LUMINANCE
 } GskMaskMode;
-

gsk/gskpath.h

@@ -17,8 +17,7 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#ifndef __GSK_PATH_H__
-#define __GSK_PATH_H__
+#pragma once
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
@@ -31,19 +30,22 @@ G_BEGIN_DECLS
 
 /**
  * GskPathForeachFlags:
- * @GSK_PATH_FOREACH_ALLOW_CURVES: Allow emission of %GSK_PATH_CURVE
- *     operations.
+ * @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, gsk_path_foreach() will only emit a path with all operations
+ * 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.
+ * operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and `GSK_PATH_CLOSE`.
  */
 typedef enum
 {
-  GSK_PATH_FOREACH_ALLOW_CURVES = (1 << 0)
+  GSK_PATH_FOREACH_ALLOW_QUAD  = (1 << 0),
+  GSK_PATH_FOREACH_ALLOW_CUBIC = (1 << 1),
+  GSK_PATH_FOREACH_ALLOW_CONIC = (1 << 2),
 } GskPathForeachFlags;
 
 /**
@@ -51,6 +53,7 @@ typedef enum
  * @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
@@ -62,14 +65,13 @@ typedef enum
 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_ALL
 GType                   gsk_path_get_type                       (void) G_GNUC_CONST;
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_new_from_cairo                 (const cairo_path_t     *path);
 
 GDK_AVAILABLE_IN_ALL
 GskPath *               gsk_path_ref                            (GskPath                *self);
@@ -91,6 +93,7 @@ void                    gsk_path_to_cairo                       (GskPath
 
 GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_is_empty                       (GskPath                *self);
+
 GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_get_bounds                     (GskPath                *self,
                                                                  graphene_rect_t        *bounds);
@@ -101,8 +104,46 @@ gboolean                gsk_path_foreach                        (GskPath
                                                                  GskPathForeachFunc      func,
                                                                  gpointer                user_data);
 
+GDK_AVAILABLE_IN_ALL
+gboolean                gsk_path_dash                           (GskPath                *path,
+                                                                 GskStroke              *stroke,
+                                                                 float                   tolerance,
+                                                                 GskPathForeachFunc      func,
+                                                                 gpointer                user_data);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_stroke                         (GskPath                *self,
+                                                                 GskStroke              *stroke);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_offset                         (GskPath                *self,
+                                                                 float                   distance,
+                                                                 GskStroke              *stroke);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_union                          (GskPath                *first,
+                                                                 GskPath                *second,
+                                                                 GskFillRule             fill_rule);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_intersection                   (GskPath                *first,
+                                                                 GskPath                *second,
+                                                                 GskFillRule             fill_rule);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_difference                     (GskPath                *first,
+                                                                 GskPath                *second,
+                                                                 GskFillRule             fill_rule);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_symmetric_difference           (GskPath                *first,
+                                                                 GskPath                *second,
+                                                                 GskFillRule             fill_rule);
+
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_simplify                       (GskPath                *self,
+                                                                 GskFillRule             fill_rule);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPath, gsk_path_unref)
 
 G_END_DECLS
-
-#endif /* __GSK_PATH_H__ */

gsk/gskpathbuilder.c

@@ -19,17 +19,18 @@
 
 #include "config.h"
 
+#include <math.h>
+
 #include "gskpathbuilder.h"
 
 #include "gskpathprivate.h"
 
 /**
- * SECTION:gskpathbuilder
- * @Title: Building paths
- * @Short_description: Building paths of lines and curves
- * @See_also: #GskPath, #GskPathMeasure
+ * GskPathBuilder:
  *
- * This section describes how to construct #GskPath structures.
+ * A `GskPathBuilder` struct is an opaque struct. It is meant to
+ * not be kept around and only be used to create new `GskPath`
+ * objects.
  *
  * A path is constructed like this:
  *
@@ -46,28 +47,21 @@
  *   return gsk_path_builder_free_to_path (builder);
  * ]|
  *
- * Adding contours to the path can be done in two ways.  
+ * Adding contours to the path can be done in two ways.
  * The easiest option is to use the `gsk_path_builder_add_*` group
  * of functions that add predefined contours to the current path,
- * either common shapes like gsk_path_builder_add_circle()
- * or by adding from other paths like gsk_path_builder_add_path().
+ * either common shapes like [method@Gsk.PathBuilder.add_circle]
+ * or by adding from other paths like [method@Gsk.PathBuilder.add_path].
  *
  * The other option is to define each line and curve manually with
  * the `gsk_path_builder_*_to` group of functions. You start with
- * a call to gsk_path_builder_move_to() to set the starting point
+ * a call to [method@Gsk.PathBuilder.move_to] to set the starting point
  * and then use multiple calls to any of the drawing functions to
  * move the pen along the plane. Once you are done, you can call
- * gsk_path_builder_close() to close the path by connecting it
+ * [method@Gsk.PathBuilder.close] to close the path by connecting it
  * back with a line to the starting point.
- * This is similar for how paths are drawn in Cairo.
- */
-
-/**
- * GskPathBuilder:
  *
- * A #GskPathBuilder struct is an opaque struct. It is meant to
- * not be kept around and only be used to create new #GskPath
- * objects.
+ * This is similar for how paths are drawn in Cairo.
  */
 
 struct _GskPathBuilder
@@ -91,12 +85,13 @@ G_DEFINE_BOXED_TYPE (GskPathBuilder,
 /**
  * gsk_path_builder_new:
  *
- * Create a new #GskPathBuilder object. The resulting builder
- * would create an empty #GskPath. Use addition functions to add
- * types to it.
+ * Create a new `GskPathBuilder` object.
  *
- * Returns: a new #GskPathBuilder
- **/
+ * The resulting builder would create an empty `GskPath`.
+ * Use addition functions to add types to it.
+ *
+ * Returns: a new `GskPathBuilder`
+ */
 GskPathBuilder *
 gsk_path_builder_new (void)
 {
@@ -105,7 +100,7 @@ gsk_path_builder_new (void)
   self = g_slice_new0 (GskPathBuilder);
   self->ref_count = 1;
 
-  self->ops = g_array_new (FALSE, FALSE, sizeof (GskStandardOperation));
+  self->ops = g_array_new (FALSE, FALSE, sizeof (gskpathop));
   self->points = g_array_new (FALSE, FALSE, sizeof (graphene_point_t));
 
   /* Be explicit here */
@@ -116,14 +111,14 @@ gsk_path_builder_new (void)
 
 /**
  * gsk_path_builder_ref:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
  * Acquires a reference on the given builder.
  *
- * This function is intended primarily for bindings. #GskPathBuilder objects
- * should not be kept around.
+ * This function is intended primarily for bindings.
+ * `GskPathBuilder` objects should not be kept around.
  *
- * Returns: (transfer none): the given #GskPathBuilder with
+ * Returns: (transfer none): the given `GskPathBuilder` with
  *   its reference count increased
  */
 GskPathBuilder *
@@ -137,6 +132,19 @@ gsk_path_builder_ref (GskPathBuilder *self)
   return self;
 }
 
+/* We're cheating here. Out pathops are relative to the NULL pointer,
+ * so that we can not care about the points GArray reallocating itself
+ * until we create the contour.
+ * This does however mean that we need to not use gsk_pathop_get_points()
+ * without offsetting the returned pointer.
+ */
+static inline gskpathop
+gsk_pathop_encode_index (GskPathOperation op,
+                         gsize            index)
+{
+  return gsk_pathop_encode (op, ((graphene_point_t *) NULL) + index);
+}
+
 static void
 gsk_path_builder_ensure_current (GskPathBuilder *self)
 {
@@ -144,7 +152,7 @@ gsk_path_builder_ensure_current (GskPathBuilder *self)
     return;
 
   self->flags = GSK_PATH_FLAT;
-  g_array_append_vals (self->ops, &(GskStandardOperation) { GSK_PATH_MOVE, 0 }, 1);
+  g_array_append_vals (self->ops, (gskpathop[1]) { gsk_pathop_encode_index (GSK_PATH_MOVE, 0) }, 1);
   g_array_append_val (self->points, self->current_point);
 }
 
@@ -156,7 +164,7 @@ gsk_path_builder_append_current (GskPathBuilder         *self,
 {
   gsk_path_builder_ensure_current (self);
 
-  g_array_append_vals (self->ops, &(GskStandardOperation) { op, self->points->len - 1 }, 1);
+  g_array_append_vals (self->ops, (gskpathop[1]) { gsk_pathop_encode_index (op, self->points->len - 1) }, 1);
   g_array_append_vals (self->points, points, n_points);
 
   self->current_point = points[n_points - 1];
@@ -171,10 +179,11 @@ gsk_path_builder_end_current (GskPathBuilder *self)
    return;
 
   contour = gsk_standard_contour_new (self->flags,
-                                      (GskStandardOperation *) self->ops->data,
-                                      self->ops->len,
                                       (graphene_point_t *) self->points->data,
-                                      self->points->len);
+                                      self->points->len,
+                                      (gskpathop *) self->ops->data,
+                                      self->ops->len,
+                                      (graphene_point_t *) self->points->data - (graphene_point_t *) NULL);
 
   g_array_set_size (self->ops, 0);
   g_array_set_size (self->points, 0);
@@ -194,7 +203,7 @@ gsk_path_builder_clear (GskPathBuilder *self)
 
 /**
  * gsk_path_builder_unref:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
  * Releases a reference on the given builder.
  */
@@ -217,12 +226,12 @@ gsk_path_builder_unref (GskPathBuilder *self)
 
 /**
  * gsk_path_builder_free_to_path: (skip)
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
- * Creates a new #GskPath from the current state of the
+ * Creates a new `GskPath` from the current state of the
  * given builder, and frees the @builder instance.
  *
- * Returns: (transfer full): the newly created #GskPath
+ * Returns: (transfer full): the newly created `GskPath`
  *   with all the contours added to the builder
  */
 GskPath *
@@ -241,17 +250,18 @@ gsk_path_builder_free_to_path (GskPathBuilder *self)
 
 /**
  * gsk_path_builder_to_path:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
- * Creates a new #GskPath from the given builder.
+ * Creates a new `GskPath` from the given builder.
  *
- * The given #GskPathBuilder is reset once this function returns;
- * you cannot call this function multiple times on the same builder instance.
+ * The given `GskPathBuilder` is reset once this function returns;
+ * you cannot call this function multiple times on the same builder
+ * instance.
  *
- * This function is intended primarily for bindings. C code should use
- * gsk_path_builder_free_to_path().
+ * This function is intended primarily for bindings.
+ * C code should use [method@Gsk.PathBuilder.free_to_path].
  *
- * Returns: (transfer full): the newly created #GskPath
+ * Returns: (transfer full): the newly created `GskPath`
  *   with all the contours added to the builder
  */
 GskPath *
@@ -283,7 +293,7 @@ gsk_path_builder_add_contour (GskPathBuilder *self,
 
 /**
  * gsk_path_builder_get_current_point:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
  * Gets the current point. The current point is used for relative
  * drawing commands and updated after every operation.
@@ -291,7 +301,7 @@ gsk_path_builder_add_contour (GskPathBuilder *self,
  * When the builder is created, the default current point is set to (0, 0).
  *
  * Returns: (transfer none): The current point
- **/
+ */
 const graphene_point_t *
 gsk_path_builder_get_current_point (GskPathBuilder *self)
 {
@@ -302,21 +312,19 @@ gsk_path_builder_get_current_point (GskPathBuilder *self)
 
 /**
  * gsk_path_builder_add_path:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  * @path: (transfer none): the path to append
  *
  * Appends all of @path to the builder.
- **/
+ */
 void
 gsk_path_builder_add_path (GskPathBuilder *self,
                            GskPath        *path)
 {
-  gsize i;
-
   g_return_if_fail (self != NULL);
   g_return_if_fail (path != NULL);
 
-  for (i = 0; i < gsk_path_get_n_contours (path); i++)
+  for (gsize i = 0; i < gsk_path_get_n_contours (path); i++)
     {
       const GskContour *contour = gsk_path_get_contour (path, i);
 
@@ -324,9 +332,80 @@ gsk_path_builder_add_path (GskPathBuilder *self,
     }
 }
 
+/**
+ * gsk_path_builder_add_reverse_path:
+ * @self: a `GskPathBuilder`
+ * @path: (transfer none): the path to append
+ *
+ * Appends all of @path to the builder, in reverse
+ * order.
+ */
+void
+gsk_path_builder_add_reverse_path (GskPathBuilder *self,
+                                   GskPath        *path)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (path != NULL);
+
+  for (gsize i = gsk_path_get_n_contours (path); i > 0; i--)
+    {
+      const GskContour *contour = gsk_path_get_contour (path, i - 1);
+
+      gsk_path_builder_add_contour (self, gsk_contour_reverse (contour));
+    }
+}
+
+/**
+ * gsk_path_builder_add_cairo_path:
+ * @self: a `GskPathBuilder`
+ *
+ * Adds a Cairo path to the builder.
+ *
+ * You can use cairo_copy_path() to access the path
+ * from a Cairo context.
+ */
+void
+gsk_path_builder_add_cairo_path (GskPathBuilder     *self,
+                                 const cairo_path_t *path)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (path != NULL);
+
+  for (gsize i = 0; i < path->num_data; i += path->data[i].header.length)
+    {
+      const cairo_path_data_t *data = &path->data[i];
+
+      switch (data->header.type)
+        {
+        case CAIRO_PATH_MOVE_TO:
+          gsk_path_builder_move_to (self, data[1].point.x, data[1].point.y);
+          break;
+
+        case CAIRO_PATH_LINE_TO:
+          gsk_path_builder_line_to (self, data[1].point.x, data[1].point.y);
+          break;
+
+        case CAIRO_PATH_CURVE_TO:
+          gsk_path_builder_cubic_to (self,
+                                     data[1].point.x, data[1].point.y,
+                                     data[2].point.x, data[2].point.y,
+                                     data[3].point.x, data[3].point.y);
+          break;
+
+        case CAIRO_PATH_CLOSE_PATH:
+          gsk_path_builder_close (self);
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+}
+
 /**
  * gsk_path_builder_add_rect:
- * @self: A #GskPathBuilder
+ * @self: A `GskPathBuilder`
  * @rect: The rectangle to create a path for
  *
  * Adds @rect as a new contour to the path built by the builder.
@@ -336,7 +415,7 @@ gsk_path_builder_add_path (GskPathBuilder *self,
  *
  * If the the width or height are 0, the path will be a closed
  * horizontal or vertical line. If both are 0, it'll be a closed dot.
- **/
+ */
 void
 gsk_path_builder_add_rect (GskPathBuilder        *self,
                            const graphene_rect_t *rect)
@@ -352,13 +431,33 @@ gsk_path_builder_add_rect (GskPathBuilder        *self,
 }
 
 /**
- * gsk_path_builder_add_circle:
+ * gsk_path_builder_add_rounded_rect:
  * @self: a #GskPathBuilder
+ * @rect: the rounded rect
+ *
+ * Adds @rect as a new contour to the path built in @self.
+ */
+void
+gsk_path_builder_add_rounded_rect (GskPathBuilder       *self,
+                                   const GskRoundedRect *rect)
+{
+  GskContour *contour;
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (rect != NULL);
+
+  contour = gsk_rounded_rect_contour_new (rect);
+  gsk_path_builder_add_contour (self, contour);
+}
+
+/**
+ * gsk_path_builder_add_circle:
+ * @self: a `GskPathBuilder`
  * @center: the center of the circle
  * @radius: the radius of the circle
  *
  * Adds a circle with the @center and @radius.
- **/
+ */
 void
 gsk_path_builder_add_circle (GskPathBuilder         *self,
                              const graphene_point_t *center,
@@ -375,17 +474,63 @@ gsk_path_builder_add_circle (GskPathBuilder         *self,
 }
 
 /**
- * gsk_path_builder_move_to:
+ * gsk_path_builder_add_ellipse:
  * @self: a #GskPathBuilder
+ * @center: the center point of the ellipse
+ * @radius: the radius of the ellipse in x/y direction
+ *
+ * Adds an ellipse with the given @center and the @radius in
+ * x/y direction.
+ */
+void
+gsk_path_builder_add_ellipse (GskPathBuilder         *self,
+                              const graphene_point_t *center,
+                              const graphene_size_t  *radius)
+{
+  const float weight = sqrt(0.5f);
+  graphene_point_t pts[8];
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (center != NULL);
+  g_return_if_fail (radius != NULL);
+
+  pts[0] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
+                                center->y);
+  pts[1] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
+                                center->y + radius->height / 2);
+  pts[2] = GRAPHENE_POINT_INIT (center->x,
+                                center->y + radius->height / 2);
+  pts[3] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
+                                center->y + radius->height / 2);
+  pts[4] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
+                                center->y);
+  pts[5] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
+                                center->y - radius->height / 2);
+  pts[6] = GRAPHENE_POINT_INIT (center->x,
+                                center->y - radius->height / 2);
+  pts[7] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
+                                center->y - radius->height / 2);
+
+  gsk_path_builder_move_to (self, pts[0].x, pts[0].y);
+  gsk_path_builder_conic_to (self, pts[1].x, pts[1].y, pts[2].x, pts[2].y, weight);
+  gsk_path_builder_conic_to (self, pts[3].x, pts[3].y, pts[4].x, pts[4].y, weight);
+  gsk_path_builder_conic_to (self, pts[5].x, pts[5].y, pts[6].x, pts[6].y, weight);
+  gsk_path_builder_conic_to (self, pts[7].x, pts[7].y, pts[0].x, pts[0].y, weight);
+  gsk_path_builder_close (self);
+}
+
+/**
+ * gsk_path_builder_move_to:
+ * @self: a `GskPathBuilder`
  * @x: x coordinate
  * @y: y coordinate
  *
  * Starts a new contour by placing the pen at @x, @y.
  *
- * If gsk_path_builder_move_to() is called twice in succession, the first
- * call will result in a contour made up of a single point. The second call
- * will start a new contour.
- **/
+ * If this function is called twice in succession, the first
+ * call will result in a contour made up of a single point.
+ * The second call will start a new contour.
+ */
 void
 gsk_path_builder_move_to (GskPathBuilder *self,
                           float           x,
@@ -402,15 +547,15 @@ gsk_path_builder_move_to (GskPathBuilder *self,
 
 /**
  * gsk_path_builder_rel_move_to:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  * @x: x offset
  * @y: y offset
  *
  * Starts a new contour by placing the pen at @x, @y relative to the current
  * point.
  *
- * This is the relative version of gsk_path_builder_move_to().
- **/
+ * This is the relative version of [method@Gsk.PathBuilder.move_to].
+ */
 void
 gsk_path_builder_rel_move_to (GskPathBuilder *self,
                               float           x,
@@ -425,13 +570,13 @@ gsk_path_builder_rel_move_to (GskPathBuilder *self,
 
 /**
  * gsk_path_builder_line_to:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  * @x: x coordinate
  * @y: y coordinate
  *
- * Draws a line from the current point to @x, @y and makes it the new current
- * point.
- **/
+ * Draws a line from the current point to @x, @y and makes it
+ * the new current point.
+ */
 void
 gsk_path_builder_line_to (GskPathBuilder *self,
                           float           x,
@@ -453,15 +598,15 @@ gsk_path_builder_line_to (GskPathBuilder *self,
 
 /**
  * gsk_path_builder_rel_line_to:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  * @x: x offset
  * @y: y offset
  *
  * Draws a line from the current point to a point offset to it by @x, @y
  * and makes it the new current point.
  *
- * This is the relative version of gsk_path_builder_line_to().
- **/
+ * This is the relative version of [method@Gsk.PathBuilder.line_to].
+ */
 void
 gsk_path_builder_rel_line_to (GskPathBuilder *self,
                               float           x,
@@ -475,8 +620,70 @@ gsk_path_builder_rel_line_to (GskPathBuilder *self,
 }
 
 /**
- * gsk_path_builder_curve_to:
+ * gsk_path_builder_quad_to:
  * @self: a #GskPathBuilder
+ * @x1: x coordinate of control point
+ * @y1: y coordinate of control point
+ * @x2: x coordinate of the end of the curve
+ * @y2: y coordinate of the end of the curve
+ *
+ * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+ * from the current point to @x2, @y2 with @x1, @y1 as the control point.
+ *
+ * After this, @x2, @y2 will be the new current point.
+ */
+void
+gsk_path_builder_quad_to (GskPathBuilder *self,
+                          float           x1,
+                          float           y1,
+                          float           x2,
+                          float           y2)
+{
+  g_return_if_fail (self != NULL);
+
+  self->flags &= ~GSK_PATH_FLAT;
+  gsk_path_builder_append_current (self,
+                                   GSK_PATH_QUAD,
+                                   2, (graphene_point_t[2]) {
+                                     GRAPHENE_POINT_INIT (x1, y1),
+                                     GRAPHENE_POINT_INIT (x2, y2)
+                                   });
+}
+
+/**
+ * gsk_path_builder_rel_quad_to:
+ * @self: a `GskPathBuilder`
+ * @x1: x offset of control point
+ * @y1: y offset of control point
+ * @x2: x offset of the end of the curve
+ * @y2: y offset of the end of the curve
+ *
+ * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+ * from the current point to @x2, @y2 with @x1, @y1 the control point.
+ *
+ * All coordinates are given relative to the current point.
+ *
+ * This is the relative version of [method@Gsk.PathBuilder.quad_to].
+ */
+void
+gsk_path_builder_rel_quad_to (GskPathBuilder *self,
+                              float           x1,
+                              float           y1,
+                              float           x2,
+                              float           y2)
+{
+  g_return_if_fail (self != NULL);
+
+  gsk_path_builder_quad_to (self,
+                            self->current_point.x + x1,
+                            self->current_point.y + y1,
+                            self->current_point.x + x2,
+                            self->current_point.y + y2);
+}
+
+/**
+ * gsk_path_builder_cubic_to:
+ * @self: a `GskPathBuilder`
  * @x1: x coordinate of first control point
  * @y1: y coordinate of first control point
  * @x2: x coordinate of second control point
@@ -489,9 +696,9 @@ gsk_path_builder_rel_line_to (GskPathBuilder *self,
  * points.
  *
  * After this, @x3, @y3 will be the new current point.
- **/
+ */
 void
-gsk_path_builder_curve_to (GskPathBuilder *self,
+gsk_path_builder_cubic_to (GskPathBuilder *self,
                            float           x1,
                            float           y1,
                            float           x2,
@@ -503,7 +710,7 @@ gsk_path_builder_curve_to (GskPathBuilder *self,
 
   self->flags &= ~GSK_PATH_FLAT;
   gsk_path_builder_append_current (self,
-                                   GSK_PATH_CURVE,
+                                   GSK_PATH_CUBIC,
                                    3, (graphene_point_t[3]) {
                                      GRAPHENE_POINT_INIT (x1, y1),
                                      GRAPHENE_POINT_INIT (x2, y2),
@@ -512,8 +719,8 @@ gsk_path_builder_curve_to (GskPathBuilder *self,
 }
 
 /**
- * gsk_path_builder_rel_curve_to:
- * @self: a #GskPathBuilder
+ * gsk_path_builder_rel_cubic_to:
+ * @self: a `GskPathBuilder`
  * @x1: x offset of first control point
  * @y1: y offset of first control point
  * @x2: x offset of second control point
@@ -525,10 +732,10 @@ gsk_path_builder_curve_to (GskPathBuilder *self,
  * from the current point to @x3, @y3 with @x1, @y1 and @x2, @y2 as the control
  * points. All coordinates are given relative to the current point.
  *
- * This is the relative version of gsk_path_builder_curve_to().
- **/
+ * This is the relative version of [method@Gsk.PathBuilder.cubic_to].
+ */
 void
-gsk_path_builder_rel_curve_to (GskPathBuilder *self,
+gsk_path_builder_rel_cubic_to (GskPathBuilder *self,
                                float           x1,
                                float           y1,
                                float           x2,
@@ -538,7 +745,7 @@ gsk_path_builder_rel_curve_to (GskPathBuilder *self,
 {
   g_return_if_fail (self != NULL);
 
-  gsk_path_builder_curve_to (self,
+  gsk_path_builder_cubic_to (self,
                              self->current_point.x + x1,
                              self->current_point.y + y1,
                              self->current_point.x + x2,
@@ -547,18 +754,90 @@ gsk_path_builder_rel_curve_to (GskPathBuilder *self,
                              self->current_point.y + y3);
 }
 
+/**
+ * gsk_path_builder_conic_to:
+ * @self: a `GskPathBuilder`
+ * @x1: x coordinate of control point
+ * @y1: y coordinate of control point
+ * @x2: x coordinate of the end of the curve
+ * @y2: y coordinate of the end of the curve
+ * @weight: weight of the curve
+ *
+ * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
+ * from the current point to @x2, @y2 with the given
+ * @weight and @x1, @y1 as the single control point.
+ *
+ * Conic curves can be used to draw ellipses and circles.
+ *
+ * After this, @x2, @y2 will be the new current point.
+ */
+void
+gsk_path_builder_conic_to (GskPathBuilder *self,
+                           float           x1,
+                           float           y1,
+                           float           x2,
+                           float           y2,
+                           float           weight)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (weight >= 0);
+
+  self->flags &= ~GSK_PATH_FLAT;
+  gsk_path_builder_append_current (self,
+                                   GSK_PATH_CONIC,
+                                   3, (graphene_point_t[3]) {
+                                     GRAPHENE_POINT_INIT (x1, y1),
+                                     GRAPHENE_POINT_INIT (weight, 0),
+                                     GRAPHENE_POINT_INIT (x2, y2)
+                                   });
+}
+
+/**
+ * gsk_path_builder_rel_conic_to:
+ * @self: a `GskPathBuilder`
+ * @x1: x offset of control point
+ * @y1: y offset of control point
+ * @x2: x offset of the end of the curve
+ * @y2: y offset of the end of the curve
+ * @weight: weight of the curve
+ *
+ * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
+ * from the current point to @x2, @y2 with the given
+ * @weight and @x1, @y1 as the single control point.
+ *
+ * This is the relative version of [method@Gsk.PathBuilder.conic_to].
+ */
+void
+gsk_path_builder_rel_conic_to (GskPathBuilder *self,
+                               float           x1,
+                               float           y1,
+                               float           x2,
+                               float           y2,
+                               float           weight)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (weight >= 0);
+
+  gsk_path_builder_conic_to (self,
+                             self->current_point.x + x1,
+                             self->current_point.y + y1,
+                             self->current_point.x + x2,
+                             self->current_point.y + y2,
+                             weight);
+}
+
 /**
  * gsk_path_builder_close:
- * @self: a #GskPathBuilder
+ * @self: a `GskPathBuilder`
  *
  * Ends the current contour with a line back to the start point.
  *
- * Note that this is different from calling gsk_path_builder_line_to()
+ * Note that this is different from calling [method@Gsk.PathBuilder.line_to]
  * with the start point in that the contour will be closed. A closed
  * contour behaves different from an open one when stroking its start
  * and end point are considered connected, so they will be joined
  * via the line join, and not ended with line caps.
- **/
+ */
 void
 gsk_path_builder_close (GskPathBuilder *self)
 {
@@ -577,9 +856,8 @@ gsk_path_builder_close (GskPathBuilder *self)
   gsk_path_builder_end_current (self);
 }
 
-
 static void
-arc_segment (GskPathBuilder *builder,
+arc_segment (GskPathBuilder *self,
              double          cx,
              double          cy,
              double          rx,
@@ -601,7 +879,7 @@ arc_segment (GskPathBuilder *builder,
   x2 = x3 + rx * (t * sin_th1);
   y2 = y3 + ry * (-t * cos_th1);
 
-  gsk_path_builder_curve_to (builder,
+  gsk_path_builder_cubic_to (self,
                              cx + cos_phi * x1 - sin_phi * y1,
                              cy + sin_phi * x1 + cos_phi * y1,
                              cx + cos_phi * x2 - sin_phi * y2,
@@ -610,19 +888,21 @@ arc_segment (GskPathBuilder *builder,
                              cy + sin_phi * x3 + cos_phi * y3);
 }
 
-#ifndef HAVE_SINCOS
 static inline void
-sincos (double angle,
-        double *y,
-        double *x)
+_sincos (double angle,
+         double *y,
+         double *x)
 {
+#ifdef HAVE_SINCOS
+  sincos (angle, y, x);
+#else
   *x = cos (angle);
   *y = sin (angle);
-}
 #endif
+}
 
 void
-gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
+gsk_path_builder_svg_arc_to (GskPathBuilder *self,
                              float           rx,
                              float           ry,
                              float           x_axis_rotation,
@@ -653,9 +933,9 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
   double th_half;
   double t;
 
-  if (builder->points->len > 0)
+  if (self->points->len > 0)
     {
-      current = &g_array_index (builder->points, graphene_point_t, builder->points->len - 1);
+      current = &g_array_index (self->points, graphene_point_t, self->points->len - 1);
       x1 = current->x;
       y1 = current->y;
     }
@@ -668,7 +948,7 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
   y2 = y;
 
   phi = x_axis_rotation * M_PI / 180.0;
-  sincos (phi, &sin_phi, &cos_phi);
+  _sincos (phi, &sin_phi, &cos_phi);
 
   rx = fabs (rx);
   ry = fabs (ry);
@@ -731,7 +1011,7 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
   n_segs = ceil (fabs (delta_theta / (M_PI_2 + 0.001)));
   d_theta = delta_theta / n_segs;
   theta = theta1;
-  sincos (theta1, &sin_th1, &cos_th1);
+  _sincos (theta1, &sin_th1, &cos_th1);
 
   th_half = d_theta / 2;
   t = (8.0 / 3.0) * sin (th_half / 2) * sin (th_half / 2) / sin (th_half);
@@ -742,8 +1022,8 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
       theta1 = theta + d_theta;
       sin_th0 = sin_th1;
       cos_th0 = cos_th1;
-      sincos (theta1, &sin_th1, &cos_th1);
-      arc_segment (builder,
+      _sincos (theta1, &sin_th1, &cos_th1);
+      arc_segment (self,
                    cx, cy, rx, ry,
                    sin_phi, cos_phi,
                    sin_th0, cos_th0,
@@ -751,3 +1031,32 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
                    t);
     }
 }
+
+/**
+ * gsk_path_builder_add_layout:
+ * @self: a #GskPathBuilder
+ * @layout: the pango layout to add
+ *
+ * Adds the outlines for the glyphs in @layout to
+ * the builder.
+ */
+void
+gsk_path_builder_add_layout (GskPathBuilder *self,
+                             PangoLayout    *layout)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+  cairo_path_t *cairo_path;
+
+  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
+  cr = cairo_create (surface);
+
+  pango_cairo_layout_path (cr, layout);
+  cairo_path = cairo_copy_path (cr);
+
+  gsk_path_builder_add_cairo_path (self, cairo_path);
+
+  cairo_path_destroy (cairo_path);
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+}

gsk/gskpathbuilder.h

@@ -17,14 +17,14 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#ifndef __GSK_PATH_BUILDER_H__
-#define __GSK_PATH_BUILDER_H__
+#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
@@ -52,12 +52,34 @@ GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_path               (GskPathBuilder         *self,
                                                                  GskPath                *path);
 GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_reverse_path       (GskPathBuilder         *self,
+                                                                 GskPath                *path);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_cairo_path         (GskPathBuilder         *self,
+                                                                 const cairo_path_t     *path);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_layout             (GskPathBuilder         *self,
+                                                                 PangoLayout            *layout);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_rect               (GskPathBuilder         *self,
                                                                  const graphene_rect_t  *rect);
 GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_rounded_rect       (GskPathBuilder         *self,
+                                                                 const GskRoundedRect   *rect);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_circle             (GskPathBuilder         *self,
                                                                  const graphene_point_t *center,
                                                                  float                   radius);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_ellipse            (GskPathBuilder         *self,
+                                                                 const graphene_point_t *center,
+                                                                 const graphene_size_t  *radius);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_add_segment            (GskPathBuilder         *self,
+                                                                 GskPathMeasure         *measure,
+                                                                 float                   start,
+                                                                 float                   end);
 
 GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_move_to                (GskPathBuilder         *self,
@@ -76,7 +98,19 @@ void                    gsk_path_builder_rel_line_to            (GskPathBuilder
                                                                  float                   x,
                                                                  float                   y);
 GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_curve_to               (GskPathBuilder         *self,
+void                    gsk_path_builder_quad_to                (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_rel_quad_to            (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_cubic_to               (GskPathBuilder         *self,
                                                                  float                   x1,
                                                                  float                   y1,
                                                                  float                   x2,
@@ -84,7 +118,7 @@ void                    gsk_path_builder_curve_to               (GskPathBuilder
                                                                  float                   x3,
                                                                  float                   y3);
 GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_rel_curve_to           (GskPathBuilder         *self,
+void                    gsk_path_builder_rel_cubic_to           (GskPathBuilder         *self,
                                                                  float                   x1,
                                                                  float                   y1,
                                                                  float                   x2,
@@ -92,10 +126,22 @@ void                    gsk_path_builder_rel_curve_to           (GskPathBuilder
                                                                  float                   x3,
                                                                  float                   y3);
 GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_conic_to               (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   weight);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_rel_conic_to           (GskPathBuilder         *self,
+                                                                 float                   x1,
+                                                                 float                   y1,
+                                                                 float                   x2,
+                                                                 float                   y2,
+                                                                 float                   weight);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_close                  (GskPathBuilder         *self);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathBuilder, gsk_path_builder_unref)
 
 G_END_DECLS
-
-#endif /* __GSK_PATH_BUILDER_H__ */

gsk/gskpathdash.c

@@ -0,0 +1,304 @@
+/*
+ * 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:
+ * @path: 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 @path with the dash pattern from @stroke.
+ *
+ * Returns: `FALSE` if @func returned FALSE`, `TRUE` otherwise.
+ */
+gboolean
+gsk_path_dash (GskPath            *path,
+               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 (path, -1, func, user_data);
+
+  for (i = 0; i < gsk_path_get_n_contours (path); i++)
+    {
+      if (!gsk_contour_dash (gsk_path_get_contour (path, i), stroke, tolerance, func, user_data))
+        return FALSE;
+    }
+
+  return TRUE;
+}
+

gsk/gskpathmeasure.c

@@ -20,17 +20,23 @@
 #include "config.h"
 
 #include "gskpathmeasure.h"
+#include "gskpathbuilder.h"
 
+#include "gskpathbuilder.h"
+#include "gskpathpointprivate.h"
 #include "gskpathprivate.h"
 
 /**
- * SECTION:gskpathmeasure
- * @Title: PathMeasure
- * @Short_description: Measuring operations on paths
- * @See_also: #GskPath
+ * `GskPathMeasure` is an object that allows measurements
+ * on `GskPath`s such as determining the length of the path.
  *
- * #GskPathMeasure is an object that allows measuring operations on #GskPaths.
- * These operations are useful when implementing animations.
+ * Many measuring operations require approximating the path
+ * with simpler shapes. Therefore, a `GskPathMeasure` has
+ * a tolerance that determines what amount is required
+ * for such approximations.
+ *
+ * A `GskPathMeasure` struct is a reference counted struct
+ * and should be treated as opaque.
  */
 
 typedef struct _GskContourMeasure GskContourMeasure;
@@ -54,13 +60,6 @@ struct _GskPathMeasure
   GskContourMeasure measures[];
 };
 
-/**
- * GskPathMeasure:
- *
- * A #GskPathMeasure struct is a reference counted struct
- * and should be treated as opaque.
- */
-
 G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
                      gsk_path_measure_ref,
                      gsk_path_measure_unref)
@@ -71,8 +70,8 @@ G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
  *
  * Creates a measure object for the given @path.
  *
- * Returns: a new #GskPathMeasure representing @path
- **/
+ * Returns: a new `GskPathMeasure` representing @path
+ */
 GskPathMeasure *
 gsk_path_measure_new (GskPath *path)
 {
@@ -86,8 +85,8 @@ gsk_path_measure_new (GskPath *path)
  *
  * Creates a measure object for the given @path and @tolerance.
  *
- * Returns: a new #GskPathMeasure representing @path
- **/
+ * Returns: a new `GskPathMeasure` representing @path
+ */
 GskPathMeasure *
 gsk_path_measure_new_with_tolerance (GskPath *path,
                                      float    tolerance)
@@ -109,7 +108,7 @@ gsk_path_measure_new_with_tolerance (GskPath *path,
 
   for (i = 0; i < n_contours; i++)
     {
-      self->measures[i].contour_data = gsk_contour_init_measure (path, 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;
@@ -120,12 +119,12 @@ gsk_path_measure_new_with_tolerance (GskPath *path,
 
 /**
  * gsk_path_measure_ref:
- * @self: a #GskPathMeasure
+ * @self: a `GskPathMeasure`
  *
- * Increases the reference count of a #GskPathMeasure by one.
+ * Increases the reference count of a `GskPathMeasure` by one.
  *
- * Returns: the passed in #GskPathMeasure.
- **/
+ * Returns: the passed in `GskPathMeasure`.
+ */
 GskPathMeasure *
 gsk_path_measure_ref (GskPathMeasure *self)
 {
@@ -138,11 +137,12 @@ gsk_path_measure_ref (GskPathMeasure *self)
 
 /**
  * gsk_path_measure_unref:
- * @self: a #GskPathMeasure
+ * @self: a `GskPathMeasure`
  *
- * Decreases the reference count of a #GskPathMeasure by one.
- * If the resulting reference count is zero, frees the path_measure.
- **/
+ * Decreases the reference count of a `GskPathMeasure` by one.
+ *
+ * If the resulting reference count is zero, frees the object.
+ */
 void
 gsk_path_measure_unref (GskPathMeasure *self)
 {
@@ -157,23 +157,52 @@ gsk_path_measure_unref (GskPathMeasure *self)
 
   for (i = 0; i < self->n_contours; i++)
     {
-      gsk_contour_free_measure (self->path, i, self->measures[i].contour_data);
+      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
+ */
+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
+ */
+float
+gsk_path_measure_get_tolerance (GskPathMeasure *self)
+{
+  return self->tolerance;
+}
+
 /**
  * gsk_path_measure_get_length:
- * @self: a #GskPathMeasure
+ * @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
- **/
+ */
 float
 gsk_path_measure_get_length (GskPathMeasure *self)
 {
@@ -182,6 +211,30 @@ gsk_path_measure_get_length (GskPathMeasure *self)
   return self->length;
 }
 
+/**
+ * gsk_path_measure_is_closed:
+ * @self: a `GskPathMeasure`
+ *
+ * Returns if the path being measured represents a single closed
+ * contour.
+ *
+ * Returns: `TRUE` if the current path is closed
+ */
+gboolean
+gsk_path_measure_is_closed (GskPathMeasure *self)
+{
+  const GskContour *contour;
+
+  g_return_val_if_fail (self != NULL, FALSE);
+
+  /* XXX: is the empty path closed? Currently it's not */
+  if (self->n_contours != 1)
+    return FALSE;
+
+  contour = gsk_path_get_contour (self->path, 0);
+  return gsk_contour_get_flags (contour) & GSK_PATH_CLOSED ? TRUE : FALSE;
+}
+
 static float
 gsk_path_measure_clamp_distance (GskPathMeasure *self,
                                  float           distance)
@@ -192,198 +245,17 @@ gsk_path_measure_clamp_distance (GskPathMeasure *self,
   return CLAMP (distance, 0, self->length);
 }
 
-/**
- * gsk_path_measure_get_point:
- * @self: a #GskPathMeasure
- * @distance: distance into the path
- * @pos: (out caller-allocates) (optional): The coordinates
- *    of the position at @distance
- * @tangent: (out caller-allocates) (optional): The tangent
- *    to the position at @distance
- *
- * Calculates the coordinates and tangent of the point @distance
- * units into the path. The value will be clamped to the length
- * of the path.
- *
- * If the point is a discontinuous edge in the path, the returned
- * point and tangent will describe the line starting at that point
- * going forward.
- *
- * If @self describes an empty path, the returned point will be 
- * set to `(0, 0)` and the tangent will be the x axis or `(1, 0)`.
- **/
-void
-gsk_path_measure_get_point (GskPathMeasure   *self,
-                            float             distance,
-                            graphene_point_t *pos,
-                            graphene_vec2_t  *tangent)
-{
-  gsize i;
-
-  g_return_if_fail (self != NULL);
-
-  if (pos == NULL && tangent == NULL)
-    return;
-
-  distance = gsk_path_measure_clamp_distance (self, distance);
-
-  for (i = 0; i < self->n_contours; i++)
-    {
-      if (distance < self->measures[i].length)
-        break;
-
-      distance -= self->measures[i].length;
-    }
-
-  /* weird corner cases */
-  if (i == self->n_contours)
-    {
-      /* the empty path goes here */
-      if (self->n_contours == 0)
-        {
-          if (pos)
-            graphene_point_init (pos, 0.f, 0.f);
-          if (tangent)
-            graphene_vec2_init (tangent, 1.f, 0.f);
-          return;
-        }
-      /* rounding errors can make this happen */
-      i = self->n_contours - 1;
-      distance = self->measures[i].length;
-    }
-
-  gsk_contour_get_point (self->path,
-                         i,
-                         self->measures[i].contour_data,
-                         distance,
-                         pos,
-                         tangent);
-}
-
-/**
- * gsk_path_measure_get_closest_point:
- * @self: a #GskPathMeasure
- * @point: the point to fond the closest point to
- * @out_pos: (out caller-allocates) (optional): return location
- *    for the closest point
- *
- * Gets the point on the path that is closest to @point.
- *
- * If the path being measured is empty, return 0 and set
- * @out_pos to (0, 0).
- *
- * This is a simpler and slower version of
- * gsk_path_measure_get_closest_point_full(). Use that one if you
- * need more control.
- *
- * Returns: The offset into the path of the closest point
- **/
-float
-gsk_path_measure_get_closest_point (GskPathMeasure         *self,
-                                    const graphene_point_t *point,
-                                    graphene_point_t       *out_pos)
-{
-  float result;
-
-  g_return_val_if_fail (self != NULL, 0.0f);
-
-  if (gsk_path_measure_get_closest_point_full (self, 
-                                               point,
-                                               INFINITY,
-                                               &result,
-                                               out_pos,
-                                               NULL,
-                                               NULL))
-    return result;
-
-  if (out_pos)
-    *out_pos = GRAPHENE_POINT_INIT (0, 0);
-
-  return 0;
-
-}
-
-/**
- * gsk_path_measure_get_closest_point_full:
- * @self: a #GskPathMeasure
- * @point: the point to fond the closest point to
- * @threshold: The maximum allowed distance between the path and @point.
- *     Use INFINITY to look for any point.
- * @out_distance: (out caller-allocates) (optional): The 
- *     distance between the found closest point on the path and the given
- *     @point.
- * @out_pos: (out caller-allocates) (optional): return location
- *     for the closest point
- * @out_offset: (out caller-allocates) (optional): The offset into
- *     the path of the found point
- * @out_tangent: (out caller-allocates) (optional): return location for
- *     the tangent at the closest point
- *
- * Gets the point on the path that is closest to @point. If no point on
- * path is closer to @point than @threshold, return %FALSE.
- *
- * Returns: %TRUE if a point was found, %FALSE otherwise.
- **/
-gboolean
-gsk_path_measure_get_closest_point_full (GskPathMeasure         *self,
-                                         const graphene_point_t *point,
-                                         float                   threshold,
-                                         float                  *out_distance,
-                                         graphene_point_t       *out_pos,
-                                         float                  *out_offset,
-                                         graphene_vec2_t        *out_tangent)
-{
-  gboolean result;
-  gsize i;
-  float distance, length;
-
-  g_return_val_if_fail (self != NULL, FALSE);
-  g_return_val_if_fail (point != NULL, FALSE);
-
-  result = FALSE;
-  length = 0;
-
-  for (i = 0; i < self->n_contours; i++)
-    {
-      if (gsk_contour_get_closest_point (self->path,
-                                         i,
-                                         self->measures[i].contour_data,
-                                         self->tolerance,
-                                         point,
-                                         threshold,
-                                         &distance,
-                                         out_pos,
-                                         out_offset,
-                                         out_tangent))
-        {
-          result = TRUE;
-          if (out_offset)
-            *out_offset += length;
-
-          if (distance < self->tolerance)
-            break;
-          threshold = distance - self->tolerance;
-        }
-
-      length += self->measures[i].length;
-    }
-
-  if (result && out_distance)
-    *out_distance = distance;
-
-  return result;
-}
-
 /**
  * gsk_path_measure_in_fill:
- * @self: a #GskPathMeasure
+ * @self: a `GskPathMeasure`
  * @point: the point to test
  * @fill_rule: the fill rule to follow
  *
- * Returns whether the given point is inside the area that would be
- * affected if the path of @self was filled according to @fill_rule.
+ * Returns whether the given point is inside the area
+ * that would be affected if the path was filled according
+ * to @fill_rule.
  *
- * Returns: %TRUE if @point is inside
+ * Returns: `TRUE` if @point is inside
  */
 gboolean
 gsk_path_measure_in_fill (GskPathMeasure         *self,
@@ -391,18 +263,12 @@ gsk_path_measure_in_fill (GskPathMeasure         *self,
                           GskFillRule             fill_rule)
 {
   int winding = 0;
-  gboolean on_edge = FALSE;
   int i;
 
   for (i = 0; i < self->n_contours; i++)
-    {
-      winding += gsk_contour_get_winding (gsk_path_get_contour (self->path, i),
-                                          self->measures[i].contour_data,
-                                          point,
-                                          &on_edge);
-      if (on_edge)
-        return TRUE;
-    }
+    winding += gsk_contour_get_winding (gsk_path_get_contour (self->path, i),
+                                        self->measures[i].contour_data,
+                                        point);
 
   switch (fill_rule)
     {
@@ -415,52 +281,29 @@ gsk_path_measure_in_fill (GskPathMeasure         *self,
     }
 }
 
-
-/**
- * gsk_path_measure_add_segment:
- * @self: a #GskPathMeasure
- * @builder: the builder to add the segment to
- * @start: start distance into the path
- * @end: end distance into the path
- *
- * Adds to @builder the segment of @path inbetween @start and @end.
- *
- * The distances are given relative to the length of @self's path,
- * from 0 for the beginning of the path to
- * gsk_path_measure_get_length() for the end of the path. The values
- * will be clamped to that range.
- *
- * If @start >= @end after clamping, no path will be added.
- **/
-void
-gsk_path_measure_add_segment (GskPathMeasure *self,
-                              GskPathBuilder *builder,
-                              float           start,
-                              float           end)
+static void
+gsk_path_builder_add_segment_chunk (GskPathBuilder *self,
+                                    GskPathMeasure *measure,
+                                    gboolean        emit_move_to,
+                                    float           start,
+                                    float           end)
 {
-  gsize i;
+  g_assert (start < end);
 
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (builder != NULL);
-
-  start = gsk_path_measure_clamp_distance (self, start);
-  end = gsk_path_measure_clamp_distance (self, end);
-  if (start >= end)
-    return;
-
-  for (i = 0; i < self->n_contours; i++)
+  for (gsize i = 0; i < measure->n_contours; i++)
     {
-      if (self->measures[i].length < start)
+      if (measure->measures[i].length < start)
         {
-          start -= self->measures[i].length;
-          end -= self->measures[i].length;
+          start -= measure->measures[i].length;
+          end -= measure->measures[i].length;
         }
-      else if (start > 0 || end < self->measures[i].length)
+      else if (start > 0 || end < measure->measures[i].length)
         {
-          float len = MIN (end, self->measures[i].length);
-          gsk_contour_add_segment (gsk_path_get_contour (self->path, i),
-                                   builder,
-                                   self->measures[i].contour_data,
+          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;
@@ -470,8 +313,178 @@ gsk_path_measure_add_segment (GskPathMeasure *self,
         }
       else
         {
-          end -= self->measures[i].length;
-          gsk_path_builder_add_contour (builder, gsk_contour_dup (gsk_path_get_contour (self->path, i)));
+          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.
+ */
+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_measure_is_closed (measure);
+      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
+ *
+ * Returns a `GskPathPoint` representing the point at the given
+ * distance into the path.
+ *
+ * An empty path has no points, so `NULL` is returned in that case.
+ *
+ * Returns: (transfer full) (nullable): a newly allocated `GskPathPoint`
+ */
+GskPathPoint *
+gsk_path_measure_get_point (GskPathMeasure *self,
+                            float           distance)
+{
+  gsize i;
+  float contour_offset;
+  float offset;
+  const GskContour *contour;
+
+  g_return_val_if_fail (self != NULL, NULL);
+
+  if (self->n_contours == 0)
+    return NULL;
+
+  contour_offset = 0;
+  offset = gsk_path_measure_clamp_distance (self, distance);
+
+  for (i = 0; i < self->n_contours - 1; i++)
+    {
+      if (offset < self->measures[i].length)
+        break;
+
+      contour_offset += self->measures[i].length;
+      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);
+
+  return gsk_path_point_new (self,
+                             contour, self->measures[i].contour_data,
+                             contour_offset, offset);
+}
+
+/**
+ * gsk_path_measure_get_closest_point:
+ * @self: a `GskPathMeasure`
+ * @point: the point to fond the closest point to
+ * @threshold: The maximum allowed distance between the path and @point.
+ *   Use `INFINITY` to look for any point.
+ *
+ * Returns a `GskPathPoint` representing the point on the path
+ * that is closest to the given point.
+ *
+ * If no point on the path is closer than @threshold, `NULL` is returned.
+ *
+ * Returns: (transfer full) (nullable): a newly allocated `GskPathPoint`
+ */
+GskPathPoint *
+gsk_path_measure_get_closest_point (GskPathMeasure         *self,
+                                    const graphene_point_t *point,
+                                    float                   threshold)
+{
+  gssize best_idx;
+  float best_offset;
+  float best_contour_offset;
+  float contour_offset;
+
+  contour_offset = 0;
+  best_idx = -1;
+
+  for (gsize i = 0; i < self->n_contours; i++)
+    {
+      float distance, offset;
+
+      if (gsk_contour_get_closest_point (gsk_path_get_contour (self->path, i),
+                                         self->measures[i].contour_data,
+                                         self->tolerance,
+                                         point,
+                                         threshold,
+                                         &distance,
+                                         NULL,
+                                         &offset,
+                                         NULL))
+        {
+          best_idx = i;
+          best_offset = offset;
+          best_contour_offset = contour_offset;
+
+          if (distance < self->tolerance)
+            break;
+
+          threshold = distance - self->tolerance;
+        }
+
+      contour_offset += self->measures[i].length;
+    }
+
+  if (best_idx != -1)
+    return gsk_path_point_new (self,
+                               gsk_path_get_contour (self->path, best_idx),
+                               self->measures[best_idx].contour_data,
+                               best_contour_offset, best_offset);
+
+  return NULL;
+}

gsk/gskpathmeasure.h

@@ -17,8 +17,7 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#ifndef __GSK_PATH_MEASURE_H__
-#define __GSK_PATH_MEASURE_H__
+#pragma once
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
@@ -26,6 +25,7 @@
 
 
 #include <gsk/gskpath.h>
+#include <gsk/gskpathpoint.h>
 
 G_BEGIN_DECLS
 
@@ -45,37 +45,29 @@ GDK_AVAILABLE_IN_ALL
 void                    gsk_path_measure_unref                  (GskPathMeasure         *self);
 
 GDK_AVAILABLE_IN_ALL
-float                   gsk_path_measure_get_length             (GskPathMeasure         *self);
+GskPath *               gsk_path_measure_get_path               (GskPathMeasure         *self) G_GNUC_PURE;
 GDK_AVAILABLE_IN_ALL
-void                    gsk_path_measure_get_point              (GskPathMeasure         *self,
-                                                                 float                   distance,
-                                                                 graphene_point_t       *pos,
-                                                                 graphene_vec2_t        *tangent);
-GDK_AVAILABLE_IN_ALL
-float                   gsk_path_measure_get_closest_point      (GskPathMeasure         *self,
-                                                                 const graphene_point_t *point,
-                                                                 graphene_point_t       *out_pos);
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_measure_get_closest_point_full (GskPathMeasure         *self,
-                                                                 const graphene_point_t *point,
-                                                                 float                   threshold,
-                                                                 float                  *out_distance,
-                                                                 graphene_point_t       *out_pos,
-                                                                 float                  *out_offset,
-                                                                 graphene_vec2_t        *out_tangent);
+float                   gsk_path_measure_get_tolerance          (GskPathMeasure         *self) G_GNUC_PURE;
 
 GDK_AVAILABLE_IN_ALL
-void                    gsk_path_measure_add_segment            (GskPathMeasure         *self,
-                                                                 GskPathBuilder         *builder,
-                                                                 float                   start,
-                                                                 float                   end);
+float                   gsk_path_measure_get_length             (GskPathMeasure         *self);
+GDK_AVAILABLE_IN_ALL
+gboolean                gsk_path_measure_is_closed              (GskPathMeasure         *self);
 
 GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_measure_in_fill                (GskPathMeasure         *self,
                                                                  const graphene_point_t *point,
                                                                  GskFillRule             fill_rule);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathMeasure, gsk_path_measure_unref)
-G_END_DECLS
+GDK_AVAILABLE_IN_ALL
+GskPathPoint *          gsk_path_measure_get_point              (GskPathMeasure         *self,
+                                                                 float                   distance);
 
-#endif /* __GSK_PATH_MEASURE_H__ */
+GDK_AVAILABLE_IN_ALL
+GskPathPoint *          gsk_path_measure_get_closest_point      (GskPathMeasure         *self,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold);
+
+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,195 @@
+#include "config.h"
+
+#include "gskpathpointprivate.h"
+
+#include "gskcontourprivate.h"
+#include "gskpathmeasure.h"
+
+#include "gdk/gdkprivate.h"
+
+
+/**
+ * GskPathPoint:
+ *
+ * `GskPathPoint` is an opaque, immutable 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.PathMeasure.get_path_point]
+ * or [method@Gsk.PathMeasure.get_closest_point].
+ */
+
+struct _GskPathPoint
+{
+  guint ref_count;
+
+  GskPathMeasure *measure;
+  const GskContour *contour;
+  gpointer measure_data;
+  float contour_offset;  /* distance from beginning of path to contour */
+  float offset;          /* offset of point inside contour */
+};
+
+G_DEFINE_BOXED_TYPE (GskPathPoint, gsk_path_point,
+                     gsk_path_point_ref,
+                     gsk_path_point_unref)
+
+GskPathPoint *
+gsk_path_point_new (GskPathMeasure   *measure,
+                    const GskContour *contour,
+                    gpointer          measure_data,
+                    float             contour_offset,
+                    float             offset)
+{
+  GskPathPoint *self;
+
+  self = g_new0 (GskPathPoint, 1);
+
+  self->ref_count = 1;
+
+  self->measure = gsk_path_measure_ref (measure);
+  self->contour = contour;
+  self->measure_data = measure_data;
+  self->contour_offset = contour_offset;
+  self->offset = offset;
+
+  return self;
+}
+
+/**
+ * gsk_path_point_ref:
+ * @self: a `GskPathPoint`
+ *
+ * Increases the reference count of a `GskPathPoint` by one.
+ *
+ * Returns: the passed in `GskPathPoint`
+ */
+GskPathPoint *
+gsk_path_point_ref (GskPathPoint *self)
+{
+  g_return_val_if_fail (self != NULL, NULL);
+
+  self->ref_count++;
+
+  return self;
+}
+
+/**
+ * gsk_path_point_unref:
+ * @self: a `GskPathPoint`
+ *
+ * Decreases the reference count of a `GskPathPoint` by one.
+ *
+ * If the resulting reference count is zero, frees the path_measure.
+ */
+void
+gsk_path_point_unref (GskPathPoint *self)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (self->ref_count > 0);
+
+  self->ref_count--;
+  if (self->ref_count > 0)
+    return;
+
+  gsk_path_measure_unref (self->measure);
+
+  g_free (self);
+}
+
+GskPathMeasure *
+gsk_path_point_get_measure (GskPathPoint *self)
+{
+  return self->measure;
+}
+
+/**
+ * gsk_path_point_get_distance:
+ * @self: a `GskPathPoint`
+ *
+ * Returns the distance of the given point from the start of the path.
+ *
+ * This is the length of the contour from the beginning of the path
+ * to the point.
+ *
+ * Returns: The offset of point in path
+ */
+float
+gsk_path_point_get_distance (GskPathPoint *self)
+{
+  return self->contour_offset + self->offset;
+}
+
+/**
+ * gsk_path_point_get_position:
+ * @self: a `GskPathPoint`
+ * @position: (out caller-allocates): Return location for
+ *   the coordinates of the point
+ *
+ * Gets the position of the point.
+ */
+void
+gsk_path_point_get_position (GskPathPoint     *self,
+                             graphene_point_t *position)
+{
+  gsk_contour_get_point (self->contour,
+                         self->measure_data,
+                         self->offset,
+                         GSK_PATH_END,
+                         position, NULL);
+}
+
+/**
+ * gsk_path_point_get_tangent:
+ * @self: 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.
+ */
+void
+gsk_path_point_get_tangent (GskPathPoint     *self,
+                            GskPathDirection  direction,
+                            graphene_vec2_t  *tangent)
+{
+  gsk_contour_get_point (self->contour,
+                         self->measure_data,
+                         self->offset,
+                         direction,
+                         NULL, tangent);
+}
+
+/**
+ * gsk_path_point_get_curvature:
+ * @self: a `GskPathPoint`
+ * @center: (out caller-allocates): Return location for
+ *   the center of the osculating circle
+ *
+ * Calculates the curvature at the point @distance units into
+ * the path.
+ *
+ * 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
+ */
+float
+gsk_path_point_get_curvature (GskPathPoint     *self,
+                              graphene_point_t *center)
+{
+  return gsk_contour_get_curvature (self->contour,
+                                    self->measure_data,
+                                    self->offset,
+                                    center);
+}

gsk/gskpathpoint.h

@@ -0,0 +1,43 @@
+#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 ())
+
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_path_point_get_type        (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_ALL
+GskPathPoint *          gsk_path_point_ref             (GskPathPoint *self);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_point_unref           (GskPathPoint *self);
+
+GDK_AVAILABLE_IN_ALL
+GskPathMeasure *        gsk_path_point_get_measure     (GskPathPoint     *self);
+
+GDK_AVAILABLE_IN_ALL
+float                   gsk_path_point_get_distance    (GskPathPoint     *self);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_point_get_position    (GskPathPoint     *self,
+                                                        graphene_point_t *position);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_point_get_tangent     (GskPathPoint     *self,
+                                                        GskPathDirection  direction,
+                                                        graphene_vec2_t  *tangent);
+
+GDK_AVAILABLE_IN_ALL
+float                   gsk_path_point_get_curvature   (GskPathPoint     *self,
+                                                        graphene_point_t *center);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathPoint, gsk_path_point_unref)
+
+G_END_DECLS

gsk/gskpathpointprivate.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "gskpathpoint.h"
+#include "gskcontourprivate.h"
+#include "gskpathmeasure.h"
+
+G_BEGIN_DECLS
+
+GskPathPoint * gsk_path_point_new (GskPathMeasure *measure,
+                                   const GskContour *contour,
+                                   gpointer          measure_data,
+                                   float             contour_offset,
+                                   float             offset);
+
+G_END_DECLS
+

gsk/gskpathprivate.h

@@ -18,90 +18,32 @@
  */
 
 
-#ifndef __GSK_PATH_PRIVATE_H__
-#define __GSK_PATH_PRIVATE_H__
+#pragma once
 
 #include "gskpath.h"
 
+#include "gskcontourprivate.h"
+#include "gskpathopprivate.h"
+
 G_BEGIN_DECLS
 
 /* Same as Skia, so looks like a good value. ¯\_(ツ)_/¯ */
 #define GSK_PATH_TOLERANCE_DEFAULT (0.5)
 
-typedef enum 
-{
-  GSK_PATH_FLAT,
-  GSK_PATH_CLOSED
-} GskPathFlags;
-
-typedef struct _GskContour GskContour;
-typedef struct _GskContourClass GskContourClass;
-
-typedef struct _GskStandardOperation GskStandardOperation;
-
-struct _GskStandardOperation {
-  GskPathOperation op;
-  gsize point; /* index into points array of the start point (last point of previous op) */
-};
-
-GskContour *            gsk_rect_contour_new                    (const graphene_rect_t  *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                   GskStandardOperation *ops,
-                                                                 gsize                   n_ops,
-                                                                 const                   graphene_point_t *points,
-                                                                 gsize                   n_points);
-
 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);
-gboolean                gsk_path_foreach_with_tolerance         (GskPath              *self,
-                                                                 GskPathForeachFlags   flags,
-                                                                 double                tolerance,
-                                                                 GskPathForeachFunc    func,
-                                                                 gpointer              user_data);
+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);
 
-GskContour *            gsk_contour_dup                         (const GskContour     *src);
-gpointer                gsk_contour_init_measure                (GskPath              *path,
-                                                                 gsize                 i,
-                                                                 float                 tolerance,
-                                                                 float                *out_length);
-void                    gsk_contour_free_measure                (GskPath              *path,
-                                                                 gsize                 i,
-                                                                 gpointer              data);
-void                    gsk_contour_get_start_end               (const GskContour       *self,
-                                                                 graphene_point_t       *start,
-                                                                 graphene_point_t       *end);
-void                    gsk_contour_get_point                   (GskPath              *path,
-                                                                 gsize                 i,
-                                                                 gpointer              measure_data,
-                                                                 float                 distance,
-                                                                 graphene_point_t     *pos,
-                                                                 graphene_vec2_t      *tangent);
-gboolean                gsk_contour_get_closest_point           (GskPath                *path,
-                                                                 gsize                   i,
-                                                                 gpointer                measure_data,
-                                                                 float                   tolerance,
-                                                                 const graphene_point_t *point,
-                                                                 float                   threshold,
-                                                                 float                  *out_distance,
-                                                                 graphene_point_t       *out_pos,
-                                                                 float                  *out_offset,
-                                                                 graphene_vec2_t        *out_tangent);
-int                     gsk_contour_get_winding                 (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 const graphene_point_t *point,
-                                                                 gboolean               *on_edge);
-void                    gsk_contour_add_segment                 (const GskContour       *self,
-                                                                 GskPathBuilder         *builder,
-                                                                 gpointer                measure_data,
-                                                                 float                   start,
-                                                                 float                   end);
 
 void                    gsk_path_builder_add_contour            (GskPathBuilder         *builder,
                                                                  GskContour             *contour);
@@ -115,7 +57,24 @@ void                    gsk_path_builder_svg_arc_to             (GskPathBuilder
                                                                  float                   x,
                                                                  float                   y);
 
+gboolean                gsk_path_get_stroke_bounds              (GskPath                *self,
+                                                                 const GskStroke        *stroke,
+                                                                 graphene_rect_t        *bounds);
+
+typedef enum
+{
+  GSK_PATH_OP_SIMPLIFY,
+  GSK_PATH_OP_UNION,
+  GSK_PATH_OP_INTERSECTION,
+  GSK_PATH_OP_DIFFERENCE,
+  GSK_PATH_OP_XOR
+} GskPathOp;
+
+GskPath *               gsk_path_op                             (GskPathOp               operation,
+                                                                 GskFillRule             fill_rule,
+                                                                 GskPath                *first,
+                                                                 GskPath                *second);
+
+
 G_END_DECLS
 
-#endif /* __GSK_PATH_PRIVATE_H__ */
-

gsk/gskrendernode.h

@@ -470,11 +470,11 @@ GskRenderNode *         gsk_fill_node_new                       (GskRenderNode
                                                                  GskPath                  *path,
                                                                  GskFillRule               fill_rule);
 GDK_AVAILABLE_IN_ALL
-GskRenderNode *         gsk_fill_node_get_child                 (GskRenderNode            *node);
+GskRenderNode *         gsk_fill_node_get_child                 (const GskRenderNode      *node);
 GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_fill_node_get_path                  (GskRenderNode            *node);
+GskPath *               gsk_fill_node_get_path                  (const GskRenderNode      *node);
 GDK_AVAILABLE_IN_ALL
-GskFillRule             gsk_fill_node_get_fill_rule             (GskRenderNode            *node);
+GskFillRule             gsk_fill_node_get_fill_rule             (const GskRenderNode      *node);
 
 GDK_AVAILABLE_IN_ALL
 GType                   gsk_stroke_node_get_type                (void) G_GNUC_CONST;
@@ -483,11 +483,11 @@ GskRenderNode *         gsk_stroke_node_new                     (GskRenderNode
                                                                  GskPath                  *path,
                                                                  const GskStroke          *stroke);
 GDK_AVAILABLE_IN_ALL
-GskRenderNode *         gsk_stroke_node_get_child               (GskRenderNode            *node);
+GskRenderNode *         gsk_stroke_node_get_child               (const GskRenderNode      *node);
 GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_stroke_node_get_path                (GskRenderNode            *node);
+GskPath *               gsk_stroke_node_get_path                (const GskRenderNode      *node);
 GDK_AVAILABLE_IN_ALL
-const GskStroke *       gsk_stroke_node_get_stroke              (GskRenderNode            *node);
+const GskStroke *       gsk_stroke_node_get_stroke              (const GskRenderNode      *node);
 
 GDK_AVAILABLE_IN_ALL
 GType                   gsk_shadow_node_get_type                (void) G_GNUC_CONST;

gsk/gskrendernodeimpl.c

@@ -25,7 +25,7 @@
 #include "gskdebugprivate.h"
 #include "gskdiffprivate.h"
 #include "gl/gskglrenderer.h"
-#include "gskpath.h"
+#include "gskpathprivate.h"
 #include "gskrendererprivate.h"
 #include "gskroundedrectprivate.h"
 #include "gskstrokeprivate.h"
@@ -4471,10 +4471,10 @@ gsk_fill_node_class_init (gpointer g_class,
  * @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
+ * 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
+ * Returns: (transfer none) (type GskFillNode): A new `GskRenderNode`
  */
 GskRenderNode *
 gsk_fill_node_new (GskRenderNode *child,
@@ -4505,16 +4505,16 @@ gsk_fill_node_new (GskRenderNode *child,
 
 /**
  * gsk_fill_node_get_child:
- * @node: (type GskFillNode): a fill #GskRenderNode
+ * @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
  **/
 GskRenderNode *
-gsk_fill_node_get_child (GskRenderNode *node)
+gsk_fill_node_get_child (const GskRenderNode *node)
 {
-  GskFillNode *self = (GskFillNode *) node;
+  const GskFillNode *self = (const GskFillNode *) node;
 
   g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
 
@@ -4523,17 +4523,17 @@ gsk_fill_node_get_child (GskRenderNode *node)
 
 /**
  * gsk_fill_node_get_path:
- * @node: (type GskFillNode): a fill #GskRenderNode
+ * @node: (type GskFillNode): a fill `GskRenderNode`
  *
- * Retrievs the path used to describe the area filled with the contents of
+ * Retrieves the path used to describe the area filled with the contents of
  * the @node.
  *
- * Returns: (transfer none): a #GskPath
+ * Returns: (transfer none): a `GskPath`
  */
 GskPath *
-gsk_fill_node_get_path (GskRenderNode *node)
+gsk_fill_node_get_path (const GskRenderNode *node)
 {
-  GskFillNode *self = (GskFillNode *) node;
+  const GskFillNode *self = (const GskFillNode *) node;
 
   g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
 
@@ -4542,16 +4542,16 @@ gsk_fill_node_get_path (GskRenderNode *node)
 
 /**
  * gsk_fill_node_get_fill_rule:
- * @node: (type GskFillNode): a fill #GskRenderNode
+ * @node: (type GskFillNode): a fill `GskRenderNode`
  *
- * Retrievs the fill rule used to determine how the path is filled.
+ * Retrieves the fill rule used to determine how the path is filled.
  *
- * Returns: a #GskFillRule
+ * Returns: a `GskFillRule`
  */
 GskFillRule
-gsk_fill_node_get_fill_rule (GskRenderNode *node)
+gsk_fill_node_get_fill_rule (const GskRenderNode *node)
 {
-  GskFillNode *self = (GskFillNode *) 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);
 
@@ -4567,6 +4567,7 @@ struct _GskStrokeNode
 
   GskRenderNode *child;
   GskPath *path;
+  GskPath *stroke_path;
   GskStroke stroke;
 };
 
@@ -4578,6 +4579,7 @@ gsk_stroke_node_finalize (GskRenderNode *node)
 
   gsk_render_node_unref (self->child);
   gsk_path_unref (self->path);
+  gsk_path_unref (self->stroke_path);
   gsk_stroke_clear (&self->stroke);
 
   parent_class->finalize (node);
@@ -4608,8 +4610,8 @@ gsk_stroke_node_draw (GskRenderNode *node,
 
 static void
 gsk_stroke_node_diff (GskRenderNode  *node1,
-                    GskRenderNode  *node2,
-                    cairo_region_t *region)
+                      GskRenderNode  *node2,
+                      cairo_region_t *region)
 {
   GskStrokeNode *self1 = (GskStrokeNode *) node1;
   GskStrokeNode *self2 = (GskStrokeNode *) node2;
@@ -4632,7 +4634,7 @@ gsk_stroke_node_diff (GskRenderNode  *node1,
 
 static void
 gsk_stroke_node_class_init (gpointer g_class,
-                          gpointer class_data)
+                            gpointer class_data)
 {
   GskRenderNodeClass *node_class = g_class;
 
@@ -4661,6 +4663,7 @@ gsk_stroke_node_new (GskRenderNode   *child,
 {
   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);
@@ -4672,9 +4675,12 @@ gsk_stroke_node_new (GskRenderNode   *child,
   self->child = gsk_render_node_ref (child);
   self->path = gsk_path_ref (path);
   gsk_stroke_init_copy (&self->stroke, stroke);
+  self->stroke_path = gsk_path_stroke (path, &self->stroke);
 
-  /* XXX: Figure out a way to compute bounds from the path */
-  graphene_rect_init_from_rect (&node->bounds, &child->bounds);
+  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;
 }
@@ -4688,9 +4694,9 @@ gsk_stroke_node_new (GskRenderNode   *child,
  * Returns: (transfer none): The child that is getting drawn
  **/
 GskRenderNode *
-gsk_stroke_node_get_child (GskRenderNode *node)
+gsk_stroke_node_get_child (const GskRenderNode *node)
 {
-  GskStrokeNode *self = (GskStrokeNode *) node;
+  const GskStrokeNode *self = (const GskStrokeNode *) node;
 
   g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
 
@@ -4701,33 +4707,43 @@ gsk_stroke_node_get_child (GskRenderNode *node)
  * gsk_stroke_node_get_path:
  * @node: (type GskStrokeNode): a stroke #GskRenderNode
  *
- * Retrievs the path that will be stroked with the contents of
+ * Retrieves the path that will be stroked with the contents of
  * the @node.
  *
  * Returns: (transfer none): a #GskPath
  */
 GskPath *
-gsk_stroke_node_get_path (GskRenderNode *node)
+gsk_stroke_node_get_path (const GskRenderNode *node)
 {
-  GskStrokeNode *self = (GskStrokeNode *) 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;
 }
 
+GskPath *
+gsk_stroke_node_get_stroke_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->stroke_path;
+}
+
 /**
  * gsk_stroke_node_get_stroke:
  * @node: (type GskStrokeNode): a stroke #GskRenderNode
  *
- * Retrievs the stroke attributes used in this @node.
+ * Retrieves the stroke attributes used in this @node.
  *
  * Returns: a #GskStroke
  */
 const GskStroke *
-gsk_stroke_node_get_stroke (GskRenderNode *node)
+gsk_stroke_node_get_stroke (const GskRenderNode *node)
 {
-  GskStrokeNode *self = (GskStrokeNode *) node;
+  const GskStrokeNode *self = (const GskStrokeNode *) node;
 
   g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
 
@@ -6067,8 +6083,6 @@ gsk_mask_node_draw (GskRenderNode *node,
   cairo_clip (cr);
 
   cairo_mask (cr, mask_pattern);
-
-  cairo_pattern_destroy (mask_pattern);
 }
 
 static void

gsk/gskrendernodeparser.c

@@ -24,12 +24,10 @@
 #include "gskrendernodeparserprivate.h"
 
 #include "gskpath.h"
-#include "gskpathbuilder.h"
 #include "gskroundedrectprivate.h"
 #include "gskrendernodeprivate.h"
 #include "gskstroke.h"
 #include "gsktransformprivate.h"
-#include "gskenumtypes.h"
 
 #include "gdk/gdkrgbaprivate.h"
 #include "gdk/gdktextureprivate.h"
@@ -1163,26 +1161,6 @@ create_default_render_node (void)
   return gsk_color_node_new (&GDK_RGBA("FF00CC"), &GRAPHENE_RECT_INIT (0, 0, 50, 50));
 }
 
-static GskPath *
-create_default_path (void)
-{
-  GskPathBuilder *builder;
-  guint i;
-
-  builder = gsk_path_builder_new ();
-
-  gsk_path_builder_move_to (builder, 25, 0);
-  for (i = 1; i < 5; i++)
-    {
-      gsk_path_builder_line_to (builder,
-                                sin (i * G_PI * 0.8) * 25 + 25,
-                                -cos (i * G_PI * 0.8) * 25 + 25);
-    }
-  gsk_path_builder_close (builder);
-
-  return gsk_path_builder_free_to_path (builder);
-}
-
 static GskRenderNode *
 parse_color_node (GtkCssParser *parser,
                   Context      *context)
@@ -2106,215 +2084,6 @@ parse_rounded_clip_node (GtkCssParser *parser,
   return result;
 }
 
-static gboolean
-parse_path (GtkCssParser *parser,
-            Context      *context,
-            gpointer      out_path)
-{
-  GskPath *path;
-  char *str = NULL;
-
-  if (!parse_string (parser, context, &str))
-    return FALSE;
-
-  path = gsk_path_parse (str);
-  g_free (str);
-
-  if (path == NULL)
-    {
-      gtk_css_parser_error_value (parser, "Invalid path");
-      return FALSE;
-    }
-
-  *((GskPath **) out_path) = path;
-
-  return TRUE;
-}
-
-static void
-clear_path (gpointer inout_path)
-{
-  g_clear_pointer ((GskPath **) inout_path, gsk_path_unref);
-}
-
-static gboolean
-parse_dash (GtkCssParser *parser,
-            Context      *context,
-            gpointer      out_dash)
-{
-  GArray *dash;
-  double d;
-
-  /* because CSS does this, too */
-  if (gtk_css_parser_try_ident (parser, "none"))
-    {
-      *((GArray **) out_dash) = NULL;
-      return TRUE;
-    }
-
-  dash = g_array_new (FALSE, FALSE, sizeof (float));
-  do {
-    if (!gtk_css_parser_consume_number (parser, &d))
-      {
-        g_array_free (dash, TRUE);
-        return FALSE;
-      }
-
-    g_array_append_vals (dash, (float[1]) { d }, 1);
-  } while (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNLESS_NUMBER) ||
-           gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNLESS_INTEGER));
-
-  *((GArray **) out_dash) = dash;
-
-  return TRUE;
-}
-
-static void
-clear_dash (gpointer inout_array)
-{
-  g_clear_pointer ((GArray **) inout_array, g_array_unref);
-}
-
-static gboolean
-parse_enum (GtkCssParser *parser,
-            GType         type,
-            gpointer      out_value)
-{
-  GEnumClass *class;
-  GEnumValue *v;
-  char *enum_name;
-
-  enum_name = gtk_css_parser_consume_ident (parser);
-  if (enum_name == NULL)
-    return FALSE;
-
-  class = g_type_class_ref (type);
-
-  v = g_enum_get_value_by_nick (class, enum_name);
-  if (v == NULL)
-    {
-      gtk_css_parser_error_value (parser, "Unknown value \"%s\" for enum \"%s\"",
-                                  enum_name, g_type_name (type));
-      g_free (enum_name);
-      g_type_class_unref (class);
-      return FALSE;
-    }
-
-  *(int*)out_value = v->value;
-
-  g_free (enum_name);
-  g_type_class_unref (class);
-
-  gtk_css_parser_consume_token (parser);
-
-  return TRUE;
-}
-
-static gboolean
-parse_fill_rule (GtkCssParser *parser,
-                 Context      *context,
-                 gpointer      out_rule)
-{
-  return parse_enum (parser, GSK_TYPE_FILL_RULE, out_rule);
-}
-
-static GskRenderNode *
-parse_fill_node (GtkCssParser *parser,
-                 Context      *context)
-{
-  GskRenderNode *child = NULL;
-  GskPath *path = NULL;
-  int rule = GSK_FILL_RULE_WINDING;
-  const Declaration declarations[] = {
-    { "child", parse_node, clear_node, &child },
-    { "path", parse_path, clear_path, &path },
-    { "fill-rule", parse_fill_rule, NULL, &rule },
-  };
-  GskRenderNode *result;
-
-  parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
-  if (child == NULL)
-    child = create_default_render_node ();
-  if (path == NULL)
-    path = create_default_path ();
-
-  result = gsk_fill_node_new (child, path, rule);
-
-  gsk_path_unref (path);
-
-  gsk_render_node_unref (child);
-
-  return result;
-}
-
-static gboolean
-parse_line_cap (GtkCssParser *parser,
-                Context      *context,
-                gpointer      out)
-{
-  return parse_enum (parser, GSK_TYPE_LINE_CAP, out);
-}
-
-static gboolean
-parse_line_join (GtkCssParser *parser,
-                 Context      *context,
-                 gpointer      out)
-{
-  return parse_enum (parser, GSK_TYPE_LINE_JOIN, out);
-}
-
-static GskRenderNode *
-parse_stroke_node (GtkCssParser *parser,
-                   Context      *context)
-{
-  GskRenderNode *child = NULL;
-  GskPath *path = NULL;
-  double line_width = 1.0;
-  int line_cap = GSK_LINE_CAP_BUTT;
-  int line_join = GSK_LINE_JOIN_MITER;
-  double miter_limit = 4.0;
-  GArray *dash = NULL;
-  double dash_offset = 0.0;
-  GskStroke *stroke;
-
-  const Declaration declarations[] = {
-    { "child", parse_node, clear_node, &child },
-    { "path", parse_path, clear_path, &path },
-    { "line-width", parse_double, NULL, &line_width },
-    { "line-cap", parse_line_cap, NULL, &line_cap },
-    { "line-join", parse_line_join, NULL, &line_join },
-    { "miter-limit", parse_double, NULL, &miter_limit },
-    { "dash", parse_dash, clear_dash, &dash },
-    { "dash-offset", parse_double, NULL, &dash_offset},
-  };
-  GskRenderNode *result;
-
-  parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
-  if (child == NULL)
-    child = create_default_render_node ();
-  if (path == NULL)
-    path = create_default_path ();
-
-  stroke = gsk_stroke_new (line_width);
-  gsk_stroke_set_line_cap (stroke, line_cap);
-  gsk_stroke_set_line_join (stroke, line_join);
-  gsk_stroke_set_miter_limit (stroke, miter_limit);
-  if (dash)
-    {
-      gsk_stroke_set_dash (stroke, (float *) dash->data, dash->len);
-      g_array_free (dash, TRUE);
-    }
-  gsk_stroke_set_dash_offset (stroke, dash_offset);
-
-  result = gsk_stroke_node_new (child, path, stroke);
-
-  gsk_path_unref (path);
-  gsk_stroke_free (stroke);
-  gsk_render_node_unref (child);
-
-  return result;
-}
-
 static GskRenderNode *
 parse_shadow_node (GtkCssParser *parser,
                    Context      *context)
@@ -2397,8 +2166,6 @@ parse_node (GtkCssParser *parser,
     { "repeating-linear-gradient", parse_repeating_linear_gradient_node },
     { "repeating-radial-gradient", parse_repeating_radial_gradient_node },
     { "rounded-clip", parse_rounded_clip_node },
-    { "fill", parse_fill_node },
-    { "stroke", parse_stroke_node },
     { "shadow", parse_shadow_node },
     { "text", parse_text_node },
     { "texture", parse_texture_node },
@@ -2720,15 +2487,6 @@ printer_init (Printer       *self,
   printer_init_duplicates_for_node (self, node);
 }
 
-static void
-printer_clear (Printer *self)
-{
-  if (self->str)
-    g_string_free (self->str, TRUE);
-  g_hash_table_unref (self->named_nodes);
-  g_hash_table_unref (self->named_textures);
-}
-
 #define IDENT_LEVEL 2 /* Spaces per level */
 static void
 _indent (Printer *self)
@@ -3061,11 +2819,8 @@ append_escaping_newlines (GString    *str,
     len = strcspn (string, "\n");
     g_string_append_len (str, string, len);
     string += len;
-    if (*string)
-      {
-        g_string_append (str, "\\\n");
-        string++;
-      }
+    g_string_append (str, "\\\n");
+    string++;
   } while (*string);
 }
 
@@ -3264,83 +3019,6 @@ gsk_text_node_serialize_glyphs (GskRenderNode *node,
     pango_glyph_string_free (ascii);
 }
 
-static const char *
-enum_to_nick (GType type,
-              int   value)
-{
-  GEnumClass *class;
-  GEnumValue *v;
-
-  class = g_type_class_ref (type);
-  v = g_enum_get_value (class, value);
-  g_type_class_unref (class);
-
-  return v->value_nick;
-}
-
-static void
-append_enum_param (Printer    *p,
-                   const char *param_name,
-                   GType       type,
-                   int         value)
-{
-  _indent (p);
-  g_string_append_printf (p->str, "%s: ", param_name);
-  g_string_append (p->str, enum_to_nick (type, value));
-  g_string_append_c (p->str, ';');
-  g_string_append_c (p->str, '\n');
-}
-
-static void
-append_path_param (Printer    *p,
-                   const char *param_name,
-                   GskPath    *path)
-{
-  char *str, *s;
-
-  _indent (p);
-  g_string_append (p->str, "path: \"\\\n");
-  str = gsk_path_to_string (path);
-  /* Put each command on a new line */
-  for (s = str; *s; s++)
-    {
-      if (*s == ' ' &&
-          (s[1] == 'M' || s[1] == 'C' || s[1] == 'Z' || s[1] == 'L'))
-        *s = '\n';
-    }
-  append_escaping_newlines (p->str, str);
-  g_string_append (p->str, "\";\n");
-  g_free (str);
-}
-
-static void
-append_dash_param (Printer     *p,
-                   const char  *param_name,
-                   const float *dash,
-                   gsize        n_dash)
-{
-  _indent (p);
-  g_string_append (p->str, "dash: ");
-
-  if (n_dash == 0)
-    {
-      g_string_append (p->str, "none");
-    }
-  else
-    {
-      gsize i;
-
-      string_append_double (p->str, dash[0]);
-      for (i = 1; i < n_dash; i++)
-        {
-          g_string_append_c (p->str, ' ');
-          string_append_double (p->str, dash[i]);
-        }
-    }
-
-  g_string_append (p->str, ";\n");
-}
-
 static void
 render_node_print (Printer       *p,
                    GskRenderNode *node)
@@ -3516,11 +3194,14 @@ render_node_print (Printer       *p,
 
     case GSK_FILL_NODE:
       {
+        char *path_str;
+
         start_node (p, "fill", node_name);
 
         append_node_param (p, "child", gsk_fill_node_get_child (node));
-        append_path_param (p, "path", gsk_fill_node_get_path (node));
-        append_enum_param (p, "fill-rule", GSK_TYPE_FILL_RULE, gsk_fill_node_get_fill_rule (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);
       }
@@ -3529,23 +3210,17 @@ render_node_print (Printer       *p,
     case GSK_STROKE_NODE:
       {
         const GskStroke *stroke;
-        const float *dash;
-        gsize n_dash;
+        char *path_str;
 
         start_node (p, "stroke", node_name);
 
         append_node_param (p, "child", gsk_stroke_node_get_child (node));
-        append_path_param (p, "path", gsk_stroke_node_get_path (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.0f);
-        append_enum_param (p, "line-cap", GSK_TYPE_LINE_CAP, gsk_stroke_get_line_cap (stroke));
-        append_enum_param (p, "line-join", GSK_TYPE_LINE_JOIN, gsk_stroke_get_line_join (stroke));
-        append_float_param (p, "miter-limit", gsk_stroke_get_miter_limit (stroke), 4.0f);
-        dash = gsk_stroke_get_dash (stroke, &n_dash);
-        if (dash)
-          append_dash_param (p, "dash", dash, n_dash);
-        append_float_param (p, "dash-offset", gsk_stroke_get_dash_offset (stroke), 0.0f);
+        append_float_param (p, "line-width", gsk_stroke_get_line_width (stroke), 0.0);
 
         end_node (p);
       }
@@ -4054,7 +3729,6 @@ GBytes *
 gsk_render_node_serialize (GskRenderNode *node)
 {
   Printer p;
-  GBytes *res;
 
   printer_init (&p, node);
 
@@ -4074,9 +3748,5 @@ gsk_render_node_serialize (GskRenderNode *node)
       render_node_print (&p, node);
     }
 
-  res = g_string_free_to_bytes (g_steal_pointer (&p.str));
-
-  printer_clear (&p);
-
-  return res;
+  return g_string_free_to_bytes (p.str);
 }

gsk/gskrendernodeprivate.h

@@ -87,6 +87,7 @@ gboolean        gsk_container_node_is_disjoint          (const GskRenderNode
 
 gboolean        gsk_render_node_use_offscreen_for_opacity (const GskRenderNode       *node);
 
+GskPath *      gsk_stroke_node_get_stroke_path           (const GskRenderNode *node);
 
 G_END_DECLS
 

gsk/gskspline.c

@@ -25,215 +25,6 @@
 
 #include <math.h>
 
-typedef struct
-{
-  graphene_point_t last_point;
-  float last_progress;
-  float tolerance;
-  GskSplineAddPointFunc func;
-  gpointer user_data;
-} GskCubicDecomposition;
-
-static void
-gsk_spline_decompose_add_point (GskCubicDecomposition  *decomp,
-                                const graphene_point_t *pt,
-                                float                   progress)
-{
-  if (graphene_point_equal (&decomp->last_point, pt))
-    return;
-
-  decomp->func (&decomp->last_point, pt, decomp->last_progress, decomp->last_progress + progress, decomp->user_data);
-  decomp->last_point = *pt;
-  decomp->last_progress += progress;
-}
-
-static void
-gsk_spline_cubic_get_coefficients (graphene_point_t       coeffs[4],
-                                   const graphene_point_t pts[4])
-{
-  coeffs[0] = GRAPHENE_POINT_INIT (pts[3].x - 3.0f * pts[2].x + 3.0f * pts[1].x - pts[0].x,
-                                   pts[3].y - 3.0f * pts[2].y + 3.0f * pts[1].y - pts[0].y);
-  coeffs[1] = GRAPHENE_POINT_INIT (3.0f * pts[2].x - 6.0f * pts[1].x + 3.0f * pts[0].x,
-                                   3.0f * pts[2].y - 6.0f * pts[1].y + 3.0f * pts[0].y);
-  coeffs[2] = GRAPHENE_POINT_INIT (3.0f * pts[1].x - 3.0f * pts[0].x,
-                                   3.0f * pts[1].y - 3.0f * pts[0].y);
-  coeffs[3] = pts[0];
-}
-
-void
-gsk_spline_get_point_cubic (const graphene_point_t  pts[4],
-                            float                   progress,
-                            graphene_point_t       *pos,
-                            graphene_vec2_t        *tangent)
-{
-  graphene_point_t c[4];
-
-  gsk_spline_cubic_get_coefficients (c, pts);
-
-  if (pos)
-    *pos = GRAPHENE_POINT_INIT (((c[0].x * progress + c[1].x) * progress +c[2].x) * progress + c[3].x,
-                                ((c[0].y * progress + c[1].y) * progress +c[2].y) * progress + c[3].y);
-  if (tangent)
-    {
-      graphene_vec2_init (tangent,
-                          (3.0f * c[0].x * progress + 2.0f * c[1].x) * progress + c[2].x,
-                          (3.0f * c[0].y * progress + 2.0f * c[1].y) * progress + c[2].y);
-      graphene_vec2_normalize (tangent, tangent);
-    }
-}
-
-void
-gsk_spline_split_cubic (const graphene_point_t pts[4],
-                        graphene_point_t       result1[4],
-                        graphene_point_t       result2[4],
-                        float                  progress)
-{
-    graphene_point_t ab, bc, cd;
-    graphene_point_t abbc, bccd;
-    graphene_point_t final;
-
-    graphene_point_interpolate (&pts[0], &pts[1], progress, &ab);
-    graphene_point_interpolate (&pts[1], &pts[2], progress, &bc);
-    graphene_point_interpolate (&pts[2], &pts[3], progress, &cd);
-    graphene_point_interpolate (&ab, &bc, progress, &abbc);
-    graphene_point_interpolate (&bc, &cd, progress, &bccd);
-    graphene_point_interpolate (&abbc, &bccd, progress, &final);
-
-    memcpy (result1, (graphene_point_t[4]) { pts[0], ab, abbc, final }, sizeof (graphene_point_t[4]));
-    memcpy (result2, (graphene_point_t[4]) { final, bccd, cd, pts[3] }, sizeof (graphene_point_t[4]));
-}
-
-#if 0
-/* Return an upper bound on the error (squared) that could result from
- * approximating a spline as a line segment connecting the two endpoints. */
-static float
-gsk_spline_error_squared (const graphene_point_t pts[4])
-{
-  float bdx, bdy, berr;
-  float cdx, cdy, cerr;
-
-  /* We are going to compute the distance (squared) between each of the the b
-   * and c control points and the segment a-b. The maximum of these two
-   * distances will be our approximation error. */
-
-  bdx = pts[1].x - pts[0].x;
-  bdy = pts[1].y - pts[0].y;
-
-  cdx = pts[2].x - pts[0].x;
-  cdy = pts[2].y - pts[0].y;
-
-  if (!graphene_point_equal (&pts[0], &pts[3]))
-    {
-      float dx, dy, u, v;
-
-      /* Intersection point (px):
-       *     px = p1 + u(p2 - p1)
-       *     (p - px) ∙ (p2 - p1) = 0
-       * Thus:
-       *     u = ((p - p1) ∙ (p2 - p1)) / ∥p2 - p1∥²;
-       */
-
-      dx = pts[3].x - pts[0].x;
-      dy = pts[3].y - pts[0].y;
-      v = dx * dx + dy * dy;
-
-      u = bdx * dx + bdy * dy;
-      if (u <= 0)
-        {
-          /* bdx -= 0;
-           * bdy -= 0;
-           */
-        }
-      else if (u >= v)
-        {
-          bdx -= dx;
-          bdy -= dy;
-        }
-      else
-        {
-          bdx -= u/v * dx;
-          bdy -= u/v * dy;
-        }
-
-      u = cdx * dx + cdy * dy;
-      if (u <= 0)
-        {
-          /* cdx -= 0;
-           * cdy -= 0;
-           */
-        }
-      else if (u >= v)
-        {
-          cdx -= dx;
-          cdy -= dy;
-        }
-      else
-        {
-          cdx -= u/v * dx;
-          cdy -= u/v * dy;
-        }
-    }
-
-    berr = bdx * bdx + bdy * bdy;
-    cerr = cdx * cdx + cdy * cdy;
-    if (berr > cerr)
-      return berr;
-    else
-      return cerr;
-}
-#endif
-
-/* taken from Skia, including the very descriptive name */
-static gboolean
-gsk_spline_cubic_too_curvy (const graphene_point_t pts[4],
-                            float                  tolerance)
-{
-  graphene_point_t p;
-
-  graphene_point_interpolate (&pts[0], &pts[3], 1.0f / 3, &p);
-  if (ABS (p.x - pts[1].x) + ABS (p.y - pts[1].y)  > tolerance)
-    return TRUE;
-
-  graphene_point_interpolate (&pts[0], &pts[3], 2.0f / 3, &p);
-  if (ABS (p.x - pts[2].x) + ABS (p.y - pts[2].y)  > tolerance)
-    return TRUE;
-
-  return FALSE;
-}
-
-static void
-gsk_spline_decompose_into (GskCubicDecomposition  *decomp,
-                           const graphene_point_t  pts[4],
-                           float                   progress)
-{
-  graphene_point_t left[4], right[4];
-
-  if (!gsk_spline_cubic_too_curvy (pts, decomp->tolerance) || progress < 1 / 1024.f)
-    {
-      gsk_spline_decompose_add_point (decomp, &pts[3], progress);
-      return;
-    }
-
-  gsk_spline_split_cubic (pts, left, right, 0.5);
-
-  gsk_spline_decompose_into (decomp, left, progress / 2);
-  gsk_spline_decompose_into (decomp, right, progress / 2);
-}
-
-void 
-gsk_spline_decompose_cubic (const graphene_point_t pts[4],
-                            float                  tolerance,
-                            GskSplineAddPointFunc  add_point_func,
-                            gpointer               user_data)
-{
-  GskCubicDecomposition decomp = { pts[0], 0.0f, tolerance, add_point_func, user_data };
-
-  gsk_spline_decompose_into (&decomp, pts, 1.0f);
-
-  g_assert (graphene_point_equal (&decomp.last_point, &pts[3]));
-  g_assert (decomp.last_progress == 1.0f || decomp.last_progress == 0.0f);
-}
-
 /* Spline deviation from the circle in radius would be given by:
 
         error = sqrt (x**2 + y**2) - 1

gsk/gsksplineprivate.h

@@ -25,25 +25,6 @@
 
 G_BEGIN_DECLS
 
-typedef void (* GskSplineAddPointFunc) (const graphene_point_t *from,
-                                        const graphene_point_t *to,
-                                        float                   from_progress,
-                                        float                   to_progress,
-                                        gpointer                user_data);
-
-void                    gsk_spline_get_point_cubic              (const graphene_point_t  pts[4],
-                                                                 float                   progress,
-                                                                 graphene_point_t       *pos,
-                                                                 graphene_vec2_t        *tangent);
-void                    gsk_spline_split_cubic                  (const graphene_point_t  pts[4],
-                                                                 graphene_point_t        result1[4],
-                                                                 graphene_point_t        result2[4],
-                                                                 float                   progress);
-void                    gsk_spline_decompose_cubic              (const graphene_point_t  pts[4],
-                                                                 float                   tolerance,
-                                                                 GskSplineAddPointFunc   add_point_func,
-                                                                 gpointer                user_data);
-
 typedef gboolean (* GskSplineAddCurveFunc) (const graphene_point_t curve[4],
                                             gpointer               user_data);
 gboolean                gsk_spline_decompose_arc                (const graphene_point_t *center,

gsk/gskstroke.c

@@ -21,40 +21,24 @@
 
 #include "gskstrokeprivate.h"
 
-/**
- * SECTION:gskstroke
- * @Title: Stroke
- * @Short_description: Properties of a stroke operation
- * @See_also: #GskPath, gsk_stroke_node_new()
- *
- * This section describes the #GskStroke structure that is used to
- * describe lines and curves that are more complex than simple rectangles.
- *
- * #GskStroke is an immutable struct. After creation, you cannot change
- * the types it represents. Instead, new #GskStroke have to be created.
- * The #GskStrokeBuilder structure is meant to help in this endeavor.
- */
-
 /**
  * GskStroke:
  *
- * A #GskStroke struct is an opaque struct that should be copied
- * on use.
+ * 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)
+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.
+ * Creates a new `GskStroke` with the given @line_width.
  *
- * Returns: a new #GskStroke
- **/
+ * Returns: a new `GskStroke`
+ */
 GskStroke *
 gsk_stroke_new (float line_width)
 {
@@ -74,12 +58,12 @@ gsk_stroke_new (float line_width)
 
 /**
  * gsk_stroke_copy:
- * @other: #GskStroke to copy
+ * @other: `GskStroke` to copy
  *
  * Creates a copy of the given @other stroke.
  *
- * Returns: a new #GskStroke. Use gsk_stroke_free() to free it.
- **/
+ * Returns: a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it
+ */
 GskStroke *
 gsk_stroke_copy (const GskStroke *other)
 {
@@ -96,10 +80,10 @@ gsk_stroke_copy (const GskStroke *other)
 
 /**
  * gsk_stroke_free:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
- * Frees a #GskStroke.
- **/
+ * Frees a `GskStroke`.
+ */
 void
 gsk_stroke_free (GskStroke *self)
 {
@@ -111,6 +95,14 @@ gsk_stroke_free (GskStroke *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.
+ */
 void
 gsk_stroke_to_cairo (const GskStroke *self,
                      cairo_t         *cr)
@@ -139,6 +131,7 @@ gsk_stroke_to_cairo (const GskStroke *self,
     {
       case GSK_LINE_JOIN_MITER:
       case GSK_LINE_JOIN_MITER_CLIP:
+      case GSK_LINE_JOIN_ARCS:
         cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
         break;
       case GSK_LINE_JOIN_ROUND:
@@ -171,13 +164,13 @@ gsk_stroke_to_cairo (const GskStroke *self,
 
 /**
  * gsk_stroke_equal:
- * @stroke1: the first #GskStroke
- * @stroke2: the second #GskStroke
+ * @stroke1: the first `GskStroke`
+ * @stroke2: the second `GskStroke`
  *
  * Checks if 2 strokes are identical.
  *
- * Returns: %TRUE if the 2 strokes are equal, %FALSE otherwise
- **/
+ * Returns: `TRUE` if the 2 strokes are equal, `FALSE` otherwise
+ */
 gboolean
 gsk_stroke_equal (gconstpointer stroke1,
                   gconstpointer stroke2)
@@ -190,12 +183,13 @@ gsk_stroke_equal (gconstpointer stroke1,
 
 /**
  * gsk_stroke_set_line_width:
- * @self: a #GskStroke
+ * @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.
- **/
+ * Sets the line width to be used when stroking.
+ *
+ * The line width must be > 0.
+ */
 void
 gsk_stroke_set_line_width (GskStroke *self,
                            float      line_width)
@@ -208,12 +202,12 @@ gsk_stroke_set_line_width (GskStroke *self,
 
 /**
  * gsk_stroke_get_line_width:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
  * Gets the line width used.
  *
  * Returns: The line width
- **/
+ */
 float
 gsk_stroke_get_line_width (const GskStroke *self)
 {
@@ -224,12 +218,13 @@ gsk_stroke_get_line_width (const GskStroke *self)
 
 /**
  * gsk_stroke_set_line_cap:
- * @self: a #GskStroke
- * @line_cap: the #GskLineCap
+ * @self: a`GskStroke`
+ * @line_cap: the `GskLineCap`
  *
  * Sets the line cap to be used when stroking.
- * See #GskLineCap for details.
- **/
+ *
+ * See [enum@Gsk.LineCap] for details.
+ */
 void
 gsk_stroke_set_line_cap (GskStroke  *self,
                          GskLineCap  line_cap)
@@ -241,12 +236,14 @@ gsk_stroke_set_line_cap (GskStroke  *self,
 
 /**
  * gsk_stroke_get_line_cap:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
- * Gets the line cap used. See #GskLineCap for details.
+ * Gets the line cap used.
+ *
+ * See [enum@Gsk.LineCap] for details.
  *
  * Returns: The line cap
- **/
+ */
 GskLineCap
 gsk_stroke_get_line_cap (const GskStroke *self)
 {
@@ -257,12 +254,13 @@ gsk_stroke_get_line_cap (const GskStroke *self)
 
 /**
  * gsk_stroke_set_line_join:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  * @line_join: The line join to use
  *
  * Sets the line join to be used when stroking.
- * See #GskLineJoin for details.
- **/
+ *
+ * See [enum@Gsk.LineJoin] for details.
+ */
 void
 gsk_stroke_set_line_join (GskStroke   *self,
                           GskLineJoin  line_join)
@@ -274,12 +272,14 @@ gsk_stroke_set_line_join (GskStroke   *self,
 
 /**
  * gsk_stroke_get_line_join:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
- * Gets the line join used. See #GskLineJoin for details.
+ * Gets the line join used.
+ *
+ * See [enum@Gsk.LineJoin] for details.
  *
  * Returns: The line join
- **/
+ */
 GskLineJoin
 gsk_stroke_get_line_join (const GskStroke *self)
 {
@@ -290,16 +290,17 @@ gsk_stroke_get_line_join (const GskStroke *self)
 
 /**
  * gsk_stroke_set_miter_limit:
- * @self: a #GskStroke
- * @limit: the miter limit, must be non-negative
+ * @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.
+ * turns of joins get cut off.
  *
- * For joins of type %GSK_LINE_JOIN_MITER that exceed the miter
+ * 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,
+ * `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.
  */
 void
@@ -314,9 +315,9 @@ gsk_stroke_set_miter_limit (GskStroke  *self,
 
 /**
  * gsk_stroke_get_miter_limit:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
- * Returns the miter limit of a #GskStroke.
+ * Returns the miter limit of a `GskStroke`.
  */
 float
 gsk_stroke_get_miter_limit (const GskStroke *self)
@@ -328,32 +329,35 @@ gsk_stroke_get_miter_limit (const GskStroke *self)
 
 /**
  * gsk_stroke_set_dash:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  * @dash: (array length=n_dash) (transfer none) (nullable):
- *     the array of dashes 
+ *     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.
+ * Sets the dash pattern to use by this stroke.
  *
- * If @n_dash is 0, if all elements in @dash are 0, or if there are negative
- * values in @dash, then dashing is disabled.
+ * 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.
  *
- * If @n_dash is 1, an alternating "on" and "off" pattern with the single
- * dash length provided is assumed.
+ * 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 uneven, the dash array will be used with the first element
- * in @dash defining an "on" or "off" in alternating passes through the array.
+ * 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
- * @gsk_stroke_set_dash_offset().
- **/
+ * [method@Gsk.Stroke.set_dash_offset].
+ */
 void
 gsk_stroke_set_dash (GskStroke   *self,
                      const float *dash,
@@ -385,15 +389,15 @@ gsk_stroke_set_dash (GskStroke   *self,
 
 /**
  * gsk_stroke_get_dash:
- * @self: a #GskStroke
+ * @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.
+ * 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.
- **/
+ *   The dash array or `NULL` if the dash array is empty.
+ */
 const float *
 gsk_stroke_get_dash (const GskStroke *self,
                      gsize           *n_dash)
@@ -408,15 +412,16 @@ gsk_stroke_get_dash (const GskStroke *self,
 
 /**
  * gsk_stroke_set_dash_offset:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  * @offset: offset into the dash pattern
  *
- * Sets the offset into the dash pattern set via gsk_stroke_set_dash() where
- * dashing should begin.
+ * 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.
- **/
+ * 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.
+ */
 void
 gsk_stroke_set_dash_offset (GskStroke *self,
                             float      offset)
@@ -428,9 +433,9 @@ gsk_stroke_set_dash_offset (GskStroke *self,
 
 /**
  * gsk_stroke_get_dash_offset:
- * @self: a #GskStroke
+ * @self: a `GskStroke`
  *
- * Returns the dash_offset of a #GskStroke.
+ * Returns the dash_offset of a `GskStroke`.
  */
 float
 gsk_stroke_get_dash_offset (const GskStroke *self)

gsk/gskstroke.h

@@ -17,8 +17,7 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#ifndef __GSK_STROKE_H__
-#define __GSK_STROKE_H__
+#pragma once
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
@@ -60,13 +59,11 @@ void                    gsk_stroke_set_line_join                (GskStroke
 GDK_AVAILABLE_IN_ALL
 GskLineJoin             gsk_stroke_get_line_join                (const GskStroke        *self);
 
-GDK_AVAILABLE_IN_ALL
 void                    gsk_stroke_set_miter_limit              (GskStroke              *self,
                                                                  float                   limit);
 GDK_AVAILABLE_IN_ALL
 float                   gsk_stroke_get_miter_limit              (const GskStroke        *self);
 
-GDK_AVAILABLE_IN_ALL
 void                    gsk_stroke_set_dash                     (GskStroke              *self,
                                                                  const float            *dash,
                                                                  gsize                   n_dash);
@@ -80,8 +77,9 @@ void                    gsk_stroke_set_dash_offset              (GskStroke
 GDK_AVAILABLE_IN_ALL
 float                   gsk_stroke_get_dash_offset              (const GskStroke        *self);
 
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_to_cairo                     (const GskStroke        *self,
+                                                                 cairo_t                *cr);
 
 
 G_END_DECLS
-
-#endif /* __GSK_STROKE_H__ */

gsk/gskstrokeprivate.h

@@ -18,8 +18,7 @@
  */
 
 
-#ifndef __GSK_STROKE_PRIVATE_H__
-#define __GSK_STROKE_PRIVATE_H__
+#pragma once
 
 #include "gskstroke.h"
 
@@ -54,10 +53,4 @@ gsk_stroke_clear (GskStroke *stroke)
   stroke->n_dash = 0; /* better safe than sorry */
 }
 
-void                    gsk_stroke_to_cairo                     (const GskStroke        *self,
-                                                                 cairo_t                *cr);
-
 G_END_DECLS
-
-#endif /* __GSK_STROKE_PRIVATE_H__ */
-

gsk/gsktypes.h

@@ -28,6 +28,7 @@
 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,12 +23,15 @@ gsk_private_gl_shaders = [
 ]
 
 gsk_public_sources = files([
-  'gskdiff.c',
   'gskcairorenderer.c',
+  'gskdiff.c',
   'gskglshader.c',
   'gskpath.c',
   'gskpathbuilder.c',
   'gskpathmeasure.c',
+  'gskpathops.c',
+  'gskpathpoint.c',
+  'gskpathstroke.c',
   'gskrenderer.c',
   'gskrendernode.c',
   'gskrendernodeimpl.c',
@@ -41,7 +44,11 @@ gsk_public_sources = files([
 
 gsk_private_sources = files([
   'gskcairoblur.c',
+  'gskcontour.c',
+  'gskcurve.c',
+  'gskcurveintersect.c',
   'gskdebug.c',
+  'gskpathdash.c',
   'gskprivate.c',
   'gskprofiler.c',
   'gskspline.c',
@@ -74,6 +81,7 @@ gsk_public_headers = files([
   'gskpath.h',
   'gskpathbuilder.h',
   'gskpathmeasure.h',
+  'gskpathpoint.h',
   'gskrenderer.h',
   'gskrendernode.h',
   'gskroundedrect.h',
@@ -112,7 +120,6 @@ gsk_private_vulkan_shaders = []
 # on constantly regenerated files.
 gsk_private_vulkan_compiled_shaders = []
 gsk_private_vulkan_compiled_shaders_deps = []
-gsk_private_vulkan_shader_headers = []
 
 if have_vulkan
   gsk_private_sources += files([
@@ -207,7 +214,6 @@ libgsk = static_library('gsk',
     gsk_private_sources,
     gsk_enums,
     gskresources,
-    gsk_private_vulkan_shader_headers,
   ],
   dependencies: gsk_deps,
   include_directories: [ confinc, ],

gsk/vulkan/gskvulkanblendmodepipeline.c

@@ -2,8 +2,6 @@
 
 #include "gskvulkanblendmodepipelineprivate.h"
 
-#include "vulkan/resources/blend-mode.vert.h"
-
 struct _GskVulkanBlendModePipeline
 {
   GObject parent_instance;
@@ -11,12 +9,89 @@ struct _GskVulkanBlendModePipeline
 
 typedef struct _GskVulkanBlendModeInstance GskVulkanBlendModeInstance;
 
+struct _GskVulkanBlendModeInstance
+{
+  float rect[4];
+  float top_rect[4];
+  float bottom_rect[4];
+  float top_tex_rect[4];
+  float bottom_tex_rect[4];
+  guint32 top_tex_id[2];
+  guint32 bottom_tex_id[2];
+  guint32 blend_mode;
+};
+
 G_DEFINE_TYPE (GskVulkanBlendModePipeline, gsk_vulkan_blend_mode_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_blend_mode_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_blend_mode_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanBlendModeInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, top_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, bottom_rect),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, top_tex_rect),
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, bottom_tex_rect),
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, top_tex_id),
+      },
+      {
+          .location = 6,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, bottom_tex_id),
+      },
+      {
+          .location = 7,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlendModeInstance, blend_mode),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void

gsk/vulkan/gskvulkanblurpipeline.c

@@ -2,19 +2,68 @@
 
 #include "gskvulkanblurpipelineprivate.h"
 
-#include "vulkan/resources/blur.vert.h"
-
 struct _GskVulkanBlurPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanBlurInstance GskVulkanBlurInstance;
+
+struct _GskVulkanBlurInstance
+{
+  float rect[4];
+  float tex_rect[4];
+  float blur_radius;
+  guint32 tex_id[2];
+};
+
 G_DEFINE_TYPE (GskVulkanBlurPipeline, gsk_vulkan_blur_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_blur_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_blur_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanBlurInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlurInstance, tex_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlurInstance, blur_radius),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBlurInstance, tex_id),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -56,7 +105,7 @@ gsk_vulkan_blur_pipeline_collect_vertex_data (GskVulkanBlurPipeline  *pipeline,
                                               const graphene_point_t *offset,
                                               const graphene_rect_t  *rect,
                                               const graphene_rect_t  *tex_rect,
-                                              double                  radius)
+                                              double                  blur_radius)
 {
   GskVulkanBlurInstance *instance = (GskVulkanBlurInstance *) data;
 
@@ -68,7 +117,7 @@ gsk_vulkan_blur_pipeline_collect_vertex_data (GskVulkanBlurPipeline  *pipeline,
   instance->tex_rect[1] = tex_rect->origin.y;
   instance->tex_rect[2] = tex_rect->size.width;
   instance->tex_rect[3] = tex_rect->size.height;
-  instance->radius = radius;
+  instance->blur_radius = blur_radius;
   instance->tex_id[0] = tex_id[0];
   instance->tex_id[1] = tex_id[1];
 }

gsk/vulkan/gskvulkanborderpipeline.c

@@ -4,19 +4,91 @@
 
 #include "gskroundedrectprivate.h"
 
-#include "vulkan/resources/border.vert.h"
-
 struct _GskVulkanBorderPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanBorderInstance GskVulkanBorderInstance;
+
+struct _GskVulkanBorderInstance
+{
+  float rect[12];
+  float widths[4];
+  float colors[16];
+};
+
 G_DEFINE_TYPE (GskVulkanBorderPipeline, gsk_vulkan_border_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_border_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_border_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanBorderInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, rect),
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, rect) + 4 * sizeof (float),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, rect) + 8 * sizeof (float),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, widths),
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, colors),
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, colors) + 4 * sizeof (float),
+      },
+      {
+          .location = 6,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, colors) + 8 * sizeof (float),
+      },
+      {
+          .location = 7,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBorderInstance, colors) + 12 * sizeof (float),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -65,11 +137,11 @@ gsk_vulkan_border_pipeline_collect_vertex_data (GskVulkanBorderPipeline *pipelin
   gsk_rounded_rect_to_float (rect, offset, instance->rect);
   for (i = 0; i < 4; i++)
     {
-      instance->border_widths[i] = widths[i];
-      instance->border_colors[4 * i + 0] = colors[i].red;
-      instance->border_colors[4 * i + 1] = colors[i].green;
-      instance->border_colors[4 * i + 2] = colors[i].blue;
-      instance->border_colors[4 * i + 3] = colors[i].alpha;
+      instance->widths[i] = widths[i];
+      instance->colors[4 * i + 0] = colors[i].red;
+      instance->colors[4 * i + 1] = colors[i].green;
+      instance->colors[4 * i + 2] = colors[i].blue;
+      instance->colors[4 * i + 3] = colors[i].alpha;
     }
 }
 

gsk/vulkan/gskvulkanboxshadowpipeline.c

@@ -2,8 +2,6 @@
 
 #include "gskvulkanboxshadowpipelineprivate.h"
 
-#include "vulkan/resources/inset-shadow.vert.h"
-
 #include "gskroundedrectprivate.h"
 
 struct _GskVulkanBoxShadowPipeline
@@ -11,12 +9,82 @@ struct _GskVulkanBoxShadowPipeline
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanBoxShadowInstance GskVulkanBoxShadowInstance;
+
+struct _GskVulkanBoxShadowInstance
+{
+  float outline[12];
+  float color[4];
+  float offset[2];
+  float spread;
+  float blur_radius;
+};
+
 G_DEFINE_TYPE (GskVulkanBoxShadowPipeline, gsk_vulkan_box_shadow_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_box_shadow_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_inset_shadow_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanBoxShadowInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, outline),
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, outline) + 4 * sizeof (float),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, outline) + 8 * sizeof (float),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, color),
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, offset),
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, spread),
+      },
+      {
+          .location = 6,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanBoxShadowInstance, blur_radius),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -62,7 +130,7 @@ gsk_vulkan_box_shadow_pipeline_collect_vertex_data (GskVulkanBoxShadowPipeline *
                                                     float                      spread,
                                                     float                      blur_radius)
 {
-  GskVulkanInsetShadowInstance *instance = (GskVulkanInsetShadowInstance *) data;
+  GskVulkanBoxShadowInstance *instance = (GskVulkanBoxShadowInstance *) data;
 
   gsk_rounded_rect_to_float (outline, offset, instance->outline);
   instance->color[0] = color->red;

gsk/vulkan/gskvulkanbuffer.c

@@ -78,8 +78,8 @@ gsk_vulkan_buffer_new_map (GdkVulkanContext  *context,
 {
   return gsk_vulkan_buffer_new_internal (context,
                                          size,
-                                         (mode & GSK_VULKAN_READ ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : 0) |
-                                         (mode & GSK_VULKAN_WRITE ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT : 0));
+                                         (mode & GSK_VULKAN_READ ? VK_BUFFER_USAGE_TRANSFER_SRC_BIT : 0) |
+                                         (mode & GSK_VULKAN_WRITE ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : 0));
 }
 
 void

gsk/vulkan/gskvulkancolorpipeline.c

@@ -2,19 +2,54 @@
 
 #include "gskvulkancolorpipelineprivate.h"
 
-#include "vulkan/resources/color.vert.h"
-
 struct _GskVulkanColorPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanColorInstance GskVulkanColorInstance;
+
+struct _GskVulkanColorInstance
+{
+  float rect[4];
+  float color[4];
+};
+
 G_DEFINE_TYPE (GskVulkanColorPipeline, gsk_vulkan_color_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_color_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_color_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanColorInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanColorInstance, color),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void

gsk/vulkan/gskvulkancolortextpipeline.c

@@ -2,19 +2,61 @@
 
 #include "gskvulkancolortextpipelineprivate.h"
 
-#include "vulkan/resources/texture.vert.h"
-
 struct _GskVulkanColorTextPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanColorTextInstance GskVulkanColorTextInstance;
+
+struct _GskVulkanColorTextInstance
+{
+  float rect[4];
+  float tex_rect[4];
+  guint32 tex_id[2];
+};
+
 G_DEFINE_TYPE (GskVulkanColorTextPipeline, gsk_vulkan_color_text_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_color_text_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_texture_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanColorTextInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanColorTextInstance, rect),
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanColorTextInstance, tex_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanColorTextInstance, tex_id),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -63,7 +105,7 @@ gsk_vulkan_color_text_pipeline_collect_vertex_data (GskVulkanColorTextPipeline *
                                                     guint                       num_glyphs,
                                                     float                       scale)
 {
-  GskVulkanTextureInstance *instances = (GskVulkanTextureInstance *) data;
+  GskVulkanColorTextInstance *instances = (GskVulkanColorTextInstance *) data;
   int i;
   int count = 0;
   int x_position = 0;
@@ -79,7 +121,7 @@ gsk_vulkan_color_text_pipeline_collect_vertex_data (GskVulkanColorTextPipeline *
         {
           double cx = (x_position + gi->geometry.x_offset) / PANGO_SCALE;
           double cy = gi->geometry.y_offset / PANGO_SCALE;
-          GskVulkanTextureInstance *instance = &instances[count];
+          GskVulkanColorTextInstance *instance = &instances[count];
           GskVulkanCachedGlyph *glyph;
 
           glyph = gsk_vulkan_renderer_get_cached_glyph (renderer,

gsk/vulkan/gskvulkancrossfadepipeline.c

@@ -2,19 +2,96 @@
 
 #include "gskvulkancrossfadepipelineprivate.h"
 
-#include "vulkan/resources/cross-fade.vert.h"
-
 struct _GskVulkanCrossFadePipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanCrossFadeInstance GskVulkanCrossFadeInstance;
+
+struct _GskVulkanCrossFadeInstance
+{
+  float rect[4];
+  float start_rect[4];
+  float end_rect[4];
+  float start_tex_rect[4];
+  float end_tex_rect[4];
+  guint32 start_tex_id[2];
+  guint32 end_tex_id[2];
+  float progress;
+};
+
 G_DEFINE_TYPE (GskVulkanCrossFadePipeline, gsk_vulkan_cross_fade_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_cross_fade_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_cross_fade_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanCrossFadeInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, start_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, end_rect),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, start_tex_rect),
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, end_tex_rect),
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, start_tex_id),
+      },
+      {
+          .location = 6,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, end_tex_id),
+      },
+      {
+          .location = 7,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanCrossFadeInstance, progress),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void

gsk/vulkan/gskvulkaneffectpipeline.c

@@ -2,19 +2,93 @@
 
 #include "gskvulkaneffectpipelineprivate.h"
 
-#include "vulkan/resources/color-matrix.vert.h"
-
 struct _GskVulkanEffectPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanEffectInstance GskVulkanEffectInstance;
+
+struct _GskVulkanEffectInstance
+{
+  float rect[4];
+  float tex_rect[4];
+  float color_matrix[16];
+  float color_offset[4];
+  guint32 tex_id[2];
+};
+
 G_DEFINE_TYPE (GskVulkanEffectPipeline, gsk_vulkan_effect_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_effect_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_color_matrix_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanEffectInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, tex_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, color_matrix),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, color_matrix) + sizeof (float) * 4,
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, color_matrix) + sizeof (float) * 8,
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, color_matrix) + sizeof (float) * 12,
+      },
+      {
+          .location = 6,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, color_offset),
+      },
+      {
+          .location = 7,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanEffectInstance, tex_id),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -59,7 +133,7 @@ gsk_vulkan_effect_pipeline_collect_vertex_data (GskVulkanEffectPipeline *pipelin
                                                 const graphene_matrix_t *color_matrix,
                                                 const graphene_vec4_t   *color_offset)
 {
-  GskVulkanColorMatrixInstance *instance = (GskVulkanColorMatrixInstance *) data;
+  GskVulkanEffectInstance *instance = (GskVulkanEffectInstance *) data;
 
   instance->rect[0] = rect->origin.x + offset->x;
   instance->rect[1] = rect->origin.y + offset->y;

gsk/vulkan/gskvulkanimage.c

@@ -488,6 +488,24 @@ gsk_memory_format_get_fallback (GdkMemoryFormat format)
     }
 }
 
+GdkMemoryFormat
+gsk_render_node_get_preferred_vulkan_format (GskRenderNode *node)
+{
+  switch (gsk_render_node_get_preferred_depth (node))
+  {
+    case GDK_MEMORY_U8:
+      return GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
+    case GDK_MEMORY_U16:
+      return GDK_MEMORY_R16G16B16A16_PREMULTIPLIED;
+    case GDK_MEMORY_FLOAT16:
+      return GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED;
+    case GDK_MEMORY_FLOAT32:
+      return GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED;
+    default:
+      g_return_val_if_reached (GDK_MEMORY_R8G8B8A8_PREMULTIPLIED);
+  }
+}
+
 static gboolean
 gsk_vulkan_context_supports_format (GdkVulkanContext *context,
                                     VkFormat          format)

gsk/vulkan/gskvulkanimageprivate.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <gdk/gdk.h>
+#include <gsk/gskrendernode.h>
 
 #include "gskvulkanbufferprivate.h"
 #include "gskvulkancommandpoolprivate.h"
@@ -21,6 +22,8 @@ void                    gsk_vulkan_uploader_free                        (GskVulk
 void                    gsk_vulkan_uploader_reset                       (GskVulkanUploader      *self);
 void                    gsk_vulkan_uploader_upload                      (GskVulkanUploader      *self);
 
+GdkMemoryFormat         gsk_render_node_get_preferred_vulkan_format     (GskRenderNode          *node);
+
 GskVulkanImage *        gsk_vulkan_image_new_for_swapchain              (GdkVulkanContext       *context,
                                                                          VkImage                 image,
                                                                          VkFormat                format,

gsk/vulkan/gskvulkanlineargradientpipeline.c

@@ -2,19 +2,82 @@
 
 #include "gskvulkanlineargradientpipelineprivate.h"
 
-#include "vulkan/resources/linear.vert.h"
-
 struct _GskVulkanLinearGradientPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanLinearGradientInstance GskVulkanLinearGradientInstance;
+
+struct _GskVulkanLinearGradientInstance
+{
+  float rect[4];
+  float start[2];
+  float end[2];
+  gint32 repeating;
+  gint32 offset;
+  gint32 stop_count;
+};
+
 G_DEFINE_TYPE (GskVulkanLinearGradientPipeline, gsk_vulkan_linear_gradient_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_linear_gradient_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_linear_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanLinearGradientInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = 0,
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanLinearGradientInstance, start),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanLinearGradientInstance, end),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanLinearGradientInstance, repeating),
+      },
+      {
+          .location = 4,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanLinearGradientInstance, offset),
+      },
+      {
+          .location = 5,
+          .binding = 0,
+          .format = VK_FORMAT_R32_SINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanLinearGradientInstance, stop_count),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -60,7 +123,7 @@ gsk_vulkan_linear_gradient_pipeline_collect_vertex_data (GskVulkanLinearGradient
                                                          gsize                            gradient_offset,
                                                          gsize                            n_stops)
 {
-  GskVulkanLinearInstance *instance = (GskVulkanLinearInstance *) data;
+  GskVulkanLinearGradientInstance *instance = (GskVulkanLinearGradientInstance *) data;
 
   instance->rect[0] = rect->origin.x + offset->x;
   instance->rect[1] = rect->origin.y + offset->y;
@@ -71,7 +134,7 @@ gsk_vulkan_linear_gradient_pipeline_collect_vertex_data (GskVulkanLinearGradient
   instance->end[0] = end->x + offset->x;
   instance->end[1] = end->y + offset->y;
   instance->repeating = repeating;
-  instance->stop_offset = gradient_offset;
+  instance->offset = gradient_offset;
   instance->stop_count = n_stops;
 }
 

gsk/vulkan/gskvulkanpipeline.c

@@ -5,8 +5,6 @@
 #include "gskvulkanpushconstantsprivate.h"
 #include "gskvulkanshaderprivate.h"
 
-#include "gdk/gdkvulkancontextprivate.h"
-
 #include <graphene.h>
 
 typedef struct _GskVulkanPipelinePrivate GskVulkanPipelinePrivate;
@@ -89,7 +87,7 @@ gsk_vulkan_pipeline_new (GType             pipeline_type,
   priv->vertex_stride = vertex_input_state->pVertexBindingDescriptions[0].stride;
 
   GSK_VK_CHECK (vkCreateGraphicsPipelines, device,
-                                           gdk_vulkan_context_get_pipeline_cache (context),
+                                           VK_NULL_HANDLE,
                                            1,
                                            &(VkGraphicsPipelineCreateInfo) {
                                                .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
@@ -162,8 +160,6 @@ gsk_vulkan_pipeline_new (GType             pipeline_type,
                                            NULL,
                                            &priv->pipeline);
 
-  gdk_vulkan_context_pipeline_cache_updated (context);
-
   return self;
 }
 

gsk/vulkan/gskvulkanrender.c

@@ -41,8 +41,6 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-#define N_DESCRIPTOR_SETS 3
-
 struct _GskVulkanRender
 {
   GskRenderer *renderer;
@@ -54,7 +52,7 @@ struct _GskVulkanRender
 
   GskVulkanCommandPool *command_pool;
   VkFence fence;
-  VkDescriptorSetLayout descriptor_set_layouts[N_DESCRIPTOR_SETS];
+  VkDescriptorSetLayout descriptor_set_layout;
   VkPipelineLayout pipeline_layout;
   GskVulkanUploader *uploader;
 
@@ -62,7 +60,7 @@ struct _GskVulkanRender
   GskDescriptorImageInfos descriptor_samplers;
   GskDescriptorBufferInfos descriptor_buffers;
   VkDescriptorPool descriptor_pool;
-  VkDescriptorSet descriptor_sets[N_DESCRIPTOR_SETS];
+  VkDescriptorSet descriptor_set;
   GskVulkanPipeline *pipelines[GSK_VULKAN_N_PIPELINES];
 
   GskVulkanImage *target;
@@ -150,9 +148,9 @@ gsk_vulkan_render_new (GskRenderer      *renderer,
                                         &(VkDescriptorPoolCreateInfo) {
                                             .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                                             .flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
-                                            .maxSets = N_DESCRIPTOR_SETS,
-                                            .poolSizeCount = N_DESCRIPTOR_SETS,
-                                            .pPoolSizes = (VkDescriptorPoolSize[N_DESCRIPTOR_SETS]) {
+                                            .maxSets = 1,
+                                            .poolSizeCount = 3,
+                                            .pPoolSizes = (VkDescriptorPoolSize[3]) {
                                                 {
                                                     .type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
                                                     .descriptorCount = DESCRIPTOR_POOL_MAXITEMS
@@ -173,7 +171,7 @@ gsk_vulkan_render_new (GskRenderer      *renderer,
   GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
                                              &(VkDescriptorSetLayoutCreateInfo) {
                                                  .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-                                                 .bindingCount = 1,
+                                                 .bindingCount = 3,
                                                  .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
                                                  .pBindings = (VkDescriptorSetLayoutBinding[3]) {
                                                      {
@@ -181,55 +179,15 @@ gsk_vulkan_render_new (GskRenderer      *renderer,
                                                          .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
                                                          .descriptorCount = DESCRIPTOR_POOL_MAXITEMS,
                                                          .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
-                                                     }
-                                                 },
-                                                 .pNext = &(VkDescriptorSetLayoutBindingFlagsCreateInfo) {
-                                                   .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
-                                                   .bindingCount = 1,
-                                                   .pBindingFlags = (VkDescriptorBindingFlags[1]) {
-                                                     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
-                                                     | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
-                                                     | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
-                                                   },
-                                                 }
-                                             },
-                                             NULL,
-                                             &self->descriptor_set_layouts[0]);
-
-  GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
-                                             &(VkDescriptorSetLayoutCreateInfo) {
-                                                 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-                                                 .bindingCount = 1,
-                                                 .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
-                                                 .pBindings = (VkDescriptorSetLayoutBinding[1]) {
+                                                     },
                                                      {
-                                                         .binding = 0,
+                                                         .binding = 1,
                                                          .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
                                                          .descriptorCount = DESCRIPTOR_POOL_MAXITEMS,
                                                          .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
-                                                     }
-                                                 },
-                                                 .pNext = &(VkDescriptorSetLayoutBindingFlagsCreateInfo) {
-                                                   .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
-                                                   .bindingCount = 1,
-                                                   .pBindingFlags = (VkDescriptorBindingFlags[1]) {
-                                                     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
-                                                     | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
-                                                     | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
-                                                   },
-                                                 }
-                                             },
-                                             NULL,
-                                             &self->descriptor_set_layouts[1]);
-
-  GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
-                                             &(VkDescriptorSetLayoutCreateInfo) {
-                                                 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-                                                 .bindingCount = 1,
-                                                 .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
-                                                 .pBindings = (VkDescriptorSetLayoutBinding[1]) {
+                                                     },
                                                      {
-                                                         .binding = 0,
+                                                         .binding = 2,
                                                          .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                                                          .descriptorCount = DESCRIPTOR_POOL_MAXITEMS,
                                                          .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
@@ -237,8 +195,14 @@ gsk_vulkan_render_new (GskRenderer      *renderer,
                                                  },
                                                  .pNext = &(VkDescriptorSetLayoutBindingFlagsCreateInfo) {
                                                    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
-                                                   .bindingCount = 1,
-                                                   .pBindingFlags = (VkDescriptorBindingFlags[1]) {
+                                                   .bindingCount = 3,
+                                                   .pBindingFlags = (VkDescriptorBindingFlags[3]) {
+                                                     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
+                                                     | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
+                                                     | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+                                                     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
+                                                     | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
+                                                     | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
                                                      VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
                                                      | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
                                                      | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
@@ -246,13 +210,15 @@ gsk_vulkan_render_new (GskRenderer      *renderer,
                                                  }
                                              },
                                              NULL,
-                                             &self->descriptor_set_layouts[2]);
+                                             &self->descriptor_set_layout);
 
   GSK_VK_CHECK (vkCreatePipelineLayout, device,
                                         &(VkPipelineLayoutCreateInfo) {
                                             .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-                                            .setLayoutCount = G_N_ELEMENTS (self->descriptor_set_layouts),
-                                            .pSetLayouts = self->descriptor_set_layouts,
+                                            .setLayoutCount = 1,
+                                            .pSetLayouts = (VkDescriptorSetLayout[1]) {
+                                              self->descriptor_set_layout
+                                            },
                                             .pushConstantRangeCount = gsk_vulkan_push_constants_get_range_count (),
                                             .pPushConstantRanges = gsk_vulkan_push_constants_get_ranges ()
                                         },
@@ -418,12 +384,12 @@ gsk_vulkan_render_get_pipeline (GskVulkanRender       *self,
     { "texture",                    1, gsk_vulkan_color_text_pipeline_new },
     { "texture-clip",               1, gsk_vulkan_color_text_pipeline_new },
     { "texture-clip-rounded",       1, gsk_vulkan_color_text_pipeline_new },
-    { "cross-fade",                 2, gsk_vulkan_cross_fade_pipeline_new },
-    { "cross-fade-clip",            2, gsk_vulkan_cross_fade_pipeline_new },
-    { "cross-fade-clip-rounded",    2, gsk_vulkan_cross_fade_pipeline_new },
-    { "blend-mode",                 2, gsk_vulkan_blend_mode_pipeline_new },
-    { "blend-mode-clip",            2, gsk_vulkan_blend_mode_pipeline_new },
-    { "blend-mode-clip-rounded",    2, gsk_vulkan_blend_mode_pipeline_new },
+    { "crossfade",                  2, gsk_vulkan_cross_fade_pipeline_new },
+    { "crossfade-clip",             2, gsk_vulkan_cross_fade_pipeline_new },
+    { "crossfade-clip-rounded",     2, gsk_vulkan_cross_fade_pipeline_new },
+    { "blendmode",                  2, gsk_vulkan_blend_mode_pipeline_new },
+    { "blendmode-clip",             2, gsk_vulkan_blend_mode_pipeline_new },
+    { "blendmode-clip-rounded",     2, gsk_vulkan_blend_mode_pipeline_new },
   };
 
   g_return_val_if_fail (type < GSK_VULKAN_N_PIPELINES, NULL);
@@ -437,18 +403,10 @@ gsk_vulkan_render_get_pipeline (GskVulkanRender       *self,
   return self->pipelines[type];
 }
 
-void
-gsk_vulkan_render_bind_descriptor_sets (GskVulkanRender *self,
-                                        VkCommandBuffer  command_buffer)
+VkDescriptorSet
+gsk_vulkan_render_get_descriptor_set (GskVulkanRender *self)
 {
-  vkCmdBindDescriptorSets (command_buffer,
-                           VK_PIPELINE_BIND_POINT_GRAPHICS,
-                           self->pipeline_layout,
-                           0,
-                           3,
-                           self->descriptor_sets,
-                           0,
-                           NULL);
+  return self->descriptor_set;
 }
 
 gsize
@@ -579,6 +537,11 @@ gsk_vulkan_render_prepare_descriptor_sets (GskVulkanRender *self)
       gsk_vulkan_render_pass_reserve_descriptor_sets (pass, self);
     }
   
+  if (gsk_descriptor_image_infos_get_size (&self->descriptor_samplers) == 0 &&
+      gsk_descriptor_image_infos_get_size (&self->descriptor_images) == 0 &&
+      gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) == 0)
+    return;
+
   if (self->storage_buffer_memory)
     {
       gsk_vulkan_buffer_unmap (self->storage_buffer);
@@ -590,26 +553,26 @@ gsk_vulkan_render_prepare_descriptor_sets (GskVulkanRender *self)
                                           &(VkDescriptorSetAllocateInfo) {
                                               .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                                               .descriptorPool = self->descriptor_pool,
-                                              .descriptorSetCount = N_DESCRIPTOR_SETS,
-                                              .pSetLayouts = self->descriptor_set_layouts,
+                                              .descriptorSetCount = 1,
+                                              .pSetLayouts = &self->descriptor_set_layout,
                                               .pNext = &(VkDescriptorSetVariableDescriptorCountAllocateInfo) {
                                                 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
-                                                .descriptorSetCount = N_DESCRIPTOR_SETS,
-                                                .pDescriptorCounts = (uint32_t[N_DESCRIPTOR_SETS]) {
-                                                  MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_images)),
-                                                  MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_samplers)),
-                                                  MAX (1, gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers))
+                                                .descriptorSetCount = 1,
+                                                .pDescriptorCounts = (uint32_t[1]) {
+                                                  gsk_descriptor_image_infos_get_size (&self->descriptor_images)
+                                                  + gsk_descriptor_image_infos_get_size (&self->descriptor_samplers)
+                                                  + gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers)
                                                 }
                                               }
                                           },
-                                          self->descriptor_sets);
+                                          &self->descriptor_set);
 
   n_descriptor_sets = 0;
   if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) > 0)
     {
       descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
           .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[0],
+          .dstSet = self->descriptor_set,
           .dstBinding = 0,
           .dstArrayElement = 0,
           .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_images),
@@ -621,8 +584,8 @@ gsk_vulkan_render_prepare_descriptor_sets (GskVulkanRender *self)
     {
       descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
           .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[1],
-          .dstBinding = 0,
+          .dstSet = self->descriptor_set,
+          .dstBinding = 1,
           .dstArrayElement = 0,
           .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_samplers),
           .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
@@ -633,8 +596,8 @@ gsk_vulkan_render_prepare_descriptor_sets (GskVulkanRender *self)
     {
       descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
           .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[2],
-          .dstBinding = 0,
+          .dstSet = self->descriptor_set,
+          .dstBinding = 2,
           .dstArrayElement = 0,
           .descriptorCount = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers),
           .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
@@ -778,10 +741,9 @@ gsk_vulkan_render_free (GskVulkanRender *self)
   gsk_descriptor_image_infos_clear (&self->descriptor_samplers);
   gsk_descriptor_buffer_infos_clear (&self->descriptor_buffers);
 
-  for (i = 0; i < N_DESCRIPTOR_SETS; i++)
-    vkDestroyDescriptorSetLayout (device,
-                                  self->descriptor_set_layouts[i],
-                                  NULL);
+  vkDestroyDescriptorSetLayout (device,
+                                self->descriptor_set_layout,
+                                NULL);
 
   vkDestroyFence (device,
                   self->fence,

gsk/vulkan/gskvulkanrenderer.c

@@ -14,9 +14,8 @@
 
 #include "gdk/gdkdisplayprivate.h"
 #include "gdk/gdkdrawcontextprivate.h"
-#include "gdk/gdkprofilerprivate.h"
 #include "gdk/gdktextureprivate.h"
-#include "gdk/gdkvulkancontextprivate.h"
+#include "gdk/gdkprofilerprivate.h"
 
 #include <graphene.h>
 
@@ -287,8 +286,7 @@ gsk_vulkan_renderer_render_texture (GskRenderer           *renderer,
                                          ceil (viewport->size.width),
                                          ceil (viewport->size.height));
   image = gsk_vulkan_image_new_for_offscreen (self->vulkan,
-                                              gdk_vulkan_context_get_offscreen_format (self->vulkan,
-                                                  gsk_render_node_get_preferred_depth (root)),
+                                              gsk_render_node_get_preferred_vulkan_format (root),
                                               rounded_viewport.size.width,
                                               rounded_viewport.size.height);
 

gsk/vulkan/gskvulkanrenderpass.c

@@ -26,8 +26,6 @@
 #include "gskvulkanrendererprivate.h"
 #include "gskprivate.h"
 
-#include "gdk/gdkvulkancontextprivate.h"
-
 #define ORTHO_NEAR_PLANE        -10000
 #define ORTHO_FAR_PLANE          10000
 
@@ -1279,8 +1277,7 @@ gsk_vulkan_render_pass_render_offscreen (GdkVulkanContext      *vulkan,
                              ceil (scale_y * viewport->size.height));
 
   result = gsk_vulkan_image_new_for_offscreen (vulkan,
-                                               gdk_vulkan_context_get_offscreen_format (vulkan,
-                                                   gsk_render_node_get_preferred_depth (node)),
+                                               gsk_render_node_get_preferred_vulkan_format (node),
                                                view.size.width, view.size.height);
 
 #ifdef G_ENABLE_DEBUG
@@ -2441,6 +2438,7 @@ gsk_vulkan_render_pass_draw (GskVulkanRenderPass *self,
                              VkPipelineLayout     pipeline_layout,
                              VkCommandBuffer      command_buffer)
 {
+  VkDescriptorSet descriptor_set;
   cairo_rectangle_int_t rect;
 
   vkCmdSetViewport (command_buffer,
@@ -2473,7 +2471,16 @@ gsk_vulkan_render_pass_draw (GskVulkanRenderPass *self,
                         },
                         VK_SUBPASS_CONTENTS_INLINE);
 
-  gsk_vulkan_render_bind_descriptor_sets (render, command_buffer);
+  descriptor_set = gsk_vulkan_render_get_descriptor_set (render);
+  if (descriptor_set)
+    vkCmdBindDescriptorSets (command_buffer,
+                             VK_PIPELINE_BIND_POINT_GRAPHICS,
+                             pipeline_layout,
+                             0,
+                             1,
+                             &descriptor_set,
+                             0,
+                             NULL);
 
   gsk_vulkan_render_pass_draw_rect (self, render, pipeline_layout, command_buffer);
 

gsk/vulkan/gskvulkanrenderprivate.h

@@ -93,8 +93,7 @@ guchar *                gsk_vulkan_render_get_buffer_memory             (GskVulk
                                                                          gsize                   size,
                                                                          gsize                   alignment,
                                                                          gsize                  *out_offset);
-void                    gsk_vulkan_render_bind_descriptor_sets          (GskVulkanRender        *self,
-                                                                         VkCommandBuffer         command_buffer);
+VkDescriptorSet         gsk_vulkan_render_get_descriptor_set            (GskVulkanRender        *self);
 
 void                    gsk_vulkan_render_draw                          (GskVulkanRender        *self);
 

gsk/vulkan/gskvulkantextpipeline.c

@@ -2,19 +2,68 @@
 
 #include "gskvulkantextpipelineprivate.h"
 
-#include "vulkan/resources/mask.vert.h"
-
 struct _GskVulkanTextPipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanTextInstance GskVulkanTextInstance;
+
+struct _GskVulkanTextInstance
+{
+  float rect[4];
+  float tex_rect[4];
+  float color[4];
+  guint32 tex_id[2];
+};
+
 G_DEFINE_TYPE (GskVulkanTextPipeline, gsk_vulkan_text_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_text_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_mask_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanTextInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextInstance, rect),
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextInstance, tex_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextInstance, color),
+      },
+      {
+          .location = 3,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextInstance, tex_id),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void
@@ -64,7 +113,7 @@ gsk_vulkan_text_pipeline_collect_vertex_data (GskVulkanTextPipeline  *pipeline,
                                               guint                   num_glyphs,
                                               float                   scale)
 {
-  GskVulkanMaskInstance *instances = (GskVulkanMaskInstance *) data;
+  GskVulkanTextInstance *instances = (GskVulkanTextInstance *) data;
   int i;
   int count = 0;
   int x_position = 0;
@@ -80,7 +129,7 @@ gsk_vulkan_text_pipeline_collect_vertex_data (GskVulkanTextPipeline  *pipeline,
         {
           double cx = (x_position + gi->geometry.x_offset) / PANGO_SCALE;
           double cy = gi->geometry.y_offset / PANGO_SCALE;
-          GskVulkanMaskInstance *instance = &instances[count];
+          GskVulkanTextInstance *instance = &instances[count];
           GskVulkanCachedGlyph *glyph;
 
           glyph = gsk_vulkan_renderer_get_cached_glyph (renderer,

gsk/vulkan/gskvulkantexturepipeline.c

@@ -2,19 +2,61 @@
 
 #include "gskvulkantexturepipelineprivate.h"
 
-#include "vulkan/resources/texture.vert.h"
-
 struct _GskVulkanTexturePipeline
 {
   GObject parent_instance;
 };
 
+typedef struct _GskVulkanTextureInstance GskVulkanTextureInstance;
+
+struct _GskVulkanTextureInstance
+{
+  float rect[4];
+  float tex_rect[4];
+  guint32 tex_id[2];
+};
+
 G_DEFINE_TYPE (GskVulkanTexturePipeline, gsk_vulkan_texture_pipeline, GSK_TYPE_VULKAN_PIPELINE)
 
 static const VkPipelineVertexInputStateCreateInfo *
 gsk_vulkan_texture_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
 {
-  return &gsk_vulkan_texture_info;
+  static const VkVertexInputBindingDescription vertexBindingDescriptions[] = {
+      {
+          .binding = 0,
+          .stride = sizeof (GskVulkanTextureInstance),
+          .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE
+      }
+  };
+  static const VkVertexInputAttributeDescription vertexInputAttributeDescription[] = {
+      {
+          .location = 0,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextureInstance, rect),
+      },
+      {
+          .location = 1,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32B32A32_SFLOAT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextureInstance, tex_rect),
+      },
+      {
+          .location = 2,
+          .binding = 0,
+          .format = VK_FORMAT_R32G32_UINT,
+          .offset = G_STRUCT_OFFSET (GskVulkanTextureInstance, tex_id),
+      }
+  };
+  static const VkPipelineVertexInputStateCreateInfo info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      .vertexBindingDescriptionCount = G_N_ELEMENTS (vertexBindingDescriptions),
+      .pVertexBindingDescriptions = vertexBindingDescriptions,
+      .vertexAttributeDescriptionCount = G_N_ELEMENTS (vertexInputAttributeDescription),
+      .pVertexAttributeDescriptions = vertexInputAttributeDescription
+  };
+
+  return &info;
 }
 
 static void