Include precompiled versions of .ui files

These are smaller, and a faster to process than .ui files.

.gitlab-ci.yml

@@ -167,7 +167,7 @@ macos:
   needs: []
   before_script:
     - bash .gitlab-ci/show-info-osx.sh
-    - pip3 install --user meson==0.56
+    - pip3 install --user meson==0.59
     - pip3 install --user ninja
     - export PATH=/Users/gitlabrunner/Library/Python/3.7/bin:$PATH
     - export MESON_FORCE_BACKTRACE=1

.gitlab-ci/test-msvc.bat

@@ -5,7 +5,7 @@ call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliar
 @echo on
 
 :: FIXME: make warnings fatal
-pip3 install --upgrade --user meson==0.56.2  || goto :error
+pip3 install --upgrade --user meson==0.59 || goto :error
 meson -Dmedia-gstreamer=disabled _build || goto :error
 ninja -C _build || goto :error
 

demos/gtk-demo/clipboard.c

@@ -1,12 +1,10 @@
 /* Clipboard
  *
  * GdkClipboard is used for clipboard handling. This demo shows how to
- * copy and paste text to and from the clipboard.
+ * copy and paste text, images, colors or files to and from the clipboard.
  *
- * It also shows how to transfer images via the clipboard or via
- * drag-and-drop, and how to make clipboard contents persist after
- * the application exits. Clipboard persistence requires a clipboard
- * manager to run.
+ * You can also use Drag-And-Drop to copy the data from the source to the
+ * target.
  */
 
 #include <glib/gi18n.h>
@@ -14,22 +12,103 @@
 #include <string.h>
 #include "demoimage.h"
 
-static GtkWidget *window = NULL;
+static void
+copy_button_clicked (GtkStack *source_stack,
+                     gpointer  user_data)
+{
+  GdkClipboard *clipboard;
+  const char *visible_child_name;
+  GtkWidget *visible_child;
+
+  clipboard = gtk_widget_get_clipboard (GTK_WIDGET (source_stack));
+
+  visible_child = gtk_stack_get_visible_child (source_stack);
+  visible_child_name = gtk_stack_get_visible_child_name (source_stack);
+
+  if (strcmp (visible_child_name, "Text") == 0)
+    {
+      gdk_clipboard_set_text (clipboard, gtk_editable_get_text (GTK_EDITABLE (visible_child)));
+    }
+  else if (strcmp (visible_child_name, "Image") == 0)
+    {
+      GtkWidget *child;
+
+      for (child = gtk_widget_get_first_child (visible_child); child; child = gtk_widget_get_next_sibling (child))
+        {
+          if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (child)))
+            {
+              GtkWidget *image = gtk_widget_get_first_child (child);
+              GdkPaintable *paintable = gtk_image_get_paintable (GTK_IMAGE (image));
+
+              if (GDK_IS_TEXTURE (paintable))
+                gdk_clipboard_set (clipboard, GDK_TYPE_TEXTURE, paintable);
+              else
+                gdk_clipboard_set (clipboard, GDK_TYPE_PAINTABLE, paintable);
+              break;
+            }
+        }
+    }
+  else if (strcmp (visible_child_name, "Color") == 0)
+    {
+      GdkRGBA color;
+
+      gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (visible_child), &color);
+      gdk_clipboard_set (clipboard, GDK_TYPE_RGBA, &color);
+    }
+  else if (strcmp (visible_child_name, "File") == 0)
+    {
+      gdk_clipboard_set (clipboard, G_TYPE_FILE, g_object_get_data (G_OBJECT (visible_child), "file"), NULL);
+    }
+  else
+    {
+      g_print ("TODO");
+    }
+}
 
 static void
-copy_button_clicked (GtkWidget *button,
-                     gpointer   user_data)
+present_value (GtkStack     *dest_stack,
+               const GValue *value)
 {
-  GtkWidget *entry;
-  GdkClipboard *clipboard;
+  GtkWidget *child;
 
-  entry = GTK_WIDGET (user_data);
+  if (G_VALUE_HOLDS (value, G_TYPE_FILE))
+    {
+      GFile *file;
 
-  /* Get the clipboard object */
-  clipboard = gtk_widget_get_clipboard (entry);
+      gtk_stack_set_visible_child_name (dest_stack, "File");
+      child = gtk_stack_get_visible_child (dest_stack);
 
-  /* Set clipboard text */
-  gdk_clipboard_set_text (clipboard, gtk_editable_get_text (GTK_EDITABLE (entry)));
+      file = g_value_get_object (value);
+      g_object_set (child, "label", g_file_peek_path (file), NULL);
+    }
+  else if (G_VALUE_HOLDS (value, GDK_TYPE_RGBA))
+    {
+      GdkRGBA *color;
+
+      gtk_stack_set_visible_child_name (dest_stack, "Color");
+      child = gtk_widget_get_first_child (gtk_stack_get_visible_child (dest_stack));
+
+      color = g_value_get_boxed (value);
+      g_object_set (child, "rgba", color, NULL);
+    }
+  else if (G_VALUE_HOLDS (value, GDK_TYPE_TEXTURE) ||
+           G_VALUE_HOLDS (value, GDK_TYPE_PAINTABLE))
+    {
+      GdkPaintable *paintable;
+
+      gtk_stack_set_visible_child_name (dest_stack, "Image");
+      child = gtk_stack_get_visible_child (dest_stack);
+
+      paintable = g_value_get_object (value);
+      g_object_set (child, "paintable", paintable, NULL);
+    }
+  else if (G_VALUE_HOLDS (value, G_TYPE_STRING))
+    {
+      gtk_stack_set_visible_child_name (dest_stack, "Text");
+      child = gtk_stack_get_visible_child (dest_stack);
+
+      gtk_label_set_label (GTK_LABEL (child), g_value_get_string (value));
+    }
 }
 
 static void
@@ -37,149 +116,259 @@ paste_received (GObject      *source_object,
                 GAsyncResult *result,
                 gpointer      user_data)
 {
+  GtkStack *dest_stack = user_data;
   GdkClipboard *clipboard;
-  GtkWidget *entry;
-  char *text;
+  const GValue *value;
   GError *error = NULL;
 
   clipboard = GDK_CLIPBOARD (source_object);
-  entry = GTK_WIDGET (user_data);
 
-  /* Get the resulting text of the read operation */
-  text = gdk_clipboard_read_text_finish (clipboard, result, &error);
-
-  if (text)
+  value = gdk_clipboard_read_value_finish (clipboard, result, &error);
+  if (value)
     {
-      /* Set the entry text */
-      gtk_editable_set_text (GTK_EDITABLE (entry), text);
-      g_free (text);
+      present_value (dest_stack, value);
     }
   else
     {
-      GtkWidget *dialog;
-
-      /* Show an error about why pasting failed.
-       * Usually you probably want to ignore such failures,
-       * but for demonstration purposes, we show the error.
-       */
-      dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                       GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
-                                       GTK_MESSAGE_ERROR,
-                                       GTK_BUTTONS_CLOSE,
-                                       "Could not paste text: %s",
-                                       error->message);
-      g_signal_connect (dialog, "response",
-                        G_CALLBACK (gtk_window_destroy), NULL);
-      gtk_widget_show (dialog);
-
+      g_print ("%s\n", error->message);
       g_error_free (error);
     }
 }
 
 static void
-paste_button_clicked (GtkWidget *button,
-                      gpointer   user_data)
+paste_button_clicked (GtkStack *dest_stack,
+                      gpointer  user_data)
 {
-  GtkWidget *entry;
   GdkClipboard *clipboard;
+  GdkContentFormats *formats;
 
-  entry = GTK_WIDGET (user_data);
+  clipboard = gtk_widget_get_clipboard (GTK_WIDGET (dest_stack));
+  formats = gdk_clipboard_get_formats (clipboard);
 
-  /* Get the clipboard object */
-  clipboard = gtk_widget_get_clipboard (entry);
+  if (gdk_content_formats_contain_gtype (formats, GDK_TYPE_TEXTURE))
+    gdk_clipboard_read_value_async (clipboard, GDK_TYPE_TEXTURE, 0, NULL, paste_received, dest_stack);
+  else if (gdk_content_formats_contain_gtype (formats, GDK_TYPE_PAINTABLE))
+    gdk_clipboard_read_value_async (clipboard, GDK_TYPE_PAINTABLE, 0, NULL, paste_received, dest_stack);
+  else if (gdk_content_formats_contain_gtype (formats, GDK_TYPE_RGBA))
+    gdk_clipboard_read_value_async (clipboard, GDK_TYPE_RGBA, 0, NULL, paste_received, dest_stack);
+  else if (gdk_content_formats_contain_gtype (formats, G_TYPE_FILE))
+    gdk_clipboard_read_value_async (clipboard, G_TYPE_FILE, 0, NULL, paste_received, dest_stack);
+  else if (gdk_content_formats_contain_gtype (formats, G_TYPE_STRING))
+    gdk_clipboard_read_value_async (clipboard, G_TYPE_STRING, 0, NULL, paste_received, dest_stack);
+}
 
-  /* Request the contents of the clipboard, contents_received will be
-     called when we do get the contents.
-   */
-  gdk_clipboard_read_text_async (clipboard, NULL, paste_received, entry);
+static void
+update_copy_button_sensitivity (GtkWidget *source_stack)
+{
+  GtkButton *copy_button;
+  const char *visible_child_name;
+  GtkWidget *visible_child;
+  gboolean sensitive;
+
+  copy_button = GTK_BUTTON (g_object_get_data (G_OBJECT (source_stack), "copy-button"));
+
+  visible_child = gtk_stack_get_visible_child (GTK_STACK (source_stack));
+  visible_child_name = gtk_stack_get_visible_child_name (GTK_STACK (source_stack));
+  if (strcmp (visible_child_name, "Text") == 0)
+    {
+      sensitive = strlen (gtk_editable_get_text (GTK_EDITABLE (visible_child))) > 0;
+    }
+  else if (strcmp (visible_child_name, "Color") == 0 ||
+           strcmp (visible_child_name, "Image") == 0)
+    {
+      sensitive = TRUE;
+    }
+  else if (strcmp (visible_child_name, "File") == 0)
+    {
+      sensitive = g_object_get_data (G_OBJECT (visible_child), "file") != NULL;
+    }
+  else
+    {
+      sensitive = FALSE;
+    }
+
+  gtk_widget_set_sensitive (GTK_WIDGET (copy_button), sensitive);
+}
+
+static void
+source_changed_cb (GtkButton  *copy_button,
+                   GParamSpec *pspec,
+                   GtkWidget  *source_stack)
+{
+  update_copy_button_sensitivity (source_stack);
+}
+
+static void
+text_changed_cb (GtkButton  *copy_button,
+                 GParamSpec *pspec,
+                 GtkWidget  *entry)
+{
+  update_copy_button_sensitivity (gtk_widget_get_ancestor (entry, GTK_TYPE_STACK));
+}
+
+static void
+file_button_set_file (GtkButton *button,
+                      GFile     *file)
+{
+  gtk_label_set_label (GTK_LABEL (gtk_button_get_child (button)), g_file_peek_path (file));
+  g_object_set_data_full (G_OBJECT (button), "file", g_object_ref (file), g_object_unref);
+}
+
+static void
+file_chooser_response (GtkNativeDialog *dialog,
+                       int              response,
+                       GtkButton       *button)
+{
+  gtk_native_dialog_hide (dialog);
+
+  if (response == GTK_RESPONSE_ACCEPT)
+    {
+      GFile *file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
+      file_button_set_file (button, file);
+      g_object_unref (file);
+
+      update_copy_button_sensitivity (gtk_widget_get_ancestor (GTK_WIDGET (button), GTK_TYPE_STACK));
+    }
+
+  gtk_native_dialog_destroy (dialog);
+}
+
+static void
+open_file_cb (GtkWidget *button)
+{
+  GtkFileChooserNative *chooser;
+
+  chooser = gtk_file_chooser_native_new ("Choose a file",
+                                         GTK_WINDOW (gtk_widget_get_ancestor (button, GTK_TYPE_WINDOW)),
+                                         GTK_FILE_CHOOSER_ACTION_OPEN,
+                                         "_Open",
+                                         "_Cancel");
+
+  g_signal_connect (chooser, "response", G_CALLBACK (file_chooser_response), button);
+  gtk_native_dialog_show (GTK_NATIVE_DIALOG (chooser));
+}
+
+static void
+update_paste_button_sensitivity (GdkClipboard *clipboard,
+                                 GtkWidget    *paste_button)
+{
+  GdkContentFormats *formats;
+  gboolean sensitive = FALSE;
+
+  formats = gdk_clipboard_get_formats (clipboard);
+
+  if (gdk_content_formats_contain_gtype (formats, G_TYPE_FILE) ||
+      gdk_content_formats_contain_gtype (formats, GDK_TYPE_RGBA) ||
+      gdk_content_formats_contain_gtype (formats, GDK_TYPE_TEXTURE) ||
+      gdk_content_formats_contain_gtype (formats, GDK_TYPE_PAINTABLE) ||
+      gdk_content_formats_contain_gtype (formats, G_TYPE_STRING))
+    sensitive = TRUE;
+
+  gtk_widget_set_sensitive (paste_button, sensitive);
+}
+
+static void
+unset_clipboard_handler (gpointer data)
+{
+  GdkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
+
+  g_signal_handlers_disconnect_by_func (clipboard, update_paste_button_sensitivity, data);
+}
+
+static gboolean
+on_drop (GtkStack      *dest_stack,
+         const GValue  *value,
+         double         x,
+         double         y,
+         gpointer       data)
+{
+  present_value (dest_stack, value);
+  return TRUE;
+}
+
+static GdkContentProvider *
+drag_prepare (GtkDragSource *drag_source,
+              double         x,
+              double         y,
+              gpointer       data)
+{
+  GtkWidget *button;
+  GValue value = G_VALUE_INIT;
+
+  button = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (drag_source));
+
+  if (GTK_IS_TOGGLE_BUTTON (button))
+    {
+      GtkWidget *image = gtk_widget_get_first_child (button);
+      GdkPaintable *paintable = gtk_image_get_paintable (GTK_IMAGE (image));
+
+      if (GDK_IS_TEXTURE (paintable))
+        {
+          g_value_init (&value, GDK_TYPE_TEXTURE);
+          g_value_set_object (&value, paintable);
+        }
+      else
+        {
+          g_value_init (&value, GDK_TYPE_PAINTABLE);
+          g_value_set_object (&value, paintable);
+        }
+    }
+  else
+    {
+      GFile *file = g_object_get_data (G_OBJECT (button), "file");
+
+      if (file)
+        {
+          g_value_init (&value, G_TYPE_FILE);
+          g_value_set_object (&value, file);
+        }
+      else
+        return NULL;
+    }
+
+  return gdk_content_provider_new_for_value (&value);
 }
 
 GtkWidget *
 do_clipboard (GtkWidget *do_widget)
 {
+  static GtkWidget *window = NULL;
+
   if (!window)
     {
-      GtkWidget *vbox, *hbox;
-      GtkWidget *label;
-      GtkWidget *entry, *button;
-      GtkWidget *image;
+      GtkBuilderScope *scope;
+      GtkBuilder *builder;
+      GtkWidget *button;
 
-      window = gtk_window_new ();
-      gtk_window_set_display (GTK_WINDOW (window),
-                              gtk_widget_get_display (do_widget));
-      gtk_window_set_title (GTK_WINDOW (window), "Clipboard");
+      scope = gtk_builder_cscope_new ();
+      gtk_builder_cscope_add_callback_symbols (GTK_BUILDER_CSCOPE (scope),
+                                               "copy_button_clicked", G_CALLBACK (copy_button_clicked),
+                                               "paste_button_clicked", G_CALLBACK (paste_button_clicked),
+                                               "source_changed_cb", G_CALLBACK (source_changed_cb),
+                                               "text_changed_cb", G_CALLBACK (text_changed_cb),
+                                               "open_file_cb", G_CALLBACK (open_file_cb),
+                                               "on_drop", G_CALLBACK (on_drop),
+                                               "drag_prepare", G_CALLBACK (drag_prepare),
+                                               NULL);
+
+      builder = gtk_builder_new ();
+      gtk_builder_set_scope (builder, scope);
+      gtk_builder_add_from_resource (builder, "/clipboard/clipboard.ui", NULL);
+
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
       g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
 
-      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_widget_set_margin_start (vbox, 8);
-      gtk_widget_set_margin_end (vbox, 8);
-      gtk_widget_set_margin_top (vbox, 8);
-      gtk_widget_set_margin_bottom (vbox, 8);
+      button = GTK_WIDGET (gtk_builder_get_object (builder, "copy_button"));
+      g_object_set_data (gtk_builder_get_object (builder, "source_stack"), "copy-button", button);
 
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      button = GTK_WIDGET (gtk_builder_get_object (builder, "paste_button"));
+      g_signal_connect (gtk_widget_get_clipboard (button), "changed",
+                        G_CALLBACK (update_paste_button_sensitivity), button);
+      g_object_set_data_full (G_OBJECT (button), "clipboard-handler", button, unset_clipboard_handler);
 
-      label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
-
-      gtk_box_append (GTK_BOX (vbox), label);
-
-      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
-      gtk_widget_set_margin_start (hbox, 8);
-      gtk_widget_set_margin_end (hbox, 8);
-      gtk_widget_set_margin_top (hbox, 8);
-      gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
-
-      /* Create the first entry */
-      entry = gtk_entry_new ();
-      gtk_box_append (GTK_BOX (hbox), entry);
-
-      /* Create the button */
-      button = gtk_button_new_with_mnemonic (_("_Copy"));
-      gtk_box_append (GTK_BOX (hbox), button);
-      g_signal_connect (button, "clicked",
-                        G_CALLBACK (copy_button_clicked), entry);
-
-      label = gtk_label_new ("\"Paste\" will paste the text from the clipboard to the entry");
-      gtk_box_append (GTK_BOX (vbox), label);
-
-      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
-      gtk_widget_set_margin_start (hbox, 8);
-      gtk_widget_set_margin_end (hbox, 8);
-      gtk_widget_set_margin_top (hbox, 8);
-      gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
-
-      /* Create the second entry */
-      entry = gtk_entry_new ();
-      gtk_box_append (GTK_BOX (hbox), entry);
-
-      /* Create the button */
-      button = gtk_button_new_with_mnemonic (_("_Paste"));
-      gtk_box_append (GTK_BOX (hbox), button);
-      g_signal_connect (button, "clicked",
-                        G_CALLBACK (paste_button_clicked), entry);
-
-      label = gtk_label_new ("Images can be transferred via the clipboard, too");
-      gtk_box_append (GTK_BOX (vbox), label);
-
-      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
-      gtk_widget_set_margin_start (hbox, 8);
-      gtk_widget_set_margin_end (hbox, 8);
-      gtk_widget_set_margin_top (hbox, 8);
-      gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
-
-      /* Create the first image */
-      image = demo_image_new ("dialog-warning");
-      gtk_box_append (GTK_BOX (hbox), image);
-
-      /* Create the second image */
-      image = demo_image_new ("process-stop");
-      gtk_box_append (GTK_BOX (hbox), image);
-
-      /* Create the third image */
-      image = demo_image_new ("weather-clear");
-      gtk_box_append (GTK_BOX (hbox), image);
+      g_object_unref (builder);
+      g_object_unref (scope);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/clipboard.ui

@@ -0,0 +1,288 @@
+
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="resizable">1</property>
+    <property name="title">Clipboard</property>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <property name="margin-start">12</property>
+        <property name="margin-end">12</property>
+        <property name="margin-top">12</property>
+        <property name="margin-bottom">12</property>
+        <property name="spacing">12</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">“Copy” will copy the selected data the clipboard, “Paste” will show the current clipboard contents. You can also drag the data to the bottom.</property>
+            <property name="wrap">1</property>
+            <property name="max-width-chars">40</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkDropDown" id="source_chooser">
+                <property name="valign">center</property>
+                <property name="model">
+                  <object class="GtkStringList">
+                    <items>
+                      <item>Text</item>
+                      <item>Color</item>
+                      <item>Image</item>
+                      <item>File</item>
+                    </items>
+                  </object>
+                </property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkStack" id="source_stack">
+                <signal name="notify::visible-child" handler="source_changed_cb" object="copy_button"/>
+                <property name="vexpand">1</property>
+                <binding name="visible-child-name">
+                  <lookup name="string" type="GtkStringObject">
+                    <lookup name="selected-item">
+                      source_chooser
+                    </lookup>
+                  </lookup>
+                </binding>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Text</property>
+                    <property name="child">
+                      <object class="GtkEntry" id="source_text">
+                        <property name="valign">center</property>
+                        <signal name="notify::text" handler="text_changed_cb" object="copy_button"/>
+                        <property name="text">Copy this!</property>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Color</property>
+                    <property name="child">
+                      <object class="GtkColorButton" id="source_color">
+                        <property name="valign">center</property>
+                        <property name="rgba">purple</property>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Image</property>
+                    <property name="child">
+                      <object class="GtkBox">
+                        <property name="valign">center</property>
+                        <style>
+                          <class name="linked"/>
+                        </style>
+                        <child>
+                          <object class="GtkToggleButton" id="image_rose">
+                            <property name="active">1</property>
+                            <child>
+                              <object class="GtkDragSource">
+                                <signal name="prepare" handler="drag_prepare"/>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkImage">
+                                <style>
+                                  <class name="large-icons"/>
+                                </style>
+                                <property name="paintable">resource:///transparent/portland-rose.jpg</property>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkToggleButton" id="image_floppy">
+                            <property name="group">image_rose</property>
+                            <child>
+                              <object class="GtkDragSource">
+                                <signal name="prepare" handler="drag_prepare"/>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkImage">
+                                <style>
+                                  <class name="large-icons"/>
+                                </style>
+                                <property name="paintable">resource:///images/floppybuddy.gif</property>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkToggleButton" id="image_logo">
+                            <property name="group">image_floppy</property>
+                            <child>
+                              <object class="GtkDragSource">
+                                <signal name="prepare" handler="drag_prepare"/>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkImage">
+                                <style>
+                                  <class name="large-icons"/>
+                                </style>
+                                <property name="paintable">resource:///images/org.gtk.Demo4.svg</property>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">File</property>
+                    <property name="child">
+                      <object class="GtkButton" id="source_file">
+                        <child>
+                          <object class="GtkDragSource">
+                            <property name="propagation-phase">capture</property>
+                            <signal name="prepare" handler="drag_prepare"/>
+                          </object>
+                        </child>
+                        <property name="valign">center</property>
+                        <property name="child">
+                          <object class="GtkLabel">
+                            <property name="label">—</property>
+                            <property name="xalign">0</property>
+                            <property name="ellipsize">start</property>
+                          </object>
+                        </property>
+                        <signal name="clicked" handler="open_file_cb"/>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="copy_button">
+                <property name="valign">center</property>
+                <property name="label" translatable="yes">_Copy</property>
+                <signal name="clicked" handler="copy_button_clicked" object="source_stack"/>
+                <property name="use-underline">1</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkDropTarget">
+                <property name="actions">copy</property>
+                <property name="formats">GdkTexture GdkPaintable GFile GdkRGBA gchararray</property>
+                <signal name="drop" handler="on_drop" object="dest_stack"/>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="paste_button">
+                <property name="label" translatable="yes">_Paste</property>
+                <signal name="clicked" handler="paste_button_clicked" object="dest_stack"/>
+                <property name="use-underline">1</property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="xalign">0</property>
+                <binding name="label">
+                  <lookup name="visible-child-name" type="GtkStack">
+                    dest_stack
+                  </lookup>
+                </binding>
+              </object>
+            </child>
+            <child>
+              <object class="GtkStack" id="dest_stack">
+                <property name="halign">end</property>
+                <property name="valign">center</property>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name"></property>
+                    <property name="child">
+                      <object class="GtkLabel">
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Text</property>
+                    <property name="child">
+                      <object class="GtkLabel">
+                        <property name="halign">end</property>
+                        <property name="valign">center</property>
+                        <property name="xalign">0</property>
+                        <property name="ellipsize">end</property>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Image</property>
+                    <property name="child">
+                      <object class="GtkImage">
+                        <property name="halign">end</property>
+                        <property name="valign">center</property>
+                        <style>
+                          <class name="large-icons"/>
+                        </style>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">Color</property>
+                    <property name="child">
+                      <object class="GtkBox">
+                        <property name="halign">end</property>
+                        <property name="valign">center</property>
+                        <child>
+                          <object class="GtkColorSwatch">
+                            <property name="accessible-role">img</property>
+                            <property name="can-focus">0</property>
+                            <property name="selectable">0</property>
+                            <property name="has-menu">0</property>
+                          </object>
+                        </child>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkStackPage">
+                    <property name="name">File</property>
+                    <property name="child">
+                      <object class="GtkLabel">
+                        <property name="halign">end</property>
+                        <property name="valign">center</property>
+                        <property name="xalign">0</property>
+                        <property name="hexpand">1</property>
+                        <property name="ellipsize">start</property>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/cursors.c

@@ -24,7 +24,6 @@ do_cursors (GtkWidget *do_widget)
 
       builder = gtk_builder_new_from_resource ("/cursors/cursors.ui");
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       g_signal_connect (window, "destroy",
@@ -35,7 +34,9 @@ do_cursors (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    {
+      gtk_window_destroy (GTK_WINDOW (window));
+    }
 
   return window;
 }

demos/gtk-demo/curve-editor.h

@@ -1,36 +0,0 @@
-#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,
-                                                 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

@@ -1,272 +0,0 @@
-/* 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_curve_to (builder, cx + kr, pad,
-                                      w - pad, cy - kr,
-                                      w - pad, cy);
-  gsk_path_builder_curve_to (builder, w - pad, cy + kr,
-                                      cx + kr, h - pad,
-                                      cx, h - pad);
-  gsk_path_builder_curve_to (builder, cx - kr, h - pad,
-                                      pad, cy + kr,
-                                      pad, cy);
-  gsk_path_builder_curve_to (builder, pad, cy - kr,
-                                      cx - kr, pad,
-                                      cx, pad);
-  gsk_path_builder_close (builder);
-
-  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_circle_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 (GtkColorChooser *chooser,
-               GParamSpec      *pspec,
-               CurveEditor     *editor)
-{
-  GdkRGBA color;
-
-  gtk_color_chooser_get_rgba (chooser, &color);
-  curve_editor_set_color (editor, &color);
-}
-
-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), 310, 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_button_new_with_rgba (&(GdkRGBA){ 0., 0., 0., 1.});
-      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_chooser_set_rgba (GTK_COLOR_CHOOSER (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_widget_show (window);
-  else
-    gtk_window_destroy (GTK_WINDOW (window));
-
-  return window;
-}

demos/gtk-demo/demo.gresource.xml

@@ -15,6 +15,7 @@
     <file>demo.ui</file>
   </gresource>
   <gresource prefix="/clipboard">
+    <file>clipboard.ui</file>
     <file>demoimage.c</file>
     <file>demoimage.h</file>
   </gresource>
@@ -249,10 +250,6 @@
   <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>
@@ -270,7 +267,6 @@
     <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>dropdown.c</file>
@@ -291,7 +287,6 @@
     <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>
@@ -330,9 +325,6 @@
     <file>paintable_symbolic.c</file>
     <file>panes.c</file>
     <file>password_entry.c</file>
-    <file>path_fill.c</file>
-    <file>path_maze.c</file>
-    <file>path_text.c</file>
     <file>peg_solitaire.c</file>
     <file>pickers.c</file>
     <file>printing.c</file>
@@ -417,9 +409,6 @@
   <gresource prefix="/fontrendering">
     <file>fontrendering.ui</file>
   </gresource>
-  <gresource prefix="/path_text">
-    <file>path_text.ui</file>
-  </gresource>
   <gresource prefix="/org/gtk/Demo4">
     <file>icons/16x16/actions/application-exit.png</file>
     <file>icons/16x16/actions/document-new.png</file>

demos/gtk-demo/main.c

@@ -512,7 +512,7 @@ load_file (const char *demoname,
 
   info_buffer = gtk_text_buffer_new (NULL);
   gtk_text_buffer_create_tag (info_buffer, "title",
-                              "size", 18 * 1024,
+                              "font", "Sans 18",
                               "pixels-below-lines", 10,
                               NULL);
 

demos/gtk-demo/meson.build

@@ -17,7 +17,6 @@ demos = files([
   'css_pixbufs.c',
   'css_shadows.c',
   'cursors.c',
-  'curve.c',
   'dialog.c',
   'drawingarea.c',
   'dnd.c',
@@ -35,7 +34,6 @@ demos = files([
   'gestures.c',
   'glarea.c',
   'gltransition.c',
-  'glyphs.c',
   'headerbar.c',
   'hypertext.c',
   'iconscroll.c',
@@ -72,9 +70,6 @@ demos = files([
   'paintable_symbolic.c',
   'panes.c',
   'password_entry.c',
-  'path_fill.c',
-  'path_maze.c',
-  'path_text.c',
   'peg_solitaire.c',
   'pickers.c',
   'printing.c',
@@ -133,7 +128,6 @@ extra_demo_sources = files([
   'script-names.c',
   'unicode-names.c',
   'suggestionentry.c',
-  'curve-editor.c',
 ])
 
 if harfbuzz_dep.found() and pangoft_dep.found()

demos/gtk-demo/path_fill.c

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

demos/gtk-demo/path_maze.c

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

demos/gtk-demo/path_text.c

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

demos/gtk-demo/path_text.ui

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

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

@@ -16,6 +16,7 @@ SYNOPSIS
 |   **gtk4-builder-tool** enumerate <FILE>
 |   **gtk4-builder-tool** simplify [OPTIONS...] <FILE>
 |   **gtk4-builder-tool** preview [OPTIONS...] <FILE>
+|   **gtk4-builder-tool** precompile [OPTIONS...] <FILE>
 
 DESCRIPTION
 -----------
@@ -83,3 +84,10 @@ to do manual fixups  after the initial conversion.
 ``--3to4``
 
   Transform a GTK 3 UI definition file to the equivalent GTK 4 definitions.
+
+Precompilation
+^^^^^^^^^^^^^^
+
+The ``precompile`` command creates a more compact, and faster to load compiled
+form of the ui file that is understood by GtkBuilder. The output is written
+to a file with the extension ``.precompiled``.

gdk/gdkcontentdeserializer.c

@@ -49,7 +49,7 @@
 
 typedef struct _Deserializer Deserializer;
 
-struct _Deserializer 
+struct _Deserializer
 {
   const char *                    mime_type; /* interned */
   GType                           type;
@@ -934,25 +934,6 @@ init (void)
 
   formats = gdk_pixbuf_get_formats ();
 
-  /* Make sure png comes first */
-  for (f = formats; f; f = f->next)
-    {
-      GdkPixbufFormat *fmt = f->data;
-      char *name;
-
-      name = gdk_pixbuf_format_get_name (fmt);
-      if (g_str_equal (name, "png"))
-        {
-          formats = g_slist_delete_link (formats, f);
-          formats = g_slist_prepend (formats, fmt);
-
-          g_free (name);
-          break;
-        }
-
-      g_free (name);
-    }
-
   for (f = formats; f; f = f->next)
     {
       GdkPixbufFormat *fmt = f->data;

gdk/gdkcontentformats.c

@@ -718,19 +718,33 @@ gdk_content_formats_builder_to_formats (GdkContentFormatsBuilder *builder)
 
   g_return_val_if_fail (builder != NULL, NULL);
 
-  gtypes = g_new (GType, builder->n_gtypes + 1);
-  i = builder->n_gtypes;
-  gtypes[i--] = G_TYPE_INVALID;
-  /* add backwards because most important type is last in the list */
-  for (l = builder->gtypes; l; l = l->next)
-    gtypes[i--] = GPOINTER_TO_SIZE (l->data);
+  if (builder->n_gtypes > 0)
+    {
+      gtypes = g_new (GType, builder->n_gtypes + 1);
+      i = builder->n_gtypes;
+      gtypes[i--] = G_TYPE_INVALID;
+      /* add backwards because most important type is last in the list */
+      for (l = builder->gtypes; l; l = l->next)
+        gtypes[i--] = GPOINTER_TO_SIZE (l->data);
+    }
+  else
+    {
+      gtypes = NULL;
+    }
 
-  mime_types = g_new (const char *, builder->n_mime_types + 1);
-  i = builder->n_mime_types;
-  mime_types[i--] = NULL;
-  /* add backwards because most important type is last in the list */
-  for (l = builder->mime_types; l; l = l->next)
-    mime_types[i--] = l->data;
+  if (builder->n_mime_types > 0)
+    {
+      mime_types = g_new (const char *, builder->n_mime_types + 1);
+      i = builder->n_mime_types;
+      mime_types[i--] = NULL;
+      /* add backwards because most important type is last in the list */
+      for (l = builder->mime_types; l; l = l->next)
+        mime_types[i--] = l->data;
+    }
+  else
+    {
+      mime_types = NULL;
+    }
 
   result = gdk_content_formats_new_take (gtypes, builder->n_gtypes,
                                          mime_types, builder->n_mime_types);

gdk/gdkcontentserializer.c

@@ -54,7 +54,7 @@
 
 typedef struct _Serializer Serializer;
 
-struct _Serializer 
+struct _Serializer
 {
   const char *                    mime_type; /* interned */
   GType                           type;
@@ -446,7 +446,7 @@ lookup_serializer (const char *mime_type,
           serializer->type == type)
         return serializer;
     }
-  
+
   return NULL;
 }
 
@@ -630,7 +630,7 @@ pixbuf_serializer (GdkContentSerializer *serializer)
   const GValue *value;
   GdkPixbuf *pixbuf;
   const char *name;
-  
+
   name = gdk_content_serializer_get_user_data (serializer);
   value = gdk_content_serializer_get_value (serializer);
 
@@ -651,7 +651,7 @@ pixbuf_serializer (GdkContentSerializer *serializer)
   gdk_pixbuf_save_to_stream_async (pixbuf,
                                    gdk_content_serializer_get_output_stream (serializer),
                                    name,
-				   gdk_content_serializer_get_cancellable (serializer),
+                                   gdk_content_serializer_get_cancellable (serializer),
                                    pixbuf_serializer_finish,
                                    serializer,
                                    g_str_equal (name, "png") ? "compression" : NULL, "2",
@@ -823,7 +823,7 @@ file_uri_serializer (GdkContentSerializer *serializer)
   else if (G_VALUE_HOLDS (value, GDK_TYPE_FILE_LIST))
     {
       GSList *l;
-      
+
       for (l = g_value_get_boxed (value); l; l = l->next)
         {
           uri = g_file_get_uri (l->data);
@@ -867,7 +867,7 @@ file_text_serializer (GdkContentSerializer *serializer)
     {
       GString *str;
       GSList *l;
-      
+
       str = g_string_new (NULL);
 
       for (l = g_value_get_boxed (value); l; l = l->next)
@@ -966,25 +966,6 @@ init (void)
 
   formats = gdk_pixbuf_get_formats ();
 
-  /* Make sure png comes first */
-  for (f = formats; f; f = f->next)
-    {
-      GdkPixbufFormat *fmt = f->data;
-      char *name;
-
-      name = gdk_pixbuf_format_get_name (fmt);
-      if (g_str_equal (name, "png"))
-        {
-          formats = g_slist_delete_link (formats, f);
-          formats = g_slist_prepend (formats, fmt);
-
-          g_free (name);
-          break;
-        }
-
-      g_free (name);
-    }
-
   for (f = formats; f; f = f->next)
     {
       GdkPixbufFormat *fmt = f->data;

gdk/gdkdevice.c

@@ -132,6 +132,8 @@ gdk_device_class_init (GdkDeviceClass *klass)
    * GdkDevice:source: (attributes org.gtk.Property.get=gdk_device_get_source)
    *
    * Source type for the device.
+   *
+   * Deprecated: 4.6: Use GdkDeviceTool:tool-type instead
    */
   device_props[PROP_SOURCE] =
       g_param_spec_enum ("source",
@@ -596,6 +598,8 @@ gdk_device_get_has_cursor (GdkDevice *device)
  * Determines the type of the device.
  *
  * Returns: a `GdkInputSource`
+ *
+ * Deprecated: 4.6: Use gdk_device_tool_get_tool_type() instead
  */
 GdkInputSource
 gdk_device_get_source (GdkDevice *device)

gdk/gdkdevice.h

@@ -92,7 +92,7 @@ GDK_AVAILABLE_IN_ALL
 GdkDisplay *        gdk_device_get_display              (GdkDevice *device);
 GDK_AVAILABLE_IN_ALL
 GdkSeat *           gdk_device_get_seat                 (GdkDevice *device);
-GDK_AVAILABLE_IN_ALL
+GDK_DEPRECATED_IN_4_6_FOR(gdk_device_tool_get_tool_type)
 GdkDeviceTool *     gdk_device_get_device_tool          (GdkDevice *device);
 
 GDK_AVAILABLE_IN_ALL

gdk/gdkmarshalers.list

@@ -2,3 +2,4 @@ BOOLEAN:BOXED
 BOOLEAN:OBJECT
 BOOLEAN:POINTER
 VOID:POINTER,POINTER,BOOLEAN,BOOLEAN
+VOID:INT,INT

gdk/gdksurface.c

@@ -605,11 +605,14 @@ gdk_surface_class_init (GdkSurfaceClass *klass)
                   0,
                   NULL,
                   NULL,
-                  NULL,
+                  _gdk_marshal_VOID__INT_INT,
                   G_TYPE_NONE,
                   2,
                   G_TYPE_INT,
                   G_TYPE_INT);
+  g_signal_set_va_marshaller (signals[LAYOUT],
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              _gdk_marshal_VOID__INT_INTv);
 
   /**
    * GdkSurface::render:

gdk/gdktexture.h

@@ -89,10 +89,6 @@ GDK_AVAILABLE_IN_ALL
 void                    gdk_texture_download                   (GdkTexture      *texture,
                                                                 guchar          *data,
                                                                 gsize            stride);
-GDK_AVAILABLE_IN_4_6
-void                    gdk_texture_download_float             (GdkTexture      *texture,
-                                                                float           *data,
-                                                                gsize            stride);
 GDK_AVAILABLE_IN_ALL
 gboolean                gdk_texture_save_to_png                (GdkTexture      *texture,
                                                                 const char      *filename);

gdk/loaders/gdktiff.c

@@ -240,7 +240,7 @@ static const FormatData format_data[] = {
   [GDK_MEMORY_A8R8G8B8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA },
   [GDK_MEMORY_R8G8B8A8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA },
   [GDK_MEMORY_A8B8G8R8]                         = { GDK_MEMORY_R8G8B8A8,                          8, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_UNASSALPHA },
-  [GDK_MEMORY_R8G8B8]                           = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0                      }, 
+  [GDK_MEMORY_R8G8B8]                           = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0                      },
   [GDK_MEMORY_B8G8R8]                           = { GDK_MEMORY_R8G8B8,                            8, 3, SAMPLEFORMAT_UINT,   0                      },
   [GDK_MEMORY_R16G16B16]                        = { GDK_MEMORY_R16G16B16,                        16, 3, SAMPLEFORMAT_UINT,   0                      },
   [GDK_MEMORY_R16G16B16A16_PREMULTIPLIED]       = { GDK_MEMORY_R16G16B16A16_PREMULTIPLIED,       16, 4, SAMPLEFORMAT_UINT,   EXTRASAMPLE_ASSOCALPHA },
@@ -376,6 +376,13 @@ gdk_load_tiff (GBytes  *input_bytes,
   G_GNUC_UNUSED gint64 before = GDK_PROFILER_CURRENT_TIME;
 
   tif = tiff_open_read (input_bytes);
+  if (!tif)
+    {
+      g_set_error_literal (error,
+                           GDK_TEXTURE_ERROR, GDK_TEXTURE_ERROR_CORRUPT_IMAGE,
+                           _("Could not load TIFF data"));
+      return NULL;
+    }
 
   TIFFSetDirectory (tif, 0);
 

gdk/x11/gdkclipboard-x11.c

@@ -76,11 +76,30 @@ print_atoms (GdkX11Clipboard *cb,
   });
 }
 
+static void
+gdk_x11_clipboard_default_output_closed (GObject      *stream,
+                                         GAsyncResult *result,
+                                         gpointer      user_data)
+{
+  GError *error = NULL;
+
+  if (!g_output_stream_close_finish (G_OUTPUT_STREAM (stream), result, &error))
+    {
+      GDK_NOTE (CLIPBOARD,
+                g_printerr ("-------: failed to close stream: %s\n",
+                            error->message));
+      g_error_free (error);
+    }
+
+  g_object_unref (stream);
+}
+
 static void
 gdk_x11_clipboard_default_output_done (GObject      *clipboard,
                                        GAsyncResult *result,
                                        gpointer      user_data)
 {
+  GOutputStream *stream = user_data;
   GError *error = NULL;
 
   if (!gdk_clipboard_write_finish (GDK_CLIPBOARD (clipboard), result, &error))
@@ -90,6 +109,12 @@ gdk_x11_clipboard_default_output_done (GObject      *clipboard,
                             GDK_X11_CLIPBOARD (clipboard)->selection, error->message));
       g_error_free (error);
     }
+
+  g_output_stream_close_async (stream,
+                               G_PRIORITY_DEFAULT,
+                               NULL, 
+                               gdk_x11_clipboard_default_output_closed,
+                               NULL);
 }
 
 static void
@@ -103,8 +128,7 @@ gdk_x11_clipboard_default_output_handler (GOutputStream   *stream,
                              G_PRIORITY_DEFAULT,
                              NULL,
                              gdk_x11_clipboard_default_output_done,
-                             NULL);
-  g_object_unref (stream);
+                             stream);
 }
 
 static GInputStream * 

gdk/x11/gdkdrag-x11.c

@@ -1612,11 +1612,30 @@ gdk_x11_drag_set_hotspot (GdkDrag *drag,
     }
 }
 
+static void
+gdk_x11_drag_default_output_closed (GObject      *stream,
+                                    GAsyncResult *result,
+                                    gpointer      user_data)
+{
+  GError *error = NULL;
+
+  if (!g_output_stream_close_finish (G_OUTPUT_STREAM (stream), result, &error))
+    {
+      GDK_NOTE (DND,
+                g_printerr ("failed to close stream: %s\n",
+                            error->message));
+      g_error_free (error);
+    }
+
+  g_object_unref (stream);
+}
+
 static void
 gdk_x11_drag_default_output_done (GObject      *drag,
                                   GAsyncResult *result,
                                   gpointer      user_data)
 {
+  GOutputStream *stream = user_data;
   GError *error = NULL;
 
   if (!gdk_drag_write_finish (GDK_DRAG (drag), result, &error))
@@ -1624,6 +1643,12 @@ gdk_x11_drag_default_output_done (GObject      *drag,
       GDK_DISPLAY_NOTE (gdk_drag_get_display (GDK_DRAG (drag)), DND, g_printerr ("failed to write stream: %s\n", error->message));
       g_error_free (error);
     }
+
+  g_output_stream_close_async (stream,
+                               G_PRIORITY_DEFAULT,
+                               NULL, 
+                               gdk_x11_drag_default_output_closed,
+                               NULL);
 }
 
 static void
@@ -1637,8 +1662,7 @@ gdk_x11_drag_default_output_handler (GOutputStream *stream,
                         G_PRIORITY_DEFAULT,
                         NULL,
                         gdk_x11_drag_default_output_done,
-                        NULL);
-  g_object_unref (stream);
+                        stream);
 }
 
 static gboolean

gdk/x11/gdkselectionoutputstream-x11.c

@@ -57,7 +57,8 @@ struct _GdkX11SelectionOutputStreamPrivate {
   GTask *pending_task;
 
   guint incr : 1;
-  guint delete_pending : 1;
+  guint sent_end_of_stream : 1;
+  guint delete_pending : 1; /* owns a reference */
 };
 
 struct _GdkX11PendingSelectionNotify
@@ -176,12 +177,16 @@ gdk_x11_selection_output_stream_needs_flush_unlocked (GdkX11SelectionOutputStrea
 {
   GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
 
-  if (priv->data->len == 0 && priv->notify == NULL)
+  if (priv->sent_end_of_stream)
     return FALSE;
 
-  if (g_output_stream_is_closing (G_OUTPUT_STREAM (stream)))
+  if (g_output_stream_is_closing (G_OUTPUT_STREAM (stream)) ||
+      g_output_stream_is_closed (G_OUTPUT_STREAM (stream)))
     return TRUE;
 
+  if (priv->data->len == 0 && priv->notify == NULL)
+    return FALSE;
+
   if (priv->flush_requested)
     return TRUE;
 
@@ -284,6 +289,8 @@ gdk_x11_selection_output_stream_perform_flush (GdkX11SelectionOutputStream *stre
       g_byte_array_remove_range (priv->data, 0, n_elements * element_size);
       if (priv->data->len < element_size)
         priv->flush_requested = FALSE;
+      if (!priv->incr || n_elements == 0)
+        priv->sent_end_of_stream = TRUE;
     }
 
   if (priv->notify)
@@ -292,6 +299,7 @@ gdk_x11_selection_output_stream_perform_flush (GdkX11SelectionOutputStream *stre
       priv->notify = NULL;
     }
 
+  g_object_ref (stream);
   priv->delete_pending = TRUE;
   g_cond_broadcast (&priv->cond);
   g_mutex_unlock (&priv->mutex);
@@ -494,60 +502,6 @@ gdk_x11_selection_output_stream_flush_finish (GOutputStream  *stream,
   return g_task_propagate_boolean (G_TASK (result), error);
 }
 
-static gboolean
-gdk_x11_selection_output_stream_invoke_close (gpointer stream)
-{
-  GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
-
-  GDK_X11_DISPLAY (priv->display)->streams = g_slist_remove (GDK_X11_DISPLAY (priv->display)->streams, stream);
-  g_signal_handlers_disconnect_by_func (priv->display,
-                                        gdk_x11_selection_output_stream_xevent,
-                                        stream);
-  g_object_unref (stream);
-
-  return G_SOURCE_REMOVE;
-}
-
-static gboolean
-gdk_x11_selection_output_stream_close (GOutputStream  *stream,
-                                       GCancellable   *cancellable,
-                                       GError        **error)
-{
-  g_main_context_invoke (NULL, gdk_x11_selection_output_stream_invoke_close, g_object_ref (stream));
-
-  return TRUE;
-}
-
-static void
-gdk_x11_selection_output_stream_close_async (GOutputStream       *stream,
-                                             int                  io_priority,
-                                             GCancellable        *cancellable,
-                                             GAsyncReadyCallback  callback,
-                                             gpointer             user_data)
-{
-  GTask *task;
-
-  task = g_task_new (stream, cancellable, callback, user_data);
-  g_task_set_source_tag (task, gdk_x11_selection_output_stream_close_async);
-  g_task_set_priority (task, io_priority);
-
-  gdk_x11_selection_output_stream_invoke_close (stream);
-  g_task_return_boolean (task, TRUE);
-
-  g_object_unref (task);
-}
-
-static gboolean
-gdk_x11_selection_output_stream_close_finish (GOutputStream  *stream,
-                                              GAsyncResult   *result,
-                                              GError        **error)
-{
-  g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
-  g_return_val_if_fail (g_async_result_is_tagged (result, gdk_x11_selection_output_stream_close_async), FALSE);
-
-  return g_task_propagate_boolean (G_TASK (result), error);
-}
-
 static void
 gdk_x11_selection_output_stream_finalize (GObject *object)
 {
@@ -557,6 +511,13 @@ gdk_x11_selection_output_stream_finalize (GObject *object)
   /* not sending a notify is terrible */
   g_assert (priv->notify == NULL);
 
+  GDK_DISPLAY_NOTE (priv->display, SELECTION, g_printerr ("%s:%s: finalizing\n",
+                                                          priv->selection, priv->target));
+  GDK_X11_DISPLAY (priv->display)->streams = g_slist_remove (GDK_X11_DISPLAY (priv->display)->streams, stream);
+  g_signal_handlers_disconnect_by_func (priv->display,
+                                        gdk_x11_selection_output_stream_xevent,
+                                        stream);
+
   g_byte_array_unref (priv->data);
   g_cond_clear (&priv->cond);
   g_mutex_clear (&priv->mutex);
@@ -579,14 +540,11 @@ gdk_x11_selection_output_stream_class_init (GdkX11SelectionOutputStreamClass *kl
   
   output_stream_class->write_fn = gdk_x11_selection_output_stream_write;
   output_stream_class->flush = gdk_x11_selection_output_stream_flush;
-  output_stream_class->close_fn = gdk_x11_selection_output_stream_close;
 
   output_stream_class->write_async = gdk_x11_selection_output_stream_write_async;
   output_stream_class->write_finish = gdk_x11_selection_output_stream_write_finish;
   output_stream_class->flush_async = gdk_x11_selection_output_stream_flush_async;
   output_stream_class->flush_finish = gdk_x11_selection_output_stream_flush_finish;
-  output_stream_class->close_async = gdk_x11_selection_output_stream_close_async;
-  output_stream_class->close_finish = gdk_x11_selection_output_stream_close_finish;
 }
 
 static void
@@ -628,6 +586,7 @@ gdk_x11_selection_output_stream_xevent (GdkDisplay   *display,
       if (gdk_x11_selection_output_stream_needs_flush (stream) &&
           gdk_x11_selection_output_stream_can_flush (stream))
         gdk_x11_selection_output_stream_perform_flush (stream);
+      g_object_unref (stream); /* from unsetting the delete_pending */
       return FALSE;
 
     default:

gsk/broadway/gskbroadwayrenderer.c

@@ -269,8 +269,6 @@ collect_reused_child_nodes (GskRenderer *renderer,
     case GSK_BLEND_NODE:
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
-    case GSK_FILL_NODE:
-    case GSK_STROKE_NODE:
 
     default:
 
@@ -857,8 +855,6 @@ gsk_broadway_renderer_add_node (GskRenderer *renderer,
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
     case GSK_GL_SHADER_NODE:
-    case GSK_FILL_NODE:
-    case GSK_STROKE_NODE:
     default:
       break; /* Fallback */
     }

gsk/gl/gskglcommandqueue.c

@@ -282,7 +282,7 @@ snapshot_uniforms (GskGLUniformState    *state,
     {
       const GskGLUniformMapping *mapping = &program->mappings[i];
 
-      if (!mapping->info.initial && mapping->info.format && mapping->location > -1)
+      if (!mapping->info.initial && mapping->location > -1)
         {
           uniform[count].location = mapping->location;
           uniform[count].info = mapping->info;

gsk/gl/gskgldriver.c

@@ -32,7 +32,6 @@
 #include "gskglcommandqueueprivate.h"
 #include "gskglcompilerprivate.h"
 #include "gskglglyphlibraryprivate.h"
-#include "gskglglyphylibraryprivate.h"
 #include "gskgliconlibraryprivate.h"
 #include "gskglprogramprivate.h"
 #include "gskglshadowlibraryprivate.h"
@@ -45,6 +44,9 @@
 #include <gdk/gdkprofilerprivate.h>
 #include <gdk/gdktextureprivate.h>
 
+#define ATLAS_SIZE 512
+#define MAX_OLD_RATIO 0.5
+
 G_DEFINE_TYPE (GskGLDriver, gsk_gl_driver, G_TYPE_OBJECT)
 
 static guint
@@ -154,6 +156,50 @@ gsk_gl_driver_collect_unused_textures (GskGLDriver *self,
   return collected;
 }
 
+static void
+gsk_gl_texture_atlas_free (GskGLTextureAtlas *atlas)
+{
+  if (atlas->texture_id != 0)
+    {
+      glDeleteTextures (1, &atlas->texture_id);
+      atlas->texture_id = 0;
+    }
+
+  g_clear_pointer (&atlas->nodes, g_free);
+  g_slice_free (GskGLTextureAtlas, atlas);
+}
+
+GskGLTextureAtlas *
+gsk_gl_driver_create_atlas (GskGLDriver *self)
+{
+  GskGLTextureAtlas *atlas;
+
+  g_return_val_if_fail (GSK_IS_GL_DRIVER (self), NULL);
+
+  atlas = g_slice_new0 (GskGLTextureAtlas);
+  atlas->width = ATLAS_SIZE;
+  atlas->height = ATLAS_SIZE;
+  /* TODO: We might want to change the strategy about the amount of
+   *       nodes here? stb_rect_pack.h says width is optimal. */
+  atlas->nodes = g_malloc0_n (atlas->width, sizeof (struct stbrp_node));
+  stbrp_init_target (&atlas->context, atlas->width, atlas->height, atlas->nodes, atlas->width);
+  atlas->texture_id = gsk_gl_command_queue_create_texture (self->command_queue,
+                                                           atlas->width,
+                                                           atlas->height,
+                                                           GL_RGBA8,
+                                                           GL_LINEAR,
+                                                           GL_LINEAR);
+
+  gdk_gl_context_label_object_printf (gdk_gl_context_get_current (),
+                                      GL_TEXTURE, atlas->texture_id,
+                                      "Texture atlas %d",
+                                      atlas->texture_id);
+
+  g_ptr_array_add (self->atlases, atlas);
+
+  return atlas;
+}
+
 static void
 remove_program (gpointer data)
 {
@@ -180,29 +226,6 @@ gsk_gl_driver_shader_weak_cb (gpointer  data,
     g_hash_table_remove (self->shader_cache, where_object_was);
 }
 
-G_GNUC_NULL_TERMINATED static inline GBytes *
-join_sources (GBytes *first_bytes,
-              ...)
-{
-  GByteArray *byte_array = g_byte_array_new ();
-  GBytes *bytes = first_bytes;
-  va_list args;
-
-  va_start (args, first_bytes);
-  while (bytes != NULL)
-    {
-      gsize len;
-      const guint8 *data = g_bytes_get_data (bytes, &len);
-      if (len > 0)
-        g_byte_array_append (byte_array, data, len);
-      g_bytes_unref (bytes);
-      bytes = va_arg (args, GBytes *);
-    }
-  va_end (args);
-
-  return g_byte_array_free_to_bytes (byte_array);
-}
-
 static void
 gsk_gl_driver_dispose (GObject *object)
 {
@@ -212,10 +235,6 @@ gsk_gl_driver_dispose (GObject *object)
   g_assert (self->in_frame == FALSE);
 
 #define GSK_GL_NO_UNIFORMS
-#define GSK_GL_SHADER_RESOURCE(name)
-#define GSK_GL_SHADER_STRING(str)
-#define GSK_GL_SHADER_SINGLE(name)
-#define GSK_GL_SHADER_JOINED(kind, ...)
 #define GSK_GL_ADD_UNIFORM(pos, KEY, name)
 #define GSK_GL_DEFINE_PROGRAM(name, resource, uniforms) \
   GSK_GL_DELETE_PROGRAM(name);                          \
@@ -229,10 +248,6 @@ gsk_gl_driver_dispose (GObject *object)
   } G_STMT_END;
 # include "gskglprograms.defs"
 #undef GSK_GL_NO_UNIFORMS
-#undef GSK_GL_SHADER_RESOURCE
-#undef GSK_GL_SHADER_STRING
-#undef GSK_GL_SHADER_SINGLE
-#undef GSK_GL_SHADER_JOINED
 #undef GSK_GL_ADD_UNIFORM
 #undef GSK_GL_DEFINE_PROGRAM
 
@@ -274,11 +289,11 @@ gsk_gl_driver_dispose (GObject *object)
   g_assert (!self->texture_id_to_key || g_hash_table_size (self->texture_id_to_key) == 0);
   g_assert (!self->key_to_texture_id|| g_hash_table_size (self->key_to_texture_id) == 0);
 
-  g_clear_object (&self->glyphs_library);
-  g_clear_object (&self->glyphy_library);
-  g_clear_object (&self->icons_library);
-  g_clear_object (&self->shadows_library);
+  g_clear_object (&self->glyphs);
+  g_clear_object (&self->icons);
+  g_clear_object (&self->shadows);
 
+  g_clear_pointer (&self->atlases, g_ptr_array_unref);
   g_clear_pointer (&self->autorelease_framebuffers, g_array_unref);
   g_clear_pointer (&self->key_to_texture_id, g_hash_table_unref);
   g_clear_pointer (&self->textures, g_hash_table_unref);
@@ -315,6 +330,7 @@ gsk_gl_driver_init (GskGLDriver *self)
   self->shader_cache = g_hash_table_new_full (NULL, NULL, NULL, remove_program);
   self->texture_pool = g_array_new (FALSE, FALSE, sizeof (guint));
   self->render_targets = g_ptr_array_new ();
+  self->atlases = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_gl_texture_atlas_free);
 }
 
 static gboolean
@@ -332,14 +348,14 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
 
   /* Setup preambles that are shared by all shaders */
   gsk_gl_compiler_set_preamble_from_resource (compiler,
-                                              GSK_GL_COMPILER_ALL,
-                                              "/org/gtk/libgsk/gl/preamble.glsl");
+                                               GSK_GL_COMPILER_ALL,
+                                               "/org/gtk/libgsk/gl/preamble.glsl");
   gsk_gl_compiler_set_preamble_from_resource (compiler,
-                                              GSK_GL_COMPILER_VERTEX,
-                                              "/org/gtk/libgsk/gl/preamble.vs.glsl");
+                                               GSK_GL_COMPILER_VERTEX,
+                                               "/org/gtk/libgsk/gl/preamble.vs.glsl");
   gsk_gl_compiler_set_preamble_from_resource (compiler,
-                                              GSK_GL_COMPILER_FRAGMENT,
-                                              "/org/gtk/libgsk/gl/preamble.fs.glsl");
+                                               GSK_GL_COMPILER_FRAGMENT,
+                                               "/org/gtk/libgsk/gl/preamble.fs.glsl");
 
   /* Setup attributes that are provided via VBO */
   gsk_gl_compiler_bind_attribute (compiler, "aPosition", 0);
@@ -349,28 +365,10 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
 
   /* Use XMacros to register all of our programs and their uniforms */
 #define GSK_GL_NO_UNIFORMS
-#define GSK_GL_SHADER_RESOURCE(name)                                                            \
-  g_bytes_ref(g_resources_lookup_data("/org/gtk/libgsk/gl/" name, 0, NULL))
-#define GSK_GL_SHADER_STRING(str)                                                               \
-  g_bytes_new_static(str, strlen(str))
-#define GSK_GL_SHADER_SINGLE(bytes)                                                             \
-  G_STMT_START {                                                                                \
-    GBytes *b = bytes;                                                                          \
-    gsk_gl_compiler_set_source (compiler, GSK_GL_COMPILER_ALL, b);                              \
-    g_bytes_unref (b);                                                                          \
-  } G_STMT_END;
-#define GSK_GL_SHADER_JOINED(kind, ...)                                                         \
-  G_STMT_START {                                                                                \
-    GBytes *bytes = join_sources(__VA_ARGS__);                                                  \
-    gsk_gl_compiler_set_source (compiler, GSK_GL_COMPILER_##kind, bytes);                       \
-    g_bytes_unref (bytes);                                                                      \
-  } G_STMT_END;
 #define GSK_GL_ADD_UNIFORM(pos, KEY, name)                                                      \
   gsk_gl_program_add_uniform (program, #name, UNIFORM_##KEY);
-#define GSK_GL_DEFINE_PROGRAM(name, sources, uniforms)                                          \
-  gsk_gl_compiler_set_source (compiler, GSK_GL_COMPILER_VERTEX, NULL);                          \
-  gsk_gl_compiler_set_source (compiler, GSK_GL_COMPILER_FRAGMENT, NULL);                        \
-  sources                                                                                       \
+#define GSK_GL_DEFINE_PROGRAM(name, resource, uniforms)                                         \
+  gsk_gl_compiler_set_source_from_resource (compiler, GSK_GL_COMPILER_ALL, resource);           \
   GSK_GL_COMPILE_PROGRAM(name ## _no_clip, uniforms, "#define NO_CLIP 1\n");                    \
   GSK_GL_COMPILE_PROGRAM(name ## _rect_clip, uniforms, "#define RECT_CLIP 1\n");                \
   GSK_GL_COMPILE_PROGRAM(name, uniforms, "");
@@ -403,11 +401,6 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
 #undef GSK_GL_DEFINE_PROGRAM_CLIP
 #undef GSK_GL_DEFINE_PROGRAM
 #undef GSK_GL_ADD_UNIFORM
-#undef GSK_GL_SHADER_SINGLE
-#undef GSK_GL_SHADER_JOINED
-#undef GSK_GL_SHADER_RESOURCE
-#undef GSK_GL_SHADER_STRING
-#undef GSK_GL_NO_UNIFORMS
 
   ret = TRUE;
 
@@ -463,10 +456,9 @@ gsk_gl_driver_new (GskGLCommandQueue  *command_queue,
       return NULL;
     }
 
-  self->glyphs_library = gsk_gl_glyph_library_new (self);
-  self->glyphy_library = gsk_gl_glyphy_library_new (self);
-  self->icons_library = gsk_gl_icon_library_new (self);
-  self->shadows_library = gsk_gl_shadow_library_new (self);
+  self->glyphs = gsk_gl_glyph_library_new (self);
+  self->icons = gsk_gl_icon_library_new (self);
+  self->shadows = gsk_gl_shadow_library_new (self);
 
   gdk_profiler_end_mark (before, "create GskGLDriver", NULL);
 
@@ -526,6 +518,37 @@ failure:
   return g_steal_pointer (&driver);
 }
 
+static GPtrArray *
+gsk_gl_driver_compact_atlases (GskGLDriver *self)
+{
+  GPtrArray *removed = NULL;
+
+  g_assert (GSK_IS_GL_DRIVER (self));
+
+  for (guint i = self->atlases->len; i > 0; i--)
+    {
+      GskGLTextureAtlas *atlas = g_ptr_array_index (self->atlases, i - 1);
+
+      if (gsk_gl_texture_atlas_get_unused_ratio (atlas) > MAX_OLD_RATIO)
+        {
+          GSK_NOTE (GLYPH_CACHE,
+                    g_message ("Dropping atlas %d (%g.2%% old)", i,
+                               100.0 * gsk_gl_texture_atlas_get_unused_ratio (atlas)));
+          if (removed == NULL)
+            removed = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_gl_texture_atlas_free);
+          g_ptr_array_add (removed, g_ptr_array_steal_index (self->atlases, i - 1));
+        }
+    }
+
+  GSK_NOTE (GLYPH_CACHE, {
+    static guint timestamp;
+    if (timestamp++ % 60 == 0)
+      g_message ("%d atlases", self->atlases->len);
+  });
+
+  return removed;
+}
+
 /**
  * gsk_gl_driver_begin_frame:
  * @self: a `GskGLDriver`
@@ -542,6 +565,7 @@ gsk_gl_driver_begin_frame (GskGLDriver       *self,
                            GskGLCommandQueue *command_queue)
 {
   gint64 last_frame_id;
+  GPtrArray *removed;
 
   g_return_if_fail (GSK_IS_GL_DRIVER (self));
   g_return_if_fail (GSK_IS_GL_COMMAND_QUEUE (command_queue));
@@ -556,16 +580,19 @@ gsk_gl_driver_begin_frame (GskGLDriver       *self,
 
   gsk_gl_command_queue_begin_frame (self->command_queue);
 
+  /* Compact atlases with too many freed pixels */
+  removed = gsk_gl_driver_compact_atlases (self);
+
   /* Mark unused pixel regions of the atlases */
-  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->icons_library),
-                                      self->current_frame_id);
-  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphs_library),
-                                      self->current_frame_id);
-  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphy_library),
-                                      self->current_frame_id);
+  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->icons),
+                                       self->current_frame_id,
+                                       removed);
+  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphs),
+                                       self->current_frame_id,
+                                       removed);
 
   /* Cleanup old shadows */
-  gsk_gl_shadow_library_begin_frame (self->shadows_library);
+  gsk_gl_shadow_library_begin_frame (self->shadows);
 
   /* Remove all textures that are from a previous frame or are no
    * longer used by linked GdkTexture. We do this at the beginning
@@ -573,6 +600,9 @@ gsk_gl_driver_begin_frame (GskGLDriver       *self,
    * we block on any resources while delivering our frames.
    */
   gsk_gl_driver_collect_unused_textures (self, last_frame_id - 1);
+
+  /* Now free atlas textures */
+  g_clear_pointer (&removed, g_ptr_array_unref);
 }
 
 /**
@@ -1152,23 +1182,14 @@ void
 gsk_gl_driver_save_atlases_to_png (GskGLDriver *self,
                                    const char  *directory)
 {
-  GPtrArray *atlases;
-
   g_return_if_fail (GSK_IS_GL_DRIVER (self));
 
   if (directory == NULL)
     directory = ".";
 
-#define copy_atlases(dst, library) \
-  g_ptr_array_extend(dst, GSK_GL_TEXTURE_LIBRARY(library)->atlases, NULL, NULL)
-  atlases = g_ptr_array_new ();
-  copy_atlases (atlases, self->glyphs_library);
-  copy_atlases (atlases, self->icons_library);
-#undef copy_atlases
-
-  for (guint i = 0; i < atlases->len; i++)
+  for (guint i = 0; i < self->atlases->len; i++)
     {
-      GskGLTextureAtlas *atlas = g_ptr_array_index (atlases, i);
+      GskGLTextureAtlas *atlas = g_ptr_array_index (self->atlases, i);
       char *filename = g_strdup_printf ("%s%sframe-%d-atlas-%d.png",
                                         directory,
                                         G_DIR_SEPARATOR_S,
@@ -1177,8 +1198,6 @@ gsk_gl_driver_save_atlases_to_png (GskGLDriver *self,
       write_atlas_to_png (self, atlas, filename);
       g_free (filename);
     }
-
-  g_ptr_array_unref (atlases);
 }
 #endif
 

gsk/gl/gskgldriverprivate.h

@@ -100,16 +100,17 @@ struct _GskGLDriver
   GskGLCommandQueue *shared_command_queue;
   GskGLCommandQueue *command_queue;
 
-  GskGLGlyphLibrary *glyphs_library;
-  GskGLGlyphyLibrary *glyphy_library;
-  GskGLIconLibrary *icons_library;
-  GskGLShadowLibrary *shadows_library;
+  GskGLGlyphLibrary *glyphs;
+  GskGLIconLibrary *icons;
+  GskGLShadowLibrary *shadows;
 
   GArray *texture_pool;
   GHashTable *textures;
   GHashTable *key_to_texture_id;
   GHashTable *texture_id_to_key;
 
+  GPtrArray *atlases;
+
   GHashTable *shader_cache;
 
   GArray *autorelease_framebuffers;
@@ -183,6 +184,7 @@ void                gsk_gl_driver_add_texture_slices     (GskGLDriver         *s
 GskGLProgram      * gsk_gl_driver_lookup_shader          (GskGLDriver         *self,
                                                           GskGLShader         *shader,
                                                           GError             **error);
+GskGLTextureAtlas * gsk_gl_driver_create_atlas           (GskGLDriver         *self);
 
 #ifdef G_ENABLE_DEBUG
 void                gsk_gl_driver_save_atlases_to_png    (GskGLDriver         *self,

gsk/gl/gskglglyphlibrary.c

@@ -84,64 +84,15 @@ gsk_gl_glyph_value_free (gpointer data)
 }
 
 static void
-gsk_gl_glyph_library_clear_cache (GskGLTextureLibrary *library)
+gsk_gl_glyph_library_begin_frame (GskGLTextureLibrary *library,
+                                  gint64               frame_id,
+                                  GPtrArray           *removed_atlases)
 {
   GskGLGlyphLibrary *self = (GskGLGlyphLibrary *)library;
 
-  g_assert (GSK_IS_GL_GLYPH_LIBRARY (self));
-
   memset (self->front, 0, sizeof self->front);
 }
 
-static void
-gsk_gl_glyph_library_init_atlas (GskGLTextureLibrary *self,
-                                 GskGLTextureAtlas   *atlas)
-{
-  gboolean packed G_GNUC_UNUSED;
-  int x, y;
-  guint gl_format;
-  guint gl_type;
-  guint8 pixel_data[4 * 3 * 3];
-
-  g_assert (GSK_IS_GL_GLYPH_LIBRARY (self));
-  g_assert (atlas != NULL);
-
-  /* Insert a single pixel at 0,0 for use in coloring */
-
-  gdk_gl_context_push_debug_group_printf (gdk_gl_context_get_current (),
-                                          "Initializing Atlas");
-
-  packed = gsk_gl_texture_library_allocate (self, atlas, 3, 3, &x, &y);
-  g_assert (packed);
-  g_assert (x == 0 && y == 0);
-
-  memset (pixel_data, 255, sizeof pixel_data);
-
-  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
-    {
-      gl_format = GL_RGBA;
-      gl_type = GL_UNSIGNED_BYTE;
-    }
-  else
-    {
-      gl_format = GL_BGRA;
-      gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
-    }
-
-  glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
-
-  glTexSubImage2D (GL_TEXTURE_2D, 0,
-                   0, 0,
-                   3, 3,
-                   gl_format, gl_type,
-                   pixel_data);
-
-  gdk_gl_context_pop_debug_group (gdk_gl_context_get_current ());
-
-  self->driver->command_queue->n_uploads++;
-}
-
-
 static void
 gsk_gl_glyph_library_finalize (GObject *object)
 {
@@ -160,8 +111,7 @@ gsk_gl_glyph_library_class_init (GskGLGlyphLibraryClass *klass)
 
   object_class->finalize = gsk_gl_glyph_library_finalize;
 
-  library_class->clear_cache = gsk_gl_glyph_library_clear_cache;
-  library_class->init_atlas = gsk_gl_glyph_library_init_atlas;
+  library_class->begin_frame = gsk_gl_glyph_library_begin_frame;
 }
 
 static void

gsk/gl/gskglglyphylibrary.c

@@ -1,523 +0,0 @@
-/* gskglglyphylibrary.c
- *
- * Copyright 2020 Christian Hergert <chergert@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-/* Some of the glyphy cache is based upon the original glyphy code.
- * It's license is provided below.
- */
-/*
- * Copyright 2012 Google, Inc. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Google Author(s): Behdad Esfahbod
- */
-
-#include "config.h"
-
-#include <gdk/gdkglcontextprivate.h>
-#include <gdk/gdkmemoryformatprivate.h>
-#include <gdk/gdkprofilerprivate.h>
-
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglglyphylibraryprivate.h"
-
-#include "gskpath.h"
-
-#include <glyphy.h>
-
-#define TOLERANCE (1/2048.)
-#define MIN_FONT_SIZE 14
-#define GRID_SIZE 20 /* Per EM */
-#define ENLIGHTEN_MAX .01 /* Per EM */
-#define EMBOLDEN_MAX .024 /* Per EM */
-#define ITEM_W 64
-#define ITEM_H_QUANTUM 8
-
-G_DEFINE_TYPE (GskGLGlyphyLibrary, gsk_gl_glyphy_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
-
-GskGLGlyphyLibrary *
-gsk_gl_glyphy_library_new (GskGLDriver *driver)
-{
-  g_return_val_if_fail (GSK_IS_GL_DRIVER (driver), NULL);
-
-  return g_object_new (GSK_TYPE_GL_GLYPHY_LIBRARY,
-                       "driver", driver,
-                       NULL);
-}
-
-static guint
-gsk_gl_glyphy_key_hash (gconstpointer data)
-{
-  const GskGLGlyphyKey *key = data;
-
-  /* malloc()'d pointers already guarantee 3 bits from the LSB on 64-bit and
-   * 2 bits from the LSB on 32-bit. Shift by enough to give us 256 entries
-   * in our front cache for the glyph since languages will naturally cluster
-   * for us.
-   */
-
-  return (key->font << 8) ^ key->glyph;
-}
-
-static gboolean
-gsk_gl_glyphy_key_equal (gconstpointer v1,
-                         gconstpointer v2)
-{
-  return memcmp (v1, v2, sizeof (GskGLGlyphyKey)) == 0;
-}
-
-static void
-gsk_gl_glyphy_key_free (gpointer data)
-{
-  GskGLGlyphyKey *key = data;
-
-  g_slice_free (GskGLGlyphyKey, key);
-}
-
-static void
-gsk_gl_glyphy_value_free (gpointer data)
-{
-  g_slice_free (GskGLGlyphyValue, data);
-}
-
-static void
-gsk_gl_glyphy_library_clear_cache (GskGLTextureLibrary *library)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)library;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-
-  memset (self->front, 0, sizeof self->front);
-}
-
-static void
-gsk_gl_glyphy_library_init_atlas (GskGLTextureLibrary *library,
-                                  GskGLTextureAtlas   *atlas)
-{
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (library));
-  g_assert (atlas != NULL);
-
-  atlas->cursor_x = 0;
-  atlas->cursor_y = 0;
-}
-
-static gboolean
-gsk_gl_glyphy_library_allocate (GskGLTextureLibrary *library,
-                                GskGLTextureAtlas   *atlas,
-                                int                  width,
-                                int                  height,
-                                int                 *out_x,
-                                int                 *out_y)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)library;
-  int cursor_save_x;
-  int cursor_save_y;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-  g_assert (atlas != NULL);
-
-  cursor_save_x = atlas->cursor_x;
-  cursor_save_y = atlas->cursor_y;
-
-  if ((height & (self->item_h_q-1)) != 0)
-    height = (height + self->item_h_q - 1) & ~(self->item_h_q - 1);
-
-  /* Require allocations in columns of 64 and rows of 8 */
-  g_assert (width == self->item_w);
-  g_assert ((height % self->item_h_q) == 0);
-
-  if (atlas->cursor_y + height > atlas->height)
-    {
-      /* Go to next column */
-      atlas->cursor_x += self->item_w;
-      atlas->cursor_y = 0;
-    }
-
-  if (atlas->cursor_x + width <= atlas->width &&
-      atlas->cursor_y + height <= atlas->height)
-    {
-      *out_x = atlas->cursor_x;
-      *out_y = atlas->cursor_y;
-      atlas->cursor_y += height;
-      return TRUE;
-    }
-
-  atlas->cursor_x = cursor_save_x;
-  atlas->cursor_y = cursor_save_y;
-
-  return FALSE;
-}
-
-static void
-gsk_gl_glyphy_library_finalize (GObject *object)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)object;
-
-  g_clear_pointer (&self->acc, glyphy_arc_accumulator_destroy);
-  g_clear_pointer (&self->acc_endpoints, g_array_unref);
-
-  G_OBJECT_CLASS (gsk_gl_glyphy_library_parent_class)->finalize (object);
-}
-
-GQuark quark_glyphy_font_key;
-
-static void
-gsk_gl_glyphy_library_class_init (GskGLGlyphyLibraryClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GskGLTextureLibraryClass *library_class = GSK_GL_TEXTURE_LIBRARY_CLASS (klass);
-
-  quark_glyphy_font_key = g_quark_from_static_string ("glyphy-font-key");
-
-  object_class->finalize = gsk_gl_glyphy_library_finalize;
-
-  library_class->allocate = gsk_gl_glyphy_library_allocate;
-  library_class->clear_cache = gsk_gl_glyphy_library_clear_cache;
-  library_class->init_atlas = gsk_gl_glyphy_library_init_atlas;
-}
-
-static void
-gsk_gl_glyphy_library_init (GskGLGlyphyLibrary *self)
-{
-  GskGLTextureLibrary *tl = (GskGLTextureLibrary *)self;
-
-  tl->max_entry_size = 0;
-  tl->max_frame_age = 512;
-  tl->atlas_width = 2048;
-  tl->atlas_height = 1024;
-  gsk_gl_texture_library_set_funcs (tl,
-                                    gsk_gl_glyphy_key_hash,
-                                    gsk_gl_glyphy_key_equal,
-                                    gsk_gl_glyphy_key_free,
-                                    gsk_gl_glyphy_value_free);
-
-  self->acc = glyphy_arc_accumulator_create ();
-  self->acc_endpoints = g_array_new (FALSE, FALSE, sizeof (glyphy_arc_endpoint_t));
-  self->item_w = ITEM_W;
-  self->item_h_q = ITEM_H_QUANTUM;
-}
-
-static glyphy_bool_t
-accumulate_endpoint (glyphy_arc_endpoint_t *endpoint,
-                     GArray                *endpoints)
-{
-  g_array_append_vals (endpoints, endpoint, 1);
-  return TRUE;
-}
-
-static void
-move_to (hb_draw_funcs_t *dfuncs,
-         GskPathBuilder  *builder,
-         hb_draw_state_t *st,
-         float            x,
-         float            y,
-         void            *data)
-{
-  gsk_path_builder_move_to (builder, x, y);
-}
-
-static void
-line_to (hb_draw_funcs_t *dfuncs,
-         GskPathBuilder  *builder,
-         hb_draw_state_t *st,
-         float            x,
-         float            y,
-         void            *data)
-{
-  gsk_path_builder_line_to (builder, x, y);
-}
-
-static void
-cubic_to (hb_draw_funcs_t *dfuncs,
-          GskPathBuilder  *builder,
-          hb_draw_state_t *st,
-          float            x1,
-          float            y1,
-          float            x2,
-          float            y2,
-          float            x3,
-          float            y3,
-          void            *data)
-{
-  gsk_path_builder_curve_to (builder, x1, y1, x2, y2, x3, y3);
-}
-
-static void
-close_path (hb_draw_funcs_t *dfuncs,
-            GskPathBuilder  *builder,
-            hb_draw_state_t *st,
-            void            *data)
-{
-  gsk_path_builder_close (builder);
-}
-
-static hb_draw_funcs_t *
-gsk_path_get_draw_funcs (void)
-{
-  static hb_draw_funcs_t *funcs = NULL;
-
-  if (!funcs)
-    {
-      funcs = hb_draw_funcs_create ();
-
-      hb_draw_funcs_set_move_to_func (funcs, (hb_draw_move_to_func_t) move_to, NULL, NULL);
-      hb_draw_funcs_set_line_to_func (funcs, (hb_draw_line_to_func_t) line_to, NULL, NULL);
-      hb_draw_funcs_set_cubic_to_func (funcs, (hb_draw_cubic_to_func_t) cubic_to, NULL, NULL);
-      hb_draw_funcs_set_close_path_func (funcs, (hb_draw_close_path_func_t) close_path, NULL, NULL);
-
-      hb_draw_funcs_make_immutable (funcs);
-    }
-
-  return funcs;
-}
-
-static gboolean
-acc_callback (GskPathOperation        op,
-              const graphene_point_t *pts,
-              gsize                   n_pts,
-              float                   weight,
-              gpointer                user_data)
-{
-  glyphy_arc_accumulator_t *acc = user_data;
-  glyphy_point_t p0, p1, p2, p3;
-
-  switch (op)
-    {
-    case GSK_PATH_MOVE:
-      p0.x = pts[0].x; p0.y = pts[0].y;
-      glyphy_arc_accumulator_move_to (acc, &p0);
-      break;
-    case GSK_PATH_CLOSE:
-      glyphy_arc_accumulator_close_path (acc);
-      break;
-    case GSK_PATH_LINE:
-      p1.x = pts[1].x; p1.y = pts[1].y;
-      glyphy_arc_accumulator_line_to (acc, &p1);
-      break;
-    case GSK_PATH_CURVE:
-      p1.x = pts[1].x; p1.y = pts[1].y;
-      p2.x = pts[2].x; p2.y = pts[2].y;
-      p3.x = pts[3].x; p3.y = pts[3].y;
-      glyphy_arc_accumulator_cubic_to (acc, &p1, &p2, &p3);
-      break;
-    case GSK_PATH_CONIC:
-    default:
-      g_assert_not_reached ();
-    }
-
-  return TRUE;
-}
-
-static inline gboolean
-encode_glyph (GskGLGlyphyLibrary *self,
-              hb_font_t          *font,
-              unsigned int        glyph_index,
-              double              tolerance_per_em,
-              glyphy_rgba_t      *buffer,
-              guint               buffer_len,
-              guint              *output_len,
-              guint              *nominal_width,
-              guint              *nominal_height,
-              glyphy_extents_t   *extents)
-{
-  hb_face_t *face = hb_font_get_face (font);
-  guint upem = hb_face_get_upem (face);
-  double tolerance = upem * tolerance_per_em;
-  double faraway = (double)upem / (MIN_FONT_SIZE * M_SQRT2);
-  double unit_size = (double) upem / GRID_SIZE;
-  double enlighten_max = (double) upem * ENLIGHTEN_MAX;
-  double embolden_max = (double) upem * EMBOLDEN_MAX;
-  double avg_fetch_achieved;
-  GskPathBuilder *builder;
-  GskPath *path, *simplified;
-
-  self->acc_endpoints->len = 0;
-
-  glyphy_arc_accumulator_reset (self->acc);
-  glyphy_arc_accumulator_set_tolerance (self->acc, tolerance);
-  glyphy_arc_accumulator_set_callback (self->acc,
-                                       (glyphy_arc_endpoint_accumulator_callback_t)accumulate_endpoint,
-                                       self->acc_endpoints);
-
-  builder = gsk_path_builder_new ();
-  hb_font_get_glyph_shape (font, glyph_index, gsk_path_get_draw_funcs (), builder);
-  path = gsk_path_builder_free_to_path (builder);
-  simplified = gsk_path_simplify (path);
-
-  gsk_path_foreach (simplified, GSK_PATH_FOREACH_ALLOW_CURVE, acc_callback, self->acc);
-  gsk_path_unref (simplified);
-  gsk_path_unref (path);
-
-  if (!glyphy_arc_accumulator_successful (self->acc))
-    return FALSE;
-
-  g_assert (glyphy_arc_accumulator_get_error (self->acc) <= tolerance);
-
-  if (self->acc_endpoints->len > 0)
-    glyphy_outline_winding_from_even_odd ((gpointer)self->acc_endpoints->data,
-                                          self->acc_endpoints->len,
-                                          FALSE);
-
-  if (!glyphy_arc_list_encode_blob2 ((gpointer)self->acc_endpoints->data,
-                                     self->acc_endpoints->len,
-                                     buffer,
-                                     buffer_len,
-                                     faraway,
-                                     unit_size,
-                                     enlighten_max,
-                                     embolden_max,
-                                     &avg_fetch_achieved,
-                                     output_len,
-                                     nominal_width,
-                                     nominal_height,
-                                     extents))
-    return FALSE;
-
-  glyphy_extents_scale (extents, 1./upem, 1./upem);
-
-  return TRUE;
-}
-
-static inline hb_font_t *
-get_nominal_size_hb_font (PangoFont *font)
-{
-  hb_font_t *hbfont;
-  const float *coords;
-  unsigned int length;
-
-  hbfont = (hb_font_t *) g_object_get_data ((GObject *)font, "glyph-nominal-size-font");
-  if (hbfont == NULL)
-    {
-      hbfont = hb_font_create (hb_font_get_face (pango_font_get_hb_font (font)));
-      coords = hb_font_get_var_coords_design (pango_font_get_hb_font (font), &length);
-      if (length > 0)
-        hb_font_set_var_coords_design (hbfont, coords, length);
-
-      g_object_set_data_full ((GObject *)font, "glyphy-nominal-size-font",
-                              hbfont, (GDestroyNotify)hb_font_destroy);
-    }
-
-  return hbfont;
-}
-
-gboolean
-gsk_gl_glyphy_library_add (GskGLGlyphyLibrary      *self,
-                           GskGLGlyphyKey          *key,
-                           PangoFont               *font,
-                           const GskGLGlyphyValue **out_value)
-{
-  static glyphy_rgba_t buffer[4096 * 16];
-  GskGLTextureLibrary *tl = (GskGLTextureLibrary *)self;
-  GskGLGlyphyValue *value;
-  glyphy_extents_t extents;
-  hb_font_t *hbfont;
-  guint packed_x;
-  guint packed_y;
-  guint nominal_w, nominal_h;
-  guint output_len = 0;
-  guint texture_id;
-  guint width, height;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-  g_assert (key != NULL);
-  g_assert (font != NULL);
-  g_assert (out_value != NULL);
-
-  hbfont = get_nominal_size_hb_font (font);
-
-  /* Convert the glyph to a list of arcs */
-  if (!encode_glyph (self, hbfont, key->glyph, TOLERANCE,
-                     buffer, sizeof buffer, &output_len,
-                     &nominal_w, &nominal_h, &extents))
-    return FALSE;
-
-  /* Allocate space for list within atlas */
-  width = self->item_w;
-  height = (output_len + width - 1) / width;
-  value = gsk_gl_texture_library_pack (tl, key, sizeof *value,
-                                       width, height, 0,
-                                       &packed_x, &packed_y);
-
-  g_assert (packed_x % ITEM_W == 0);
-  g_assert (packed_y % ITEM_H_QUANTUM == 0);
-
-  /* Make sure we found space to pack */
-  texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (value);
-  if (texture_id == 0)
-    return FALSE;
-
-  if (!glyphy_extents_is_empty (&extents))
-    {
-      /* Connect the texture for data upload */
-      glActiveTexture (GL_TEXTURE0);
-      glBindTexture (GL_TEXTURE_2D, texture_id);
-
-      g_assert (width > 0);
-      g_assert (height > 0);
-
-      /* Upload the arc list */
-      if (width * height == output_len)
-        {
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y,
-                           width, height,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer);
-        }
-      else
-        {
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y,
-                           width, height - 1,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer);
-          /* Upload the last row separately */
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y + height - 1,
-                           output_len - (width * (height - 1)), 1,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer + (width * (height - 1)));
-        }
-    }
-
-  value->extents.min_x = extents.min_x;
-  value->extents.min_y = extents.min_y;
-  value->extents.max_x = extents.max_x;
-  value->extents.max_y = extents.max_y;
-  value->nominal_w = nominal_w;
-  value->nominal_h = nominal_h;
-  value->atlas_x = packed_x / self->item_w;
-  value->atlas_y = packed_y / self->item_h_q;
-
-  *out_value = value;
-
-  return TRUE;
-}

gsk/gl/gskglglyphylibraryprivate.h

@@ -1,142 +0,0 @@
-/* gskglglyphylibraryprivate.h
- *
- * Copyright 2020-2022 Christian Hergert <chergert@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.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 program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__
-#define __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__
-
-#include <glyphy.h>
-#include <pango/pango.h>
-
-#include "gskgltexturelibraryprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_GL_GLYPHY_LIBRARY (gsk_gl_glyphy_library_get_type())
-
-typedef guint FontKey;
-
-extern GQuark quark_glyphy_font_key;
-
-static inline FontKey
-gsk_gl_glyphy_library_get_font_key (PangoFont *font)
-{
-  FontKey key;
-
-  key = (FontKey) GPOINTER_TO_UINT (g_object_get_qdata ((GObject *)font, quark_glyphy_font_key));
-  if (key == 0)
-    {
-      PangoFontDescription *desc = pango_font_describe (font);
-      pango_font_description_set_size (desc, 10 * PANGO_SCALE);
-      key = (FontKey) pango_font_description_hash (desc);
-      pango_font_description_free (desc);
-      g_object_set_qdata ((GObject *)font, quark_glyphy_font_key, GUINT_TO_POINTER (key));
-    }
-
-  return key;
-}
-
-static inline float
-gsk_gl_glyphy_library_get_font_scale (PangoFont *font)
-{
-  hb_font_t *hbfont;
-  int x_scale, y_scale;
-
-  hbfont = pango_font_get_hb_font (font);
-  hb_font_get_scale (hbfont, &x_scale, &y_scale);
-
-  return MAX (x_scale, y_scale) / 1000.0;
-}
-
-
-typedef struct _GskGLGlyphyKey
-{
-  FontKey font;
-  PangoGlyph glyph;
-} GskGLGlyphyKey;
-
-typedef struct _GskGLGlyphyValue
-{
-  GskGLTextureAtlasEntry entry;
-  struct {
-    float min_x;
-    float min_y;
-    float max_x;
-    float max_y;
-  } extents;
-  guint nominal_w;
-  guint nominal_h;
-  guint atlas_x;
-  guint atlas_y;
-} GskGLGlyphyValue;
-
-G_DECLARE_FINAL_TYPE (GskGLGlyphyLibrary, gsk_gl_glyphy_library, GSK, GL_GLYPHY_LIBRARY, GskGLTextureLibrary)
-
-struct _GskGLGlyphyLibrary
-{
-  GskGLTextureLibrary parent_instance;
-  glyphy_arc_accumulator_t *acc;
-  GArray *acc_endpoints;
-  guint item_w;
-  guint item_h_q;
-  struct {
-    GskGLGlyphyKey key;
-    const GskGLGlyphyValue *value;
-  } front[256];
-};
-
-GskGLGlyphyLibrary *gsk_gl_glyphy_library_new (GskGLDriver             *driver);
-gboolean            gsk_gl_glyphy_library_add (GskGLGlyphyLibrary      *self,
-                                               GskGLGlyphyKey          *key,
-                                               PangoFont               *font,
-                                               const GskGLGlyphyValue **out_value);
-
-static inline guint
-gsk_gl_glyphy_library_lookup_or_add (GskGLGlyphyLibrary      *self,
-                                     const GskGLGlyphyKey    *key,
-                                     PangoFont               *font,
-                                     const GskGLGlyphyValue **out_value)
-{
-  GskGLTextureAtlasEntry *entry;
-  guint front_index = key->glyph & 0xFF;
-
-  if (memcmp (key, &self->front[front_index], sizeof *key) == 0)
-    {
-      *out_value = self->front[front_index].value;
-    }
-  else if (gsk_gl_texture_library_lookup ((GskGLTextureLibrary *)self, key, &entry))
-    {
-      *out_value = (GskGLGlyphyValue *)entry;
-      self->front[front_index].key = *key;
-      self->front[front_index].value = *out_value;
-    }
-  else
-    {
-      GskGLGlyphyKey *k = g_slice_copy (sizeof *key, key);
-      gsk_gl_glyphy_library_add (self, k, font, out_value);
-      self->front[front_index].key = *key;
-      self->front[front_index].value = *out_value;
-    }
-
-  return GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (*out_value);
-}
-
-G_END_DECLS
-
-#endif /* __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__ */

gsk/gl/gskglprograms.defs

@@ -1,71 +1,71 @@
 GSK_GL_DEFINE_PROGRAM (blend,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("blend.glsl")),
+                       "/org/gtk/libgsk/gl/blend.glsl",
                        GSK_GL_ADD_UNIFORM (1, BLEND_SOURCE2, u_source2)
                        GSK_GL_ADD_UNIFORM (2, BLEND_MODE, u_mode))
 
 GSK_GL_DEFINE_PROGRAM (blit,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("blit.glsl")),
+                       "/org/gtk/libgsk/gl/blit.glsl",
                        GSK_GL_NO_UNIFORMS)
 
 GSK_GL_DEFINE_PROGRAM (blur,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("blur.glsl")),
+                       "/org/gtk/libgsk/gl/blur.glsl",
                        GSK_GL_ADD_UNIFORM (1, BLUR_RADIUS, u_blur_radius)
                        GSK_GL_ADD_UNIFORM (2, BLUR_SIZE, u_blur_size)
                        GSK_GL_ADD_UNIFORM (3, BLUR_DIR, u_blur_dir))
 
 GSK_GL_DEFINE_PROGRAM (border,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("border.glsl")),
+                       "/org/gtk/libgsk/gl/border.glsl",
                        GSK_GL_ADD_UNIFORM (1, BORDER_WIDTHS, u_widths)
                        GSK_GL_ADD_UNIFORM (2, BORDER_OUTLINE_RECT, u_outline_rect))
 
 GSK_GL_DEFINE_PROGRAM (color,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("color.glsl")),
+                       "/org/gtk/libgsk/gl/color.glsl",
                        GSK_GL_NO_UNIFORMS)
 
 GSK_GL_DEFINE_PROGRAM (coloring,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("coloring.glsl")),
+                       "/org/gtk/libgsk/gl/coloring.glsl",
                        GSK_GL_NO_UNIFORMS)
 
 GSK_GL_DEFINE_PROGRAM (color_matrix,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("color_matrix.glsl")),
+                       "/org/gtk/libgsk/gl/color_matrix.glsl",
                        GSK_GL_ADD_UNIFORM (1, COLOR_MATRIX_COLOR_MATRIX, u_color_matrix)
                        GSK_GL_ADD_UNIFORM (2, COLOR_MATRIX_COLOR_OFFSET, u_color_offset))
 
 GSK_GL_DEFINE_PROGRAM (conic_gradient,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("conic_gradient.glsl")),
+                       "/org/gtk/libgsk/gl/conic_gradient.glsl",
                        GSK_GL_ADD_UNIFORM (1, CONIC_GRADIENT_COLOR_STOPS, u_color_stops)
                        GSK_GL_ADD_UNIFORM (2, CONIC_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
                        GSK_GL_ADD_UNIFORM (3, CONIC_GRADIENT_GEOMETRY, u_geometry))
 
 GSK_GL_DEFINE_PROGRAM (cross_fade,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("cross_fade.glsl")),
+                       "/org/gtk/libgsk/gl/cross_fade.glsl",
                        GSK_GL_ADD_UNIFORM (1, CROSS_FADE_PROGRESS, u_progress)
                        GSK_GL_ADD_UNIFORM (2, CROSS_FADE_SOURCE2, u_source2))
 
 GSK_GL_DEFINE_PROGRAM (filled_border,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("filled_border.glsl")),
+                       "/org/gtk/libgsk/gl/filled_border.glsl",
                        GSK_GL_ADD_UNIFORM (1, FILLED_BORDER_WIDTHS, u_widths)
                        GSK_GL_ADD_UNIFORM (2, FILLED_BORDER_OUTLINE_RECT, u_outline_rect))
 
 GSK_GL_DEFINE_PROGRAM (inset_shadow,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("inset_shadow.glsl")),
+                       "/org/gtk/libgsk/gl/inset_shadow.glsl",
                        GSK_GL_ADD_UNIFORM (1, INSET_SHADOW_SPREAD, u_spread)
                        GSK_GL_ADD_UNIFORM (2, INSET_SHADOW_OFFSET, u_offset)
                        GSK_GL_ADD_UNIFORM (3, INSET_SHADOW_OUTLINE_RECT, u_outline_rect))
 
 GSK_GL_DEFINE_PROGRAM (linear_gradient,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("linear_gradient.glsl")),
+                       "/org/gtk/libgsk/gl/linear_gradient.glsl",
                        GSK_GL_ADD_UNIFORM (1, LINEAR_GRADIENT_COLOR_STOPS, u_color_stops)
                        GSK_GL_ADD_UNIFORM (2, LINEAR_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
                        GSK_GL_ADD_UNIFORM (3, LINEAR_GRADIENT_POINTS, u_points)
                        GSK_GL_ADD_UNIFORM (4, LINEAR_GRADIENT_REPEAT, u_repeat))
 
 GSK_GL_DEFINE_PROGRAM (outset_shadow,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("outset_shadow.glsl")),
+                       "/org/gtk/libgsk/gl/outset_shadow.glsl",
                        GSK_GL_ADD_UNIFORM (1, OUTSET_SHADOW_OUTLINE_RECT, u_outline_rect))
 
 GSK_GL_DEFINE_PROGRAM (radial_gradient,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("radial_gradient.glsl")),
+                       "/org/gtk/libgsk/gl/radial_gradient.glsl",
                        GSK_GL_ADD_UNIFORM (1, RADIAL_GRADIENT_COLOR_STOPS, u_color_stops)
                        GSK_GL_ADD_UNIFORM (2, RADIAL_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
                        GSK_GL_ADD_UNIFORM (3, RADIAL_GRADIENT_REPEAT, u_repeat)
@@ -73,30 +73,12 @@ GSK_GL_DEFINE_PROGRAM (radial_gradient,
                        GSK_GL_ADD_UNIFORM (5, RADIAL_GRADIENT_GEOMETRY, u_geometry))
 
 GSK_GL_DEFINE_PROGRAM (repeat,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("repeat.glsl")),
+                       "/org/gtk/libgsk/gl/repeat.glsl",
                        GSK_GL_ADD_UNIFORM (1, REPEAT_CHILD_BOUNDS, u_child_bounds)
                        GSK_GL_ADD_UNIFORM (2, REPEAT_TEXTURE_RECT, u_texture_rect))
 
 GSK_GL_DEFINE_PROGRAM (unblurred_outset_shadow,
-                       GSK_GL_SHADER_SINGLE (GSK_GL_SHADER_RESOURCE ("unblurred_outset_shadow.glsl")),
+                       "/org/gtk/libgsk/gl/unblurred_outset_shadow.glsl",
                        GSK_GL_ADD_UNIFORM (1, UNBLURRED_OUTSET_SHADOW_SPREAD, u_spread)
                        GSK_GL_ADD_UNIFORM (2, UNBLURRED_OUTSET_SHADOW_OFFSET, u_offset)
                        GSK_GL_ADD_UNIFORM (3, UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, u_outline_rect))
-
-GSK_GL_DEFINE_PROGRAM (glyphy,
-                       GSK_GL_SHADER_JOINED (VERTEX,
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.vs.glsl"),
-                                             NULL)
-                       GSK_GL_SHADER_JOINED (FRAGMENT,
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.atlas.glsl"),
-                                             GSK_GL_SHADER_STRING (glyphy_common_shader_source ()),
-                                             GSK_GL_SHADER_STRING ("#define GLYPHY_SDF_PSEUDO_DISTANCE 1\n"),
-                                             GSK_GL_SHADER_STRING (glyphy_sdf_shader_source ()),
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.fs.glsl"),
-                                             NULL),
-                       GSK_GL_ADD_UNIFORM (0, GLYPHY_CONTRAST, u_contrast)
-                       GSK_GL_ADD_UNIFORM (1, GLYPHY_GAMMA_ADJUST, u_gamma_adjust)
-                       GSK_GL_ADD_UNIFORM (2, GLYPHY_OUTLINE_THICKNESS, u_outline_thickness)
-                       GSK_GL_ADD_UNIFORM (3, GLYPHY_OUTLINE, u_outline)
-                       GSK_GL_ADD_UNIFORM (4, GLYPHY_BOLDNESS, u_boldness)
-                       GSK_GL_ADD_UNIFORM (6, GLYPHY_ATLAS_INFO, u_atlas_info))

gsk/gl/gskglrenderjob.c

@@ -33,12 +33,10 @@
 #include <gsk/gskroundedrectprivate.h>
 #include <math.h>
 #include <string.h>
-#include <pango/pangofc-font.h>
 
 #include "gskglcommandqueueprivate.h"
 #include "gskgldriverprivate.h"
 #include "gskglglyphlibraryprivate.h"
-#include "gskglglyphylibraryprivate.h"
 #include "gskgliconlibraryprivate.h"
 #include "gskglprogramprivate.h"
 #include "gskglrenderjobprivate.h"
@@ -247,6 +245,47 @@ gsk_rounded_rect_shrink_to_minimum (GskRoundedRect *self)
                                   self->corner[1].height + self->corner[2].height);
 }
 
+static inline gboolean G_GNUC_PURE
+node_supports_2d_transform (const GskRenderNode *node)
+{
+  switch ((int)gsk_render_node_get_node_type (node))
+    {
+    case GSK_COLOR_NODE:
+    case GSK_OPACITY_NODE:
+    case GSK_COLOR_MATRIX_NODE:
+    case GSK_TEXTURE_NODE:
+    case GSK_CROSS_FADE_NODE:
+    case GSK_LINEAR_GRADIENT_NODE:
+    case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+    case GSK_CONIC_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+    case GSK_DEBUG_NODE:
+    case GSK_TEXT_NODE:
+    case GSK_CAIRO_NODE:
+    case GSK_BLEND_NODE:
+    case GSK_BLUR_NODE:
+      return TRUE;
+
+    case GSK_SHADOW_NODE:
+      return node_supports_2d_transform (gsk_shadow_node_get_child (node));
+
+    case GSK_TRANSFORM_NODE:
+      return node_supports_2d_transform (gsk_transform_node_get_child (node));
+
+    case GSK_CONTAINER_NODE:
+      for (guint i = 0, p = gsk_container_node_get_n_children (node); i < p; i++)
+        {
+          if (!node_supports_2d_transform (gsk_container_node_get_child (node, i)))
+            return FALSE;
+        }
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
 static inline gboolean G_GNUC_PURE
 node_supports_transform (const GskRenderNode *node)
 {
@@ -259,24 +298,26 @@ node_supports_transform (const GskRenderNode *node)
 
   switch ((int)gsk_render_node_get_node_type (node))
     {
-      case GSK_COLOR_NODE:
-      case GSK_OPACITY_NODE:
-      case GSK_COLOR_MATRIX_NODE:
-      case GSK_TEXTURE_NODE:
-      case GSK_CROSS_FADE_NODE:
-      case GSK_LINEAR_GRADIENT_NODE:
-      case GSK_DEBUG_NODE:
-      case GSK_TEXT_NODE:
-        return TRUE;
+    case GSK_COLOR_NODE:
+    case GSK_OPACITY_NODE:
+    case GSK_COLOR_MATRIX_NODE:
+    case GSK_TEXTURE_NODE:
+    case GSK_CROSS_FADE_NODE:
+    case GSK_DEBUG_NODE:
+    case GSK_TEXT_NODE:
+    case GSK_CAIRO_NODE:
+    case GSK_BLEND_NODE:
+    case GSK_BLUR_NODE:
+      return TRUE;
 
-      case GSK_SHADOW_NODE:
-        return node_supports_transform (gsk_shadow_node_get_child (node));
+    case GSK_SHADOW_NODE:
+      return node_supports_transform (gsk_shadow_node_get_child (node));
 
-      case GSK_TRANSFORM_NODE:
-        return node_supports_transform (gsk_transform_node_get_child (node));
+    case GSK_TRANSFORM_NODE:
+      return node_supports_transform (gsk_transform_node_get_child (node));
 
-      default:
-        return FALSE;
+    default:
+      return FALSE;
     }
 }
 
@@ -2019,6 +2060,14 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob      *job,
     break;
 
     case GSK_TRANSFORM_CATEGORY_2D:
+      if (node_supports_2d_transform (child))
+        {
+          gsk_gl_render_job_push_modelview (job, transform);
+          gsk_gl_render_job_visit_node (job, child);
+          gsk_gl_render_job_pop_modelview (job);
+          return;
+        }
+      G_GNUC_FALLTHROUGH;
     case GSK_TRANSFORM_CATEGORY_3D:
     case GSK_TRANSFORM_CATEGORY_ANY:
     case GSK_TRANSFORM_CATEGORY_UNKNOWN:
@@ -2457,9 +2506,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
       scaled_outline.corner[i].height *= scale_y;
     }
 
-  cached_tid = gsk_gl_shadow_library_lookup (job->driver->shadows_library,
-                                             &scaled_outline,
-                                             blur_radius);
+  cached_tid = gsk_gl_shadow_library_lookup (job->driver->shadows, &scaled_outline, blur_radius);
 
   if (cached_tid == 0)
     {
@@ -2521,7 +2568,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
                                            blur_radius * scale_x,
                                            blur_radius * scale_y);
 
-      gsk_gl_shadow_library_insert (job->driver->shadows_library,
+      gsk_gl_shadow_library_insert (job->driver->shadows,
                                     &scaled_outline,
                                     blur_radius,
                                     blurred_texture_id);
@@ -2931,10 +2978,10 @@ compute_phase_and_pos (float value, float *pos)
 }
 
 static inline void
-gsk_gl_render_job_visit_text_node_legacy (GskGLRenderJob      *job,
-                                          const GskRenderNode *node,
-                                          const GdkRGBA       *color,
-                                          gboolean             force_color)
+gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
+                                   const GskRenderNode *node,
+                                   const GdkRGBA       *color,
+                                   gboolean             force_color)
 {
   const PangoFont *font = gsk_text_node_get_font (node);
   const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
@@ -2943,7 +2990,7 @@ gsk_gl_render_job_visit_text_node_legacy (GskGLRenderJob      *job,
   guint num_glyphs = gsk_text_node_get_num_glyphs (node);
   float x = offset->x + job->offset_x;
   float y = offset->y + job->offset_y;
-  GskGLGlyphLibrary *library = job->driver->glyphs_library;
+  GskGLGlyphLibrary *library = job->driver->glyphs;
   GskGLCommandBatch *batch;
   int x_position = 0;
   GskGLGlyphKey lookup;
@@ -3069,259 +3116,6 @@ gsk_gl_render_job_visit_text_node_legacy (GskGLRenderJob      *job,
   gsk_gl_render_job_end_draw (job);
 }
 
-typedef struct
-{
-  float x;
-  float y;
-  float g16hi;
-  float g16lo;
-} EncodedGlyph;
-
-static inline unsigned int
-glyph_encode (guint atlas_x ,  /* 7 bits */
-              guint atlas_y,   /* 7 bits */
-              guint corner_x,  /* 1 bit */
-              guint corner_y,  /* 1 bit */
-              guint nominal_w, /* 6 bits */
-              guint nominal_h) /* 6 bits */
-{
-  guint x, y;
-
-  g_assert (0 == (atlas_x & ~0x7F));
-  g_assert (0 == (atlas_y & ~0x7F));
-  g_assert (0 == (corner_x & ~1));
-  g_assert (0 == (corner_y & ~1));
-  g_assert (0 == (nominal_w & ~0x3F));
-  g_assert (0 == (nominal_h & ~0x3F));
-
-  x = (((atlas_x << 6) | nominal_w) << 1) | corner_x;
-  y = (((atlas_y << 6) | nominal_h) << 1) | corner_y;
-
-  return (x << 16) | y;
-}
-
-static inline void
-encoded_glyph_init (EncodedGlyph           *eg,
-                    float                   x,
-                    float                   y,
-                    guint                   corner_x,
-                    guint                   corner_y,
-                    const GskGLGlyphyValue *gi)
-{
-  guint encoded = glyph_encode (gi->atlas_x, gi->atlas_y, corner_x, corner_y, gi->nominal_w, gi->nominal_h);
-
-  eg->x = x;
-  eg->y = y;
-  eg->g16hi = encoded >> 16;
-  eg->g16lo = encoded & 0xFFFF;
-}
-
-static inline void
-add_encoded_glyph (GskGLDrawVertex    *vertices,
-                   const EncodedGlyph *eg,
-                   const guint16       c[4])
-{
-  *vertices = (GskGLDrawVertex) { .position = { eg->x, eg->y}, .uv = { eg->g16hi, eg->g16lo}, .color = { c[0], c[1], c[2], c[3] } };
-}
-
-static void
-get_synthetic_font_params (PangoFont   *font,
-                           gboolean    *embolden,
-                           PangoMatrix *matrix)
-{
-  *embolden = FALSE;
-
-  if (PANGO_IS_FC_FONT (font))
-    {
-      FcPattern *pattern = pango_fc_font_get_pattern (PANGO_FC_FONT (font));
-      FcBool b;
-      FcMatrix mat;
-      FcMatrix *m;
-
-      if (FcPatternGetBool (pattern, FC_EMBOLDEN, 0, &b) == FcResultMatch)
-        *embolden = b;
-
-      FcMatrixInit (&mat);
-      for (int i = 0; FcPatternGetMatrix (pattern, FC_MATRIX, i, &m) == FcResultMatch; i++)
-        FcMatrixMultiply (&mat, &mat, m);
-
-      matrix->xx = mat.xx;
-      matrix->xy = mat.xy;
-      matrix->yx = mat.yx;
-      matrix->yy = mat.yy;
-    }
-}
-
-static inline void
-gsk_gl_render_job_visit_text_node_glyphy (GskGLRenderJob      *job,
-                                          const GskRenderNode *node,
-                                          const GdkRGBA       *color)
-{
-  const graphene_point_t *offset;
-  const PangoGlyphInfo *glyphs;
-  const PangoGlyphInfo *gi;
-  GskGLGlyphyLibrary *library;
-  GskGLCommandBatch *batch;
-  PangoFont *font;
-  GskGLDrawVertex *vertices;
-  const guint16 *c;
-  GskGLGlyphyKey lookup;
-  guint16 cc[4];
-  float x;
-  float y;
-  guint last_texture = 0;
-  guint num_glyphs;
-  guint used = 0;
-  guint i;
-  int x_position = 0;
-  float font_scale;
-  gboolean embolden;
-  PangoMatrix matrix = PANGO_MATRIX_INIT;
-
-#define GRID_SIZE 20
-
-  g_assert (!gsk_text_node_has_color_glyphs (node));
-
-  if (!(num_glyphs = gsk_text_node_get_num_glyphs (node)))
-    return;
-
-  if (RGBA_IS_CLEAR (color))
-    return;
-
-  font = (PangoFont *)gsk_text_node_get_font (node);
-  get_synthetic_font_params (font, &embolden, &matrix);
-
-  glyphs = gsk_text_node_get_glyphs (node, NULL);
-  library = job->driver->glyphy_library;
-  offset = gsk_text_node_get_offset (node);
-  x = offset->x + job->offset_x;
-  y = offset->y + job->offset_y;
-
-  rgba_to_half (color, cc);
-  c = cc;
-
-  gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, glyphy));
-
-  batch = gsk_gl_command_queue_get_batch (job->command_queue);
-  vertices = gsk_gl_command_queue_add_n_vertices (job->command_queue, num_glyphs);
-
-  lookup.font = gsk_gl_glyphy_library_get_font_key (font);
-  font_scale = gsk_gl_glyphy_library_get_font_scale (font);
-
-  for (i = 0, gi = glyphs; i < num_glyphs; i++, gi++)
-    {
-      const GskGLGlyphyValue *glyph;
-      float cx = 0, cy = 0;
-      guint texture_id;
-
-      lookup.glyph = gi->glyph;
-      texture_id = gsk_gl_glyphy_library_lookup_or_add (library, &lookup, font, &glyph);
-
-      if G_UNLIKELY (texture_id == 0)
-        continue;
-
-      if G_UNLIKELY (last_texture != texture_id || batch->draw.vbo_count + GSK_GL_N_VERTICES > 0xffff)
-        {
-          if G_LIKELY (last_texture != 0)
-            {
-              guint vbo_offset = batch->draw.vbo_offset + batch->draw.vbo_count;
-
-              /* Since we have batched added our VBO vertices to avoid repeated
-               * calls to the buffer, we need to manually tweak the vbo offset
-               * of the new batch as otherwise it will point at the end of our
-               * vbo array.
-               */
-              gsk_gl_render_job_split_draw (job);
-              batch = gsk_gl_command_queue_get_batch (job->command_queue);
-              batch->draw.vbo_offset = vbo_offset;
-            }
-
-          gsk_gl_program_set_uniform4i (job->current_program,
-                                        UNIFORM_GLYPHY_ATLAS_INFO, 0,
-                                        GSK_GL_TEXTURE_LIBRARY (library)->atlas_width,
-                                        GSK_GL_TEXTURE_LIBRARY (library)->atlas_height,
-                                        library->item_w,
-                                        library->item_h_q);
-          gsk_gl_program_set_uniform_texture (job->current_program,
-                                              UNIFORM_SHARED_SOURCE, 0,
-                                              GL_TEXTURE_2D,
-                                              GL_TEXTURE0,
-                                              texture_id);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_GAMMA_ADJUST, 0,
-                                        1.0);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_CONTRAST, 0,
-                                        1.0);
-
-          /* 0.0208 is the value used by freetype for synthetic emboldening */
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_BOLDNESS, 0,
-                                        embolden ? 0.0208 * GRID_SIZE : 0.0);
-
-#if 0
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_OUTLINE_THICKNESS, 0,
-                                        1.0);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_OUTLINE, 0,
-                                        1.0);
-#endif
-
-          last_texture = texture_id;
-        }
-
-      cx = (float)(x_position + gi->geometry.x_offset) / PANGO_SCALE;
-      if G_UNLIKELY (gi->geometry.y_offset != 0)
-        cy = (float)(gi->geometry.y_offset) / PANGO_SCALE;
-
-      x_position += gi->geometry.width;
-
-      EncodedGlyph encoded[4];
-#define ENCODE_CORNER(_cx, _cy) \
-  G_STMT_START { \
-    float _dx = _cx * (glyph->extents.max_x - glyph->extents.min_x); \
-    float _dy = _cy * (glyph->extents.max_y - glyph->extents.min_y); \
-    float _vx = x + cx + font_scale * (glyph->extents.min_x + matrix.xx * _dx + matrix.xy * _dy); \
-    float _vy = y + cy - font_scale * (glyph->extents.min_y + matrix.yx * _dx + matrix.yy * _dy); \
-    encoded_glyph_init (&encoded[_cx * 2 + _cy], _vx, _vy, _cx, _cy, glyph); \
-  } G_STMT_END
-      ENCODE_CORNER (0, 0);
-      ENCODE_CORNER (0, 1);
-      ENCODE_CORNER (1, 0);
-      ENCODE_CORNER (1, 1);
-#undef ENCODE_CORNER
-
-      add_encoded_glyph (vertices++, &encoded[0], c);
-      add_encoded_glyph (vertices++, &encoded[1], c);
-      add_encoded_glyph (vertices++, &encoded[2], c);
-
-      add_encoded_glyph (vertices++, &encoded[1], c);
-      add_encoded_glyph (vertices++, &encoded[2], c);
-      add_encoded_glyph (vertices++, &encoded[3], c);
-
-      batch->draw.vbo_count += GSK_GL_N_VERTICES;
-      used++;
-    }
-
-  if (used != num_glyphs)
-    gsk_gl_command_queue_retract_n_vertices (job->command_queue, num_glyphs - used);
-
-  gsk_gl_render_job_end_draw (job);
-}
-
-static inline void
-gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
-                                   const GskRenderNode *node,
-                                   const GdkRGBA       *color,
-                                   gboolean             force_color)
-{
-  if (!gsk_text_node_has_color_glyphs (node))
-    gsk_gl_render_job_visit_text_node_glyphy (job, node, color);
-  else
-    gsk_gl_render_job_visit_text_node_legacy (job, node, color, force_color);
-}
-
 static inline void
 gsk_gl_render_job_visit_shadow_node (GskGLRenderJob      *job,
                                      const GskRenderNode *node)
@@ -3699,14 +3493,14 @@ gsk_gl_render_job_upload_texture (GskGLRenderJob       *job,
                                   GdkTexture           *texture,
                                   GskGLRenderOffscreen *offscreen)
 {
-  if (gsk_gl_texture_library_can_cache ((GskGLTextureLibrary *)job->driver->icons_library,
+  if (gsk_gl_texture_library_can_cache ((GskGLTextureLibrary *)job->driver->icons,
                                         texture->width,
                                         texture->height) &&
       !GDK_IS_GL_TEXTURE (texture))
     {
       const GskGLIconData *icon_data;
 
-      gsk_gl_icon_library_lookup_or_add (job->driver->icons_library, texture, &icon_data);
+      gsk_gl_icon_library_lookup_or_add (job->driver->icons, texture, &icon_data);
       offscreen->texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);
       memcpy (&offscreen->area, &icon_data->entry.area, sizeof offscreen->area);
     }
@@ -4024,11 +3818,6 @@ gsk_gl_render_job_visit_node (GskGLRenderJob      *job,
       gsk_gl_render_job_visit_as_fallback (job, node);
     break;
 
-    case GSK_FILL_NODE:
-    case GSK_STROKE_NODE:
-      gsk_gl_render_job_visit_as_fallback (job, node);
-    break;
-
     case GSK_NOT_A_RENDER_NODE:
     default:
       g_assert_not_reached ();

gsk/gl/gskglshadowlibrary.c

@@ -29,9 +29,9 @@
 
 struct _GskGLShadowLibrary
 {
-  GObject      parent_instance;
+  GObject        parent_instance;
   GskGLDriver *driver;
-  GArray      *shadows;
+  GArray        *shadows;
 };
 
 typedef struct _Shadow

gsk/gl/gskgltexturelibrary.c

@@ -27,10 +27,7 @@
 #include "gskgldriverprivate.h"
 #include "gskgltexturelibraryprivate.h"
 
-#define DEFAULT_MAX_FRAME_AGE 60
-#define DEFAULT_ATLAS_WIDTH 512
-#define DEFAULT_ATLAS_HEIGHT 512
-#define MAX_OLD_RATIO 0.5
+#define MAX_FRAME_AGE 60
 
 G_DEFINE_ABSTRACT_TYPE (GskGLTextureLibrary, gsk_gl_texture_library, G_TYPE_OBJECT)
 
@@ -42,143 +39,6 @@ enum {
 
 static GParamSpec *properties [N_PROPS];
 
-static void
-gsk_gl_texture_atlas_free (GskGLTextureAtlas *atlas)
-{
-  if (atlas->texture_id != 0)
-    {
-      glDeleteTextures (1, &atlas->texture_id);
-      atlas->texture_id = 0;
-    }
-
-  g_clear_pointer (&atlas->nodes, g_free);
-  g_slice_free (GskGLTextureAtlas, atlas);
-}
-
-static gboolean
-gsk_gl_texture_library_real_compact (GskGLTextureLibrary *self,
-                                     gint64               frame_id)
-{
-  GPtrArray *removed = NULL;
-  gboolean ret = FALSE;
-  gboolean periodic_scan;
-
-  g_assert (GSK_IS_GL_TEXTURE_LIBRARY (self));
-
-  periodic_scan = (self->max_frame_age > 0 &&
-                   (frame_id % self->max_frame_age) == 0);
-
-  for (guint i = self->atlases->len; i > 0; i--)
-    {
-      GskGLTextureAtlas *atlas = g_ptr_array_index (self->atlases, i - 1);
-
-      if (gsk_gl_texture_atlas_get_unused_ratio (atlas) > MAX_OLD_RATIO)
-        {
-          GSK_NOTE (GLYPH_CACHE,
-                    g_message ("Dropping atlas %d (%g.2%% old)", i,
-                               100.0 * gsk_gl_texture_atlas_get_unused_ratio (atlas)));
-          if (removed == NULL)
-            removed = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_gl_texture_atlas_free);
-          g_ptr_array_add (removed, g_ptr_array_steal_index (self->atlases, i - 1));
-        }
-    }
-
-  if (periodic_scan || removed != NULL)
-    {
-      GskGLTextureAtlasEntry *entry;
-      GHashTableIter iter;
-      guint dropped = 0;
-      guint atlased = 0;
-
-      g_hash_table_iter_init (&iter, self->hash_table);
-      while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&entry))
-        {
-          if (entry->is_atlased)
-            {
-              if (removed && g_ptr_array_find (removed, entry->atlas, NULL))
-                {
-                  g_hash_table_iter_remove (&iter);
-                  dropped++;
-                }
-              else if (periodic_scan)
-                {
-                  gsk_gl_texture_atlas_entry_mark_unused (entry);
-                  entry->accessed = FALSE;
-                  if (entry->is_atlased)
-                    atlased++;
-                }
-            }
-          else if (!entry->accessed)
-            {
-              gsk_gl_driver_release_texture (self->driver, entry->texture);
-              g_hash_table_iter_remove (&iter);
-              dropped++;
-            }
-        }
-
-      GSK_NOTE (GLYPH_CACHE, g_message ("%s: Dropped %d individual items",
-                                        G_OBJECT_TYPE_NAME (self),
-                                        dropped);
-                             g_message ("%s: %d items cached (%d atlased, %d individually)",
-                                        G_OBJECT_TYPE_NAME (self),
-                                        g_hash_table_size (self->hash_table),
-                                        atlased,
-                                        g_hash_table_size (self->hash_table) - atlased));
-
-      if (dropped > 0)
-        gsk_gl_texture_library_clear_cache (self);
-
-      ret = TRUE;
-
-      g_clear_pointer (&removed, g_ptr_array_unref);
-    }
-
-  GSK_NOTE (GLYPH_CACHE, {
-    static gint64 last_message;
-    gint64 now = g_get_monotonic_time ();
-    if (now - last_message > G_USEC_PER_SEC)
-      {
-        last_message = now;
-        g_message ("%s contains %d atlases",
-                   G_OBJECT_TYPE_NAME (self),
-                   self->atlases->len);
-      }
-  });
-
-  return ret;
-}
-
-static gboolean
-gsk_gl_texture_library_real_allocate (GskGLTextureLibrary *self,
-                                      GskGLTextureAtlas   *atlas,
-                                      int                  width,
-                                      int                  height,
-                                      int                 *out_x,
-                                      int                 *out_y)
-{
-  stbrp_rect rect;
-
-  g_assert (GSK_IS_GL_TEXTURE_LIBRARY (self));
-  g_assert (atlas != NULL);
-  g_assert (width > 0);
-  g_assert (height > 0);
-  g_assert (out_x != NULL);
-  g_assert (out_y != NULL);
-
-  rect.w = width;
-  rect.h = height;
-
-  stbrp_pack_rects (&atlas->context, &rect, 1);
-
-  if (rect.was_packed)
-    {
-      *out_x = rect.x;
-      *out_y = rect.y;
-    }
-
-  return rect.was_packed;
-}
-
 static void
 gsk_gl_texture_library_constructed (GObject *object)
 {
@@ -192,7 +52,6 @@ gsk_gl_texture_library_dispose (GObject *object)
 {
   GskGLTextureLibrary *self = (GskGLTextureLibrary *)object;
 
-  g_clear_pointer (&self->atlases, g_ptr_array_unref);
   g_clear_object (&self->driver);
 
   G_OBJECT_CLASS (gsk_gl_texture_library_parent_class)->dispose (object);
@@ -246,9 +105,6 @@ gsk_gl_texture_library_class_init (GskGLTextureLibraryClass *klass)
   object_class->get_property = gsk_gl_texture_library_get_property;
   object_class->set_property = gsk_gl_texture_library_set_property;
 
-  klass->compact = gsk_gl_texture_library_real_compact;
-  klass->allocate = gsk_gl_texture_library_real_allocate;
-
   properties [PROP_DRIVER] =
     g_param_spec_object ("driver",
                          "Driver",
@@ -262,10 +118,6 @@ gsk_gl_texture_library_class_init (GskGLTextureLibraryClass *klass)
 static void
 gsk_gl_texture_library_init (GskGLTextureLibrary *self)
 {
-  self->max_frame_age = DEFAULT_MAX_FRAME_AGE;
-  self->atlas_width = DEFAULT_ATLAS_WIDTH;
-  self->atlas_height = DEFAULT_ATLAS_HEIGHT;
-  self->atlases = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_gl_texture_atlas_free);
 }
 
 void
@@ -284,14 +136,78 @@ gsk_gl_texture_library_set_funcs (GskGLTextureLibrary *self,
 
 void
 gsk_gl_texture_library_begin_frame (GskGLTextureLibrary *self,
-                                    gint64               frame_id)
+                                    gint64               frame_id,
+                                    GPtrArray            *removed_atlases)
 {
+  GHashTableIter iter;
+
   g_return_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self));
 
-  gsk_gl_texture_library_compact (self, frame_id);
-
   if (GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->begin_frame)
-    GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->begin_frame (self, frame_id);
+    GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->begin_frame (self, frame_id, removed_atlases);
+
+  if (removed_atlases != NULL)
+    {
+      GskGLTextureAtlasEntry *entry;
+      guint dropped = 0;
+
+      g_hash_table_iter_init (&iter, self->hash_table);
+      while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&entry))
+        {
+          if (entry->is_atlased)
+            {
+              for (guint i = 0; i < removed_atlases->len; i++)
+                {
+                  GskGLTextureAtlas *atlas = g_ptr_array_index (removed_atlases, i);
+
+                  if (atlas == entry->atlas)
+                    {
+                      g_hash_table_iter_remove (&iter);
+                      dropped++;
+                      break;
+                    }
+                }
+            }
+        }
+
+      GSK_NOTE (GLYPH_CACHE,
+                if (dropped > 0)
+                  g_message ("%s: Dropped %d items",
+                             G_OBJECT_TYPE_NAME (self), dropped));
+    }
+
+  if (frame_id % MAX_FRAME_AGE == 0)
+    {
+      GskGLTextureAtlasEntry *entry;
+      int atlased = 0;
+      int dropped = 0;
+
+      g_hash_table_iter_init (&iter, self->hash_table);
+      while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&entry))
+        {
+          if (!entry->is_atlased && !entry->accessed)
+            {
+              gsk_gl_driver_release_texture (self->driver, entry->texture);
+              g_hash_table_iter_remove (&iter);
+              dropped++;
+              continue;
+            }
+
+          gsk_gl_texture_atlas_entry_mark_unused (entry);
+          entry->accessed = FALSE;
+          if (entry->is_atlased)
+            atlased++;
+        }
+
+      GSK_NOTE (GLYPH_CACHE, g_message ("%s: Dropped %d individual items",
+                                        G_OBJECT_TYPE_NAME (self),
+                                        dropped);
+                             g_message ("%s: %d items cached (%d atlased, %d individually)",
+                                        G_OBJECT_TYPE_NAME (self),
+                                        g_hash_table_size (self->hash_table),
+                                        atlased,
+                                        g_hash_table_size (self->hash_table) - atlased));
+    }
 }
 
 static GskGLTexture *
@@ -318,29 +234,90 @@ gsk_gl_texture_library_pack_one (GskGLTextureLibrary *self,
   return texture;
 }
 
+static inline gboolean
+gsk_gl_texture_atlas_pack (GskGLTextureAtlas *self,
+                           int                width,
+                           int                height,
+                           int               *out_x,
+                           int               *out_y)
+{
+  stbrp_rect rect;
+
+  rect.w = width;
+  rect.h = height;
+
+  stbrp_pack_rects (&self->context, &rect, 1);
+
+  if (rect.was_packed)
+    {
+      *out_x = rect.x;
+      *out_y = rect.y;
+    }
+
+  return rect.was_packed;
+}
+
 static void
-gsk_gl_texture_library_pack_any_atlas (GskGLTextureLibrary  *self,
-                                       int                   width,
-                                       int                   height,
-                                       GskGLTextureAtlas   **out_atlas,
-                                       int                  *out_x,
-                                       int                  *out_y)
+gsk_gl_texture_atlas_initialize (GskGLDriver       *driver,
+                                 GskGLTextureAtlas *atlas)
+{
+  /* Insert a single pixel at 0,0 for use in coloring */
+
+  gboolean packed G_GNUC_UNUSED;
+  int x, y;
+  guint gl_format;
+  guint gl_type;
+  guint8 pixel_data[4 * 3 * 3];
+
+  gdk_gl_context_push_debug_group_printf (gdk_gl_context_get_current (),
+                                          "Initializing Atlas");
+
+  packed = gsk_gl_texture_atlas_pack (atlas, 3, 3, &x, &y);
+  g_assert (packed);
+  g_assert (x == 0 && y == 0);
+
+  memset (pixel_data, 255, sizeof pixel_data);
+
+  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
+    {
+      gl_format = GL_RGBA;
+      gl_type = GL_UNSIGNED_BYTE;
+    }
+  else
+    {
+      gl_format = GL_BGRA;
+      gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+    }
+
+  glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
+
+  glTexSubImage2D (GL_TEXTURE_2D, 0,
+                   0, 0,
+                   3, 3,
+                   gl_format, gl_type,
+                   pixel_data);
+
+  gdk_gl_context_pop_debug_group (gdk_gl_context_get_current ());
+
+  driver->command_queue->n_uploads++;
+}
+
+static void
+gsk_gl_texture_atlases_pack (GskGLDriver        *driver,
+                             int                 width,
+                             int                 height,
+                             GskGLTextureAtlas **out_atlas,
+                             int                *out_x,
+                             int                *out_y)
 {
   GskGLTextureAtlas *atlas = NULL;
   int x, y;
 
-  g_assert (GSK_IS_GL_TEXTURE_LIBRARY (self));
-  g_assert (width > 0);
-  g_assert (height > 0);
-  g_assert (out_atlas != NULL);
-  g_assert (out_x != NULL);
-  g_assert (out_y != NULL);
-
-  for (guint i = 0; i < self->atlases->len; i++)
+  for (guint i = 0; i < driver->atlases->len; i++)
     {
-      atlas = g_ptr_array_index (self->atlases, i);
+      atlas = g_ptr_array_index (driver->atlases, i);
 
-      if (gsk_gl_texture_library_allocate (self, atlas, width, height, &x, &y))
+      if (gsk_gl_texture_atlas_pack (atlas, width, height, &x, &y))
         break;
 
       atlas = NULL;
@@ -349,10 +326,12 @@ gsk_gl_texture_library_pack_any_atlas (GskGLTextureLibrary  *self,
   if (atlas == NULL)
     {
       /* No atlas has enough space, so create a new one... */
-      atlas = gsk_gl_texture_library_acquire_atlas (self);
+      atlas = gsk_gl_driver_create_atlas (driver);
+
+      gsk_gl_texture_atlas_initialize (driver, atlas);
 
       /* Pack it onto that one, which surely has enough space... */
-      if (!gsk_gl_texture_library_allocate (self, atlas, width, height, &x, &y))
+      if (!gsk_gl_texture_atlas_pack (atlas, width, height, &x, &y))
         g_assert_not_reached ();
     }
 
@@ -401,19 +380,17 @@ gsk_gl_texture_library_pack (GskGLTextureLibrary *self,
       *out_packed_x = 0;
       *out_packed_y = 0;
     }
-  else if (self->max_entry_size == 0 ||
-           (width <= self->max_entry_size &&
-            height <= self->max_entry_size))
+  else if (width <= self->max_entry_size && height <= self->max_entry_size)
     {
       int packed_x;
       int packed_y;
 
-      gsk_gl_texture_library_pack_any_atlas (self,
-                                             padding + width + padding,
-                                             padding + height + padding,
-                                             &atlas,
-                                             &packed_x,
-                                             &packed_y);
+      gsk_gl_texture_atlases_pack (self->driver,
+                                   padding + width + padding,
+                                   padding + height + padding,
+                                   &atlas,
+                                   &packed_x,
+                                   &packed_y);
 
       entry->atlas = atlas;
       entry->is_atlased = TRUE;
@@ -447,134 +424,3 @@ gsk_gl_texture_library_pack (GskGLTextureLibrary *self,
 
   return entry;
 }
-
-/*
- * gsk_gl_texture_library_clear_cache:
- *
- * Clear the front cache if the texture library is using one. For
- * example the glyph cache would drop it's front cache to force
- * next lookups to fall through to the GHashTable key lookup.
- */
-void
-gsk_gl_texture_library_clear_cache (GskGLTextureLibrary *self)
-{
-  g_return_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self));
-
-  if (GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->clear_cache)
-    GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->clear_cache (self);
-}
-
-/*
- * gsk_gl_texture_library_compact:
- *
- * Requests that the texture library compact it's altases. That
- * generally means to traverse them to look for unused pixels over
- * a certain threshold and release them if necessary.
- *
- * Returns: %TRUE if any compaction occurred.
- */
-gboolean
-gsk_gl_texture_library_compact (GskGLTextureLibrary *self,
-                                gint64               frame_id)
-{
-  g_return_val_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self), FALSE);
-
-  if (GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->compact)
-    return GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->compact (self, frame_id);
-
-  return FALSE;
-}
-
-void
-gsk_gl_texture_library_reset (GskGLTextureLibrary *self)
-{
-  g_return_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self));
-
-  gsk_gl_texture_library_clear_cache (self);
-
-  g_hash_table_remove_all (self->hash_table);
-
-  if (self->atlases->len)
-    g_ptr_array_remove_range (self->atlases, 0, self->atlases->len);
-}
-
-void
-gsk_gl_texture_library_set_atlas_size (GskGLTextureLibrary *self,
-                                       int                  width,
-                                       int                  height)
-{
-  g_return_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self));
-
-  if (width <= 0)
-    width = DEFAULT_ATLAS_WIDTH;
-
-  if (height <= 0)
-    height = DEFAULT_ATLAS_HEIGHT;
-
-  self->atlas_height = height;
-  self->atlas_width = width;
-
-  gsk_gl_texture_library_reset (self);
-}
-
-/*
- * gsk_gl_texture_library_acquire_atlas:
- *
- * Allocates a new texture atlas based on the current size
- * and format requirements.
- */
-GskGLTextureAtlas *
-gsk_gl_texture_library_acquire_atlas (GskGLTextureLibrary *self)
-{
-  GskGLTextureAtlas *atlas;
-
-  g_return_val_if_fail (GSK_IS_GL_TEXTURE_LIBRARY (self), NULL);
-  g_return_val_if_fail (GSK_IS_GL_DRIVER (self->driver), NULL);
-  g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (self->driver->command_queue), NULL);
-  g_return_val_if_fail (self->atlas_width > 0, NULL);
-  g_return_val_if_fail (self->atlas_height > 0, NULL);
-
-  atlas = g_slice_new0 (GskGLTextureAtlas);
-  atlas->width = self->atlas_width;
-  atlas->height = self->atlas_height;
-  /* TODO: We might want to change the strategy about the amount of
-   *       nodes here? stb_rect_pack.h says width is optimal. */
-  atlas->nodes = g_malloc0_n (atlas->width, sizeof (struct stbrp_node));
-  stbrp_init_target (&atlas->context, atlas->width, atlas->height, atlas->nodes, atlas->width);
-  atlas->texture_id = gsk_gl_command_queue_create_texture (self->driver->command_queue,
-                                                           atlas->width,
-                                                           atlas->height,
-                                                           GL_RGBA8,
-                                                           GL_LINEAR,
-                                                           GL_LINEAR);
-
-  gdk_gl_context_label_object_printf (gdk_gl_context_get_current (),
-                                      GL_TEXTURE, atlas->texture_id,
-                                      "Texture atlas %d",
-                                      atlas->texture_id);
-
-  g_ptr_array_add (self->atlases, atlas);
-
-  if (GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->init_atlas)
-    GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->init_atlas (self, atlas);
-
-  return atlas;
-}
-
-gboolean
-gsk_gl_texture_library_allocate (GskGLTextureLibrary *self,
-                                 GskGLTextureAtlas   *atlas,
-                                 int                  width,
-                                 int                  height,
-                                 int                 *out_x,
-                                 int                 *out_y)
-{
-  g_assert (GSK_IS_GL_TEXTURE_LIBRARY (self));
-  g_assert (atlas != NULL);
-  g_assert (width > 0);
-  g_assert (height > 0);
-  g_assert (out_x != NULL);
-  g_assert (out_y != NULL);
-
-  return GSK_GL_TEXTURE_LIBRARY_GET_CLASS (self)->allocate (self, atlas, width, height, out_x, out_y);
-}

gsk/gl/gskgltexturelibraryprivate.h

@@ -37,14 +37,9 @@ G_BEGIN_DECLS
 
 typedef struct _GskGLTextureAtlas
 {
-  /* Used by Glyph/Icons */
   struct stbrp_context context;
   struct stbrp_node *nodes;
 
-  /* Used by Glyphy */
-  int cursor_x;
-  int cursor_y;
-
   int width;
   int height;
 
@@ -54,6 +49,8 @@ typedef struct _GskGLTextureAtlas
    * But are now unused.
    */
   int unused_pixels;
+
+  void *user_data;
 } GskGLTextureAtlas;
 
 typedef struct _GskGLTextureAtlasEntry
@@ -92,67 +89,40 @@ typedef struct _GskGLTextureAtlasEntry
 
 typedef struct _GskGLTextureLibrary
 {
-  GObject      parent_instance;
+  GObject        parent_instance;
   GskGLDriver *driver;
-  GPtrArray   *atlases;
-  GHashTable  *hash_table;
-  guint        max_entry_size;
-  guint        max_frame_age;
-  guint        atlas_width;
-  guint        atlas_height;
+  GHashTable    *hash_table;
+  guint          max_entry_size;
 } GskGLTextureLibrary;
 
 typedef struct _GskGLTextureLibraryClass
 {
   GObjectClass parent_class;
 
-  void     (*begin_frame) (GskGLTextureLibrary *library,
-                           gint64               frame_id);
-  gboolean (*compact)     (GskGLTextureLibrary *library,
-                           gint64               frame_id);
-  void     (*clear_cache) (GskGLTextureLibrary *library);
-  void     (*init_atlas)  (GskGLTextureLibrary *library,
-                           GskGLTextureAtlas   *atlas);
-  gboolean (*allocate)    (GskGLTextureLibrary *library,
-                           GskGLTextureAtlas   *atlas,
-                           int                  width,
-                           int                  height,
-                           int                 *out_x,
-                           int                 *out_y);
+  void (*begin_frame) (GskGLTextureLibrary *library,
+                       gint64               frame_id,
+                       GPtrArray           *removed_atlases);
 } GskGLTextureLibraryClass;
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GskGLTextureLibrary, g_object_unref)
 
-GType              gsk_gl_texture_library_get_type       (void) G_GNUC_CONST;
-gboolean           gsk_gl_texture_library_compact        (GskGLTextureLibrary *self,
-                                                          gint64               frame_id);
-void               gsk_gl_texture_library_clear_cache    (GskGLTextureLibrary *self);
-void               gsk_gl_texture_library_reset          (GskGLTextureLibrary *self);
-void               gsk_gl_texture_library_set_atlas_size (GskGLTextureLibrary *self,
-                                                          int                  width,
-                                                          int                  height);
-GskGLTextureAtlas *gsk_gl_texture_library_acquire_atlas  (GskGLTextureLibrary *self);
-void               gsk_gl_texture_library_set_funcs      (GskGLTextureLibrary *self,
-                                                          GHashFunc            hash_func,
-                                                          GEqualFunc           equal_func,
-                                                          GDestroyNotify       key_destroy,
-                                                          GDestroyNotify       value_destroy);
-void               gsk_gl_texture_library_begin_frame    (GskGLTextureLibrary *self,
-                                                          gint64               frame_id);
-gboolean           gsk_gl_texture_library_allocate       (GskGLTextureLibrary *self,
-                                                          GskGLTextureAtlas   *atlas,
-                                                          int                  width,
-                                                          int                  height,
-                                                          int                 *out_x,
-                                                          int                 *out_y);
-gpointer           gsk_gl_texture_library_pack           (GskGLTextureLibrary *self,
-                                                          gpointer             key,
-                                                          gsize                valuelen,
-                                                          guint                width,
-                                                          guint                height,
-                                                          int                  padding,
-                                                          guint               *out_packed_x,
-                                                          guint               *out_packed_y);
+GType    gsk_gl_texture_library_get_type    (void) G_GNUC_CONST;
+void     gsk_gl_texture_library_set_funcs   (GskGLTextureLibrary *self,
+                                             GHashFunc            hash_func,
+                                             GEqualFunc           equal_func,
+                                             GDestroyNotify       key_destroy,
+                                             GDestroyNotify       value_destroy);
+void     gsk_gl_texture_library_begin_frame (GskGLTextureLibrary *self,
+                                             gint64               frame_id,
+                                             GPtrArray           *removed_atlases);
+gpointer gsk_gl_texture_library_pack        (GskGLTextureLibrary *self,
+                                             gpointer             key,
+                                             gsize                valuelen,
+                                             guint                width,
+                                             guint                height,
+                                             int                  padding,
+                                             guint               *out_packed_x,
+                                             guint               *out_packed_y);
 
 static inline void
 gsk_gl_texture_atlas_mark_unused (GskGLTextureAtlas *self,

gsk/gl/gskgltypesprivate.h

@@ -37,7 +37,6 @@ typedef struct _GskGLCompiler GskGLCompiler;
 typedef struct _GskGLDrawVertex GskGLDrawVertex;
 typedef struct _GskGLRenderTarget GskGLRenderTarget;
 typedef struct _GskGLGlyphLibrary GskGLGlyphLibrary;
-typedef struct _GskGLGlyphyLibrary GskGLGlyphyLibrary;
 typedef struct _GskGLIconLibrary GskGLIconLibrary;
 typedef struct _GskGLProgram GskGLProgram;
 typedef struct _GskGLRenderJob GskGLRenderJob;

gsk/gl/resources/glyphy.atlas.glsl

@@ -1,15 +0,0 @@
-uniform ivec4 u_atlas_info;
-
-#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos
-#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos
-#define GLYPHY_DEMO_EXTRA_ARGS , u_source, u_atlas_info, gi.atlas_pos
-
-vec4
-glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)
-{
-  ivec2 item_geom = _atlas_info.zw;
-  vec2 pos = (vec2 (_atlas_pos.xy * item_geom +
-		   ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +
-	      + vec2 (.5, .5)) / vec2(_atlas_info.xy);
-  return GskTexture (_tex, pos);
-}

gsk/gl/resources/glyphy.fs.glsl

@@ -1,62 +0,0 @@
-// FRAGMENT_SHADER:
-// glyphy.fs.glsl
-
-uniform float u_contrast;
-uniform float u_gamma_adjust;
-uniform float u_outline_thickness;
-uniform bool  u_outline;
-uniform float u_boldness;
-
-_IN_ vec4 v_glyph;
-_IN_ vec4 final_color;
-
-#define SQRT2     1.4142135623730951
-#define SQRT2_INV 0.70710678118654757 /* 1 / sqrt(2.) */
-
-struct glyph_info_t {
-  ivec2 nominal_size;
-  ivec2 atlas_pos;
-};
-
-glyph_info_t
-glyph_info_decode (vec4 v)
-{
-  glyph_info_t gi;
-  gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4;
-  gi.atlas_pos = ivec2 (v_glyph.zw) / 256;
-  return gi;
-}
-
-float
-antialias (float d)
-{
-  return smoothstep (-.75, +.75, d);
-}
-
-void
-main()
-{
-  vec2 p = v_glyph.xy;
-  glyph_info_t gi = glyph_info_decode (v_glyph);
-
-  /* isotropic antialiasing */
-  vec2 dpdx = dFdx (p);
-  vec2 dpdy = dFdy (p);
-  float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_INV;
-
-  float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS);
-  gsdist -= u_boldness;
-  float sdist = gsdist / m * u_contrast;
-
-  if (u_outline)
-    sdist = abs (sdist) - u_outline_thickness * .5;
-
-  if (sdist > 1.)
-    discard;
-
-  float alpha = antialias (-sdist);
-  if (u_gamma_adjust != 1.)
-    alpha = pow (alpha, 1./u_gamma_adjust);
-
-  gskSetOutputColor(final_color * alpha);
-}

gsk/gl/resources/glyphy.vs.glsl

@@ -1,24 +0,0 @@
-// VERTEX_SHADER:
-// glyphy.vs.glsl
-
-_OUT_ vec4 v_glyph;
-_OUT_ vec4 final_color;
-
-vec4
-glyph_vertex_transcode (vec2 v)
-{
-  ivec2 g = ivec2 (v);
-  ivec2 corner = ivec2 (mod (v, 2.));
-  g /= 2;
-  ivec2 nominal_size = ivec2 (mod (vec2(g), 64.));
-  return vec4 (corner * nominal_size, g * 4);
-}
-
-void
-main()
-{
-  v_glyph = glyph_vertex_transcode(aUv);
-  vUv = v_glyph.zw;
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-  final_color = gsk_scaled_premultiply(aColor, u_alpha);
-}

gsk/gsk-autocleanup.h

@@ -22,8 +22,6 @@
 
 #ifndef __GI_SCANNER__
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPath, gsk_path_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathMeasure, gsk_path_measure_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskRenderer, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskRenderNode, gsk_render_node_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskTransform, gsk_transform_unref)

gsk/gsk.h

@@ -21,15 +21,11 @@
 #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/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/gskboundingbox.c

@@ -1,80 +0,0 @@
-#include "config.h"
-
-#include "gskboundingboxprivate.h"
-
-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;
-}
-
-GskBoundingBox *
-gsk_bounding_box_init_copy (GskBoundingBox       *self,
-                            const GskBoundingBox *src)
-{
-  self->min = src->min;
-  self->max = src->max;
-  return self;
-}
-
-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;
-}
-
-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);
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}

gsk/gskboundingboxprivate.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-typedef struct _GskBoundingBox GskBoundingBox;
-
-struct _GskBoundingBox {
-  graphene_point_t min;
-  graphene_point_t max;
-};
-
-GDK_AVAILABLE_IN_ALL
-GskBoundingBox * gsk_bounding_box_init (GskBoundingBox         *self,
-                                        const graphene_point_t *a,
-                                        const graphene_point_t *b);
-
-GDK_AVAILABLE_IN_ALL
-GskBoundingBox * gsk_bounding_box_init_copy (GskBoundingBox       *self,
-                                             const GskBoundingBox *src);
-
-GDK_AVAILABLE_IN_ALL
-GskBoundingBox * gsk_bounding_box_init_from_rect (GskBoundingBox        *self,
-                                                  const graphene_rect_t *bounds);
-
-GDK_AVAILABLE_IN_ALL
-void             gsk_bounding_box_expand (GskBoundingBox         *self,
-                                          const graphene_point_t *p);
-
-GDK_AVAILABLE_IN_ALL
-graphene_rect_t *gsk_bounding_box_to_rect        (const GskBoundingBox  *self,
-                                                  graphene_rect_t       *rect);
-
-GDK_AVAILABLE_IN_ALL
-gboolean         gsk_bounding_box_contains_point (const GskBoundingBox   *self,
-                                                  const graphene_point_t *p);
-
-GDK_AVAILABLE_IN_ALL
-gboolean         gsk_bounding_box_intersection (const GskBoundingBox *a,
-                                                const GskBoundingBox *b,
-                                                GskBoundingBox       *res);
-
-G_END_DECLS

gsk/gskcontourprivate.h

@@ -1,132 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_CONTOUR_PRIVATE_H__
-#define __GSK_CONTOUR_PRIVATE_H__
-
-#include <gskpath.h>
-
-#include "gskpathopprivate.h"
-
-G_BEGIN_DECLS
-
-/* A path is flat if it contains no cubic or conic segments.
- * A path is closed if all its contours end with a GSK_PATH_CLOSE
- * operation.
- */
-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_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);
-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,
-                                                                 graphene_point_t       *pos,
-                                                                 graphene_vec2_t        *tangent);
-float                   gsk_contour_get_curvature               (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 float                   distance,
-                                                                 graphene_point_t       *center);
-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,
-                                                                 gboolean               *on_edge);
-void                    gsk_contour_add_segment                 (const GskContour       *self,
-                                                                 GskPathBuilder         *builder,
-                                                                 gpointer                measure_data,
-                                                                 gboolean                emit_move_to,
-                                                                 float                   start,
-                                                                 float                   end);
-gboolean                gsk_contour_get_stroke_bounds           (const GskContour       *self,
-                                                                 const GskStroke        *stroke,
-                                                                 graphene_rect_t        *bounds);
-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,
-                                                                 GskLineJoin             line_join,
-                                                                 float                   miter_limit);
-void                    gsk_contour_default_offset              (const GskContour       *contour,
-                                                                 GskPathBuilder         *builder,
-                                                                 float                   distance,
-                                                                 GskLineJoin             line_join,
-                                                                 float                   miter_limit);
-
-gboolean                gsk_contour_is_convex                   (const GskContour       *contour);
-
-G_END_DECLS
-
-#endif /* __GSK_CONTOUR_PRIVATE_H__ */
-

gsk/gskconvexity.c

@@ -1,286 +0,0 @@
-#include "config.h"
-
-#include "gskconvexityprivate.h"
-#include "gskcontourprivate.h"
-
-typedef enum
-{
-  GSK_DIR_CHANGE_UNKNOWN,
-  GSK_DIR_CHANGE_LEFT,
-  GSK_DIR_CHANGE_RIGHT,
-  GSK_DIR_CHANGE_STRAIGHT,
-  GSK_DIR_CHANGE_REVERSE,
-  GSK_DIR_CHANGE_INVALID,
-} GskDirChange;
-
-typedef enum
-{
-  GSK_PATH_DIRECTION_UNKNOWN,
-  GSK_PATH_DIRECTION_CLOCKWISE,
-  GSK_PATH_DIRECTION_COUNTERCLOCKWISE,
-} GskPathDirection;
-
-typedef struct _GskConvexityChecker GskConvexityChecker;
-struct _GskConvexityChecker
-{
-  graphene_point_t first_point;
-  graphene_vec2_t first_vec;
-  graphene_point_t last_point;
-  graphene_vec2_t last_vec;
-  GskDirChange expected_direction;
-  GskPathDirection first_direction;
-  int reversals;
-  gboolean finite;
-  GskConvexity convexity;
-  int xsign;
-  int ysign;
-  int dx;
-  int dy;
-};
-
-static float
-cross_product (graphene_vec2_t *a,
-               graphene_vec2_t *b)
-{
-  float fa[2];
-  float fb[2];
-  graphene_vec2_to_float (a, fa);
-  graphene_vec2_to_float (b, fb);
-  return fa[0] * fb[1] - fa[1] * fb[0];
-}
-
-static GskDirChange
-direction_change (GskConvexityChecker    *c,
-                  graphene_vec2_t *v)
-{
-  float cross = cross_product (&(c->last_vec), v);
-  if (!finite (cross))
-    return GSK_DIR_CHANGE_UNKNOWN;
-
-  if (cross == 0)
-    return graphene_vec2_dot (&(c->last_vec), v) < 0
-           ? GSK_DIR_CHANGE_REVERSE
-           : GSK_DIR_CHANGE_STRAIGHT;
-
-  return cross > 0
-         ? GSK_DIR_CHANGE_RIGHT
-         : GSK_DIR_CHANGE_LEFT;
-}
-
-static gboolean
-add_vec (GskConvexityChecker *c,
-         graphene_vec2_t     *v)
-{
-  GskDirChange dir;
-  int sign;
-
-  dir = direction_change (c, v);
-  switch (dir)
-    {
-    case GSK_DIR_CHANGE_LEFT:
-    case GSK_DIR_CHANGE_RIGHT:
-      if (c->expected_direction == GSK_DIR_CHANGE_INVALID)
-        {
-          c->expected_direction = dir;
-          c->first_direction = (dir == GSK_DIR_CHANGE_RIGHT)
-                               ? GSK_PATH_DIRECTION_CLOCKWISE
-                               : GSK_PATH_DIRECTION_COUNTERCLOCKWISE;
-        }
-      else if (c->expected_direction != dir)
-        {
-          c->first_direction = GSK_PATH_DIRECTION_UNKNOWN;
-          c->convexity = GSK_CONVEXITY_CONCAVE;
-          return FALSE;
-        }
-      graphene_vec2_init_from_vec2 (&c->last_vec, v);
-      break;
-
-    case GSK_DIR_CHANGE_STRAIGHT:
-      break;
-
-    case GSK_DIR_CHANGE_REVERSE:
-      graphene_vec2_init_from_vec2 (&c->last_vec, v);
-      c->reversals++;
-      if (c->reversals > 2)
-        c->convexity = GSK_CONVEXITY_CONCAVE;
-      return c->reversals < 3;
-
-    case GSK_DIR_CHANGE_UNKNOWN:
-      c->finite = FALSE;
-      return FALSE;
-
-    case GSK_DIR_CHANGE_INVALID:
-    default:
-      g_assert_not_reached ();
-    }
-
-  if (graphene_vec2_get_x (v) > 0)
-    sign = 1;
-  else if (graphene_vec2_get_x (v) < 0)
-    sign = -1;
-  else
-    sign = 0;
-
-  if (sign != 0)
-    {
-      if (c->xsign != 42)
-        {
-          if (c->xsign != sign)
-            c->dx++;
-
-          if (c->dx > 2)
-            {
-              c->convexity = GSK_CONVEXITY_CONCAVE;
-              return FALSE;
-            }
-        }
-      c->xsign = sign;
-    }
-
-  if (graphene_vec2_get_y (v) > 0)
-    sign = 1;
-  else if (graphene_vec2_get_y (v) < 0)
-    sign = -1;
-  else
-    sign = 0;
-
-  if (sign != 0)
-    {
-      if (c->ysign != 42)
-        {
-          if (c->ysign != sign)
-            c->dy++;
-
-          if (c->dy > 2)
-            {
-              c->convexity = GSK_CONVEXITY_CONCAVE;
-              return FALSE;
-            }
-        }
-      c->ysign = sign;
-    }
-
-  return TRUE;
-}
-
-static void
-gsk_convexity_checker_init (GskConvexityChecker *c)
-{
-  c->first_point = GRAPHENE_POINT_INIT(0,0);
-  c->last_point = GRAPHENE_POINT_INIT(0,0);
-  graphene_vec2_init (&c->first_vec, 0, 0);
-  graphene_vec2_init (&c->last_vec, 0, 0);
-  c->expected_direction = GSK_DIR_CHANGE_INVALID;
-  c->first_direction = GSK_PATH_DIRECTION_UNKNOWN;
-  c->reversals = 0;
-  c->finite = TRUE;
-  c->convexity = GSK_CONVEXITY_UNKNOWN;
-  c->xsign = 42;
-  c->ysign = 42;
-  c->dx = 0;
-  c->dy = 0;
-}
-
-static void
-gsk_convexity_checker_move (GskConvexityChecker    *c,
-                            const graphene_point_t *p)
-{
-  c->first_point = c->last_point = *p;
-  c->expected_direction = GSK_DIR_CHANGE_INVALID;
-  c->convexity = GSK_CONVEXITY_CONVEX;
-}
-
-static gboolean
-gsk_convexity_checker_add_point (GskConvexityChecker    *c,
-                                 const graphene_point_t *p)
-{
-  graphene_vec2_t v;
-
-  if (graphene_point_equal (&c->last_point, p))
-    return TRUE;
-
-  graphene_vec2_init (&v,
-                      p->x - c->last_point.x,
-                      p->y - c->last_point.y);
-
-  if (graphene_point_equal (&c->first_point, &c->last_point) &&
-      c->expected_direction == GSK_DIR_CHANGE_INVALID)
-    {
-      graphene_vec2_init_from_vec2 (&c->last_vec, &v);
-      graphene_vec2_init_from_vec2 (&c->first_vec, &v);
-    }
-  else if (!add_vec (c, &v))
-    {
-      c->convexity = GSK_CONVEXITY_CONCAVE;
-      return FALSE;
-    }
-
-  c->last_point = *p;
-  return TRUE;
-}
-
-static gboolean
-gsk_convexity_checker_close (GskConvexityChecker *c)
-{
-  if (!(gsk_convexity_checker_add_point (c, &c->first_point) &&
-        add_vec (c, &c->first_vec)))
-    {
-      c->convexity = GSK_CONVEXITY_CONCAVE;
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-static gboolean
-convex_cb (GskPathOperation        op,
-           const graphene_point_t *pts,
-           gsize                   n_pts,
-           float                   weight,
-           gpointer                user_data)
-{
-  GskConvexityChecker *c = user_data;
-
-  switch (op)
-    {
-    case GSK_PATH_MOVE:
-      gsk_convexity_checker_move (c, &pts[0]);
-      break;
-    case GSK_PATH_CLOSE:
-      if (!gsk_convexity_checker_close (c))
-        return FALSE;
-      break;
-    case GSK_PATH_LINE:
-      if (!gsk_convexity_checker_add_point (c, &pts[1]))
-        return FALSE;
-      break;
-    case GSK_PATH_CURVE:
-      if (!gsk_convexity_checker_add_point (c, &pts[1]) ||
-          !gsk_convexity_checker_add_point (c, &pts[2]) ||
-          !gsk_convexity_checker_add_point (c, &pts[3]))
-        return FALSE;
-      break;
-    case GSK_PATH_CONIC:
-      if (!gsk_convexity_checker_add_point (c, &pts[1]) ||
-          !gsk_convexity_checker_add_point (c, &pts[3]))
-        return FALSE;
-      break;
-    default:
-      g_assert_not_reached ();
-    }
-
-  return TRUE;
-}
-
-GskConvexity
-gsk_contour_compute_convexity (const GskContour *contour)
-{
-  GskConvexityChecker c;
-
-  gsk_convexity_checker_init (&c);
-  gsk_contour_foreach (contour, 0.001, convex_cb, &c);
-
-  g_assert (c.convexity != GSK_CONVEXITY_UNKNOWN);
-
-  return c.convexity;
-}

gsk/gskconvexityprivate.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include "gskcontourprivate.h"
-
-typedef enum
-{
-  GSK_CONVEXITY_UNKNOWN,
-  GSK_CONVEXITY_CONVEX,
-  GSK_CONVEXITY_CONCAVE,
-} GskConvexity;
-
-GskConvexity gsk_contour_compute_convexity (const GskContour *contour);
-
-

gsk/gskcurveintersect.c

@@ -1,621 +0,0 @@
-/*
- * 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 "gskcurveprivate.h"
-
-static inline gboolean
-acceptable (float t)
-{
-  return 0 - FLT_EPSILON <= t && t <= 1 + FLT_EPSILON;
-}
-
-
-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 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 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;
-  float dist;
-
-  get_tangent (a, b, &n1);
-  angle = - atan2 (graphene_vec2_get_y (&n1), graphene_vec2_get_x (&n1));
-  sincosf (angle, &s, &c);
-
-  dist = sqrtf ((a->x - b->x)*(a->x - b->x) + (a->y - b->y)*(a->y - b->y));
-
-  for (int i = 0; i < n; i++)
-    {
-      q[i].x = ((p[i].x - a->x) * c - (p[i].y - a->y) * s) / dist;
-      q[i].y = ((p[i].x - a->x) * s + (p[i].y - a->y) * c) / dist;
-    }
-}
-
-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);
-}
-
-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;
-}
-
-static int
-line_curve_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->curve.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;
-}
-
-static void
-curve_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,
-                         float             tolerance)
-{
-  GskCurve p11, p12, p21, p22;
-  GskBoundingBox b1, b2;
-  float d1, d2;
-
-  if (*pos == n)
-    return;
-
-  gsk_curve_get_tight_bounds (curve1, &b1);
-  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);
-
-  curve_intersect_recurse (&p11, &p21, t1l,      t1l + d1, t2l,      t2l + d2, t1, t2, p, n, pos, tolerance);
-  curve_intersect_recurse (&p11, &p22, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, tolerance);
-  curve_intersect_recurse (&p12, &p21, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, tolerance);
-  curve_intersect_recurse (&p12, &p22, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, tolerance);
-}
-
-static int
-curve_intersect (const GskCurve   *curve1,
-                 const GskCurve   *curve2,
-                 float            *t1,
-                 float            *t2,
-                 graphene_point_t *p,
-                 int               n,
-                 float             tolerance)
-{
-  int pos = 0;
-
-  curve_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, tolerance);
-
-  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,
-                           float             tolerance)
-{
-  GskBoundingBox b1, b2;
-  float d1, d2;
-
-  if (*pos == n)
-    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], tolerance))
-            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, tolerance);
-  general_intersect_recurse (curve1, curve2, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, tolerance);
-  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, tolerance);
-  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, tolerance);
-}
-
-static int
-general_intersect (const GskCurve   *curve1,
-                   const GskCurve   *curve2,
-                   float            *t1,
-                   float            *t2,
-                   graphene_point_t *p,
-                   int               n,
-                   float             tolerance)
-{
-  int pos = 0;
-
-  general_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, tolerance);
-
-  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_CURVE)
-    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 = curve_intersect (&cs, &ce, tt, ss, pp, 3, 0.001);
-
-  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 (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;
-}
-
-/* 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 (memcmp (curve1, curve2, sizeof (GskCurve)) == 0)
-    return curve_self_intersect (curve1, t1, t2, p, n);
-
-  /* We special-case line-line and line-curve 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_CURVE)
-    return line_curve_intersect (curve1, curve2, t1, t2, p, n);
-  else if (op1 == GSK_PATH_CURVE && op2 == GSK_PATH_LINE)
-    return line_curve_intersect (curve2, curve1, t2, t1, p, n);
-  else if (op1 == GSK_PATH_CURVE && op2 == GSK_PATH_CURVE)
-    return curve_intersect (curve1, curve2, t1, t2, p, n, 0.001);
-  else
-    return general_intersect (curve1, curve2, t1, t2, p, n, 0.001);
-
-}

gsk/gskcurveprivate.h

@@ -1,164 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_CURVE_PRIVATE_H__
-#define __GSK_CURVE_PRIVATE_H__
-
-#include "gskpathopprivate.h"
-#include "gskboundingboxprivate.h"
-
-G_BEGIN_DECLS
-
-typedef gpointer gskpathop;
-
-typedef union _GskCurve GskCurve;
-
-typedef struct _GskLineCurve GskLineCurve;
-typedef struct _GskCurveCurve GskCurveCurve;
-typedef struct _GskConicCurve GskConicCurve;
-
-struct _GskLineCurve
-{
-  GskPathOperation op;
-
-  gboolean padding;
-
-  graphene_point_t points[2];
-};
-
-struct _GskCurveCurve
-{
-  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;
-  GskCurveCurve curve;
-  GskConicCurve conic;
-};
-
-typedef gboolean (* GskCurveAddLineFunc) (const graphene_point_t *from,
-                                          const graphene_point_t *to,
-                                          float                   from_progress,
-                                          float                   to_progress,
-                                          gpointer                user_data);
-
-typedef gboolean (* GskCurveAddCurveFunc) (const graphene_point_t points[4],
-                                           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_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_get_normal                    (const GskCurve         *curve,
-                                                                 float                   progress,
-                                                                 graphene_vec2_t        *normal);
-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,
-                                                                 float                   tolerance,
-                                                                 GskCurveAddCurveFunc    add_curve_func,
-                                                                 gpointer                user_data);
-gskpathop               gsk_curve_pathop                        (const GskCurve         *curve);
-#define gsk_curve_builder_to(curve, builder) gsk_path_builder_pathop_to ((builder), gsk_curve_pathop (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_bounds                    (const GskCurve         *curve,
-                                                                 GskBoundingBox         *bounds);
-void                    gsk_curve_get_tight_bounds              (const GskCurve         *curve,
-                                                                 GskBoundingBox         *bounds);
-
-int                     gsk_curve_intersect                     (const GskCurve         *curve1,
-                                                                 const GskCurve         *curve2,
-                                                                 float                  *t1,
-                                                                 float                  *t2,
-                                                                 graphene_point_t       *p,
-                                                                 int                     n);
-
-void                    gsk_curve_offset                        (const GskCurve         *curve,
-                                                                 float                   distance,
-                                                                 GskCurve               *offset_curve);
-void                    gsk_curve_reverse                       (const GskCurve         *curve,
-                                                                 GskCurve               *reverse);
-
-float                   gsk_curve_get_curvature                 (const GskCurve         *curve,
-                                                                 float                   t,
-                                                                 graphene_point_t       *center);
-
-int                     gsk_curve_get_curvature_points          (const GskCurve         *curve,
-                                                                 float                   t[3]);
-
-int                     gsk_curve_get_cusps                     (const GskCurve         *curve,
-                                                                 float                   t[2]);
-
-void                    gsk_curve_print                         (const GskCurve         *curve);
-
-
-G_END_DECLS
-
-#endif /* __GSK_CURVE_PRIVATE_H__ */
-

gsk/gskdebug.c

@@ -10,7 +10,6 @@ static const GdkDebugKey gsk_debug_keys[] = {
   { "surface", GSK_DEBUG_SURFACE, "Information about surfaces" },
   { "fallback", GSK_DEBUG_FALLBACK, "Information about fallbacks" },
   { "glyphcache", GSK_DEBUG_GLYPH_CACHE, "Information about glyph caching" },
-  { "paths", GSK_DEBUG_PATHS, "Information about path processing" },
   { "geometry", GSK_DEBUG_GEOMETRY, "Show borders (when using cairo)" },
   { "full-redraw", GSK_DEBUG_FULL_REDRAW, "Force full redraws" },
   { "sync", GSK_DEBUG_SYNC, "Sync after each frame" },

gsk/gskdebugprivate.h

@@ -14,7 +14,6 @@ typedef enum {
   GSK_DEBUG_VULKAN                = 1 <<  5,
   GSK_DEBUG_FALLBACK              = 1 <<  6,
   GSK_DEBUG_GLYPH_CACHE           = 1 <<  7,
-  GSK_DEBUG_PATHS                 = 1 <<  8,
   /* flags below may affect behavior */
   GSK_DEBUG_GEOMETRY              = 1 <<  9,
   GSK_DEBUG_FULL_REDRAW           = 1 << 10,

gsk/gskenums.h

@@ -1,5 +1,5 @@
 /* GSK - The GTK Scene Kit
- * Copyright 2016  Endless
+ * Copyright 2016  Endless 
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -50,7 +50,7 @@
  * @GSK_BLUR_NODE: A node that applies a blur
  * @GSK_DEBUG_NODE: Debug information that does not affect the rendering
  * @GSK_GL_SHADER_NODE: A node that uses OpenGL fragment shaders to render
-
+ 
  * The type of a node determines what the node is rendering.
  */
 typedef enum {
@@ -73,8 +73,6 @@ typedef enum {
   GSK_REPEAT_NODE,
   GSK_CLIP_NODE,
   GSK_ROUNDED_CLIP_NODE,
-  GSK_FILL_NODE,
-  GSK_STROKE_NODE,
   GSK_SHADOW_NODE,
   GSK_BLEND_NODE,
   GSK_CROSS_FADE_NODE,
@@ -169,107 +167,6 @@ typedef enum {
   GSK_CORNER_BOTTOM_LEFT
 } GskCorner;
 
-/**
- * GskFillRule:
- * @GSK_FILL_RULE_WINDING: If the path crosses the ray from
- *   left-to-right, counts +1. If the path crosses the ray
- *   from right to left, counts -1. (Left and right are determined
- *   from the perspective of looking along the ray from the starting
- *   point.) If the total count is non-zero, the point will be filled.
- * @GSK_FILL_RULE_EVEN_ODD: Counts the total number of
- *   intersections, without regard to the orientation of the contour. If
- *   the total number of intersections is odd, the point will be
- *   filled.
- *
- * #GskFillRule is used to select how paths are filled, 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.
- * (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
-} GskFillRule;
-
-/**
- * GskLineCap:
- * @GSK_LINE_CAP_BUTT: Start and stop the line exactly at the start
- *   and end point
- * @GSK_LINE_CAP_ROUND: Use a round ending, the center of the circle
- *   is the start or end point.
- * @GSK_LINE_CAP_SQUARE: use squared ending, the center of the square
- *   is the start or end point.
- *
- * Specifies how to render the start and end points of contours or
- * dashes when stroking.
- *
- * The default line cap style is @GSK_LINE_CAP_BUTT.
- */
-typedef enum {
-  GSK_LINE_CAP_BUTT,
-  GSK_LINE_CAP_ROUND,
-  GSK_LINE_CAP_SQUARE
-} GskLineCap;
-
-/**
- * GskLineJoin:
- * @GSK_LINE_JOIN_MITER: Use a sharp, angled corner
- * @GSK_LINE_JOIN_MITER_CLIP: Use a sharp, angled corner, at a distance
- * @GSK_LINE_JOIN_ROUND: Use a round join, the center of the circle is
- *   the 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
- * @GSK_LINE_JOIN_ARCS: Use a sharp angled corner made from circles
- *
- * Specifies how to render the junction of two lines when stroking.
- *
- * See [method@Gsk.Stroke.set_miter_limit] for details on the difference
- * between @GSK_LINE_JOIN_MITER and @GSK_LINE_JOIN_MITER_CLIP.
- *
- * The default line join style is @GSK_LINE_JOIN_MITER.
- **/
-typedef enum {
-  GSK_LINE_JOIN_MITER,
-  GSK_LINE_JOIN_MITER_CLIP,
-  GSK_LINE_JOIN_ROUND,
-  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_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.
- *
- * More values may be added in the future.
- **/
-typedef enum {
-  GSK_PATH_MOVE,
-  GSK_PATH_CLOSE,
-  GSK_PATH_LINE,
-  GSK_PATH_CURVE,
-  GSK_PATH_CONIC,
-} GskPathOperation;
-
 /**
  * GskSerializationError:
  * @GSK_SERIALIZATION_UNSUPPORTED_FORMAT: The format can not be identified
@@ -354,4 +251,5 @@ typedef enum
   GSK_GL_UNIFORM_TYPE_VEC4,
 } GskGLUniformType;
 
+
 #endif /* __GSK_TYPES_H__ */

gsk/gskpath.h

@@ -1,154 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#ifndef __GSK_PATH_H__
-#define __GSK_PATH_H__
-
-#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gsk/gsk.h> can be included directly."
-#endif
-
-
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-/**
- * GskPathForeachFlags:
- * @GSK_PATH_FOREACH_ALLOW_CURVE: Allow emission of `GSK_PATH_CURVE` operations.
- * @GSK_PATH_FOREACH_ALLOW_CONIC: Allow emission of `GSK_PATH_CONIC` operations.
- *
- * Flags that can be passed to [method@Gsk.Path.foreach] to enable additional
- * features.
- *
- * By default, [method@Gsk.Path.foreach] will only emit a path with all
- * operations flattened to straight lines to allow for maximum compatibility.
- * The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and
- * `GSK_PATH_CLOSE`.
- */
-typedef enum
-{
-  GSK_PATH_FOREACH_ALLOW_CURVE = (1 << 0),
-  GSK_PATH_FOREACH_ALLOW_CONIC = (1 << 1)
-} GskPathForeachFlags;
-
-/**
- * GskPathForeachFunc:
- * @op: The operation to perform
- * @pts: The points of the operation
- * @n_pts: The number of points
- * @weight: The weight for conic curves, or unused if not a conic curve.
- * @user_data: The user data provided with the function
- *
- * Prototype of the callback to iterate throught the operations of
- * a path.
- *
- * Returns: %TRUE to continue evaluating the path, %FALSE to
- *   immediately abort and not call the function again.
- */
-typedef gboolean (* GskPathForeachFunc) (GskPathOperation        op,
-                                         const graphene_point_t *pts,
-                                         gsize                   n_pts,
-                                         float                   weight,
-                                         gpointer                user_data);
-
-#define GSK_TYPE_PATH (gsk_path_get_type ())
-
-GDK_AVAILABLE_IN_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);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_unref                          (GskPath                *self);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_print                          (GskPath                *self,
-                                                                 GString                *string);
-GDK_AVAILABLE_IN_ALL
-char *                  gsk_path_to_string                      (GskPath                *self);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_parse                          (const char             *string);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_to_cairo                       (GskPath                *self,
-                                                                 cairo_t                *cr);
-
-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);
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_get_stroke_bounds              (GskPath                *path,
-                                                                 const GskStroke        *stroke,
-                                                                 graphene_rect_t        *bounds);
-
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_is_convex                      (GskPath                *self);
-
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_foreach                        (GskPath                *self,
-                                                                 GskPathForeachFlags     flags,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_reverse                        (GskPath                *self);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_transform                      (GskPath                *self,
-                                                                 GskTransform           *transform);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_stroke                         (GskPath                *self,
-                                                                 GskStroke              *stroke);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_offset                         (GskPath                *self,
-                                                                 float                   distance,
-                                                                 GskLineJoin             line_join,
-                                                                 float                   miter_limit);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_union                          (GskPath                *first,
-                                                                 GskPath                *second);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_intersection                   (GskPath                *first,
-                                                                 GskPath                *second);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_difference                     (GskPath                *first,
-                                                                 GskPath                *second);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_symmetric_difference           (GskPath                *first,
-                                                                 GskPath                *second);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_simplify                       (GskPath                *self);
-
-
-G_END_DECLS
-
-#endif /* __GSK_PATH_H__ */

gsk/gskpathbuilder.c

@@ -1,964 +0,0 @@
-/*
- * 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 "gskpathbuilder.h"
-
-#include "gskpathprivate.h"
-
-/**
- * GskPathBuilder:
- *
- * A `GskPathBuilder` is an auxiliary object that is used to
- * create new `GskPath` objects.
- *
- * A path is constructed like this:
- *
- * ```
- * GskPath *
- * construct_path (void)
- * {
- *   GskPathBuilder *builder;
- *
- *   builder = gsk_path_builder_new ();
- *
- *   // add contours to the path here
- *
- *   return gsk_path_builder_free_to_path (builder);
- * }
- * ```
- *
- * 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 [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 [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
- * [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.
- */
-
-struct _GskPathBuilder
-{
-  int ref_count;
-
-  GSList *contours; /* (reverse) list of already recorded contours */
-
-  GskPathFlags flags; /* flags for the current path */
-  graphene_point_t current_point; /* the point all drawing ops start from */
-  GArray *ops; /* operations for current contour - size == 0 means no current contour */
-  GArray *points; /* points for the operations */
-};
-
-G_DEFINE_BOXED_TYPE (GskPathBuilder,
-                     gsk_path_builder,
-                     gsk_path_builder_ref,
-                     gsk_path_builder_unref)
-
-
-/**
- * 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.
- *
- * Returns: a new `GskPathBuilder`
- **/
-GskPathBuilder *
-gsk_path_builder_new (void)
-{
-  GskPathBuilder *builder;
-
-  builder = g_slice_new0 (GskPathBuilder);
-  builder->ref_count = 1;
-
-  builder->ops = g_array_new (FALSE, FALSE, sizeof (gskpathop));
-  builder->points = g_array_new (FALSE, FALSE, sizeof (graphene_point_t));
-
-  /* Be explicit here */
-  builder->current_point = GRAPHENE_POINT_INIT (0, 0);
-
-  return builder;
-}
-
-/**
- * gsk_path_builder_ref:
- * @builder: a `GskPathBuilder`
- *
- * Acquires a reference on the given @builder.
- *
- * This function is intended primarily for bindings. `GskPathBuilder` objects
- * should not be kept around.
- *
- * Returns: (transfer none): the given `GskPathBuilder` with
- *   its reference count increased
- */
-GskPathBuilder *
-gsk_path_builder_ref (GskPathBuilder *builder)
-{
-  g_return_val_if_fail (builder != NULL, NULL);
-  g_return_val_if_fail (builder->ref_count > 0, NULL);
-
-  builder->ref_count += 1;
-
-  return builder;
-}
-
-/* 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 *builder)
-{
-  if (builder->ops->len != 0)
-    return;
-
-  builder->flags = GSK_PATH_FLAT;
-  g_array_append_vals (builder->ops, (gskpathop[1]) { gsk_pathop_encode_index (GSK_PATH_MOVE, 0) }, 1);
-  g_array_append_val (builder->points, builder->current_point);
-}
-
-static void
-gsk_path_builder_append_current (GskPathBuilder         *builder,
-                                 GskPathOperation        op,
-                                 gsize                   n_points,
-                                 const graphene_point_t *points)
-{
-  gsk_path_builder_ensure_current (builder);
-
-  g_array_append_vals (builder->ops, (gskpathop[1]) { gsk_pathop_encode_index (op, builder->points->len - 1) }, 1);
-  g_array_append_vals (builder->points, points, n_points);
-
-  builder->current_point = points[n_points - 1];
-}
-
-static void
-gsk_path_builder_end_current (GskPathBuilder *builder)
-{
-  GskContour *contour;
-
-  if (builder->ops->len == 0)
-   return;
-
-  contour = gsk_standard_contour_new (builder->flags,
-                                      (graphene_point_t *) builder->points->data,
-                                      builder->points->len,
-                                      (gskpathop *) builder->ops->data,
-                                      builder->ops->len,
-                                      (graphene_point_t *) builder->points->data - (graphene_point_t *) NULL);
-
-  g_array_set_size (builder->ops, 0);
-  g_array_set_size (builder->points, 0);
-
-  /* do this at the end to avoid inflooping when add_contour calls back here */
-  gsk_path_builder_add_contour (builder, contour);
-}
-
-static void
-gsk_path_builder_clear (GskPathBuilder *builder)
-{
-  gsk_path_builder_end_current (builder);
-
-  g_slist_free_full (builder->contours, g_free);
-  builder->contours = NULL;
-}
-
-/**
- * gsk_path_builder_unref:
- * @builder: a `GskPathBuilder`
- *
- * Releases a reference on the given @builder.
- */
-void
-gsk_path_builder_unref (GskPathBuilder *builder)
-{
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (builder->ref_count > 0);
-
-  builder->ref_count -= 1;
-
-  if (builder->ref_count > 0)
-    return;
-
-  gsk_path_builder_clear (builder);
-  g_array_unref (builder->ops);
-  g_array_unref (builder->points);
-  g_slice_free (GskPathBuilder, builder);
-}
-
-/**
- * gsk_path_builder_free_to_path: (skip)
- * @builder: a `GskPathBuilder`
- *
- * Creates a new `GskPath` from the current state of the
- * given @builder, and frees the @builder instance.
- *
- * Returns: (transfer full): the newly created `GskPath`
- *   with all the contours added to @builder
- */
-GskPath *
-gsk_path_builder_free_to_path (GskPathBuilder *builder)
-{
-  GskPath *res;
-
-  g_return_val_if_fail (builder != NULL, NULL);
-
-  res = gsk_path_builder_to_path (builder);
-
-  gsk_path_builder_unref (builder);
-
-  return res;
-}
-
-/**
- * gsk_path_builder_to_path:
- * @builder: a `GskPathBuilder`
- *
- * 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.
- *
- * This function is intended primarily for bindings. C code should use
- * gsk_path_builder_free_to_path().
- *
- * Returns: (transfer full): the newly created `GskPath`
- *   with all the contours added to @builder
- */
-GskPath *
-gsk_path_builder_to_path (GskPathBuilder *builder)
-{
-  GskPath *path;
-
-  g_return_val_if_fail (builder != NULL, NULL);
-
-  gsk_path_builder_end_current (builder);
-
-  builder->contours = g_slist_reverse (builder->contours);
-
-  path = gsk_path_new_from_contours (builder->contours);
-
-  gsk_path_builder_clear (builder);
-
-  return path;
-}
-
-void
-gsk_path_builder_add_contour (GskPathBuilder *builder,
-                              GskContour     *contour)
-{
-  gsk_path_builder_end_current (builder);
-
-  builder->contours = g_slist_prepend (builder->contours, contour);
-}
-
-/**
- * gsk_path_builder_get_current_point:
- * @builder: a #GskPathBuilder
- *
- * Gets the current point. The current point is used for relative
- * drawing commands and updated after every operation.
- *
- * When @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 *builder)
-{
-  g_return_val_if_fail (builder != NULL, NULL);
-
-  return &builder->current_point;
-}
-
-/**
- * gsk_path_builder_add_path:
- * @builder: a `GskPathBuilder`
- * @path: (transfer none): the path to append
- *
- * Appends all of @path to @builder.
- **/
-void
-gsk_path_builder_add_path (GskPathBuilder *builder,
-                           GskPath        *path)
-{
-  gsize i;
-
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (path != NULL);
-
-  for (i = 0; i < gsk_path_get_n_contours (path); i++)
-    {
-      const GskContour *contour = gsk_path_get_contour (path, i);
-
-      gsk_path_builder_add_contour (builder, gsk_contour_dup (contour));
-    }
-}
-
-/**
- * gsk_path_builder_add_rect:
- * @builder: A `GskPathBuilder`
- * @rect: The rectangle to add to @builder
- *
- * Adds a path representing the given rectangle.
- *
- * If the width or height of the rectangle is negative, the start
- * point will be on the right or bottom, respectively.
- *
- * 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        *builder,
-                           const graphene_rect_t *rect)
-{
-  GskContour *contour;
-
-  g_return_if_fail (builder != NULL);
-
-  contour = gsk_rect_contour_new (rect);
-  gsk_path_builder_add_contour (builder, contour);
-
-  gsk_contour_get_start_end (contour, NULL, &builder->current_point);
-}
-
-/**
- * gsk_path_builder_add_rounded_rect:
- * @builder: a `GskPathBuilder`
- * @rect: the rounded rect
- *
- * Adds @rect as a new contour to the path built in @builder.
- **/
-void
-gsk_path_builder_add_rounded_rect (GskPathBuilder       *builder,
-                                   const GskRoundedRect *rect)
-{
-  const float weight = sqrt(0.5f);
-
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (rect != NULL);
-
-  gsk_path_builder_move_to (builder,
-                            rect->bounds.origin.x + rect->corner[GSK_CORNER_TOP_LEFT].width,
-                            rect->bounds.origin.y);
-  /* top */
-  gsk_path_builder_line_to (builder,
-                            rect->bounds.origin.x + rect->bounds.size.width - rect->corner[GSK_CORNER_TOP_RIGHT].width,
-                            rect->bounds.origin.y);
-  /* topright corner */
-  gsk_path_builder_conic_to (builder,
-                             rect->bounds.origin.x + rect->bounds.size.width,
-                             rect->bounds.origin.y,
-                             rect->bounds.origin.x + rect->bounds.size.width,
-                             rect->bounds.origin.y + rect->corner[GSK_CORNER_TOP_RIGHT].height,
-                             weight);
-  /* right */
-  gsk_path_builder_line_to (builder,
-                            rect->bounds.origin.x + rect->bounds.size.width,
-                            rect->bounds.origin.y + rect->bounds.size.height - rect->corner[GSK_CORNER_BOTTOM_RIGHT].height);
-  /* bottomright corner */
-  gsk_path_builder_conic_to (builder,
-                             rect->bounds.origin.x + rect->bounds.size.width,
-                             rect->bounds.origin.y + rect->bounds.size.height,
-                             rect->bounds.origin.x + rect->bounds.size.width - rect->corner[GSK_CORNER_BOTTOM_RIGHT].width,
-                             rect->bounds.origin.y + rect->bounds.size.height,
-                             weight);
-  /* bottom */
-  gsk_path_builder_line_to (builder,
-                            rect->bounds.origin.x + rect->corner[GSK_CORNER_BOTTOM_LEFT].width,
-                            rect->bounds.origin.y + rect->bounds.size.height);
-  /* bottomleft corner */
-  gsk_path_builder_conic_to (builder,
-                             rect->bounds.origin.x,
-                             rect->bounds.origin.y + rect->bounds.size.height,
-                             rect->bounds.origin.x,
-                             rect->bounds.origin.y + rect->bounds.size.height - rect->corner[GSK_CORNER_BOTTOM_LEFT].height,
-                             weight);
-  /* left */
-  gsk_path_builder_line_to (builder,
-                            rect->bounds.origin.x,
-                            rect->bounds.origin.y + rect->corner[GSK_CORNER_TOP_LEFT].height);
-  /* topleft corner */
-  gsk_path_builder_conic_to (builder,
-                             rect->bounds.origin.x,
-                             rect->bounds.origin.y,
-                             rect->bounds.origin.x + rect->corner[GSK_CORNER_TOP_LEFT].width,
-                             rect->bounds.origin.y,
-                             weight);
-  /* done */
-  gsk_path_builder_close (builder);
-}
-
-/**
- * gsk_path_builder_add_circle:
- * @builder: 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         *builder,
-                             const graphene_point_t *center,
-                             float                   radius)
-{
-  GskContour *contour;
-
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (center != NULL);
-  g_return_if_fail (radius > 0);
-
-  contour = gsk_circle_contour_new (center, radius, 0, 360);
-  gsk_path_builder_add_contour (builder, contour);
-}
-
-/**
- * gsk_path_builder_add_ellipse:
- * @builder: 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         *builder,
-                              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 (builder != 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 (builder, pts[0].x, pts[0].y);
-  gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y, weight);
-  gsk_path_builder_conic_to (builder, pts[3].x, pts[3].y, pts[4].x, pts[4].y, weight);
-  gsk_path_builder_conic_to (builder, pts[5].x, pts[5].y, pts[6].x, pts[6].y, weight);
-  gsk_path_builder_conic_to (builder, pts[7].x, pts[7].y, pts[0].x, pts[0].y, weight);
-  gsk_path_builder_close (builder);
-}
-
-/**
- * gsk_path_builder_move_to:
- * @builder: 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.
- **/
-void
-gsk_path_builder_move_to (GskPathBuilder *builder,
-                          float           x,
-                          float           y)
-{
-  g_return_if_fail (builder != NULL);
-
-  gsk_path_builder_end_current (builder);
-
-  builder->current_point = GRAPHENE_POINT_INIT(x, y);
-
-  gsk_path_builder_ensure_current (builder);
-}
-
-/**
- * gsk_path_builder_rel_move_to:
- * @builder: 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 [method@Gsk.PathBuilder.move_to].
- **/
-void
-gsk_path_builder_rel_move_to (GskPathBuilder *builder,
-                              float           x,
-                              float           y)
-{
-  g_return_if_fail (builder != NULL);
-
-  gsk_path_builder_move_to (builder,
-                            builder->current_point.x + x,
-                            builder->current_point.y + y);
-}
-
-/**
- * gsk_path_builder_line_to:
- * @builder: 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.
- **/
-void
-gsk_path_builder_line_to (GskPathBuilder *builder,
-                          float           x,
-                          float           y)
-{
-  g_return_if_fail (builder != NULL);
-
-  /* skip the line if it goes to the same point */
-  if (graphene_point_equal (&builder->current_point,
-                            &GRAPHENE_POINT_INIT (x, y)))
-    return;
-
-  gsk_path_builder_append_current (builder,
-                                   GSK_PATH_LINE,
-                                   1, (graphene_point_t[1]) {
-                                     GRAPHENE_POINT_INIT (x, y)
-                                   });
-}
-
-/**
- * gsk_path_builder_rel_line_to:
- * @builder: 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 [method@Gsk.PathBuilder.line_to].
- **/
-void
-gsk_path_builder_rel_line_to (GskPathBuilder *builder,
-                              float           x,
-                              float           y)
-{
-  g_return_if_fail (builder != NULL);
-
-  gsk_path_builder_line_to (builder,
-                            builder->current_point.x + x,
-                            builder->current_point.y + y);
-}
-
-/**
- * gsk_path_builder_curve_to:
- * @builder: a `GskPathBuilder`
- * @x1: x coordinate of first control point
- * @y1: y coordinate of first control point
- * @x2: x coordinate of second control point
- * @y2: y coordinate of second control point
- * @x3: x coordinate of the end of the curve
- * @y3: y coordinate of the end of the curve
- *
- * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
- * from the current point to @x3, @y3 with @x1, @y1 and @x2, @y2 as the control
- * points.
- *
- * After this, @x3, @y3 will be the new current point.
- **/
-void
-gsk_path_builder_curve_to (GskPathBuilder *builder,
-                           float           x1,
-                           float           y1,
-                           float           x2,
-                           float           y2,
-                           float           x3,
-                           float           y3)
-{
-  g_return_if_fail (builder != NULL);
-
-  builder->flags &= ~GSK_PATH_FLAT;
-  gsk_path_builder_append_current (builder,
-                                   GSK_PATH_CURVE,
-                                   3, (graphene_point_t[3]) {
-                                     GRAPHENE_POINT_INIT (x1, y1),
-                                     GRAPHENE_POINT_INIT (x2, y2),
-                                     GRAPHENE_POINT_INIT (x3, y3)
-                                   });
-}
-
-/**
- * gsk_path_builder_rel_curve_to:
- * @builder: a `GskPathBuilder`
- * @x1: x offset of first control point
- * @y1: y offset of first control point
- * @x2: x offset of second control point
- * @y2: y offset of second control point
- * @x3: x offset of the end of the curve
- * @y3: y offset of the end of the curve
- *
- * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
- * 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 [method@Gsk.PathBuilder.curve_to].
- **/
-void
-gsk_path_builder_rel_curve_to (GskPathBuilder *builder,
-                               float           x1,
-                               float           y1,
-                               float           x2,
-                               float           y2,
-                               float           x3,
-                               float           y3)
-{
-  g_return_if_fail (builder != NULL);
-
-  gsk_path_builder_curve_to (builder,
-                             builder->current_point.x + x1,
-                             builder->current_point.y + y1,
-                             builder->current_point.x + x2,
-                             builder->current_point.y + y2,
-                             builder->current_point.x + x3,
-                             builder->current_point.y + y3);
-}
-
-/**
- * gsk_path_builder_conic_to:
- * @builder: 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 *builder,
-                           float           x1,
-                           float           y1,
-                           float           x2,
-                           float           y2,
-                           float           weight)
-{
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (weight >= 0);
-
-  builder->flags &= ~GSK_PATH_FLAT;
-  gsk_path_builder_append_current (builder,
-                                   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:
- * @builder: 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 *builder,
-                               float           x1,
-                               float           y1,
-                               float           x2,
-                               float           y2,
-                               float           weight)
-{
-  g_return_if_fail (builder != NULL);
-  g_return_if_fail (weight >= 0);
-
-  gsk_path_builder_conic_to (builder,
-                             builder->current_point.x + x1,
-                             builder->current_point.y + y1,
-                             builder->current_point.x + x2,
-                             builder->current_point.y + y2,
-                             weight);
-}
-
-/**
- * gsk_path_builder_close:
- * @builder: a `GskPathBuilder`
- *
- * Ends the current contour with a line back to the start point.
- *
- * 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 *builder)
-{
-  g_return_if_fail (builder != NULL);
-
-  if (builder->ops->len == 0)
-    return;
-
-  builder->flags |= GSK_PATH_CLOSED;
-  gsk_path_builder_append_current (builder,
-                                   GSK_PATH_CLOSE,
-                                   1, (graphene_point_t[1]) {
-                                     g_array_index (builder->points, graphene_point_t, 0)
-                                   });
-
-  gsk_path_builder_end_current (builder);
-}
-
-
-static void
-arc_segment (GskPathBuilder *builder,
-             double          cx,
-             double          cy,
-             double          rx,
-             double          ry,
-             double          sin_phi,
-             double          cos_phi,
-             double          sin_th0,
-             double          cos_th0,
-             double          sin_th1,
-             double          cos_th1,
-             double          t)
-{
-  double x1, y1, x2, y2, x3, y3;
-
-  x1 = rx * (cos_th0 - t * sin_th0);
-  y1 = ry * (sin_th0 + t * cos_th0);
-  x3 = rx * cos_th1;
-  y3 = ry * sin_th1;
-  x2 = x3 + rx * (t * sin_th1);
-  y2 = y3 + ry * (-t * cos_th1);
-
-  gsk_path_builder_curve_to (builder,
-                             cx + cos_phi * x1 - sin_phi * y1,
-                             cy + sin_phi * x1 + cos_phi * y1,
-                             cx + cos_phi * x2 - sin_phi * y2,
-                             cy + sin_phi * x2 + cos_phi * y2,
-                             cx + cos_phi * x3 - sin_phi * y3,
-                             cy + sin_phi * x3 + cos_phi * y3);
-}
-
-void
-gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
-                             float           rx,
-                             float           ry,
-                             float           x_axis_rotation,
-                             gboolean        large_arc,
-                             gboolean        positive_sweep,
-                             float           x,
-                             float           y)
-{
-  graphene_point_t *current;
-  double x1, y1, x2, y2;
-  double phi, sin_phi, cos_phi;
-  double mid_x, mid_y;
-  double lambda;
-  double d;
-  double k;
-  double x1_, y1_;
-  double cx_, cy_;
-  double  cx, cy;
-  double ux, uy, u_len;
-  double cos_theta1, theta1;
-  double vx, vy, v_len;
-  double dp_uv;
-  double cos_delta_theta, delta_theta;
-  int i, n_segs;
-  double d_theta, theta;
-  double sin_th0, cos_th0;
-  double sin_th1, cos_th1;
-  double th_half;
-  double t;
-
-  if (builder->points->len > 0)
-    {
-      current = &g_array_index (builder->points, graphene_point_t, builder->points->len - 1);
-      x1 = current->x;
-      y1 = current->y;
-    }
-  else
-    {
-      x1 = 0;
-      y1 = 0;
-    }
-  x2 = x;
-  y2 = y;
-
-  phi = x_axis_rotation * M_PI / 180.0;
-  sincos (phi, &sin_phi, &cos_phi);
-
-  rx = fabs (rx);
-  ry = fabs (ry);
-
-  mid_x = (x1 - x2) / 2;
-  mid_y = (y1 - y2) / 2;
-
-  x1_ = cos_phi * mid_x + sin_phi * mid_y;
-  y1_ = - sin_phi * mid_x + cos_phi * mid_y;
-
-  lambda = (x1_ / rx) * (x1_ / rx) + (y1_ / ry) * (y1_ / ry);
-  if (lambda > 1)
-    {
-      lambda = sqrt (lambda);
-      rx *= lambda;
-      ry *= lambda;
-    }
-
-  d = (rx * y1_) * (rx * y1_) + (ry * x1_) * (ry * x1_);
-  if (d == 0)
-    return;
-
-  k = sqrt (fabs ((rx * ry) * (rx * ry) / d - 1.0));
-  if (positive_sweep == large_arc)
-    k = -k;
-
-  cx_ = k * rx * y1_ / ry;
-  cy_ = -k * ry * x1_ / rx;
-
-  cx = cos_phi * cx_ - sin_phi * cy_ + (x1 + x2) / 2;
-  cy = sin_phi * cx_ + cos_phi * cy_ + (y1 + y2) / 2;
-
-  ux = (x1_ - cx_) / rx;
-  uy = (y1_ - cy_) / ry;
-  u_len = sqrt (ux * ux + uy * uy);
-  if (u_len == 0)
-    return;
-
-  cos_theta1 = CLAMP (ux / u_len, -1, 1);
-  theta1 = acos (cos_theta1);
-  if (uy < 0)
-    theta1 = - theta1;
-
-  vx = (- x1_ - cx_) / rx;
-  vy = (- y1_ - cy_) / ry;
-  v_len = sqrt (vx * vx + vy * vy);
-  if (v_len == 0)
-    return;
-
-  dp_uv = ux * vx + uy * vy;
-  cos_delta_theta = CLAMP (dp_uv / (u_len * v_len), -1, 1);
-  delta_theta = acos (cos_delta_theta);
-  if (ux * vy - uy * vx < 0)
-    delta_theta = - delta_theta;
-  if (positive_sweep && delta_theta < 0)
-    delta_theta += 2 * M_PI;
-  else if (!positive_sweep && delta_theta > 0)
-    delta_theta -= 2 * M_PI;
-
-  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);
-
-  th_half = d_theta / 2;
-  t = (8.0 / 3.0) * sin (th_half / 2) * sin (th_half / 2) / sin (th_half);
-
-  for (i = 0; i < n_segs; i++)
-    {
-      theta = theta1;
-      theta1 = theta + d_theta;
-      sin_th0 = sin_th1;
-      cos_th0 = cos_th1;
-      sincos (theta1, &sin_th1, &cos_th1);
-      arc_segment (builder,
-                   cx, cy, rx, ry,
-                   sin_phi, cos_phi,
-                   sin_th0, cos_th0,
-                   sin_th1, cos_th1,
-                   t);
-    }
-}
-
-/**
- * gsk_path_builder_add_layout:
- * @builder: a `GskPathBuilder`
- * @layout: the pango layout to add
- *
- * Adds the outlines for the glyphs in @layout to @builder.
- */
-void
-gsk_path_builder_add_layout (GskPathBuilder *builder,
-                             PangoLayout    *layout)
-{
-  cairo_surface_t *surface;
-  cairo_t *cr;
-  cairo_path_t *cairo_path;
-  GskPath *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_flat (cr);
-  path = gsk_path_new_from_cairo (cairo_path);
-
-  gsk_path_builder_add_path (builder, path);
-
-  gsk_path_unref (path);
-
-  cairo_path_destroy (cairo_path);
-  cairo_destroy (cr);
-  cairo_surface_destroy (surface);
-}

gsk/gskpathbuilder.h

@@ -1,132 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#ifndef __GSK_PATH_BUILDER_H__
-#define __GSK_PATH_BUILDER_H__
-
-#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gsk/gsk.h> can be included directly."
-#endif
-
-
-#include <gsk/gskroundedrect.h>
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_PATH_BUILDER (gsk_path_builder_get_type ())
-
-GDK_AVAILABLE_IN_ALL
-GType                   gsk_path_builder_get_type               (void) G_GNUC_CONST;
-
-GDK_AVAILABLE_IN_ALL
-GskPathBuilder *        gsk_path_builder_new                    (void);
-GDK_AVAILABLE_IN_ALL
-GskPathBuilder *        gsk_path_builder_ref                    (GskPathBuilder         *builder);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_unref                  (GskPathBuilder         *builder);
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_builder_free_to_path           (GskPathBuilder         *builder) G_GNUC_WARN_UNUSED_RESULT;
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_builder_to_path                (GskPathBuilder         *builder) G_GNUC_WARN_UNUSED_RESULT;
-
-GDK_AVAILABLE_IN_ALL
-const graphene_point_t *gsk_path_builder_get_current_point      (GskPathBuilder         *builder);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_path               (GskPathBuilder         *builder,
-                                                                 GskPath                *path);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_rect               (GskPathBuilder         *builder,
-                                                                 const graphene_rect_t  *rect);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_rounded_rect       (GskPathBuilder         *builder,
-                                                                 const GskRoundedRect   *rect);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_circle             (GskPathBuilder         *builder,
-                                                                 const graphene_point_t *center,
-                                                                 float                   radius);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_ellipse            (GskPathBuilder         *builder,
-                                                                 const graphene_point_t *center,
-                                                                 const graphene_size_t  *radius);
-/* next function implemented in gskpathmeasure.c */
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_segment            (GskPathBuilder         *builder,
-                                                                 GskPathMeasure         *measure,
-                                                                 float                   start,
-                                                                 float                   end);
-
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_move_to                (GskPathBuilder         *builder,
-                                                                 float                   x,
-                                                                 float                   y);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_rel_move_to            (GskPathBuilder         *builder,
-                                                                 float                   x,
-                                                                 float                   y);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_line_to                (GskPathBuilder         *builder,
-                                                                 float                   x,
-                                                                 float                   y);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_rel_line_to            (GskPathBuilder         *builder,
-                                                                 float                   x,
-                                                                 float                   y);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_curve_to               (GskPathBuilder         *builder,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   x3,
-                                                                 float                   y3);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_rel_curve_to           (GskPathBuilder         *builder,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   x3,
-                                                                 float                   y3);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_conic_to               (GskPathBuilder         *builder,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   weight);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_rel_conic_to           (GskPathBuilder         *builder,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   weight);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_close                  (GskPathBuilder         *builder);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_builder_add_layout             (GskPathBuilder         *builder,
-                                                                 PangoLayout            *layout);
-
-G_END_DECLS
-
-#endif /* __GSK_PATH_BUILDER_H__ */

gsk/gskpathdash.c

@@ -1,291 +0,0 @@
-/*
- * 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 "gskpathdashprivate.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,
-                                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_CURVE:
-    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;
-}
-
-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/gskpathdashprivate.h

@@ -1,50 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_PATH_DASH_PRIVATE_H__
-#define __GSK_PATH_DASH_PRIVATE_H__
-
-#include <gsk/gskpath.h>
-
-G_BEGIN_DECLS
-
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_dash                           (GskPath                *path,
-                                                                 GskStroke              *stroke,
-                                                                 float                   tolerance,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-
-#ifdef GTK_COMPILATION
-
-#include "gskcontourprivate.h"
-
-gboolean                gsk_contour_dash                        (const GskContour       *contour,
-                                                                 GskStroke              *stroke,
-                                                                 float                   tolerance,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-
-#endif /* GTK_COMPILATION */
-
-G_END_DECLS
-
-#endif /* __GSK_PATH_DASH_PRIVATE_H__ */
-

gsk/gskpathmeasure.c

@@ -1,677 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#include "config.h"
-
-#include "gskpathmeasure.h"
-#include "gskpathbuilder.h"
-
-#include "gskpathbuilder.h"
-#include "gskpathprivate.h"
-
-/**
- * GskPathMeasure:
- *
- * `GskPathMeasure` is an object that allows measuring operations
- * on `GskPath` objects, to determine quantities like the arc
- * length of the path, its curvature, or closest points.
- *
- * These operations are useful when implementing animations.
- */
-
-typedef struct _GskContourMeasure GskContourMeasure;
-
-struct _GskContourMeasure
-{
-  float length;
-  gpointer contour_data;
-};
-
-struct _GskPathMeasure
-{
-  /*< private >*/
-  guint ref_count;
-
-  GskPath *path;
-  float tolerance;
-
-  gsize first;
-  gsize last;
-
-  float length;
-  gsize n_contours;
-  GskContourMeasure measures[];
-};
-
-G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
-                     gsk_path_measure_ref,
-                     gsk_path_measure_unref)
-
-/**
- * gsk_path_measure_new:
- * @path: the path to measure
- *
- * Creates a measure object for the given @path with a
- * default tolerance.
- *
- * Returns: a new `GskPathMeasure` representing @path
- **/
-GskPathMeasure *
-gsk_path_measure_new (GskPath *path)
-{
-  return gsk_path_measure_new_with_tolerance (path, GSK_PATH_TOLERANCE_DEFAULT);
-}
-
-/**
- * gsk_path_measure_new_with_tolerance:
- * @path: the path to measure
- * @tolerance: the tolerance for measuring operations
- *
- * Creates a measure object for the given @path and @tolerance.
- *
- * Returns: a new `GskPathMeasure` representing @path
- **/
-GskPathMeasure *
-gsk_path_measure_new_with_tolerance (GskPath *path,
-                                     float    tolerance)
-{
-  GskPathMeasure *self;
-  gsize i, n_contours;
-
-  g_return_val_if_fail (path != NULL, NULL);
-  g_return_val_if_fail (tolerance > 0, NULL);
-
-  n_contours = gsk_path_get_n_contours (path);
-
-  self = g_malloc0 (sizeof (GskPathMeasure) + n_contours * sizeof (GskContourMeasure));
-
-  self->ref_count = 1;
-  self->path = gsk_path_ref (path);
-  self->tolerance = tolerance;
-  self->n_contours = n_contours;
-  self->first = 0;
-  self->last = n_contours;
-
-  for (i = 0; i < n_contours; i++)
-    {
-      self->measures[i].contour_data = gsk_contour_init_measure (gsk_path_get_contour (path, i),
-                                                                 self->tolerance,
-                                                                 &self->measures[i].length);
-      self->length += self->measures[i].length;
-    }
-
-  return self;
-}
-
-/**
- * gsk_path_measure_ref:
- * @self: a `GskPathMeasure`
- *
- * Increases the reference count of a `GskPathMeasure` by one.
- *
- * Returns: the passed in `GskPathMeasure`.
- **/
-GskPathMeasure *
-gsk_path_measure_ref (GskPathMeasure *self)
-{
-  g_return_val_if_fail (self != NULL, NULL);
-
-  self->ref_count++;
-
-  return self;
-}
-
-/**
- * gsk_path_measure_unref:
- * @self: a `GskPathMeasure`
- *
- * Decreases the reference count of a `GskPathMeasure` by one.
- *
- * If the resulting reference count is zero, frees the object.
- **/
-void
-gsk_path_measure_unref (GskPathMeasure *self)
-{
-  gsize i;
-
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (self->ref_count > 0);
-
-  self->ref_count--;
-  if (self->ref_count > 0)
-    return;
-
-  for (i = 0; i < self->n_contours; i++)
-    {
-      gsk_contour_free_measure (gsk_path_get_contour (self->path, i),
-                                self->measures[i].contour_data);
-    }
-
-  gsk_path_unref (self->path);
-  g_free (self);
-}
-
-/**
- * gsk_path_measure_get_path:
- * @self: a `GskPathMeasure`
- *
- * Returns the path that the measure was created for.
- *
- * Returns: (transfer none): the path of @self
- */
-GskPath *
-gsk_path_measure_get_path (GskPathMeasure *self)
-{
-  g_return_val_if_fail (self != NULL, NULL);
-
-  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)
-{
-  g_return_val_if_fail (self != NULL, 0.f);
-
-  return self->tolerance;
-}
-
-/**
- * gsk_path_measure_get_n_contours:
- * @self: a `GskPathMeasure`
- *
- * Returns the number of contours in the path being measured.
- *
- * The returned value is independent of whether @self if restricted
- * or not.
- *
- * Returns: The number of contours
- **/
-gsize
-gsk_path_measure_get_n_contours (GskPathMeasure *self)
-{
-  g_return_val_if_fail (self != NULL, 0);
-
-  return self->n_contours;
-}
-
-/**
- * gsk_path_measure_restrict_to_contour:
- * @self: a `GskPathMeasure`
- * @contour: contour to restrict to or (gsize) -1 for using the
- *   whole path
- *
- * Restricts all functions on the path to just the given @contour.
- *
- * If @contour >= gsk_path_measure_get_n_contours() - so in
- * particular when it is set to -1 - the whole path will be used.
- **/
-void
-gsk_path_measure_restrict_to_contour (GskPathMeasure *self,
-                                      gsize           contour)
-{
-  if (contour >= self->n_contours)
-    {
-      /* use the whole path */
-      self->first = 0;
-      self->last = self->n_contours;
-    }
-  else
-    {
-      /* use just one contour */
-      self->first = contour;
-      self->last = contour + 1;
-    }
-
-  self->length = 0;
-  for (gsize i = self->first; i < self->last; i++)
-    {
-      self->length += self->measures[i].length;
-    }
-}
-
-/**
- * gsk_path_measure_get_length:
- * @self: a `GskPathMeasure`
- *
- * Gets the length of the path being measured.
- *
- * The length is cached, so this function does not do any work.
- *
- * Returns: The length of the path measured by @self
- **/
-float
-gsk_path_measure_get_length (GskPathMeasure *self)
-{
-  g_return_val_if_fail (self != NULL, 0);
-
-  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->last - self->first != 1)
-    return FALSE;
-
-  contour = gsk_path_get_contour (self->path, self->first);
-  return gsk_contour_get_flags (contour) & GSK_PATH_CLOSED ? TRUE : FALSE;
-}
-
-static float
-gsk_path_measure_clamp_distance (GskPathMeasure *self,
-                                 float           distance)
-{
-  if (isnan (distance))
-    return 0;
-
-  return CLAMP (distance, 0, self->length);
-}
-
-/**
- * gsk_path_measure_get_point:
- * @self: a `GskPathMeasure`
- * @distance: distance into the path
- * @pos: (optional) (out caller-allocates): The coordinates
- *   of the position at @distance
- * @tangent: (optional) (out caller-allocates): 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 = self->first; i < self->last; i++)
-    {
-      if (distance < self->measures[i].length)
-        break;
-
-      distance -= self->measures[i].length;
-    }
-
-  /* weird corner cases */
-  if (i == self->last)
-    {
-      /* the empty path goes here */
-      if (self->first == self->last)
-        {
-          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->last - 1;
-      distance = self->measures[i].length;
-    }
-
-  gsk_contour_get_point (gsk_path_get_contour (self->path, i),
-                         self->measures[i].contour_data,
-                         distance,
-                         pos,
-                         tangent);
-}
-
-/**
- * gsk_path_measure_get_curvature:
- * @self: a `GskPathMeasure`
- * @distance: distance into the path
- * @center: (optional) (out caller-allocates): The center
- *   of the osculating circle at the point
- *
- * 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), or does
- * not exist (at sharp turns), zero is returned, and @center
- * is not modified.
- *
- * Returns: The curvature of the path at the given point
- */
-float
-gsk_path_measure_get_curvature (GskPathMeasure   *self,
-                                float             distance,
-                                graphene_point_t *center)
-{
-  gsize i;
-
-  g_return_val_if_fail (self != NULL, 0);
-
-  distance = gsk_path_measure_clamp_distance (self, distance);
-
-  for (i = self->first; i < self->last; i++)
-    {
-      if (distance < self->measures[i].length)
-        break;
-
-      distance -= self->measures[i].length;
-    }
-
-  /* weird corner cases */
-  if (i == self->last)
-    {
-      /* the empty path goes here */
-      if (self->first == self->last)
-        return 0;
-
-      /* rounding errors can make this happen */
-      i = self->last - 1;
-      distance = self->measures[i].length;
-    }
-
-  return gsk_contour_get_curvature (gsk_path_get_contour (self->path, i),
-                                    self->measures[i].contour_data,
-                                    distance,
-                                    center);
-}
-
-/**
- * gsk_path_measure_get_closest_point:
- * @self: a `GskPathMeasure`
- * @point: the point to find the closest point to
- * @out_pos: (optional) (out caller-allocates): 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
- * [method@Gsk.PathMeasure.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,
-                                               NULL,
-                                               out_pos,
-                                               &result,
-                                               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 find the closest point to
- * @threshold: The maximum allowed distance between the path and @point.
- *   Use INFINITY to look for any point.
- * @out_distance: (optional) (out caller-allocates): The
- *   distance between the found closest point on the path and the given
- *   @point.
- * @out_pos: (optional) (out caller-allocates): return location
- *   for the closest point
- * @out_offset: (optional) (out caller-allocates): The offset into
- *   the path of the found point
- * @out_tangent: (optional) (out caller-allocates): 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 = self->first; i < self->last; i++)
-    {
-      if (gsk_contour_get_closest_point (gsk_path_get_contour (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
- * @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: %TRUE if @point is inside
- */
-gboolean
-gsk_path_measure_in_fill (GskPathMeasure   *self,
-                          graphene_point_t *point,
-                          GskFillRule       fill_rule)
-{
-  int winding = 0;
-  gboolean on_edge = FALSE;
-  int i;
-
-  for (i = self->first; i < self->last; 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;
-    }
-
-  switch (fill_rule)
-    {
-    case GSK_FILL_RULE_EVEN_ODD:
-      return winding & 1;
-    case GSK_FILL_RULE_WINDING:
-      return winding != 0;
-    default:
-      g_assert_not_reached ();
-    }
-}
-
-static void
-gsk_path_builder_add_segment_chunk (GskPathBuilder *self,
-                                    GskPathMeasure *measure,
-                                    gboolean        emit_move_to,
-                                    float           start,
-                                    float           end)
-{
-  g_assert (start < end);
-
-  for (gsize i = measure->first; i < measure->last; i++)
-    {
-      if (measure->measures[i].length < start)
-        {
-          start -= measure->measures[i].length;
-          end -= measure->measures[i].length;
-        }
-      else if (start > 0 || end < measure->measures[i].length)
-        {
-          float len = MIN (end, measure->measures[i].length);
-          gsk_contour_add_segment (gsk_path_get_contour (measure->path, i),
-                                   self,
-                                   measure->measures[i].contour_data,
-                                   emit_move_to,
-                                   start,
-                                   len);
-          end -= len;
-          start = 0;
-          if (end <= 0)
-            break;
-        }
-      else
-        {
-          end -= measure->measures[i].length;
-          gsk_path_builder_add_contour (self, gsk_contour_dup (gsk_path_get_contour (measure->path, i)));
-        }
-      emit_move_to = TRUE;
-    }
-}
-
-/**
- * gsk_path_builder_add_segment:
- * @builder: a `GskPathBuilder`
- * @measure: the `GskPathMeasure` to take the segment to
- * @start: start distance into the path
- * @end: end distance into the path
- *
- * Adds to @builder 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 [method@Gsk.PathMeasure.get_length]
- * for the end of the path. The values will be clamped to that range.
- *
- * 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 *builder,
-                              GskPathMeasure *measure,
-                              float           start,
-                              float           end)
-{
-  g_return_if_fail (builder != 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 (builder, 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 (builder, measure,
-                                            TRUE,
-                                            start, measure->length);
-      else
-        need_move_to = TRUE;
-
-      if (end > 0)
-        gsk_path_builder_add_segment_chunk (builder, measure,
-                                            need_move_to,
-                                            0, end);
-      if (start == end && closed)
-        gsk_path_builder_close (builder);
-    }
-}

gsk/gskpathmeasure.h

@@ -1,92 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#ifndef __GSK_PATH_MEASURE_H__
-#define __GSK_PATH_MEASURE_H__
-
-#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gsk/gsk.h> can be included directly."
-#endif
-
-
-#include <gsk/gskpath.h>
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_PATH_MEASURE (gsk_path_measure_get_type ())
-
-GDK_AVAILABLE_IN_ALL
-GType                   gsk_path_measure_get_type               (void) G_GNUC_CONST;
-GDK_AVAILABLE_IN_ALL
-GskPathMeasure *        gsk_path_measure_new                    (GskPath                *path);
-GDK_AVAILABLE_IN_ALL
-GskPathMeasure *        gsk_path_measure_new_with_tolerance     (GskPath                *path,
-                                                                 float                   tolerance);
-
-GDK_AVAILABLE_IN_ALL
-GskPathMeasure *        gsk_path_measure_ref                    (GskPathMeasure         *self);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_measure_unref                  (GskPathMeasure         *self);
-
-GDK_AVAILABLE_IN_ALL
-GskPath *               gsk_path_measure_get_path               (GskPathMeasure         *self) G_GNUC_PURE;
-GDK_AVAILABLE_IN_ALL
-float                   gsk_path_measure_get_tolerance          (GskPathMeasure         *self) G_GNUC_PURE;
-GDK_AVAILABLE_IN_ALL
-gsize                   gsk_path_measure_get_n_contours         (GskPathMeasure         *self) G_GNUC_PURE;
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_path_measure_restrict_to_contour    (GskPathMeasure         *self,
-                                                                 gsize                   contour);
-
-GDK_AVAILABLE_IN_ALL
-float                   gsk_path_measure_get_length             (GskPathMeasure         *self);
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_measure_is_closed              (GskPathMeasure         *self);
-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_curvature          (GskPathMeasure         *self,
-                                                                 float                   distance,
-                                                                 graphene_point_t       *center);
-
-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);
-
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_path_measure_in_fill                (GskPathMeasure         *self,
-                                                                 graphene_point_t       *point,
-                                                                 GskFillRule             fill_rule);
-
-G_END_DECLS
-
-#endif /* __GSK_PATH_MEASURE_H__ */

gsk/gskpathopprivate.h

@@ -1,179 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_PATHOP_PRIVATE_H__
-#define __GSK_PATHOP_PRIVATE_H__
-
-#include <gsk/gskpath.h>
-#include <gsk/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_CURVE:
-      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_CURVE:
-      gsk_path_builder_curve_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_CURVE:
-      gsk_path_builder_curve_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
-
-#endif /* __GSK_PATHOP_PRIVATE_H__ */
-

gsk/gskpathprivate.h

@@ -1,78 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_PATH_PRIVATE_H__
-#define __GSK_PATH_PRIVATE_H__
-
-#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)
-
-GskPath *               gsk_path_new_from_contours              (const GSList           *contours);
-
-gsize                   gsk_path_get_n_contours                 (GskPath                *path);
-const GskContour *      gsk_path_get_contour                    (GskPath                *path,
-                                                                 gsize                   i);
-
-GskPathFlags            gsk_path_get_flags                      (GskPath                *self);
-
-gboolean                gsk_path_foreach_with_tolerance         (GskPath                *self,
-                                                                 GskPathForeachFlags     flags,
-                                                                 double                  tolerance,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-
-
-void                    gsk_path_builder_add_contour            (GskPathBuilder         *builder,
-                                                                 GskContour             *contour);
-
-void                    gsk_path_builder_svg_arc_to             (GskPathBuilder         *builder,
-                                                                 float                   rx,
-                                                                 float                   ry,
-                                                                 float                   x_axis_rotation,
-                                                                 gboolean                large_arc,
-                                                                 gboolean                positive_sweep,
-                                                                 float                   x,
-                                                                 float                   y);
-
-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,
-                                                                 GskPath                *first,
-                                                                 GskPath                *second);
-
-
-G_END_DECLS
-
-#endif /* __GSK_PATH_PRIVATE_H__ */
-

gsk/gskrendernode.h

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

gsk/gskrendernodeimpl.c

@@ -23,10 +23,8 @@
 #include "gskcairoblurprivate.h"
 #include "gskdebugprivate.h"
 #include "gskdiffprivate.h"
-#include "gskpath.h"
 #include "gskrendererprivate.h"
 #include "gskroundedrectprivate.h"
-#include "gskstrokeprivate.h"
 #include "gsktransformprivate.h"
 
 #include "gdk/gdktextureprivate.h"
@@ -3763,343 +3761,6 @@ gsk_rounded_clip_node_get_clip (const GskRenderNode *node)
   return &self->clip;
 }
 
-/*** GSK_FILL_NODE ***/
-
-struct _GskFillNode
-{
-  GskRenderNode render_node;
-
-  GskRenderNode *child;
-  GskPath *path;
-  GskFillRule fill_rule;
-};
-
-static void
-gsk_fill_node_finalize (GskRenderNode *node)
-{
-  GskFillNode *self = (GskFillNode *) node;
-  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_FILL_NODE));
-
-  gsk_render_node_unref (self->child);
-  gsk_path_unref (self->path);
-
-  parent_class->finalize (node);
-}
-
-static void
-gsk_fill_node_draw (GskRenderNode *node,
-                    cairo_t       *cr)
-{
-  GskFillNode *self = (GskFillNode *) node;
-
-  cairo_save (cr);
-
-  switch (self->fill_rule)
-  {
-    case GSK_FILL_RULE_WINDING:
-      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);
-      break;
-    case GSK_FILL_RULE_EVEN_ODD:
-      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-  }
-  gsk_path_to_cairo (self->path, cr);
-  cairo_clip (cr);
-
-  gsk_render_node_draw (self->child, cr);
-
-  cairo_restore (cr);
-}
-
-static void
-gsk_fill_node_diff (GskRenderNode  *node1,
-                    GskRenderNode  *node2,
-                    cairo_region_t *region)
-{
-  GskFillNode *self1 = (GskFillNode *) node1;
-  GskFillNode *self2 = (GskFillNode *) node2;
-
-  if (self1->path == self2->path)
-    {
-      cairo_region_t *sub;
-      cairo_rectangle_int_t clip_rect;
-      graphene_rect_t rect;
-
-      sub = cairo_region_create();
-      gsk_render_node_diff (self1->child, self2->child, sub);
-      graphene_rect_union (&node1->bounds, &node2->bounds, &rect);
-      rectangle_init_from_graphene (&clip_rect, &rect);
-      cairo_region_intersect_rectangle (sub, &clip_rect);
-      cairo_region_union (region, sub);
-      cairo_region_destroy (sub);
-    }
-  else
-    {
-      gsk_render_node_diff_impossible (node1, node2, region);
-    }
-}
-
-/**
- * gsk_fill_node_new:
- * @child: The node to fill the area with
- * @path: The path describing the area to fill
- * @fill_rule: The fill rule to use
- *
- * Creates a `GskRenderNode` that will fill the @child in the area
- * given by @path and @fill_rule.
- *
- * Returns: (transfer none) (type GskFillNode): A new `GskRenderNode`
- */
-GskRenderNode *
-gsk_fill_node_new (GskRenderNode *child,
-                   GskPath       *path,
-                   GskFillRule    fill_rule)
-{
-  GskFillNode *self;
-  GskRenderNode *node;
-  graphene_rect_t path_bounds;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
-  g_return_val_if_fail (path != NULL, NULL);
-
-  self = gsk_render_node_alloc (GSK_FILL_NODE);
-  node = (GskRenderNode *) self;
-
-  self->child = gsk_render_node_ref (child);
-  self->path = gsk_path_ref (path);
-  self->fill_rule = fill_rule;
-
-  if (gsk_path_get_bounds (path, &path_bounds))
-    graphene_rect_intersection (&path_bounds, &child->bounds, &node->bounds);
-  else
-    graphene_rect_init_from_rect (&node->bounds, graphene_rect_zero ());
-
-  return node;
-}
-
-/**
- * gsk_fill_node_get_child:
- * @node: (type GskFillNode): a fill `GskRenderNode`
- *
- * Gets the child node that is getting drawn by the given @node.
- *
- * Returns: (transfer none): The child that is getting drawn
- **/
-GskRenderNode *
-gsk_fill_node_get_child (const GskRenderNode *node)
-{
-  const GskFillNode *self = (const GskFillNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
-
-  return self->child;
-}
-
-/**
- * gsk_fill_node_get_path:
- * @node: (type GskFillNode): a fill `GskRenderNode`
- *
- * Retrievs the path used to describe the area filled with the contents of
- * the @node.
- *
- * Returns: (transfer none): a `GskPath`
- */
-GskPath *
-gsk_fill_node_get_path (const GskRenderNode *node)
-{
-  const GskFillNode *self = (const GskFillNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
-
-  return self->path;
-}
-
-/**
- * gsk_fill_node_get_fill_rule:
- * @node: (type GskFillNode): a fill `GskRenderNode`
- *
- * Retrievs the fill rule used to determine how the path is filled.
- *
- * Returns: a `GskFillRule`
- */
-GskFillRule
-gsk_fill_node_get_fill_rule (const GskRenderNode *node)
-{
-  const GskFillNode *self = (const GskFillNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), GSK_FILL_RULE_WINDING);
-
-  return self->fill_rule;
-}
-
-/*** GSK_STROKE_NODE ***/
-
-struct _GskStrokeNode
-{
-  GskRenderNode render_node;
-
-  GskRenderNode *child;
-  GskPath *path;
-  GskStroke stroke;
-};
-
-static void
-gsk_stroke_node_finalize (GskRenderNode *node)
-{
-  GskStrokeNode *self = (GskStrokeNode *) node;
-  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_STROKE_NODE));
-
-  gsk_render_node_unref (self->child);
-  gsk_path_unref (self->path);
-  gsk_stroke_clear (&self->stroke);
-
-  parent_class->finalize (node);
-}
-
-static void
-gsk_stroke_node_draw (GskRenderNode *node,
-                      cairo_t       *cr)
-{
-  GskStrokeNode *self = (GskStrokeNode *) node;
-
-  cairo_save (cr);
-
-  gsk_cairo_rectangle (cr, &self->child->bounds);
-  cairo_clip (cr);
-
-  cairo_push_group (cr);
-  gsk_render_node_draw (self->child, cr);
-  cairo_pop_group_to_source (cr);
-
-  gsk_stroke_to_cairo (&self->stroke, cr);
-
-  gsk_path_to_cairo (self->path, cr);
-  cairo_stroke (cr);
-
-  cairo_restore (cr);
-}
-
-static void
-gsk_stroke_node_diff (GskRenderNode  *node1,
-                      GskRenderNode  *node2,
-                      cairo_region_t *region)
-{
-  GskStrokeNode *self1 = (GskStrokeNode *) node1;
-  GskStrokeNode *self2 = (GskStrokeNode *) node2;
-
-  if (self1->path == self2->path &&
-      gsk_stroke_equal (&self1->stroke, &self2->stroke))
-    {
-      cairo_region_t *sub;
-
-      sub = cairo_region_create();
-      gsk_render_node_diff (self1->child, self2->child, sub);
-      cairo_region_union (region, sub);
-      cairo_region_destroy (sub);
-    }
-  else
-    {
-      gsk_render_node_diff_impossible (node1, node2, region);
-    }
-}
-
-/**
- * gsk_stroke_node_new:
- * @child: The node to stroke the area with
- * @path: (transfer none): The path describing the area to stroke
- * @stroke: (transfer none): The stroke attributes to use
- *
- * Creates a `GskRenderNode` that will stroke the @child along the given
- * @path using the attributes defined in @stroke.
- *
- * Returns: (transfer none) (type GskStrokeNode): A new `GskRenderNode`
- */
-GskRenderNode *
-gsk_stroke_node_new (GskRenderNode   *child,
-                     GskPath         *path,
-                     const GskStroke *stroke)
-{
-  GskStrokeNode *self;
-  GskRenderNode *node;
-  graphene_rect_t path_bounds;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
-  g_return_val_if_fail (path != NULL, NULL);
-  g_return_val_if_fail (stroke != NULL, NULL);
-
-  self = gsk_render_node_alloc (GSK_STROKE_NODE);
-  node = (GskRenderNode *) self;
-
-  self->child = gsk_render_node_ref (child);
-  self->path = gsk_path_ref (path);
-  gsk_stroke_init_copy (&self->stroke, stroke);
-
-  if (gsk_path_get_stroke_bounds (path, stroke, &path_bounds))
-    graphene_rect_intersection (&path_bounds, &child->bounds, &node->bounds);
-  else
-    graphene_rect_init_from_rect (&node->bounds, graphene_rect_zero ());
-
-  return node;
-}
-
-/**
- * gsk_stroke_node_get_child:
- * @node: (type GskStrokeNode): a stroke `GskRenderNode`
- *
- * Gets the child node that is getting drawn by the given @node.
- *
- * Returns: (transfer none): The child that is getting drawn
- **/
-GskRenderNode *
-gsk_stroke_node_get_child (const GskRenderNode *node)
-{
-  const GskStrokeNode *self = (const GskStrokeNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
-
-  return self->child;
-}
-
-/**
- * gsk_stroke_node_get_path:
- * @node: (type GskStrokeNode): a stroke `GskRenderNode`
- *
- * Retrievs the path that will be stroked with the contents of
- * the @node.
- *
- * Returns: (transfer none): a `GskPath`
- */
-GskPath *
-gsk_stroke_node_get_path (const GskRenderNode *node)
-{
-  const GskStrokeNode *self = (const GskStrokeNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
-
-  return self->path;
-}
-
-/**
- * gsk_stroke_node_get_stroke:
- * @node: (type GskStrokeNode): a stroke `GskRenderNode`
- *
- * Retrievs the stroke attributes used in this @node.
- *
- * Returns: a `GskStroke`
- */
-const GskStroke *
-gsk_stroke_node_get_stroke (const GskRenderNode *node)
-{
-  const GskStrokeNode *self = (const GskStrokeNode *) node;
-
-  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
-
-  return &self->stroke;
-}
-
 /*** GSK_SHADOW_NODE ***/
 
 /**
@@ -5622,8 +5283,6 @@ GSK_DEFINE_RENDER_NODE_TYPE (gsk_color_matrix_node, GSK_COLOR_MATRIX_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_repeat_node, GSK_REPEAT_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_clip_node, GSK_CLIP_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_rounded_clip_node, GSK_ROUNDED_CLIP_NODE)
-GSK_DEFINE_RENDER_NODE_TYPE (gsk_fill_node, GSK_FILL_NODE)
-GSK_DEFINE_RENDER_NODE_TYPE (gsk_stroke_node, GSK_STROKE_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_shadow_node, GSK_SHADOW_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_blend_node, GSK_BLEND_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_cross_fade_node, GSK_CROSS_FADE_NODE)
@@ -5923,38 +5582,6 @@ gsk_render_node_init_types_once (void)
     gsk_render_node_types[GSK_ROUNDED_CLIP_NODE] = node_type;
   }
 
-  {
-    const GskRenderNodeTypeInfo node_info =
-    {
-      GSK_FILL_NODE,
-      sizeof (GskFillNode),
-      NULL,
-      gsk_fill_node_finalize,
-      gsk_fill_node_draw,
-      NULL,
-      gsk_fill_node_diff,
-    };
-
-    GType node_type = gsk_render_node_type_register_static (I_("GskFillNode"), &node_info);
-    gsk_render_node_types[GSK_FILL_NODE] = node_type;
-  }
-
-  {
-    const GskRenderNodeTypeInfo node_info =
-    {
-      GSK_STROKE_NODE,
-      sizeof (GskStrokeNode),
-      NULL,
-      gsk_stroke_node_finalize,
-      gsk_stroke_node_draw,
-      NULL,
-      gsk_stroke_node_diff,
-    };
-
-    GType node_type = gsk_render_node_type_register_static (I_("GskStrokeNode"), &node_info);
-    gsk_render_node_types[GSK_STROKE_NODE] = node_type;
-  }
-
   {
     const GskRenderNodeTypeInfo node_info =
     {

gsk/gskrendernodeparser.c

@@ -23,13 +23,9 @@
 
 #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"
@@ -403,10 +399,7 @@ parse_string (GtkCssParser *parser,
 
   token = gtk_css_parser_get_token (parser);
   if (!gtk_css_token_is (token, GTK_CSS_TOKEN_STRING))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected a string");
-      return FALSE;
-    }
+    return FALSE;
 
   s = g_strdup (token->string.string);
   gtk_css_parser_consume_token (parser);
@@ -962,26 +955,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)
 {
@@ -1129,7 +1102,7 @@ parse_conic_gradient_node (GtkCssParser *parser)
       g_array_append_val (stops, to);
     }
 
-  result = gsk_conic_gradient_node_new (&bounds, &center, rotation,
+  result = gsk_conic_gradient_node_new (&bounds, &center, rotation, 
                                         (GskColorStop *) stops->data, stops->len);
 
   g_array_free (stops, TRUE);
@@ -1415,7 +1388,7 @@ parse_cairo_node (GtkCssParser *parser)
   parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
 
   node = gsk_cairo_node_new (&bounds);
-
+  
   if (surface != NULL)
     {
       cairo_t *cr = gsk_cairo_node_get_draw_context (node);
@@ -1792,208 +1765,6 @@ parse_rounded_clip_node (GtkCssParser *parser)
   return result;
 }
 
-static gboolean
-parse_path (GtkCssParser *parser,
-            gpointer      out_path)
-{
-  GskPath *path;
-  char *str = NULL;
-
-  if (!parse_string (parser, &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,
-            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;
-  const GtkCssToken *token;
-
-  token = gtk_css_parser_get_token (parser);
-  if (!gtk_css_token_is (token, GTK_CSS_TOKEN_IDENT))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected a valid identifier");
-      return FALSE;
-    }
-
-  class = g_type_class_ref (type);
-
-  v = g_enum_get_value_by_nick (class, token->string.string);
-  if (v == NULL)
-    {
-      gtk_css_parser_error_value (parser, "\"%s\" is not a valid identifier here", token->string.string);
-      g_type_class_unref (class);
-      return FALSE;
-    }
-
-  *(int*)out_value = v->value;
-
-  g_type_class_unref (class);
-
-  gtk_css_parser_consume_token (parser);
-
-  return TRUE;
-}
-
-static gboolean
-parse_fill_rule (GtkCssParser *parser,
-                 gpointer      out_rule)
-{
-  return parse_enum (parser, GSK_TYPE_FILL_RULE, out_rule);
-}
-
-static GskRenderNode *
-parse_fill_node (GtkCssParser *parser)
-{
-  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, 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,
-                gpointer      out)
-{
-  return parse_enum (parser, GSK_TYPE_LINE_CAP, out);
-}
-
-static gboolean
-parse_line_join (GtkCssParser *parser,
-                 gpointer      out)
-{
-  return parse_enum (parser, GSK_TYPE_LINE_JOIN, out);
-}
-
-static GskRenderNode *
-parse_stroke_node (GtkCssParser *parser)
-{
-  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, 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)
 {
@@ -2063,7 +1834,6 @@ parse_node (GtkCssParser *parser,
     { "container", parse_container_node },
     { "cross-fade", parse_cross_fade_node },
     { "debug", parse_debug_node },
-    { "fill", parse_fill_node },
     { "inset-shadow", parse_inset_shadow_node },
     { "linear-gradient", parse_linear_gradient_node },
     { "radial-gradient", parse_radial_gradient_node },
@@ -2075,7 +1845,6 @@ parse_node (GtkCssParser *parser,
     { "repeating-radial-gradient", parse_repeating_radial_gradient_node },
     { "rounded-clip", parse_rounded_clip_node },
     { "shadow", parse_shadow_node },
-    { "stroke", parse_stroke_node },
     { "text", parse_text_node },
     { "texture", parse_texture_node },
     { "transform", parse_transform_node },
@@ -2331,7 +2100,7 @@ append_float_param (Printer    *p,
                     float       value,
                     float       default_value)
 {
-  /* Don't approximate-compare here, better be too verbose */
+  /* Don't approximate-compare here, better be topo verbose */
   if (value == default_value)
     return;
 
@@ -2506,11 +2275,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);
 }
 
@@ -2625,83 +2391,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[1] == 'O'))
-        *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)
@@ -2850,42 +2539,6 @@ render_node_print (Printer       *p,
         append_rounded_rect_param (p, "clip", gsk_rounded_clip_node_get_clip (node));
         append_node_param (p, "child", gsk_rounded_clip_node_get_child (node));
 
-        end_node (p);
-      }
-      break;
-
-    case GSK_FILL_NODE:
-      {
-        start_node (p, "fill");
-
-        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));
-
-        end_node (p);
-      }
-      break;
-
-    case GSK_STROKE_NODE:
-      {
-        const GskStroke *stroke;
-        const float *dash;
-        gsize n_dash;
-
-        start_node (p, "stroke");
-
-        append_node_param (p, "child", gsk_stroke_node_get_child (node));
-        append_path_param (p, "path", gsk_stroke_node_get_path (node));
-
-        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);
 
         end_node (p);
       }
@@ -3392,4 +3045,3 @@ gsk_render_node_serialize (GskRenderNode *node)
 
   return g_string_free_to_bytes (p.str);
 }
-

gsk/gskspline.c

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

gsk/gsksplineprivate.h

@@ -1,41 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_SPLINE_PRIVATE_H__
-#define __GSK_SPLINE_PRIVATE_H__
-
-#include "gskpath.h"
-
-G_BEGIN_DECLS
-
-typedef gboolean (* GskSplineAddCurveFunc) (const graphene_point_t curve[4],
-                                            gpointer               user_data);
-gboolean                gsk_spline_decompose_arc                (const graphene_point_t *center,
-                                                                 float                   radius,
-                                                                 float                   tolerance,
-                                                                 float                   start_angle,
-                                                                 float                   end_angle,
-                                                                 GskSplineAddCurveFunc   curve_func,
-                                                                 gpointer                user_data);
-
-G_END_DECLS
-
-#endif /* __GSK_SPLINE_PRIVATE_H__ */
-

gsk/gskstroke.c

@@ -1,458 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#include "config.h"
-
-#include "gskstrokeprivate.h"
-
-/**
- * GskStroke:
- *
- * A `GskStroke` describes the attributes that are used when stroking a path.
- */
-
-G_DEFINE_BOXED_TYPE (GskStroke, gsk_stroke,
-                     gsk_stroke_copy,
-                     gsk_stroke_free)
-
-
-/**
- * gsk_stroke_new:
- * @line_width: line width of the stroke. Must be > 0
- *
- * Creates a new `GskStroke` with the given @line_width.
- *
- * Returns: a new `GskStroke`
- **/
-GskStroke *
-gsk_stroke_new (float line_width)
-{
-  GskStroke *self;
-
-  g_return_val_if_fail (line_width > 0, NULL);
-
-  self = g_new0 (GskStroke, 1);
-
-  self->line_width = line_width;
-  self->line_cap = GSK_LINE_CAP_BUTT;
-  self->line_join = GSK_LINE_JOIN_MITER;
-  self->miter_limit = 4.f; /* following svg */
-
-  return self;
-}
-
-/**
- * gsk_stroke_copy:
- * @other: `GskStroke` to copy
- *
- * Creates a copy of the given @other stroke.
- *
- * Returns: a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it.
- **/
-GskStroke *
-gsk_stroke_copy (const GskStroke *other)
-{
-  GskStroke *self;
-
-  g_return_val_if_fail (other != NULL, NULL);
-
-  self = g_new (GskStroke, 1);
-
-  gsk_stroke_init_copy (self, other);
-
-  return self;
-}
-
-/**
- * gsk_stroke_free:
- * @self: a `GskStroke`
- *
- * Frees a `GskStroke`.
- **/
-void
-gsk_stroke_free (GskStroke *self)
-{
-  if (self == NULL)
-    return;
-
-  gsk_stroke_clear (self);
-
-  g_free (self);
-}
-
-/**
- * gsk_stroke_to_cairo:
- * @self: a #GskStroke
- * @cr: the cairo context to configure
- *
- * A helper function that sets the stroke parameters
- * of @cr from the values found in @self.
- */
-void
-gsk_stroke_to_cairo (const GskStroke *self,
-                     cairo_t         *cr)
-{
-  cairo_set_line_width (cr, self->line_width);
-
-  /* gcc can optimize that to a direct case. This catches later additions to the enum */
-  switch (self->line_cap)
-    {
-      case GSK_LINE_CAP_BUTT:
-        cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
-        break;
-      case GSK_LINE_CAP_ROUND:
-        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
-        break;
-      case GSK_LINE_CAP_SQUARE:
-        cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
-        break;
-      default:
-        g_assert_not_reached ();
-        break;
-    }
-
-  /* gcc can optimize that to a direct case. This catches later additions to the enum */
-  switch (self->line_join)
-    {
-      case GSK_LINE_JOIN_MITER:
-      case GSK_LINE_JOIN_MITER_CLIP:
-      case GSK_LINE_JOIN_ARCS:
-        cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
-        break;
-      case GSK_LINE_JOIN_ROUND:
-        cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
-        break;
-      case GSK_LINE_JOIN_BEVEL:
-        cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL);
-        break;
-      default:
-        g_assert_not_reached ();
-        break;
-    }
-
-  cairo_set_miter_limit (cr, self->miter_limit);
-
-  if (self->dash_length)
-    {
-      gsize i;
-      double *dash = g_newa (double, self->n_dash);
-
-      for (i = 0; i < self->n_dash; i++)
-        {
-          dash[i] = self->dash[i];
-        }
-      cairo_set_dash (cr, dash, self->n_dash, self->dash_offset);
-    }
-  else
-    cairo_set_dash (cr, NULL, 0, 0.0);
-}
-
-/**
- * gsk_stroke_equal:
- * @stroke1: the first `GskStroke`
- * @stroke2: the second `GskStroke`
- *
- * Checks if two strokes are identical.
- *
- * Returns: %TRUE if the two strokes are equal, %FALSE otherwise
- **/
-gboolean
-gsk_stroke_equal (gconstpointer stroke1,
-                  gconstpointer stroke2)
-{
-  const GskStroke *self1 = stroke1;
-  const GskStroke *self2 = stroke2;
-
-  if (self1->line_width != self2->line_width ||
-      self1->line_cap != self2->line_cap ||
-      self1->line_join != self2->line_join ||
-      self1->miter_limit != self2->miter_limit)
-    return FALSE;
-
-  if (self1->n_dash != self2->n_dash)
-    return FALSE;
-
-  for (int i = 0; i < self1->n_dash; i++)
-    {
-      if (self1->dash[i] != self2->dash[i])
-        return FALSE;
-    }
-
-  if (self1->dash_offset != self2->dash_offset)
-    return FALSE;
-
-  return TRUE;
-}
-
-/**
- * gsk_stroke_set_line_width:
- * @self: a `GskStroke`
- * @line_width: width of the line in pixels
- *
- * Sets the line width to be used when stroking.
- *
- * The line width must be > 0.
- **/
-void
-gsk_stroke_set_line_width (GskStroke *self,
-                           float      line_width)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (line_width > 0);
-
-  self->line_width = line_width;
-}
-
-/**
- * gsk_stroke_get_line_width:
- * @self: a `GskStroke`
- *
- * Gets the line width used.
- *
- * Returns: The line width
- **/
-float
-gsk_stroke_get_line_width (const GskStroke *self)
-{
-  g_return_val_if_fail (self != NULL, 0.0);
-
-  return self->line_width;
-}
-
-/**
- * gsk_stroke_set_line_cap:
- * @self: a `GskStroke`
- * @line_cap: the `GskLineCap`
- *
- * Sets the line cap to be used when stroking.
- *
- * See `GskLineCap` for details.
- **/
-void
-gsk_stroke_set_line_cap (GskStroke  *self,
-                         GskLineCap  line_cap)
-{
-  g_return_if_fail (self != NULL);
-
-  self->line_cap = line_cap;
-}
-
-/**
- * gsk_stroke_get_line_cap:
- * @self: a `GskStroke`
- *
- * Gets the line cap used.
- *
- * See `GskLineCap` for details.
- *
- * Returns: The line cap
- **/
-GskLineCap
-gsk_stroke_get_line_cap (const GskStroke *self)
-{
-  g_return_val_if_fail (self != NULL, 0.0);
-
-  return self->line_cap;
-}
-
-/**
- * gsk_stroke_set_line_join:
- * @self: a `GskStroke`
- * @line_join: The line join to use
- *
- * Sets the line join to be used when stroking.
- *
- * See `GskLineJoin` for details.
- **/
-void
-gsk_stroke_set_line_join (GskStroke   *self,
-                          GskLineJoin  line_join)
-{
-  g_return_if_fail (self != NULL);
-
-  self->line_join = line_join;
-}
-
-/**
- * gsk_stroke_get_line_join:
- * @self: a `GskStroke`
- *
- * Gets the line join used.
- *
- * See `GskLineJoin` for details.
- *
- * Returns: The line join
- **/
-GskLineJoin
-gsk_stroke_get_line_join (const GskStroke *self)
-{
-  g_return_val_if_fail (self != NULL, 0.0);
-
-  return self->line_join;
-}
-
-/**
- * gsk_stroke_set_miter_limit:
- * @self: a `GskStroke`
- * @limit: the miter limit, must be non-negative
- *
- * 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.
- *
- * For joins of type `GSK_LINE_JOIN_MITER` that exceed the miter
- * limit, the join gets rendered as if it was of type
- * `GSK_LINE_JOIN_BEVEL`. For joins of type `GSK_LINE_JOIN_MITER_CLIP`,
- * the miter is clipped at a distance of half the miter limit.
- */
-void
-gsk_stroke_set_miter_limit (GskStroke  *self,
-                            float       limit)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (limit >= 0);
-
-  self->miter_limit = limit;
-}
-
-/**
- * gsk_stroke_get_miter_limit:
- * @self: a `GskStroke`
- *
- * Returns the miter limit of a `GskStroke`.
- */
-float
-gsk_stroke_get_miter_limit (const GskStroke *self)
-{
-  g_return_val_if_fail (self != NULL, 4.f);
-
-  return self->miter_limit;
-}
-
-/**
- * gsk_stroke_set_dash:
- * @self: a `GskStroke`
- * @dash: (array length=n_dash) (transfer none) (allow-none): the array of dashes
- * @n_dash: number of elements in @dash
- *
- * Sets the dash pattern to use by this stroke. A dash pattern is specified by
- * an array of alternating non-negative values. Each value provides the length
- * of alternate "on" and "off" portions of the stroke.
- *
- * Each "on" segment will have caps applied as if the segment were a separate
- * contour. In particular, it is valid to use an "on" length of 0 with
- * `GSK_LINE_CAP_ROUND` or `GSK_LINE_CAP_SQUARE` to draw dots or squares along
- * a path.
- *
- * If @n_dash is 0, if all elements in @dash are 0, or if there are negative
- * values in @dash, then dashing is disabled.
- *
- * If @n_dash is 1, an alternating "on" and "off" pattern with the single
- * dash length provided is assumed.
- *
- * If @n_dash is uneven, the dash array will be used with the first element
- * in @dash defining an "on" or "off" in alternating passes through the array.
- *
- * You can specify a starting offset into the dash with [method@Gsk.Stroke.set_dash_offset].
- **/
-void
-gsk_stroke_set_dash (GskStroke   *self,
-                     const float *dash,
-                     gsize        n_dash)
-{
-  float dash_length;
-  gsize i;
-
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (dash != NULL || n_dash == 0);
-
-  dash_length = 0;
-  for (i = 0; i < n_dash; i++)
-    {
-      if (!(dash[i] >= 0)) /* should catch NaN */
-        {
-          g_critical ("invalid value in dash array at position %zu", i);
-          return;
-        }
-      dash_length += dash[i];
-    }
-
-  self->dash_length = dash_length;
-  g_free (self->dash);
-  self->dash = g_memdup (dash, sizeof (gfloat) * n_dash);
-  self->n_dash = n_dash;
-
-}
-
-/**
- * gsk_stroke_get_dash:
- * @self: a `GskStroke`
- * @n_dash: (out caller-allocates): number of elements
- *   in the array returned
- *
- * Gets the dash array in use or %NULL if dashing is disabled.
- *
- * Returns: (array length=n_dash) (transfer none) (allow-none):
- *   The dash array or %NULL if the dash array is empty.
- **/
-const float *
-gsk_stroke_get_dash (const GskStroke *self,
-                     gsize           *n_dash)
-{
-  g_return_val_if_fail (self != NULL, NULL);
-  g_return_val_if_fail (n_dash != NULL, NULL);
-
-  *n_dash = self->n_dash;
-
-  return self->dash;
-}
-
-/**
- * gsk_stroke_set_dash_offset:
- * @self: a `GskStroke`
- * @offset: offset into the dash pattern
- *
- * Sets the offset into the dash pattern set via [method@Gsk.Stroke.set_dash]
- * 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.
- **/
-void
-gsk_stroke_set_dash_offset (GskStroke *self,
-                            float      offset)
-{
-  g_return_if_fail (self != NULL);
-
-  self->dash_offset = offset;
-}
-
-/**
- * gsk_stroke_get_dash_offset:
- * @self: a `GskStroke`
- *
- * Returns the dash offset of a `GskStroke`.
- */
-float
-gsk_stroke_get_dash_offset (const GskStroke *self)
-{
-  g_return_val_if_fail (self != NULL, 4.f);
-
-  return self->dash_offset;
-}

gsk/gskstroke.h

@@ -1,91 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-#ifndef __GSK_STROKE_H__
-#define __GSK_STROKE_H__
-
-#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gsk/gsk.h> can be included directly."
-#endif
-
-
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_STROKE (gsk_stroke_get_type ())
-
-GDK_AVAILABLE_IN_ALL
-GType                   gsk_stroke_get_type                     (void) G_GNUC_CONST;
-GDK_AVAILABLE_IN_ALL
-GskStroke *             gsk_stroke_new                          (float                   line_width);
-GDK_AVAILABLE_IN_ALL
-GskStroke *             gsk_stroke_copy                         (const GskStroke        *other);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_stroke_free                         (GskStroke              *self);
-
-GDK_AVAILABLE_IN_ALL
-gboolean                gsk_stroke_equal                        (gconstpointer           stroke1,
-                                                                 gconstpointer           stroke2);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_stroke_set_line_width               (GskStroke              *self,
-                                                                 float                   line_width);
-GDK_AVAILABLE_IN_ALL
-float                   gsk_stroke_get_line_width               (const GskStroke        *self);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_stroke_set_line_cap                 (GskStroke              *self,
-                                                                 GskLineCap              line_cap);
-GDK_AVAILABLE_IN_ALL
-GskLineCap              gsk_stroke_get_line_cap                 (const GskStroke        *self);
-GDK_AVAILABLE_IN_ALL
-void                    gsk_stroke_set_line_join                (GskStroke              *self,
-                                                                 GskLineJoin             line_join);
-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);
-GDK_AVAILABLE_IN_ALL
-const float *           gsk_stroke_get_dash                     (const GskStroke        *self,
-                                                                 gsize                  *n_dash);
-
-GDK_AVAILABLE_IN_ALL
-void                    gsk_stroke_set_dash_offset              (GskStroke              *self,
-                                                                 float                   offset);
-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

@@ -1,60 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#ifndef __GSK_STROKE_PRIVATE_H__
-#define __GSK_STROKE_PRIVATE_H__
-
-#include "gskstroke.h"
-
-G_BEGIN_DECLS
-
-struct _GskStroke
-{
-  float line_width;
-  GskLineCap line_cap;
-  GskLineJoin line_join;
-  float miter_limit;
-
-  float *dash;
-  gsize n_dash;
-  float dash_length; /* sum of all dashes in the array */
-  float dash_offset;
-};
-
-static inline void
-gsk_stroke_init_copy (GskStroke       *stroke,
-                      const GskStroke *other)
-{
-  *stroke = *other;
-
-  stroke->dash = g_memdup (other->dash, stroke->n_dash * sizeof (float));
-}
-
-static inline void
-gsk_stroke_clear (GskStroke *stroke)
-{
-  g_clear_pointer (&stroke->dash, g_free);
-  stroke->n_dash = 0; /* better safe than sorry */
-}
-
-G_END_DECLS
-
-#endif /* __GSK_STROKE_PRIVATE_H__ */
-

gsk/gsktypes.h

@@ -26,11 +26,7 @@
 #include <gdk/gdk.h>
 #include <gsk/gskenums.h>
 
-typedef struct _GskPath                 GskPath;
-typedef struct _GskPathBuilder          GskPathBuilder;
-typedef struct _GskPathMeasure          GskPathMeasure;
 typedef struct _GskRenderer             GskRenderer;
-typedef struct _GskStroke               GskStroke;
 typedef struct _GskTransform            GskTransform;
 
 #endif /* __GSK_TYPES_H__ */

gsk/meson.build

@@ -19,50 +19,32 @@ gsk_private_gl_shaders = [
   'gl/resources/repeat.glsl',
   'gl/resources/custom.glsl',
   'gl/resources/filled_border.glsl',
-  'gl/resources/glyphy.atlas.glsl',
-  'gl/resources/glyphy.fs.glsl',
-  'gl/resources/glyphy.vs.glsl',
 ]
 
 gsk_public_sources = files([
-  'gskcairorenderer.c',
   'gskdiff.c',
+  'gskcairorenderer.c',
   'gskglshader.c',
-  'gskpath.c',
-  'gskpathbuilder.c',
-  'gskpathdash.c',
-  'gskpathmeasure.c',
-  'gskpathops.c',
-  'gskpathstroke.c',
   'gskrenderer.c',
   'gskrendernode.c',
   'gskrendernodeimpl.c',
   'gskrendernodeparser.c',
   'gskroundedrect.c',
-  'gskstroke.c',
   'gsktransform.c',
   'gl/gskglrenderer.c',
 ])
 
 gsk_private_sources = files([
-  'gskboundingbox.c',
   'gskcairoblur.c',
-  'gskcontour.c',
-  'gskconvexity.c',
-  'gskcurve.c',
-  'gskcurveintersect.c',
   'gskdebug.c',
   'gskprivate.c',
   'gskprofiler.c',
-  'gskspline.c',
   'gl/gskglattachmentstate.c',
   'gl/gskglbuffer.c',
   'gl/gskglcommandqueue.c',
   'gl/gskglcompiler.c',
-  'gl/gskglprofiler.c',
   'gl/gskgldriver.c',
   'gl/gskglglyphlibrary.c',
-  'gl/gskglglyphylibrary.c',
   'gl/gskgliconlibrary.c',
   'gl/gskglprogram.c',
   'gl/gskglrenderjob.c',
@@ -83,13 +65,9 @@ gsk_public_headers = files([
   'gskcairorenderer.h',
   'gskenums.h',
   'gskglshader.h',
-  'gskpath.h',
-  'gskpathbuilder.h',
-  'gskpathmeasure.h',
   'gskrenderer.h',
   'gskrendernode.h',
   'gskroundedrect.h',
-  'gskstroke.h',
   'gsktransform.h',
   'gsktypes.h',
   'gsk-autocleanup.h',
@@ -200,7 +178,6 @@ gsk_deps = [
   cairo_csi_dep,
   pixbuf_dep,
   libgdk_dep,
-  libglyphy_dep,
 ]
 
 libgsk_f16c = static_library('gsk_f16c',

gsk/vulkan/gskvulkanrenderpass.c

@@ -260,8 +260,6 @@ gsk_vulkan_render_pass_add_node (GskVulkanRenderPass           *self,
     case GSK_RADIAL_GRADIENT_NODE:
     case GSK_REPEATING_RADIAL_GRADIENT_NODE:
     case GSK_CONIC_GRADIENT_NODE:
-    case GSK_FILL_NODE:
-    case GSK_STROKE_NODE:
     default:
       FALLBACK ("Unsupported node '%s'", g_type_name_from_instance ((GTypeInstance *) node));
 

gtk/gen-gtk-gresources-xml.py

@@ -66,7 +66,7 @@ for f in get_files('theme/Default/assets-hc', '.svg'):
   xml += '    <file preprocess=\'xml-stripblanks\'>theme/Default/assets-hc/{0}</file>\n'.format(f)
 
 for f in get_files('ui', '.ui'):
-  xml += '    <file>ui/{0}</file>\n'.format(f)
+  xml += '    <file alias="ui/{0}">ui/{0}.precompiled</file>\n'.format(f)
 
 xml += '\n'
 

gtk/gtkactionmuxer.c

@@ -945,6 +945,7 @@ gtk_action_muxer_register_observer (GtkActionObservable *observable,
   gboolean enabled;
   const GVariantType *parameter_type;
   GVariant *state;
+  gboolean is_duplicate;
 
   if (!muxer->observed_actions)
     muxer->observed_actions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_action);
@@ -961,22 +962,26 @@ gtk_action_muxer_register_observer (GtkActionObservable *observable,
       g_hash_table_insert (muxer->observed_actions, action->fullname, action);
     }
 
+  is_duplicate = g_slist_find (action->watchers, observer) != NULL;
   action->watchers = g_slist_prepend (action->watchers, observer);
   g_object_weak_ref (G_OBJECT (observer), gtk_action_muxer_weak_notify, action);
 
-  if (action_muxer_query_action (muxer, name,
-                                 &enabled, &parameter_type,
-                                 NULL, NULL, &state, TRUE))
+  if (!is_duplicate)
     {
-      gtk_action_muxer_action_added (muxer, name, parameter_type, enabled, state);
-      g_clear_pointer (&state, g_variant_unref);
-    }
+      if (action_muxer_query_action (muxer, name,
+                                     &enabled, &parameter_type,
+                                     NULL, NULL, &state, TRUE))
+        {
+          gtk_action_muxer_action_added (muxer, name, parameter_type, enabled, state);
+          g_clear_pointer (&state, g_variant_unref);
+        }
 
-  if (muxer->parent)
-    {
-      gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
-                                               name,
-                                               GTK_ACTION_OBSERVER (muxer));
+      if (muxer->parent)
+        {
+          gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
+                                                   name,
+                                                   GTK_ACTION_OBSERVER (muxer));
+        }
     }
 }
 

gtk/gtkbuilderprecompile.c

@@ -27,100 +27,228 @@
 
 typedef enum
 {
- RECORD_TYPE_ELEMENT,
- RECORD_TYPE_END_ELEMENT,
- RECORD_TYPE_TEXT,
-} RecordTreeType;
+  RECORD_TYPE_ELEMENT,
+  RECORD_TYPE_END_ELEMENT,
+  RECORD_TYPE_TEXT,
+} RecordDataType;
 
-typedef struct RecordDataTree RecordDataTree;
+/* All strings are owned by the string chunk */
+typedef struct {
+  /* Must be first for g_slice_free_chain() */
+  GList link;
 
-/* All strings are owned by the string table */
-struct RecordDataTree {
-  RecordDataTree *parent;
-  RecordTreeType type;
+  const char *string;
+  int len;
+  int count;
+  int offset;
+  int text_offset;
+  gboolean include_len;
+} RecordDataString;
+
+typedef struct {
+  RecordDataType type;
+  GList link;
+} RecordDataNode;
+
+typedef struct RecordDataElement RecordDataElement;
+
+struct RecordDataElement {
+  RecordDataNode base;
+
+  RecordDataElement *parent;
+  GQueue children;
   int n_attributes;
-  const char *data;
-  const char **attributes;
-  const char **values;
-  GList *children;
+  gboolean preserve_whitespace;
+  RecordDataString *name;
+  RecordDataString *attributes[];
 };
 
 typedef struct {
-  char *string;
-  int count;
-  int offset;
-} RecordDataString;
+  RecordDataNode base;
 
-static RecordDataTree *
-record_data_tree_new (RecordDataTree *parent,
-                      RecordTreeType  type,
-                      const char     *data)
-{
-  RecordDataTree *tree = g_slice_new0 (RecordDataTree);
-
-  tree->parent = parent;
-  tree->type = type;
-  tree->data = data;
-
-  if (parent)
-    parent->children = g_list_prepend  (parent->children, tree);
-
-  return tree;
-}
-
-static void
-record_data_tree_free (RecordDataTree *tree)
-{
-  g_list_free_full (tree->children, (GDestroyNotify)record_data_tree_free);
-  g_free (tree->attributes);
-  g_free (tree->values);
-  g_slice_free (RecordDataTree, tree);
-}
-
-static void
-record_data_string_free (RecordDataString *s)
-{
-  g_free (s->string);
-  g_slice_free (RecordDataString, s);
-}
-
-static const char *
-record_data_string_lookup (GHashTable *strings,
-                           const char *str,
-                           gssize      len)
-{
-  char *copy = NULL;
-  RecordDataString *s;
-
-  if (len >= 0)
-    {
-      /* Ensure str is zero terminated */
-      copy = g_strndup (str, len);
-      str = copy;
-    }
-
-  s = g_hash_table_lookup (strings, str);
-  if (s)
-    {
-      g_free (copy);
-      s->count++;
-      return s->string;
-    }
-
-  s = g_slice_new (RecordDataString);
-  s->string = copy ? copy : g_strdup (str);
-  s->count = 1;
-
-  g_hash_table_insert (strings, s->string, s);
-  return s->string;
-}
+  RecordDataString *string;
+} RecordDataText;
 
 typedef struct {
   GHashTable *strings;
-  RecordDataTree *root;
-  RecordDataTree *current;
+  GStringChunk *chunks;
+  GQueue string_list;
+  RecordDataElement *root;
+  RecordDataElement *current;
 } RecordData;
 
+static gpointer
+record_data_node_new (RecordDataElement *parent,
+                      RecordDataType     type,
+                      gsize              size)
+{
+  RecordDataNode *node = g_slice_alloc0 (size);
+
+  node->type = type;
+  node->link.data = node;
+
+  if (parent)
+    g_queue_push_tail_link (&parent->children, &node->link);
+
+  return node;
+}
+
+static gboolean
+text_is_important (const char *name)
+{
+  const char *elements[] = {
+    "property",
+    "attribute",
+    "col",
+    "action-widget",
+    "item",
+    "mime-type",
+    "pattern",
+    "suffix",
+    "mark",
+    NULL
+  };
+
+  return g_strv_contains (elements, name);
+}
+
+static RecordDataElement *
+record_data_element_new (RecordDataElement *parent,
+                         RecordDataString  *name,
+                         gsize              n_attributes)
+{
+  RecordDataElement *element;
+
+  element = record_data_node_new (parent,
+                                  RECORD_TYPE_ELEMENT,
+                                  sizeof (RecordDataElement) +
+                                  sizeof (RecordDataString) * n_attributes);
+  element->parent = parent;
+  element->name = name;
+  element->preserve_whitespace = name && text_is_important (name->string);
+  element->n_attributes = n_attributes;
+
+  return element;
+}
+
+static void
+record_data_element_append_text (RecordDataElement *parent,
+                                 RecordDataString  *string)
+{
+  RecordDataText *text;
+
+  text = record_data_node_new (parent,
+                               RECORD_TYPE_TEXT,
+                               sizeof (RecordDataText));
+  text->string = string;
+}
+
+static void
+record_data_node_free (RecordDataNode *node)
+{
+  GList *l, *next;
+  RecordDataText *text;
+  RecordDataElement *element;
+
+  switch (node->type)
+    {
+    case RECORD_TYPE_ELEMENT:
+      element = (RecordDataElement *)node;
+
+      l = element->children.head;
+      while (l)
+        {
+          next = l->next;
+          record_data_node_free (l->data);
+          l = next;
+        }
+
+      g_slice_free1 (sizeof (RecordDataElement) +
+                     sizeof (RecordDataString) * element->n_attributes, element);
+      break;
+    case RECORD_TYPE_TEXT:
+      text = (RecordDataText *)node;
+      g_slice_free (RecordDataText, text);
+      break;
+    case RECORD_TYPE_END_ELEMENT:
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static gboolean
+record_data_string_equal (gconstpointer _a,
+                          gconstpointer _b)
+{
+  const RecordDataString *a = _a;
+  const RecordDataString *b = _b;
+
+  return a->len == b->len &&
+         memcmp (a->string, b->string, a->len) == 0;
+}
+
+/* Copied from g_bytes_hash() */
+static guint
+record_data_string_hash (gconstpointer _a)
+{
+  const RecordDataString *a = _a;
+  const signed char *p, *e;
+  guint32 h = 5381;
+
+  for (p = (signed char *)a->string, e = (signed char *)a->string + a->len; p != e; p++)
+    h = (h << 5) + h + *p;
+
+  return h;
+}
+
+static int
+record_data_string_compare (gconstpointer _a,
+                            gconstpointer _b,
+                            gpointer      user_data)
+{
+  const RecordDataString *a = _a;
+  const RecordDataString *b = _b;
+
+  return b->count - a->count;
+}
+
+static RecordDataString *
+record_data_string_lookup (RecordData *data,
+                           const char *str,
+                           gssize      len)
+{
+  RecordDataString *s, tmp;
+  gboolean include_len = len >= 0;
+
+  if (len < 0)
+    len = strlen (str);
+
+  tmp.string = str;
+  tmp.len = len;
+
+  s = g_hash_table_lookup (data->strings, &tmp);
+  if (s)
+    {
+      s->count++;
+      s->include_len |= include_len;
+      return s;
+    }
+
+  s = g_slice_new (RecordDataString);
+  /* The string is zero terminated */
+  s->string = g_string_chunk_insert_len (data->chunks, str, len);
+  s->len = len;
+  s->count = 1;
+  s->include_len = include_len;
+  s->link.data = s;
+  s->link.next = NULL;
+  s->link.prev = NULL;
+
+  g_hash_table_add (data->strings, s);
+  g_queue_push_tail_link (&data->string_list, &s->link);
+  return s;
+}
+
 static void
 record_start_element (GMarkupParseContext  *context,
                       const char           *element_name,
@@ -131,21 +259,20 @@ record_start_element (GMarkupParseContext  *context,
 {
   gsize n_attrs = g_strv_length ((char **)names);
   RecordData *data = user_data;
-  RecordDataTree *child;
+  RecordDataElement *child;
+  RecordDataString *name, **attr_names, **attr_values;
   int i;
 
-  child = record_data_tree_new (data->current, RECORD_TYPE_ELEMENT,
-                                record_data_string_lookup (data->strings, element_name, -1));
+  name = record_data_string_lookup (data, element_name, -1);
+  child = record_data_element_new (data->current, name, n_attrs);
   data->current = child;
 
-  child->n_attributes = n_attrs;
-  child->attributes = g_new (const char *, n_attrs);
-  child->values = g_new (const char *, n_attrs);
-
+  attr_names = &child->attributes[0];
+  attr_values = &child->attributes[n_attrs];
   for (i = 0; i < n_attrs; i++)
     {
-      child->attributes[i] = record_data_string_lookup (data->strings, names[i], -1);
-      child->values[i] = record_data_string_lookup (data->strings, values[i], -1);
+      attr_names[i] = record_data_string_lookup (data, names[i], -1);
+      attr_values[i] = record_data_string_lookup (data, values[i], -1);
     }
 }
 
@@ -160,6 +287,23 @@ record_end_element (GMarkupParseContext  *context,
   data->current = data->current->parent;
 }
 
+static gboolean
+is_whitespace (const char *text,
+               gsize       text_len)
+{
+  const char *end;
+  const char *p;
+
+  end = text + text_len;
+  for (p = text; p < end; p = g_utf8_next_char (p))
+    {
+      if (!g_unichar_isspace (g_utf8_get_char (p)))
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
 static void
 record_text (GMarkupParseContext  *context,
              const char           *text,
@@ -168,9 +312,16 @@ record_text (GMarkupParseContext  *context,
              GError              **error)
 {
   RecordData *data = user_data;
+  RecordDataString *string;
 
-  record_data_tree_new (data->current, RECORD_TYPE_TEXT,
-                        record_data_string_lookup (data->strings, text, text_len));
+  if (text_len == 0)
+    return;
+
+  if (!data->current->preserve_whitespace && is_whitespace (text, text_len))
+    return;
+
+  string = record_data_string_lookup (data, text, text_len);
+  record_data_element_append_text (data->current, string);
 }
 
 static const GMarkupParser record_parser =
@@ -182,16 +333,6 @@ static const GMarkupParser record_parser =
   NULL, // error, fails immediately
 };
 
-static int
-compare_string (gconstpointer _a,
-                gconstpointer _b)
-{
-  const RecordDataString *a = _a;
-  const RecordDataString *b = _b;
-
-  return b->count - a->count;
-}
-
 static void
 marshal_uint32 (GString *str,
                 guint32  v)
@@ -240,54 +381,60 @@ marshal_uint32 (GString *str,
     }
 }
 
-static void
-marshal_string (GString    *marshaled,
-                GHashTable *strings,
-                const char *string)
+static int
+marshal_uint32_len (guint32 v)
 {
-  RecordDataString *s;
+  if (v < 128)
+    return 1;
 
-  s = g_hash_table_lookup (strings, string);
-  g_assert (s != NULL);
+  if (v < (1<<14))
+    return 2;
 
-  marshal_uint32 (marshaled, s->offset);
+  if (v < (1<<21))
+    return 3;
+
+  if (v < (1<<28))
+    return 4;
+
+  return 5;
 }
 
 static void
 marshal_tree (GString        *marshaled,
-              GHashTable     *strings,
-              RecordDataTree *tree)
+              RecordDataNode *node)
 {
   GList *l;
   int i;
+  RecordDataText *text;
+  RecordDataElement *element;
+  RecordDataString **attr_names, **attr_values;
 
-  /* Special case the root */
-  if (tree->parent == NULL)
-    {
-      for (l = g_list_last (tree->children); l != NULL; l = l->prev)
-        marshal_tree (marshaled, strings, l->data);
-      return;
-    }
-
-  switch (tree->type)
+  switch (node->type)
     {
     case RECORD_TYPE_ELEMENT:
+      element = (RecordDataElement *)node;
+
       marshal_uint32 (marshaled, RECORD_TYPE_ELEMENT);
-      marshal_string (marshaled, strings, tree->data);
-      marshal_uint32 (marshaled, tree->n_attributes);
-      for (i = 0; i < tree->n_attributes; i++)
+      marshal_uint32 (marshaled, element->name->offset);
+      marshal_uint32 (marshaled, element->n_attributes);
+
+      attr_names = &element->attributes[0];
+      attr_values = &element->attributes[element->n_attributes];
+      for (i = 0; i < element->n_attributes; i++)
         {
-          marshal_string (marshaled, strings, tree->attributes[i]);
-          marshal_string (marshaled, strings, tree->values[i]);
+          marshal_uint32 (marshaled, attr_names[i]->offset);
+          marshal_uint32 (marshaled, attr_values[i]->offset);
         }
-      for (l = g_list_last (tree->children); l != NULL; l = l->prev)
-        marshal_tree (marshaled, strings, l->data);
+
+      for (l = element->children.head; l != NULL; l = l->next)
+        marshal_tree (marshaled, l->data);
 
       marshal_uint32 (marshaled, RECORD_TYPE_END_ELEMENT);
       break;
     case RECORD_TYPE_TEXT:
+      text = (RecordDataText *)node;
       marshal_uint32 (marshaled, RECORD_TYPE_TEXT);
-      marshal_string (marshaled, strings, tree->data);
+      marshal_uint32 (marshaled, text->string->text_offset);
       break;
     case RECORD_TYPE_END_ELEMENT:
     default:
@@ -295,6 +442,17 @@ marshal_tree (GString        *marshaled,
     }
 }
 
+static void
+marshal_root (GString        *marshaled,
+              RecordDataNode *node)
+{
+  GList *l;
+  RecordDataElement *element = (RecordDataElement *)node;
+
+  for (l = element->children.head; l != NULL; l = l->next)
+    marshal_tree (marshaled, l->data);
+}
+
 /**
  * _gtk_buildable_parser_precompile:
  * @text: chunk of text to parse
@@ -313,20 +471,22 @@ _gtk_buildable_parser_precompile (const char  *text,
 {
   GMarkupParseContext *ctx;
   RecordData data = { 0 };
-  GList *string_table, *l;
+  GList *l;
   GString *marshaled;
   int offset;
 
-  data.strings = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)record_data_string_free);
-  data.root = record_data_tree_new (NULL, RECORD_TYPE_ELEMENT, NULL);
+  data.strings = g_hash_table_new (record_data_string_hash, record_data_string_equal);
+  data.chunks = g_string_chunk_new (512);
+  data.root = record_data_element_new (NULL, NULL, 0);
   data.current = data.root;
 
-  ctx = g_markup_parse_context_new (&record_parser, G_MARKUP_TREAT_CDATA_AS_TEXT,
-                                    &data, NULL);
+  ctx = g_markup_parse_context_new (&record_parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &data, NULL);
 
-  if (!g_markup_parse_context_parse (ctx, text, text_len, error))
+  if (!g_markup_parse_context_parse (ctx, text, text_len, error) ||
+      !g_markup_parse_context_end_parse (ctx, error))
     {
-      record_data_tree_free (data.root);
+      record_data_node_free (&data.root->base);
+      g_string_chunk_free (data.chunks);
       g_hash_table_destroy (data.strings);
       g_markup_parse_context_free (ctx);
       return NULL;
@@ -334,34 +494,45 @@ _gtk_buildable_parser_precompile (const char  *text,
 
   g_markup_parse_context_free (ctx);
 
-  string_table = g_hash_table_get_values (data.strings);
-
-  string_table = g_list_sort (string_table, compare_string);
+  g_queue_sort (&data.string_list, record_data_string_compare, NULL);
 
   offset = 0;
-  for (l = string_table; l != NULL; l = l->next)
+  for (l = data.string_list.head; l != NULL; l = l->next)
     {
       RecordDataString *s = l->data;
+
+      if (s->include_len)
+        {
+          s->text_offset = offset;
+          offset += marshal_uint32_len (s->len);
+        }
+
       s->offset = offset;
-      offset += strlen (s->string) + 1;
+      offset += s->len + 1;
     }
 
-  marshaled = g_string_new ("");
+  marshaled = g_string_sized_new (4 + offset + 32);
   /* Magic marker */
   g_string_append_len (marshaled, "GBU\0", 4);
   marshal_uint32 (marshaled, offset);
 
-  for (l = string_table; l != NULL; l = l->next)
+  for (l = data.string_list.head; l != NULL; l = l->next)
     {
       RecordDataString *s = l->data;
-      g_string_append_len (marshaled, s->string, strlen (s->string) + 1);
+
+      if (s->include_len)
+        marshal_uint32 (marshaled, s->len);
+
+      g_string_append_len (marshaled, s->string, s->len + 1);
     }
 
-  g_list_free (string_table);
+  marshal_root (marshaled, &data.root->base);
 
-  marshal_tree (marshaled, data.strings, data.root);
-
-  record_data_tree_free (data.root);
+  g_slice_free_chain (RecordDataString,
+                      (RecordDataString *)data.string_list.head,
+                      link.next);
+  record_data_node_free (&data.root->base);
+  g_string_chunk_free (data.chunks);
   g_hash_table_destroy (data.strings);
 
   return g_string_free_to_bytes (marshaled);
@@ -412,6 +583,18 @@ demarshal_string (const char **tree,
   return strings + offset;
 }
 
+static const char *
+demarshal_text (const char **tree,
+                const char  *strings,
+                guint32     *len)
+{
+  guint32 offset = demarshal_uint32 (tree);
+  const char *str = strings + offset;
+
+  *len = demarshal_uint32 (&str);
+  return str;
+}
+
 static void
 propagate_error (GtkBuildableParseContext *context,
                  GError                  **dest,
@@ -489,14 +672,15 @@ replay_text (GtkBuildableParseContext  *context,
              const char                *strings,
              GError                   **error)
 {
+  guint32 len;
   const char *text;
   GError *tmp_error = NULL;
 
-  text = demarshal_string (tree, strings);
+  text = demarshal_text (tree, strings, &len);
 
   (*context->internal_callbacks->text) (NULL,
                                         text,
-                                        strlen (text),
+                                        len,
                                         context,
                                         &tmp_error);
 

gtk/gtkcolorbutton.c

@@ -296,6 +296,7 @@ gtk_color_button_init (GtkColorButton *button)
                                  "accessible-role", GTK_ACCESSIBLE_ROLE_IMG,
                                  "selectable", FALSE,
                                  "has-menu", FALSE,
+                                 "can-drag", FALSE,
                                  NULL);
   gtk_widget_set_can_focus (button->swatch, FALSE);
   gtk_widget_remove_css_class (button->swatch, "activatable");

gtk/gtkcolorswatch.c

@@ -65,6 +65,7 @@ struct _GtkColorSwatch
 
   GtkWidget *popover;
   GtkDropTarget *dest;
+  GtkDragSource *source;
 };
 
 struct _GtkColorSwatchClass
@@ -81,7 +82,8 @@ enum
   PROP_RGBA,
   PROP_SELECTABLE,
   PROP_HAS_MENU,
-  PROP_CAN_DROP
+  PROP_CAN_DROP,
+  PROP_CAN_DRAG
 };
 
 G_DEFINE_TYPE (GtkColorSwatch, gtk_color_swatch, GTK_TYPE_WIDGET)
@@ -429,6 +431,9 @@ swatch_get_property (GObject    *object,
     case PROP_CAN_DROP:
       g_value_set_boolean (value, swatch->dest != NULL);
       break;
+    case PROP_CAN_DRAG:
+      g_value_set_boolean (value, swatch->source != NULL);
+      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -457,6 +462,9 @@ swatch_set_property (GObject      *object,
     case PROP_CAN_DROP:
       gtk_color_swatch_set_can_drop (swatch, g_value_get_boolean (value));
       break;
+    case PROP_CAN_DRAG:
+      gtk_color_swatch_set_can_drag (swatch, g_value_get_boolean (value));
+      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -470,7 +478,7 @@ swatch_finalize (GObject *object)
 
   g_free (swatch->icon);
   gtk_widget_unparent (swatch->overlay_widget);
- 
+
   G_OBJECT_CLASS (gtk_color_swatch_parent_class)->finalize (object);
 }
 
@@ -512,11 +520,14 @@ gtk_color_swatch_class_init (GtkColorSwatchClass *class)
   g_object_class_install_property (object_class, PROP_CAN_DROP,
       g_param_spec_boolean ("can-drop", P_("Can Drop"), P_("Whether the swatch should accept drops"),
                             FALSE, GTK_PARAM_READWRITE));
+  g_object_class_install_property (object_class, PROP_CAN_DRAG,
+      g_param_spec_boolean ("can-drag", P_("Can Drag"), P_("Whether the swatch should allow drags"),
+                            TRUE, GTK_PARAM_READWRITE));
 
   /**
    * GtkColorSwatch|menu.popup:
    *
-   * Opens the context menu. 
+   * Opens the context menu.
    */
   gtk_widget_class_install_action (widget_class, "menu.popup", NULL, swatch_popup_menu);
 
@@ -568,6 +579,8 @@ gtk_color_swatch_init (GtkColorSwatch *swatch)
                     G_CALLBACK (key_controller_key_pressed), swatch);
   gtk_widget_add_controller (GTK_WIDGET (swatch), controller);
 
+  gtk_color_swatch_set_can_drag (swatch, TRUE);
+
   gtk_widget_add_css_class (GTK_WIDGET (swatch), "activatable");
 
   swatch->overlay_widget = g_object_new (GTK_TYPE_IMAGE,
@@ -598,18 +611,10 @@ void
 gtk_color_swatch_set_rgba (GtkColorSwatch *swatch,
                            const GdkRGBA  *color)
 {
-  if (!swatch->has_color)
-    {
-      GtkDragSource *source;
-
-      source = gtk_drag_source_new ();
-      g_signal_connect (source, "prepare", G_CALLBACK (gtk_color_swatch_drag_prepare), swatch);
-
-      gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (source));
-    }
-
   swatch->has_color = TRUE;
   swatch->color = *color;
+  if (swatch->source)
+    gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (swatch->source), GTK_PHASE_CAPTURE);
 
   if (INTENSITY (swatch->color.red, swatch->color.green, swatch->color.blue) > 0.5)
     {
@@ -681,6 +686,30 @@ gtk_color_swatch_set_can_drop (GtkColorSwatch *swatch,
   g_object_notify (G_OBJECT (swatch), "can-drop");
 }
 
+void
+gtk_color_swatch_set_can_drag (GtkColorSwatch *swatch,
+                               gboolean        can_drag)
+{
+  if (can_drag == (swatch->source != NULL))
+    return;
+
+  if (can_drag && !swatch->source)
+    {
+      swatch->source = gtk_drag_source_new ();
+      g_signal_connect (swatch->source, "prepare", G_CALLBACK (gtk_color_swatch_drag_prepare), swatch);
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (swatch->source),
+                                                  swatch->has_color ? GTK_PHASE_CAPTURE : GTK_PHASE_NONE);
+      gtk_widget_add_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (swatch->source));
+    }
+  if (!can_drag && swatch->source)
+    {
+      gtk_widget_remove_controller (GTK_WIDGET (swatch), GTK_EVENT_CONTROLLER (swatch->source));
+      swatch->source = NULL;
+    }
+
+  g_object_notify (G_OBJECT (swatch), "can-drag");
+}
+
 void
 gtk_color_swatch_set_use_alpha (GtkColorSwatch *swatch,
                                 gboolean        use_alpha)

gtk/gtkcolorswatchprivate.h

@@ -42,6 +42,8 @@ void        gtk_color_swatch_set_hsva         (GtkColorSwatch *swatch,
                                                double          a);
 void        gtk_color_swatch_set_can_drop     (GtkColorSwatch *swatch,
                                                gboolean        can_drop);
+void        gtk_color_swatch_set_can_drag     (GtkColorSwatch *swatch,
+                                               gboolean        can_drag);
 void        gtk_color_swatch_set_icon         (GtkColorSwatch *swatch,
                                                const char     *icon);
 void        gtk_color_swatch_set_use_alpha    (GtkColorSwatch *swatch,

gtk/gtkdragicon.c

@@ -386,6 +386,7 @@ gtk_drag_icon_class_init (GtkDragIconClass *klass)
 static void
 gtk_drag_icon_init (GtkDragIcon *self)
 {
+  gtk_widget_set_can_target (GTK_WIDGET (self), FALSE);
 }
 
 /**
@@ -531,15 +532,38 @@ gtk_drag_icon_create_widget_for_value (const GValue *value)
     {
       return gtk_label_new (g_value_get_string (value));
     }
+  else if (G_VALUE_HOLDS (value, GDK_TYPE_PAINTABLE))
+    {
+      GtkWidget *image;
+
+      image = gtk_image_new_from_paintable (g_value_get_object (value));
+      gtk_widget_add_css_class (image, "large-icons");
+
+      return image;
+    }
   else if (G_VALUE_HOLDS (value, GDK_TYPE_RGBA))
     {
       GtkWidget *swatch;
 
       swatch = gtk_color_swatch_new ();
+      gtk_color_swatch_set_can_drag (GTK_COLOR_SWATCH (swatch), FALSE);
+      gtk_color_swatch_set_can_drop (GTK_COLOR_SWATCH (swatch), FALSE);
       gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (swatch), g_value_get_boxed (value));
 
       return swatch;
     }
+  else if (G_VALUE_HOLDS (value, G_TYPE_FILE))
+    {
+      GFileInfo *info;
+      GtkWidget *image;
+
+      info = g_file_query_info (G_FILE (g_value_get_object (value)), "standard::icon", 0, NULL, NULL);
+      image = gtk_image_new_from_gicon (g_file_info_get_icon (info));
+      gtk_widget_add_css_class (image, "large-icons");
+      g_object_unref (info);
+
+      return image;
+    }
   else if (G_VALUE_HOLDS (value, GTK_TYPE_TEXT_BUFFER))
     {
       GtkTextBuffer *buffer = g_value_get_object (value);
@@ -568,7 +592,7 @@ gtk_drag_icon_create_widget_for_value (const GValue *value)
       node = gsk_value_get_render_node (value);
       if (node == NULL)
         return NULL;
-      
+
       gsk_render_node_get_bounds (node, &bounds);
       paintable = gtk_render_node_paintable_new (node, &bounds);
       image = gtk_image_new_from_paintable (paintable);

gtk/gtkdroptarget.c

@@ -80,6 +80,7 @@
  *     GDK_TYPE_PIXBUF,
  *   }, 2);
  *
+ *   g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
  *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
  * }
  * ```
@@ -303,7 +304,7 @@ gtk_drop_target_load (GtkDropTarget *self)
 
   self->cancellable = g_cancellable_new ();
 
-  gdk_drop_read_value_async (self->drop, 
+  gdk_drop_read_value_async (self->drop,
                              type,
                              G_PRIORITY_DEFAULT,
                              self->cancellable,
@@ -355,13 +356,13 @@ make_action_unique (GdkDragAction actions)
 
   if (actions & GDK_ACTION_MOVE)
     return GDK_ACTION_MOVE;
-  
+
   if (actions & GDK_ACTION_LINK)
     return GDK_ACTION_LINK;
 
   return 0;
 }
-  
+
 static GdkDragAction
 gtk_drop_target_enter (GtkDropTarget  *self,
                        double          x,
@@ -370,7 +371,7 @@ gtk_drop_target_enter (GtkDropTarget  *self,
   return make_action_unique (self->actions & gdk_drop_get_actions (self->drop));
 }
 
-static GdkDragAction         
+static GdkDragAction
 gtk_drop_target_motion (GtkDropTarget  *self,
                         double          x,
                         double          y)
@@ -900,7 +901,7 @@ GdkContentFormats *
 gtk_drop_target_get_formats (GtkDropTarget *self)
 {
   g_return_val_if_fail (GTK_IS_DROP_TARGET (self), NULL);
-  
+
   return self->formats;
 }
 
@@ -929,7 +930,7 @@ gtk_drop_target_set_gtypes (GtkDropTarget *self,
   builder = gdk_content_formats_builder_new ();
   for (i = 0; i < n_types; i++)
     gdk_content_formats_builder_add_gtype (builder, types[i]);
-  
+
   self->formats = gdk_content_formats_builder_free_to_formats (builder);
 
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FORMATS]);
@@ -970,7 +971,7 @@ gtk_drop_target_set_actions (GtkDropTarget *self,
                              GdkDragAction  actions)
 {
   g_return_if_fail (GTK_IS_DROP_TARGET (self));
-  
+
   if (self->actions == actions)
     return;
 
@@ -1007,7 +1008,7 @@ gtk_drop_target_set_preload (GtkDropTarget *self,
                              gboolean       preload)
 {
   g_return_if_fail (GTK_IS_DROP_TARGET (self));
-  
+
   if (self->preload == preload)
     return;
 

gtk/gtkexpression.c

@@ -124,7 +124,7 @@
  *
  * `GtkBuilder` has support for creating expressions. The syntax here can be used where
  * a `GtkExpression` object is needed like in a `<property>` tag for an expression
- * property, or in a `<binding>` tag to bind a property to an expression.
+ * property, or in a `<binding name="property">` tag to bind a property to an expression.
  *
  * To create an property expression, use the `<lookup>` element. It can have a `type`
  * attribute to specify the object type, and a `name` attribute to specify the property

gtk/gtkimcontextquartz.c

@@ -305,7 +305,7 @@ static void
 quartz_set_cursor_location (GtkIMContext *context, GdkRectangle *area)
 {
   GtkIMContextQuartz *qc = GTK_IM_CONTEXT_QUARTZ (context);
-  GtkWidget* surface_widget = GTK_WIDGET (gdk_surface_get_widget (qc->client_surface));
+  GtkWidget* surface_widget;
   int sx, sy;
   double wx, wy;
 
@@ -317,6 +317,11 @@ quartz_set_cursor_location (GtkIMContext *context, GdkRectangle *area)
   if (!qc->focused)
     return;
 
+  surface_widget = GTK_WIDGET (gdk_surface_get_widget (qc->client_surface));
+
+  if (!surface_widget)
+    return;
+
   gdk_surface_get_origin (qc->client_surface, &sx, &sy);
   gtk_widget_translate_coordinates(qc->client_widget, surface_widget,
                                    area->x, area->y, &wx, &wy);

gtk/gtkmenutrackeritem.c

@@ -286,7 +286,7 @@ gtk_menu_tracker_item_update_visibility (GtkMenuTrackerItem *self)
   if (visible != self->is_visible)
     {
       self->is_visible = visible;
-      g_object_notify (G_OBJECT (self), "is-visible");
+      g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_IS_VISIBLE]);
     }
 }
 
@@ -300,9 +300,17 @@ gtk_menu_tracker_item_action_added (GtkActionObserver   *observer,
 {
   GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
   GVariant *action_target;
+  gboolean old_sensitive;
+  gboolean old_toggled;
+  GtkMenuTrackerItemRole old_role;
+  guint n_changed;
 
   GTK_NOTE(ACTIONS, g_message ("menutracker: action %s added", action_name));
 
+  old_sensitive = self->sensitive;
+  old_toggled = self->toggled;
+  old_role = self->role;
+
   action_target = g_menu_item_get_attribute_value (self->item, G_MENU_ATTRIBUTE_TARGET, NULL);
 
   self->can_activate = (action_target == NULL && parameter_type == NULL) ||
@@ -340,18 +348,29 @@ gtk_menu_tracker_item_action_added (GtkActionObserver   *observer,
       self->role = GTK_MENU_TRACKER_ITEM_ROLE_CHECK;
     }
 
-  g_object_freeze_notify (G_OBJECT (self));
+  /* Avoid freeze/thaw_notify as they are quite expensive in runtime/memory
+   * unless we have more than one property to update. Additionally, only
+   * notify on properties that have changed to avoid extraneous signal
+   * emission. This code can get run a lot!
+   */
+  n_changed = (old_role != self->role)
+            + (old_toggled != self->toggled)
+            + (old_sensitive != self->sensitive);
 
-  if (self->sensitive)
+  if (n_changed > 1)
+    g_object_freeze_notify (G_OBJECT (self));
+
+  if (self->sensitive != old_sensitive)
     g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]);
 
-  if (self->toggled)
+  if (self->toggled != old_toggled)
     g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]);
 
-  if (self->role != GTK_MENU_TRACKER_ITEM_ROLE_NORMAL)
+  if (self->role != old_role)
     g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ROLE]);
 
-  g_object_thaw_notify (G_OBJECT (self));
+  if (n_changed > 1)
+    g_object_thaw_notify (G_OBJECT (self));
 
   if (action_target)
     g_variant_unref (action_target);

gtk/gtkpicture.c

@@ -178,7 +178,8 @@ gtk_picture_measure (GtkWidget      *widget,
   double min_width, min_height, nat_width, nat_height;
   double default_size;
 
-  if (self->paintable == NULL)
+  /* for_size = 0 below is treated as -1, but we want to return zeros. */
+  if (self->paintable == NULL || for_size == 0)
     {
       *minimum = 0;
       *natural = 0;

gtk/gtkpopover.c

@@ -1289,28 +1289,6 @@ get_border (GtkCssNode *node,
   border->left = _gtk_css_number_value_get (style->border->border_left_width, 100);
 }
 
-static GskPath *
-gtk_popover_get_tail_path (GtkPopover *popover)
-{
-  GskPathBuilder *builder;
-  int initial_x, initial_y;
-  int tip_x, tip_y;
-  int final_x, final_y;
-
-  builder = gsk_path_builder_new ();
-
-  gtk_popover_get_gap_coords (popover,
-                              &initial_x, &initial_y,
-                              &tip_x, &tip_y,
-                              &final_x, &final_y);
-
-  gsk_path_builder_move_to (builder, initial_x, initial_y);
-  gsk_path_builder_line_to (builder, tip_x, tip_y);
-  gsk_path_builder_line_to (builder, final_x, final_y);
-
-  return gsk_path_builder_free_to_path (builder);
-}
-
 static void
 gtk_popover_apply_tail_path (GtkPopover *popover,
                              cairo_t    *cr)
@@ -1565,14 +1543,22 @@ create_arrow_render_node (GtkPopover *popover)
   GtkWidget *widget = GTK_WIDGET (popover);
   GtkStyleContext *context;
   GtkBorder border;
+  cairo_t *cr;
   GtkSnapshot *snapshot;
-  GskPath *path;
 
   snapshot = gtk_snapshot_new ();
 
+  cr = gtk_snapshot_append_cairo (snapshot,
+                                  &GRAPHENE_RECT_INIT (
+                                    0, 0,
+                                    gtk_widget_get_width (widget),
+                                    gtk_widget_get_height (widget)
+                                  ));
+
   /* Clip to the arrow shape */
-  path = gtk_popover_get_tail_path (popover);
-  gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+  cairo_save (cr);
+  gtk_popover_apply_tail_path (popover, cr);
+  cairo_clip (cr);
 
   get_border (priv->arrow_node, &border);
 
@@ -1580,34 +1566,29 @@ create_arrow_render_node (GtkPopover *popover)
   gtk_style_context_save_to_node (context, priv->arrow_node);
 
   /* Render the arrow background */
-  gtk_snapshot_render_background (snapshot, context,
-                                  0, 0,
-                                  gtk_widget_get_width (widget),
-                                  gtk_widget_get_height (widget));
+  gtk_render_background (context, cr,
+                         0, 0,
+                         gtk_widget_get_width (widget),
+                         gtk_widget_get_height (widget));
 
   /* Render the border of the arrow tip */
   if (border.bottom > 0)
     {
       GtkCssStyle *style;
       const GdkRGBA *border_color;
-      GskStroke *stroke;
-      graphene_rect_t bounds;
 
       style = gtk_css_node_get_style (priv->arrow_node);
       border_color = gtk_css_color_value_get_rgba (style->border->border_left_color ? style->border->border_left_color : style->core->color);
 
-      stroke = gsk_stroke_new (border.bottom + 1);
-      gtk_snapshot_push_stroke (snapshot, path, stroke);
-      gsk_stroke_free (stroke);
+      gtk_popover_apply_tail_path (popover, cr);
+      gdk_cairo_set_source_rgba (cr, border_color);
 
-      gsk_path_get_bounds (path, &bounds);
-      gtk_snapshot_append_color (snapshot, border_color, &bounds);
-
-      gtk_snapshot_pop (snapshot);
+      cairo_set_line_width (cr, border.bottom + 1);
+      cairo_stroke (cr);
     }
 
-  gtk_snapshot_pop (snapshot);
-  gsk_path_unref (path);
+  cairo_restore (cr);
+  cairo_destroy (cr);
 
   gtk_style_context_restore (context);
 

gtk/gtkprintoperation-unix.c

@@ -1,5 +1,5 @@
 /* GTK - The GIMP Toolkit
- * gtkprintoperation-unix.c: Print Operation Details for Unix 
+ * gtkprintoperation-unix.c: Print Operation Details for Unix
  *                           and Unix-like platforms
  * Copyright (C) 2006, Red Hat, Inc.
  *
@@ -25,7 +25,7 @@
 #include <sys/stat.h>
 #include <string.h>
 #include <errno.h>
-#include <stdlib.h>       
+#include <stdlib.h>
 #include <fcntl.h>
 
 #include <glib/gstdio.h>
@@ -45,7 +45,7 @@
 #include "gtkintl.h"
 
 
-typedef struct 
+typedef struct
 {
   GtkWindow *parent;        /* just in case we need to throw error dialogs */
   GMainLoop *loop;
@@ -56,7 +56,7 @@ typedef struct
   cairo_surface_t *surface;
   gulong job_status_changed_tag;
 
-  
+
 } GtkPrintOperationUnix;
 
 typedef struct _PrinterFinder PrinterFinder;
@@ -71,18 +71,18 @@ unix_start_page (GtkPrintOperation *op,
 		 GtkPrintContext   *print_context,
 		 GtkPageSetup      *page_setup)
 {
-  GtkPrintOperationUnix *op_unix;  
+  GtkPrintOperationUnix *op_unix;
   GtkPaperSize *paper_size;
   cairo_surface_type_t type;
   double w, h;
 
   op_unix = op->priv->platform_data;
-  
+
   paper_size = gtk_page_setup_get_paper_size (page_setup);
 
   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
-  
+
   type = cairo_surface_get_type (op_unix->surface);
 
   if ((op->priv->manual_number_up < 2) ||
@@ -167,11 +167,11 @@ shell_command_substitute_file (const char *cmd,
   *settings_filename_replaced = FALSE;
 
   start = inptr = cmd;
-  while ((inptr = strchr (inptr, '%')) != NULL) 
+  while ((inptr = strchr (inptr, '%')) != NULL)
     {
       g_string_append_len (final, start, inptr - start);
       inptr++;
-      switch (*inptr) 
+      switch (*inptr)
         {
           case 'f':
             g_string_append (final, pdf_filename);
@@ -236,11 +236,11 @@ gtk_print_operation_unix_launch_preview (GtkPrintOperation *op,
     display = gdk_display_get_default ();
 
   fd = g_file_open_tmp ("settingsXXXXXX.ini", &settings_filename, &error);
-  if (fd < 0) 
+  if (fd < 0)
     goto out;
 
   key_file = g_key_file_new ();
-  
+
   print_settings = gtk_print_settings_copy (gtk_print_operation_get_print_settings (op));
 
   if (print_settings != NULL)
@@ -345,7 +345,7 @@ gtk_print_operation_unix_launch_preview (GtkPrintOperation *op,
 
 static void
 unix_finish_send  (GtkPrintJob  *job,
-                   gpointer      user_data, 
+                   gpointer      user_data,
                    const GError *error)
 {
   GtkPrintOperation *op = (GtkPrintOperation *) user_data;
@@ -370,19 +370,19 @@ unix_end_run (GtkPrintOperation *op,
   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 
   cairo_surface_finish (op_unix->surface);
-  
+
   if (cancelled)
     return;
 
   if (wait)
     op_unix->loop = g_main_loop_new (NULL, FALSE);
-  
+
   /* TODO: Check for error */
   if (op_unix->job != NULL)
     {
       g_object_ref (op);
       gtk_print_job_send (op_unix->job,
-                          unix_finish_send, 
+                          unix_finish_send,
                           op, NULL);
     }
 
@@ -398,7 +398,7 @@ unix_end_run (GtkPrintOperation *op,
 }
 
 static void
-job_status_changed_cb (GtkPrintJob       *job, 
+job_status_changed_cb (GtkPrintJob       *job,
 		       GtkPrintOperation *op)
 {
   _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
@@ -406,7 +406,7 @@ job_status_changed_cb (GtkPrintJob       *job,
 
 
 static void
-print_setup_changed_cb (GtkPrintUnixDialog *print_dialog, 
+print_setup_changed_cb (GtkPrintUnixDialog *print_dialog,
                         GParamSpec         *pspec,
                         gpointer            user_data)
 {
@@ -450,13 +450,13 @@ get_print_dialog (GtkPrintOperation *op,
 					priv->print_settings);
 
   if (priv->default_page_setup)
-    gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd), 
+    gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
                                           priv->default_page_setup);
 
   gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
                                               priv->embed_page_setup);
 
-  gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (pd), 
+  gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (pd),
                                           priv->current_page);
 
   gtk_print_unix_dialog_set_support_selection (GTK_PRINT_UNIX_DIALOG (pd),
@@ -468,10 +468,10 @@ get_print_dialog (GtkPrintOperation *op,
   g_signal_emit_by_name (op, "create-custom-widget",
 			 &priv->custom_widget);
 
-  if (priv->custom_widget) 
+  if (priv->custom_widget)
     {
       custom_tab_label = priv->custom_tab_label;
-      
+
       if (custom_tab_label == NULL)
 	{
 	  custom_tab_label = g_get_application_name ();
@@ -480,18 +480,18 @@ get_print_dialog (GtkPrintOperation *op,
 	}
 
       label = gtk_label_new (custom_tab_label);
-      
+
       gtk_print_unix_dialog_add_custom_tab (GTK_PRINT_UNIX_DIALOG (pd),
 					    priv->custom_widget, label);
 
       g_signal_connect (pd, "notify::selected-printer", (GCallback) print_setup_changed_cb, op);
       g_signal_connect (pd, "notify::page-setup", (GCallback) print_setup_changed_cb, op);
     }
-  
+
   return pd;
 }
-  
-typedef struct 
+
+typedef struct
 {
   GtkPrintOperation           *op;
   gboolean                     do_print;
@@ -523,7 +523,7 @@ finish_print (PrintResponseData *rdata,
   GtkPrintOperationPrivate *priv = op->priv;
   GtkPrintJob *job;
   double top, bottom, left, right;
-  
+
   if (rdata->do_print)
     {
       gtk_print_operation_set_print_settings (op, settings);
@@ -555,38 +555,38 @@ finish_print (PrintResponseData *rdata,
         {
 	  GtkPrintOperationUnix *op_unix;
 	  cairo_t *cr;
-	  
+
 	  op_unix = g_new0 (GtkPrintOperationUnix, 1);
 	  priv->platform_data = op_unix;
 	  priv->free_platform_data = (GDestroyNotify) op_unix_free;
 	  op_unix->parent = rdata->parent;
-	  
+
 	  priv->start_page = unix_start_page;
 	  priv->end_page = unix_end_page;
 	  priv->end_run = unix_end_run;
-	  
+
 	  job = gtk_print_job_new (priv->job_name, printer, settings, page_setup);
           op_unix->job = job;
           gtk_print_job_set_track_print_status (job, priv->track_print_status);
-	  
+
 	  op_unix->surface = gtk_print_job_get_surface (job, &priv->error);
-	  if (op_unix->surface == NULL) 
+	  if (op_unix->surface == NULL)
             {
 	      rdata->result = GTK_PRINT_OPERATION_RESULT_ERROR;
 	      rdata->do_print = FALSE;
 	      goto out;
             }
-	  
+
 	  cr = cairo_create (op_unix->surface);
 	  gtk_print_context_set_cairo_context (priv->print_context, cr, 72, 72);
 	  cairo_destroy (cr);
 
           _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
-	  
+
           op_unix->job_status_changed_tag =
 	    g_signal_connect (job, "status-changed",
 			      G_CALLBACK (job_status_changed_cb), op);
-	  
+
           priv->print_pages = gtk_print_job_get_pages (job);
           priv->page_ranges = gtk_print_job_get_page_ranges (job, &priv->num_page_ranges);
           priv->manual_num_copies = gtk_print_job_get_num_copies (job);
@@ -598,16 +598,16 @@ finish_print (PrintResponseData *rdata,
           priv->manual_number_up = gtk_print_job_get_n_up (job);
           priv->manual_number_up_layout = gtk_print_job_get_n_up_layout (job);
         }
-    } 
+    }
  out:
   if (rdata->print_cb)
-    rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result); 
+    rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result);
 
   if (rdata->destroy)
     rdata->destroy (rdata);
 }
 
-static void 
+static void
 handle_print_response (GtkWidget *dialog,
 		       int        response,
 		       gpointer   data)
@@ -627,7 +627,7 @@ handle_print_response (GtkWidget *dialog,
       rdata->do_preview = FALSE;
       if (printer != NULL)
 	rdata->do_print = TRUE;
-    } 
+    }
   else if (response == GTK_RESPONSE_APPLY)
     {
       /* print preview */
@@ -650,15 +650,15 @@ handle_print_response (GtkWidget *dialog,
       gtk_print_operation_set_print_settings (rdata->op, settings);
       g_signal_emit_by_name (rdata->op, "custom-widget-apply", rdata->op->priv->custom_widget);
     }
- 
+
   if (rdata->loop)
     g_main_loop_quit (rdata->loop);
-  
+
   finish_print (rdata, printer, page_setup, settings, page_setup_set);
 
   if (settings)
     g_object_unref (settings);
-    
+
   gtk_window_destroy (GTK_WINDOW (pd));
 }
 
@@ -675,7 +675,7 @@ found_printer (GtkPrinter        *printer,
   if (rdata->loop)
     g_main_loop_quit (rdata->loop);
 
-  if (printer != NULL) 
+  if (printer != NULL)
     {
       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 
@@ -688,18 +688,18 @@ found_printer (GtkPrinter        *printer,
 
       gtk_print_settings_set_printer (settings,
 				      gtk_printer_get_name (printer));
-      
+
       if (priv->default_page_setup)
 	page_setup = gtk_page_setup_copy (priv->default_page_setup);
       else
 	page_setup = gtk_page_setup_new ();
   }
-  
+
   finish_print (rdata, printer, page_setup, settings, FALSE);
 
   if (settings)
     g_object_unref (settings);
-  
+
   if (page_setup)
     g_object_unref (page_setup);
 }
@@ -723,13 +723,13 @@ gtk_print_operation_unix_run_dialog_async (GtkPrintOperation          *op,
   rdata->parent = parent;
   rdata->loop = NULL;
   rdata->destroy = print_response_data_free;
-  
+
   if (show_dialog)
     {
       pd = get_print_dialog (op, parent);
       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 
-      g_signal_connect (pd, "response", 
+      g_signal_connect (pd, "response",
 			G_CALLBACK (handle_print_response), rdata);
 
       gtk_window_present (GTK_WINDOW (pd));
@@ -739,7 +739,7 @@ gtk_print_operation_unix_run_dialog_async (GtkPrintOperation          *op,
       printer_name = NULL;
       if (op->priv->print_settings)
 	printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
-      
+
       find_printer (printer_name, (GFunc) found_printer, rdata);
     }
 }
@@ -751,8 +751,8 @@ write_preview (void                *closure,
 {
   int fd = GPOINTER_TO_INT (closure);
   gssize written;
-  
-  while (length > 0) 
+
+  while (length > 0)
     {
       written = write (fd, data, length);
 
@@ -760,9 +760,9 @@ write_preview (void                *closure,
 	{
 	  if (errno == EAGAIN || errno == EINTR)
 	    continue;
-	  
+
 	  return CAIRO_STATUS_WRITE_ERROR;
-	}    
+	}
 
       data += written;
       length -= written;
@@ -792,7 +792,7 @@ gtk_print_operation_unix_create_preview_surface (GtkPrintOperation *op,
   double w, h;
   cairo_surface_t *surface;
   static cairo_user_data_key_t key;
-  
+
   filename = g_build_filename (g_get_tmp_dir (), "previewXXXXXX.pdf", NULL);
   fd = g_mkstemp (filename);
 
@@ -803,14 +803,14 @@ gtk_print_operation_unix_create_preview_surface (GtkPrintOperation *op,
     }
 
   *target = filename;
-  
+
   paper_size = gtk_page_setup_get_paper_size (page_setup);
   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
-    
+
   *dpi_x = *dpi_y = 72;
   surface = cairo_pdf_surface_create_for_stream (write_preview, GINT_TO_POINTER (fd), w, h);
- 
+
   cairo_surface_set_user_data (surface, &key, GINT_TO_POINTER (fd), close_preview);
 
   return surface;
@@ -837,7 +837,7 @@ gtk_print_operation_unix_resize_preview_surface (GtkPrintOperation *op,
                                                  cairo_surface_t   *surface)
 {
   double w, h;
-  
+
   w = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
   h = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
   cairo_pdf_surface_set_size (surface, w, h);
@@ -852,7 +852,7 @@ gtk_print_operation_unix_run_dialog (GtkPrintOperation *op,
   GtkWidget *pd;
   PrintResponseData rdata;
   const char *printer_name;
-   
+
   rdata.op = op;
   rdata.do_print = FALSE;
   rdata.do_preview = FALSE;
@@ -867,7 +867,7 @@ gtk_print_operation_unix_run_dialog (GtkPrintOperation *op,
       pd = get_print_dialog (op, parent);
       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 
-      g_signal_connect (pd, "response", 
+      g_signal_connect (pd, "response",
 			G_CALLBACK (handle_print_response), &rdata);
 
       gtk_window_present (GTK_WINDOW (pd));
@@ -882,7 +882,7 @@ gtk_print_operation_unix_run_dialog (GtkPrintOperation *op,
       printer_name = NULL;
       if (op->priv->print_settings)
 	printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
-      
+
       rdata.loop = g_main_loop_new (NULL, FALSE);
       find_printer (printer_name,
 		    (GFunc) found_printer, &rdata);
@@ -893,12 +893,12 @@ gtk_print_operation_unix_run_dialog (GtkPrintOperation *op,
     }
 
   *do_print = rdata.do_print;
-  
+
   return rdata.result;
 }
 
 
-typedef struct 
+typedef struct
 {
   GtkPageSetup         *page_setup;
   GtkPageSetupDoneFunc  done_cb;
@@ -967,13 +967,13 @@ get_page_setup_dialog (GtkWindow        *parent,
  *
  * Runs a page setup dialog, letting the user modify the values from
  * @page_setup. If the user cancels the dialog, the returned `GtkPageSetup`
- * is identical to the passed in @page_setup, otherwise it contains the 
+ * is identical to the passed in @page_setup, otherwise it contains the
  * modifications done in the dialog.
  *
  * Note that this function may use a recursive mainloop to show the page
- * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is 
+ * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
  * a problem.
- * 
+ *
  * Returns: (transfer full): a new `GtkPageSetup`
  */
 GtkPageSetup *
@@ -982,8 +982,8 @@ gtk_print_run_page_setup_dialog (GtkWindow        *parent,
 				 GtkPrintSettings *settings)
 {
   GtkWidget *dialog;
-  PageSetupResponseData rdata;  
-  
+  PageSetupResponseData rdata;
+
   rdata.page_setup = NULL;
   rdata.done_cb = NULL;
   rdata.data = NULL;
@@ -997,7 +997,7 @@ gtk_print_run_page_setup_dialog (GtkWindow        *parent,
                     &rdata);
 
   gtk_window_present (GTK_WINDOW (dialog));
- 
+
   g_main_loop_run (rdata.loop);
   g_main_loop_unref (rdata.loop);
   rdata.loop = NULL;
@@ -1034,10 +1034,10 @@ gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
 {
   GtkWidget *dialog;
   PageSetupResponseData *rdata;
-  
+
   dialog = get_page_setup_dialog (parent, page_setup, settings);
   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
-  
+
   rdata = g_new (PageSetupResponseData, 1);
   rdata->page_setup = NULL;
   rdata->done_cb = done_cb;
@@ -1051,7 +1051,7 @@ gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
   gtk_window_present (GTK_WINDOW (dialog));
  }
 
-struct _PrinterFinder 
+struct _PrinterFinder
 {
   gboolean found_printer;
   GFunc func;
@@ -1087,8 +1087,8 @@ find_printer_idle (gpointer data)
 }
 
 static void
-printer_added_cb (GtkPrintBackend *backend, 
-                  GtkPrinter      *printer, 
+printer_added_cb (GtkPrintBackend *backend,
+                  GtkPrinter      *printer,
 		  PrinterFinder   *finder)
 {
   if (finder->found_printer)
@@ -1112,26 +1112,28 @@ printer_added_cb (GtkPrintBackend *backend,
 	finder->found_printer = TRUE;
     }
   else
-    if (finder->first_printer == NULL)
-      finder->first_printer = g_object_ref (printer);
-  
+    {
+      if (finder->first_printer == NULL)
+        finder->first_printer = g_object_ref (printer);
+    }
+
   if (finder->found_printer)
     g_idle_add (find_printer_idle, finder);
 }
 
 static void
-printer_list_done_cb (GtkPrintBackend *backend, 
+printer_list_done_cb (GtkPrintBackend *backend,
 		      PrinterFinder   *finder)
 {
   finder->backends = g_list_remove (finder->backends, backend);
-  
+
   g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
   g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
-  
+
   gtk_print_backend_destroy (backend);
   g_object_unref (backend);
 
-  if (finder->backends == NULL && !finder->found_printer)
+  if (finder->backends == NULL)
     g_idle_add (find_printer_idle, finder);
 }
 
@@ -1164,11 +1166,11 @@ find_printer_init (PrinterFinder   *finder,
     }
   else
     {
-      g_signal_connect (backend, "printer-added", 
-			(GCallback) printer_added_cb, 
+      g_signal_connect (backend, "printer-added",
+			(GCallback) printer_added_cb,
 			finder);
-      g_signal_connect (backend, "printer-list-done", 
-			(GCallback) printer_list_done_cb, 
+      g_signal_connect (backend, "printer-list-done",
+			(GCallback) printer_list_done_cb,
 			finder);
     }
 
@@ -1178,15 +1180,15 @@ static void
 printer_finder_free (PrinterFinder *finder)
 {
   GList *l;
-  
+
   g_free (finder->printer_name);
-  
+
   if (finder->printer)
     g_object_unref (finder->printer);
-  
+
   if (finder->default_printer)
     g_object_unref (finder->default_printer);
-  
+
   if (finder->first_printer)
     g_object_unref (finder->first_printer);
 
@@ -1198,9 +1200,9 @@ printer_finder_free (PrinterFinder *finder)
       gtk_print_backend_destroy (backend);
       g_object_unref (backend);
     }
-  
+
   g_list_free (finder->backends);
-  
+
   g_free (finder);
 }
 
@@ -1228,10 +1230,8 @@ find_printer (const char *printer,
       find_printer_init (finder, GTK_PRINT_BACKEND (node->data));
     }
 
-  if (finder->backends == NULL && !finder->found_printer)
+  if (finder->backends == NULL)
     g_idle_add (find_printer_idle, finder);
-  else
-    printer_finder_free (finder);
 }
 
 

gtk/gtkrenderborder.c

@@ -357,16 +357,16 @@ snapshot_frame_fill (GtkSnapshot          *snapshot,
   gtk_snapshot_append_border (snapshot, outline, border_width, colors);
 }
 
-static GskStroke *
-create_stroke_style (double          line_width,
-                     GtkBorderStyle  style,
-                     double          length)
+static void
+set_stroke_style (cairo_t        *cr,
+                  double          line_width,
+                  GtkBorderStyle  style,
+                  double          length)
 {
-  GskStroke *stroke;
-  float segments[2];
+  double segments[2];
   double n;
 
-  stroke = gsk_stroke_new (line_width);
+  cairo_set_line_width (cr, line_width);
 
   if (style == GTK_BORDER_STYLE_DOTTED)
     {
@@ -374,12 +374,12 @@ create_stroke_style (double          line_width,
 
       segments[0] = 0;
       segments[1] = n ? length / n : 2;
-      gsk_stroke_set_dash (stroke, segments, 2);
+      cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
 
-      gsk_stroke_set_line_cap (stroke, GSK_LINE_CAP_ROUND);
-      gsk_stroke_set_line_join (stroke, GSK_LINE_JOIN_ROUND);
+      cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+      cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
     }
-  else if (style == GTK_BORDER_STYLE_DASHED)
+  else
     {
       n = length / line_width;
       /* Optimize the common case of an integer-sized rectangle
@@ -397,33 +397,32 @@ create_stroke_style (double          line_width,
           segments[0] = n ? (1. / 3) * length / n : 1;
           segments[1] = 2 * segments[0];
         }
-      gsk_stroke_set_dash (stroke, segments, 2);
+      cairo_set_dash (cr, segments, G_N_ELEMENTS (segments), 0);
 
-      gsk_stroke_set_line_cap (stroke, GSK_LINE_CAP_SQUARE);
-      gsk_stroke_set_line_join (stroke, GSK_LINE_JOIN_MITER);
+      cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+      cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
     }
-  else
-    {
-      g_assert_not_reached ();
-    }
-
-  return stroke;
 }
 
 static void
-snapshot_frame_stroke (GtkSnapshot          *snapshot,
-                       const GskRoundedRect *border_box,
-                       const float           border_width[4],
-                       GdkRGBA               colors[4],
-                       guint                 hidden_side,
-                       GtkBorderStyle        stroke_style)
+render_frame_stroke (cairo_t              *cr,
+                     const GskRoundedRect *border_box,
+                     const double          border_width[4],
+                     GdkRGBA               colors[4],
+                     guint                 hidden_side,
+                     GtkBorderStyle        stroke_style)
 {
+  gboolean different_colors, different_borders;
   GskRoundedRect stroke_box;
-  GskPathBuilder *builder;
-  GskPath *path;
-  GskStroke *stroke;
   guint i;
 
+  different_colors = !gdk_rgba_equal (&colors[0], &colors[1]) ||
+                     !gdk_rgba_equal (&colors[0], &colors[2]) ||
+                     !gdk_rgba_equal (&colors[0], &colors[3]);
+  different_borders = border_width[0] != border_width[1] ||
+                      border_width[0] != border_width[2] ||
+                      border_width[0] != border_width[3] ;
+
   stroke_box = *border_box;
   gsk_rounded_rect_shrink (&stroke_box,
                            border_width[GTK_CSS_TOP] / 2.0,
@@ -431,36 +430,32 @@ snapshot_frame_stroke (GtkSnapshot          *snapshot,
                            border_width[GTK_CSS_BOTTOM] / 2.0,
                            border_width[GTK_CSS_LEFT] / 2.0);
 
-  if (border_width[0] == border_width[1] &&
-      border_width[0] == border_width[2] &&
-      border_width[0] == border_width[3] &&
-      hidden_side == 0)
+  if (!different_colors && !different_borders && hidden_side == 0)
     {
       double length = 0;
 
       /* FAST PATH:
        * Mostly expected to trigger for focus rectangles */
-      for (i = 0; i < 4; i++)
+      for (i = 0; i < 4; i++) 
         {
           length += _gtk_rounded_box_guess_length (&stroke_box, i);
         }
 
-      builder = gsk_path_builder_new ();
-      gsk_path_builder_add_rounded_rect (builder, &stroke_box);
-      path = gsk_path_builder_free_to_path (builder);
-      stroke = create_stroke_style (border_width[0],
-                                    stroke_style, length);
-      gtk_snapshot_push_stroke (snapshot, path, stroke);
-      gsk_stroke_free (stroke);
-      gsk_path_unref (path);
-
-      gtk_snapshot_append_border (snapshot, border_box, border_width, colors);
-
-      gtk_snapshot_pop (snapshot);
+      gsk_rounded_rect_path (&stroke_box, cr);
+      gdk_cairo_set_source_rgba (cr, &colors[0]);
+      set_stroke_style (cr, border_width[0], stroke_style, length);
+      cairo_stroke (cr);
     }
   else
     {
-      const float weight = sqrtf(2)/2.0;
+      GskRoundedRect padding_box;
+
+      padding_box = *border_box;
+      gsk_rounded_rect_shrink (&padding_box,
+                               border_width[GTK_CSS_TOP],
+                               border_width[GTK_CSS_RIGHT],
+                               border_width[GTK_CSS_BOTTOM],
+                               border_width[GTK_CSS_LEFT]);
 
       for (i = 0; i < 4; i++)
         {
@@ -470,111 +465,49 @@ snapshot_frame_stroke (GtkSnapshot          *snapshot,
           if (border_width[i] == 0)
             continue;
 
-          builder = gsk_path_builder_new ();
+          cairo_save (cr);
+
           if (i == 0)
-            {
-              /* top */
-              gsk_path_builder_move_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_TOP_LEFT].width / 2,
-                                        stroke_box.bounds.origin.y + stroke_box.corner[GSK_CORNER_TOP_LEFT].height / 2);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x,
-                                         stroke_box.bounds.origin.y,
-                                         stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_TOP_LEFT].width,
-                                         stroke_box.bounds.origin.y,
-                                         weight);
-              gsk_path_builder_line_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_TOP_RIGHT].width,
-                                        stroke_box.bounds.origin.y);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                         stroke_box.bounds.origin.y,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_TOP_RIGHT].width / 2,
-                                         stroke_box.bounds.origin.y + stroke_box.corner[GSK_CORNER_TOP_RIGHT].height / 2,
-                                         weight);
-            }
+            _gtk_rounded_box_path_top (border_box, &padding_box, cr);
           else if (i == 1)
-            {
-              /* right */
-              gsk_path_builder_move_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_TOP_RIGHT].width / 2,
-                                        stroke_box.bounds.origin.y + stroke_box.corner[GSK_CORNER_TOP_RIGHT].height / 2);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                         stroke_box.bounds.origin.y,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                         stroke_box.bounds.origin.y + stroke_box.corner[GSK_CORNER_TOP_RIGHT].height,
-                                         weight);
-              gsk_path_builder_line_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                        stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].height);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].width / 2,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].height / 2,
-                                         weight);
-            }
+            _gtk_rounded_box_path_right (border_box, &padding_box, cr);
           else if (i == 2)
-            {
-              /* bottom */
-              gsk_path_builder_move_to (builder,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].width / 2,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].height / 2);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height,
-                                         stroke_box.bounds.origin.x + stroke_box.bounds.size.width - stroke_box.corner[GSK_CORNER_BOTTOM_RIGHT].width,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height,
-                                         weight);
-              gsk_path_builder_line_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].width,
-                                        stroke_box.bounds.origin.y + stroke_box.bounds.size.height);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height,
-                                         stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].width / 2,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].height / 2,
-                                         weight);
-            }
+            _gtk_rounded_box_path_bottom (border_box, &padding_box, cr);
           else if (i == 3)
-            {
-              /* left */
-              gsk_path_builder_move_to (builder,
-                                        stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].width / 2,
-                                        stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].height / 2);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height,
-                                         stroke_box.bounds.origin.x,
-                                         stroke_box.bounds.origin.y + stroke_box.bounds.size.height - stroke_box.corner[GSK_CORNER_BOTTOM_LEFT].height,
-                                         weight);
-              gsk_path_builder_line_to (builder,
-                                        stroke_box.bounds.origin.x,
-                                        stroke_box.bounds.origin.y + stroke_box.corner[GSK_CORNER_TOP_LEFT].height);
-              gsk_path_builder_conic_to (builder,
-                                         stroke_box.bounds.origin.x,
-                                         stroke_box.bounds.origin.y,
-                                         stroke_box.bounds.origin.x + stroke_box.corner[GSK_CORNER_TOP_LEFT].width,
-                                         stroke_box.bounds.origin.y,
-                                         weight);
-            }
+            _gtk_rounded_box_path_left (border_box, &padding_box, cr);
+          cairo_clip (cr);
 
-          path = gsk_path_builder_free_to_path (builder);
-          stroke = create_stroke_style (border_width[i],
-                                        stroke_style,
-                                        _gtk_rounded_box_guess_length (&stroke_box, i));
-          gtk_snapshot_push_stroke (snapshot, path, stroke);
-          gsk_stroke_free (stroke);
-          gsk_path_unref (path);
+          _gtk_rounded_box_path_side (&stroke_box, cr, i);
 
-          gtk_snapshot_append_border (snapshot, border_box, border_width, colors);
+          gdk_cairo_set_source_rgba (cr, &colors[i]);
+          set_stroke_style (cr,
+                            border_width[i],
+                            stroke_style,
+                            _gtk_rounded_box_guess_length (&stroke_box, i));
+          cairo_stroke (cr);
 
-          gtk_snapshot_pop (snapshot);
+          cairo_restore (cr);
         }
     }
 }
 
+static void
+snapshot_frame_stroke (GtkSnapshot          *snapshot,
+                       const GskRoundedRect *outline,
+                       const float           border_width[4],
+                       GdkRGBA               colors[4],
+                       guint                 hidden_side,
+                       GtkBorderStyle        stroke_style)
+{
+  double double_width[4] = { border_width[0], border_width[1], border_width[2], border_width[3] };
+  cairo_t *cr;
+
+  cr = gtk_snapshot_append_cairo (snapshot,
+                                  &outline->bounds);
+  render_frame_stroke (cr, outline, double_width, colors, hidden_side, stroke_style);
+  cairo_destroy (cr);
+}
+
 static void
 color_shade (const GdkRGBA *color,
              double         factor,

gtk/gtksnapshot.c

@@ -34,7 +34,6 @@
 
 #include "gsk/gskrendernodeprivate.h"
 #include "gsk/gskroundedrectprivate.h"
-#include "gsk/gskstrokeprivate.h"
 
 #include "gtk/gskpango.h"
 
@@ -110,14 +109,6 @@ struct _GtkSnapshotState {
     struct {
       GskRoundedRect bounds;
     } rounded_clip;
-    struct {
-      GskPath *path;
-      GskFillRule fill_rule;
-    } fill;
-    struct {
-      GskPath *path;
-      GskStroke stroke;
-    } stroke;
     struct {
       gsize n_shadows;
       GskShadow *shadows;
@@ -770,7 +761,7 @@ gtk_snapshot_ensure_translate (GtkSnapshot *snapshot,
       gtk_snapshot_autopush_transform (snapshot);
       state = gtk_snapshot_get_current_state (snapshot);
     }
-
+  
   gsk_transform_to_translate (state->transform, dx, dy);
 }
 
@@ -859,7 +850,7 @@ gtk_snapshot_push_clip (GtkSnapshot           *snapshot,
 {
   GtkSnapshotState *state;
   float scale_x, scale_y, dx, dy;
-
+ 
   gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
 
   state = gtk_snapshot_push_state (snapshot,
@@ -1105,135 +1096,6 @@ gtk_snapshot_push_rounded_clip (GtkSnapshot          *snapshot,
   gsk_rounded_rect_scale_affine (&state->data.rounded_clip.bounds, bounds, scale_x, scale_y, dx, dy);
 }
 
-static GskRenderNode *
-gtk_snapshot_collect_fill (GtkSnapshot      *snapshot,
-                           GtkSnapshotState *state,
-                           GskRenderNode   **nodes,
-                           guint             n_nodes)
-{
-  GskRenderNode *node, *fill_node;
-
-  node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
-  if (node == NULL)
-    return NULL;
-
-  fill_node = gsk_fill_node_new (node,
-                                 state->data.fill.path,
-                                 state->data.fill.fill_rule);
-
-  if (fill_node->bounds.size.width == 0 ||
-      fill_node->bounds.size.height == 0)
-    {
-      gsk_render_node_unref (node);
-      gsk_render_node_unref (fill_node);
-      return NULL;
-    }
-
-  gsk_render_node_unref (node);
-
-  return fill_node;
-}
-
-static void
-gtk_snapshot_clear_fill (GtkSnapshotState *state)
-{
-  gsk_path_unref (state->data.fill.path);
-}
-
-/**
- * gtk_snapshot_push_fill:
- * @snapshot: a `GtkSnapshot`
- * @path: The path describing the area to fill
- * @fill_rule: The fill rule to use
- *
- * Fills the area given by @path and @fill_rule with an image and discards everything
- * outside of it.
- *
- * The image is recorded until the next call to [method@Gtk.Snapshot.pop].
- */
-void
-gtk_snapshot_push_fill (GtkSnapshot *snapshot,
-                        GskPath     *path,
-                        GskFillRule  fill_rule)
-{
-  GtkSnapshotState *state;
-
-  /* FIXME: Is it worth calling ensure_affine() and transforming the path here? */
-  gtk_snapshot_ensure_identity (snapshot);
-
-  state = gtk_snapshot_push_state (snapshot,
-                                   gtk_snapshot_get_current_state (snapshot)->transform,
-                                   gtk_snapshot_collect_fill,
-                                   gtk_snapshot_clear_fill);
-
-  state->data.fill.path = gsk_path_ref (path);
-  state->data.fill.fill_rule = fill_rule;
-}
-
-static GskRenderNode *
-gtk_snapshot_collect_stroke (GtkSnapshot      *snapshot,
-                             GtkSnapshotState *state,
-                             GskRenderNode   **nodes,
-                             guint             n_nodes)
-{
-  GskRenderNode *node, *stroke_node;
-
-  node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
-  if (node == NULL)
-    return NULL;
-
-  stroke_node = gsk_stroke_node_new (node,
-                                     state->data.stroke.path,
-                                     &state->data.stroke.stroke);
-
-  if (stroke_node->bounds.size.width == 0 ||
-      stroke_node->bounds.size.height == 0)
-    {
-      gsk_render_node_unref (node);
-      gsk_render_node_unref (stroke_node);
-      return NULL;
-    }
-
-  gsk_render_node_unref (node);
-
-  return stroke_node;
-}
-
-static void
-gtk_snapshot_clear_stroke (GtkSnapshotState *state)
-{
-  gsk_path_unref (state->data.stroke.path);
-  gsk_stroke_clear (&state->data.stroke.stroke);
-}
-
-/**
- * gtk_snapshot_push_stroke:
- * @snapshot: a `GtkSnapshot`
- * @path: The path to stroke
- * @stroke: The stroke attributes
- *
- * Strokes the given @path with the attributes given by @stroke and the
- * image being recorded until the next call to [method@Gtk.Snapshot.pop].
- */
-void
-gtk_snapshot_push_stroke (GtkSnapshot     *snapshot,
-                          GskPath         *path,
-                          const GskStroke *stroke)
-{
-  GtkSnapshotState *state;
-
-  /* FIXME: Is it worth calling ensure_affine() and transforming the path here? */
-  gtk_snapshot_ensure_identity (snapshot);
-
-  state = gtk_snapshot_push_state (snapshot,
-                                   gtk_snapshot_get_current_state (snapshot)->transform,
-                                   gtk_snapshot_collect_stroke,
-                                   gtk_snapshot_clear_stroke);
-
-  state->data.stroke.path = gsk_path_ref (path);
-  gsk_stroke_init_copy (&state->data.stroke.stroke, stroke);
-}
-
 static GskRenderNode *
 gtk_snapshot_collect_shadow (GtkSnapshot      *snapshot,
                              GtkSnapshotState *state,
@@ -2660,7 +2522,7 @@ gtk_snapshot_append_border (GtkSnapshot          *snapshot,
   gsk_rounded_rect_scale_affine (&real_outline, outline, scale_x, scale_y, dx, dy);
 
   node = gsk_border_node_new (&real_outline,
-                              (float[4]) {
+                              (float[4]) { 
                                 border_width[0] * scale_y,
                                 border_width[1] * scale_x,
                                 border_width[2] * scale_y,

gtk/gtksnapshot.h

@@ -89,14 +89,6 @@ GDK_AVAILABLE_IN_ALL
 void            gtk_snapshot_push_rounded_clip          (GtkSnapshot            *snapshot,
                                                          const GskRoundedRect   *bounds);
 GDK_AVAILABLE_IN_ALL
-void            gtk_snapshot_push_fill                  (GtkSnapshot            *snapshot,
-                                                         GskPath                *path,
-                                                         GskFillRule             fill_rule);
-GDK_AVAILABLE_IN_ALL
-void            gtk_snapshot_push_stroke                (GtkSnapshot            *snapshot,
-                                                         GskPath                *path,
-                                                         const GskStroke        *stroke);
-GDK_AVAILABLE_IN_ALL
 void            gtk_snapshot_push_shadow                (GtkSnapshot            *snapshot,
                                                          const GskShadow        *shadow,
                                                          gsize                   n_shadows);

gtk/gtktextbtree.c

@@ -207,7 +207,7 @@ struct _GtkTextBTree {
   int end_iter_segment_char_offset;
   guint end_iter_line_stamp;
   guint end_iter_segment_stamp;
-  
+
   GHashTable *child_anchor_table;
 };
 
@@ -415,7 +415,7 @@ _gtk_text_btree_new (GtkTextTagTable *table,
   tree->end_iter_line = NULL;
   tree->end_iter_segment_byte_index = 0;
   tree->end_iter_segment_char_offset = 0;
-  
+
   g_object_ref (tree->table);
 
   tree->tag_changed_handler = g_signal_connect (tree->table,
@@ -425,7 +425,7 @@ _gtk_text_btree_new (GtkTextTagTable *table,
 
   tree->mark_table = g_hash_table_new (g_str_hash, g_str_equal);
   tree->child_anchor_table = NULL;
-  
+
   /* We don't ref the buffer, since the buffer owns us;
    * we'd have some circularity issues. The buffer always
    * lasts longer than the BTree
@@ -489,20 +489,20 @@ _gtk_text_btree_unref (GtkTextBTree *tree)
   tree->refcount -= 1;
 
   if (tree->refcount == 0)
-    {      
+    {
       g_signal_handler_disconnect (tree->table,
                                    tree->tag_changed_handler);
 
       g_object_unref (tree->table);
       tree->table = NULL;
-      
+
       gtk_text_btree_node_destroy (tree, tree->root_node);
       tree->root_node = NULL;
-      
+
       g_assert (g_hash_table_size (tree->mark_table) == 0);
       g_hash_table_destroy (tree->mark_table);
       tree->mark_table = NULL;
-      if (tree->child_anchor_table != NULL) 
+      if (tree->child_anchor_table != NULL)
 	{
 	  g_hash_table_destroy (tree->child_anchor_table);
 	  tree->child_anchor_table = NULL;
@@ -568,7 +568,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
   start_line_prev = _gtk_text_line_previous (start_line);
   end_line = _gtk_text_iter_get_text_line (end);
   end_line_next = _gtk_text_line_next (end_line);
-  
+
   line = start_line;
   while (line && line != end_line_next)
     {
@@ -576,7 +576,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
        */
       GtkTextLineSegment *seg = line->segments;
       line->dir_strong = PANGO_DIRECTION_NEUTRAL;
-      
+
       while (seg)
         {
           if (seg->type == &gtk_text_char_type && seg->byte_count > 0)
@@ -584,7 +584,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
 	      PangoDirection pango_dir;
 
               pango_dir = gdk_find_base_dir (seg->body.chars, seg->byte_count);
-	      
+
               if (pango_dir != PANGO_DIRECTION_NEUTRAL)
                 {
                   line->dir_strong = pango_dir;
@@ -607,7 +607,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
   if (start_line_prev)
     dir_above_propagated = start_line_prev->dir_propagated_forward;
 
-  /* Loop forward and propagate the direction of each paragraph 
+  /* Loop forward and propagate the direction of each paragraph
    * to all neutral lines.
    */
   line = start_line;
@@ -616,9 +616,9 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
     {
       if (line->dir_strong != PANGO_DIRECTION_NEUTRAL)
         last_strong = line->dir_strong;
-      
+
       line->dir_propagated_forward = last_strong;
-      
+
       line = _gtk_text_line_next (line);
     }
 
@@ -627,14 +627,14 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
    */
   {
     GtkTextIter end_propagate;
-    
+
     while (line &&
 	   line->dir_strong == PANGO_DIRECTION_NEUTRAL &&
 	   line->dir_propagated_forward != last_strong)
       {
         GtkTextLine *prev = line;
         line->dir_propagated_forward = last_strong;
-        
+
         line = _gtk_text_line_next(line);
         if (!line)
           {
@@ -654,7 +654,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
     _gtk_text_btree_get_iter_at_line (tree, &end_propagate, line, 0);
     _gtk_text_btree_invalidate_region (tree, end, &end_propagate, FALSE);
   }
-  
+
   /* Sweep backward */
 
   /* The variable dir_below_propagated contains the backward propagated
@@ -665,7 +665,7 @@ gtk_text_btree_resolve_bidi (GtkTextIter *start,
   if (end_line_next)
     dir_below_propagated = end_line_next->dir_propagated_back;
 
-  /* Loop backward and propagate the direction of each paragraph 
+  /* Loop backward and propagate the direction of each paragraph
    * to all neutral lines.
    */
   line = end_line;
@@ -929,7 +929,7 @@ _gtk_text_btree_delete (GtkTextIter *start,
       BTreeView *view;
       GtkTextBTreeNode *ancestor_node;
       GtkTextLine *prevline;
-      int chars_moved;      
+      int chars_moved;
 
       /* last_seg was appended to start_line up at the top of this function */
       chars_moved = 0;
@@ -948,7 +948,7 @@ _gtk_text_btree_delete (GtkTextIter *start,
         {
           node->num_chars += chars_moved;
         }
-      
+
       curnode = end_line->parent;
       for (node = curnode; node != NULL;
            node = node->parent)
@@ -1004,7 +1004,7 @@ _gtk_text_btree_delete (GtkTextIter *start,
           if (deleted_width > 0 || deleted_height > 0)
             {
               ld = _gtk_text_line_get_data (start_line, view->view_id);
-              
+
               if (ld == NULL)
                 {
                   /* This means that start_line has never been validated.
@@ -1018,7 +1018,7 @@ _gtk_text_btree_delete (GtkTextIter *start,
                   ld->height = 0;
                   ld->valid = FALSE;
                 }
-              
+
               ld->width = MAX (deleted_width, ld->width);
               ld->height += deleted_height;
               ld->valid = FALSE;
@@ -1043,7 +1043,7 @@ _gtk_text_btree_delete (GtkTextIter *start,
 
       /* avoid dangling pointer */
       deleted_lines = NULL;
-      
+
       gtk_text_btree_rebalance (tree, curnode);
     }
 
@@ -1116,7 +1116,7 @@ _gtk_text_btree_insert (GtkTextIter *iter,
   /* extract iterator info */
   tree = _gtk_text_iter_get_btree (iter);
   line = _gtk_text_iter_get_text_line (iter);
-  
+
   start_line = line;
   start_byte_index = gtk_text_iter_get_line_index (iter);
 
@@ -1131,7 +1131,7 @@ _gtk_text_btree_insert (GtkTextIter *iter,
   /* Invalidate all iterators */
   chars_changed (tree);
   segments_changed (tree);
-  
+
   /*
    * Chop the text up into lines and create a new segment for
    * each line, plus a new line for the leftovers from the
@@ -1145,11 +1145,11 @@ _gtk_text_btree_insert (GtkTextIter *iter,
   while (eol < len)
     {
       sol = eol;
-      
+
       pango_find_paragraph_boundary (text + sol,
                                      len - sol,
                                      &delim,
-                                     &eol);      
+                                     &eol);
 
       /* make these relative to the start of the text */
       delim += sol;
@@ -1160,7 +1160,7 @@ _gtk_text_btree_insert (GtkTextIter *iter,
       g_assert (eol >= delim);
       g_assert (sol >= 0);
       g_assert (eol <= len);
-      
+
       chunk_len = eol - sol;
 
       g_assert (g_utf8_validate (&text[sol], chunk_len, NULL));
@@ -1285,13 +1285,13 @@ insert_paintable_or_widget_segment (GtkTextIter        *iter,
   DV (g_print ("invalidating due to inserting paintable/widget (%s)\n", G_STRLOC));
   _gtk_text_btree_invalidate_region (tree, &start, iter, FALSE);
 }
-     
+
 void
 _gtk_text_btree_insert_paintable (GtkTextIter  *iter,
                                   GdkPaintable *paintable)
 {
   GtkTextLineSegment *seg;
-  
+
   seg = _gtk_paintable_segment_new (paintable);
   seg->body.paintable.tree = _gtk_text_iter_get_btree (iter);
   seg->body.paintable.line = _gtk_text_iter_get_text_line (iter);
@@ -1311,12 +1311,12 @@ _gtk_text_btree_insert_child_anchor (GtkTextIter        *iter,
       g_warning (G_STRLOC": Same child anchor can't be inserted twice");
       return;
     }
-  
+
   seg = _gtk_widget_segment_new (anchor);
 
   tree = seg->body.child.tree = _gtk_text_iter_get_btree (iter);
   seg->body.child.line = _gtk_text_iter_get_text_line (iter);
-  
+
   insert_paintable_or_widget_segment (iter, seg);
 
   if (tree->child_anchor_table == NULL)
@@ -1333,7 +1333,7 @@ _gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor)
   GtkTextLineSegment *seg;
 
   seg = anchor->segment;
-  
+
   g_hash_table_remove (seg->body.child.tree->child_anchor_table,
                        anchor);
 }
@@ -1538,7 +1538,7 @@ _gtk_text_btree_add_view (GtkTextBTree *tree,
   GtkTextLineData *line_data;
 
   g_return_if_fail (tree != NULL);
-  
+
   view = g_slice_new (BTreeView);
 
   view->view_id = layout;
@@ -1552,7 +1552,7 @@ _gtk_text_btree_add_view (GtkTextBTree *tree,
       g_assert (tree->views->prev == NULL);
       tree->views->prev = view;
     }
-  
+
   tree->views = view;
 
   /* The last line in the buffer has identity values for the per-view
@@ -1580,7 +1580,7 @@ _gtk_text_btree_remove_view (GtkTextBTree *tree,
   GtkTextLineData *line_data;
 
   g_return_if_fail (tree != NULL);
-  
+
   view = tree->views;
 
   while (view != NULL)
@@ -1673,7 +1673,7 @@ iter_stack_new (void)
 }
 
 static void
-iter_stack_push (IterStack         *stack, 
+iter_stack_push (IterStack         *stack,
 		 const GtkTextIter *iter)
 {
   stack->count += 1;
@@ -1687,7 +1687,7 @@ iter_stack_push (IterStack         *stack,
 }
 
 static gboolean
-iter_stack_pop (IterStack   *stack, 
+iter_stack_pop (IterStack   *stack,
 		GtkTextIter *iter)
 {
   if (stack->count == 0)
@@ -1771,7 +1771,7 @@ _gtk_text_btree_tag (const GtkTextIter *start_orig,
   g_return_if_fail (_gtk_text_iter_get_btree (start_orig) ==
                     _gtk_text_iter_get_btree (end_orig));
   g_return_if_fail (tag->priv->table == _gtk_text_iter_get_btree (start_orig)->table);
-  
+
 #if 0
   printf ("%s tag %s from %d to %d\n",
           add ? "Adding" : "Removing",
@@ -1885,7 +1885,7 @@ _gtk_text_btree_tag (const GtkTextIter *start_orig,
           g_assert (seg != NULL);
           g_assert (indexable_seg != NULL);
           g_assert (seg != indexable_seg);
-          
+
           if ( (seg->type == &gtk_text_toggle_on_type ||
                 seg->type == &gtk_text_toggle_off_type) &&
                (seg->body.toggle.info == info) )
@@ -2026,7 +2026,7 @@ get_line_internal (GtkTextBTree *tree,
   line_count = _gtk_text_btree_line_count (tree);
   if (!include_last)
     line_count -= 1;
-  
+
   if (line_number < 0)
     {
       line_number = line_count;
@@ -2387,7 +2387,7 @@ copy_segment (GString *string,
     {
       gboolean copy = TRUE;
       if (!include_nonchars &&
-          g_strcmp0 (_gtk_text_unknown_char_utf8, seg->body.child.obj->chars) == 0)
+          g_strcmp0 (_gtk_text_unknown_char_utf8, gtk_text_child_anchor_get_replacement (seg->body.child.obj)) == 0)
         {
           copy = FALSE;
         }
@@ -2400,7 +2400,7 @@ copy_segment (GString *string,
       if (copy)
         {
           g_string_append_len (string,
-                               seg->body.child.obj->chars,
+                               gtk_text_child_anchor_get_replacement (seg->body.child.obj),
                                seg->byte_count);
         }
     }
@@ -2741,7 +2741,7 @@ real_set_mark (GtkTextBTree      *tree,
   /* OK if !should_exist and it does already exist, in that case
    * we just move it.
    */
-  
+
   iter = *where;
 
 #ifdef G_ENABLE_DEBUG
@@ -2948,7 +2948,7 @@ _gtk_text_btree_release_mark_segment (GtkTextBTree       *tree,
 
   segment->body.mark.tree = NULL;
   segment->body.mark.line = NULL;
-  
+
   /* Remove the ref on the mark, which frees segment as a side effect
    * if this is the last reference.
    */
@@ -2974,7 +2974,7 @@ _gtk_text_btree_remove_mark (GtkTextBTree *tree,
 
   /* This calls cleanup_line and segments_changed */
   gtk_text_btree_unlink_segment (tree, segment, segment->body.mark.line);
-  
+
   _gtk_text_btree_release_mark_segment (tree, segment);
 }
 
@@ -3420,12 +3420,12 @@ ensure_end_iter_line (GtkTextBTree *tree)
   if (tree->end_iter_line_stamp != tree->chars_changed_stamp)
     {
       int real_line;
-	
+
        /* n_lines is without the magic line at the end */
       g_assert (_gtk_text_btree_line_count (tree) >= 1);
 
       tree->end_iter_line = _gtk_text_btree_get_line_no_last (tree, -1, &real_line);
-      
+
       tree->end_iter_line_stamp = tree->chars_changed_stamp;
     }
 }
@@ -3441,7 +3441,7 @@ ensure_end_iter_segment (GtkTextBTree *tree)
       ensure_end_iter_line (tree);
 
       last_with_chars = NULL;
-      
+
       seg = tree->end_iter_line->segments;
       while (seg != NULL)
         {
@@ -3456,7 +3456,7 @@ ensure_end_iter_segment (GtkTextBTree *tree)
       /* We know the last char in the last line is '\n' */
       tree->end_iter_segment_byte_index = last_with_chars->byte_count - 1;
       tree->end_iter_segment_char_offset = last_with_chars->char_count - 1;
-      
+
       tree->end_iter_segment_stamp = tree->segments_changed_stamp;
 
       g_assert (tree->end_iter_segment->type == &gtk_text_char_type);
@@ -3481,7 +3481,7 @@ _gtk_text_btree_is_end (GtkTextBTree       *tree,
                         int                 char_offset)
 {
   g_return_val_if_fail (byte_index >= 0 || char_offset >= 0, FALSE);
-  
+
   /* Do this first to avoid walking segments in most cases */
   if (!_gtk_text_line_contains_end_iter (line, tree))
     return FALSE;
@@ -3536,7 +3536,7 @@ GtkTextLine*
 _gtk_text_line_next_excluding_last (GtkTextLine *line)
 {
   GtkTextLine *next;
-  
+
   next = _gtk_text_line_next (line);
 
   /* If we were on the end iter line, we can't go to
@@ -3708,9 +3708,9 @@ _gtk_text_line_invalidate_wrap (GtkTextLine *line,
      is less than the max width for the parent node,
      and the case where the height is unchanged when we re-wrap.
   */
-  
+
   g_return_if_fail (ld != NULL);
-  
+
   ld->valid = FALSE;
   gtk_text_btree_node_invalidate_upward (line->parent, ld->view_id);
 }
@@ -4075,7 +4075,7 @@ _gtk_text_line_char_locate     (GtkTextLine     *line,
 
   g_return_val_if_fail (line != NULL, FALSE);
   g_return_val_if_fail (char_offset >= 0, FALSE);
-  
+
   *segment = NULL;
   *any_segment = NULL;
   chars_in_line = 0;
@@ -4216,7 +4216,7 @@ _gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
 
       /* if in the last fourth of the segment walk backwards */
       if (seg->char_count - offset < seg->char_count / 4)
-        p = g_utf8_offset_to_pointer (seg->body.chars + seg->byte_count, 
+        p = g_utf8_offset_to_pointer (seg->body.chars + seg->byte_count,
                                       offset - seg->char_count);
       else
         p = g_utf8_offset_to_pointer (seg->body.chars, offset);
@@ -4357,7 +4357,7 @@ _gtk_text_line_next_could_contain_tag (GtkTextLine  *line,
   /* Our tag summaries only have node precision, not line
    * precision. This means that if any line under a node could contain a
    * tag, then any of the others could also contain a tag.
-   * 
+   *
    * In the future we could have some mechanism to keep track of how
    * many toggles we've found under a node so far, since we have a
    * count of toggles under the node. But for now I'm going with KISS.
@@ -4828,7 +4828,7 @@ node_data_new (gpointer  view_id,
                NodeData *next)
 {
   NodeData *nd;
-  
+
   nd = g_slice_new (NodeData);
 
   nd->view_id = view_id;
@@ -4853,7 +4853,7 @@ node_data_list_destroy (NodeData *nd)
 }
 
 static inline NodeData*
-node_data_find (NodeData *nd, 
+node_data_find (NodeData *nd,
 		gpointer  view_id)
 {
   while (nd != NULL)
@@ -5439,7 +5439,7 @@ _gtk_text_btree_validate_line (GtkTextBTree     *tree,
 
   view = gtk_text_btree_get_view (tree, view_id);
   g_return_if_fail (view != NULL);
-  
+
   ld = _gtk_text_line_get_data (line, view_id);
   if (!ld || !ld->valid)
     {
@@ -6208,7 +6208,7 @@ recompute_node_counts (GtkTextBTree *tree, GtkTextBTreeNode *node)
       gtk_text_btree_node_check_valid (node, view->view_id);
       view = view->next;
     }
-  
+
   /*
    * Scan through the GtkTextBTreeNode’s tag records again and delete any Summary
    * records that still have a zero count, or that have all the toggles.
@@ -6617,7 +6617,7 @@ gtk_text_btree_node_view_check_consistency (GtkTextBTree     *tree,
   int height;
   gboolean valid;
   BTreeView *view;
-  
+
   view = tree->views;
 
   while (view != NULL)
@@ -6631,7 +6631,7 @@ gtk_text_btree_node_view_check_consistency (GtkTextBTree     *tree,
   if (view == NULL)
     g_error ("Node has data for a view %p no longer attached to the tree",
              nd->view_id);
-  
+
   gtk_text_btree_node_compute_view_aggregates (node, nd->view_id,
                                                &width, &height, &valid);
 
@@ -6644,7 +6644,7 @@ gtk_text_btree_node_view_check_consistency (GtkTextBTree     *tree,
    * invalid - we don’t guarantee that if the node is invalid there
    * are invalid lines.
    */
-  
+
   if (nd->width != width ||
       nd->height != height ||
       (nd->valid && !valid))
@@ -7142,7 +7142,7 @@ _gtk_text_btree_spew_line_short (GtkTextLine *line, int indent)
         }
       else if (seg->type == &gtk_text_child_type)
         {
-          char *str = g_strndup (seg->body.child.obj->chars, seg->byte_count);
+          char *str = g_strndup (gtk_text_child_anchor_get_replacement (seg->body.child.obj), seg->byte_count);
           printf ("%s child '%s'...\n", spaces, str);
           g_free (str);
         }
@@ -7250,7 +7250,7 @@ _gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment * seg)
     }
   else if (seg->type == &gtk_text_child_type)
     {
-      char *str = g_strndup (seg->body.child.obj->chars, seg->byte_count);
+      char *str = g_strndup (gtk_text_child_anchor_get_replacement (seg->body.child.obj), seg->byte_count);
       printf ("       '%s'\n", str);
       g_free (str);
     }