Add an simd implementation

This is strongly based on graphenes simd plumbing. All three types get represented as graphene_simf4d_t, scale as {x,y,0,0}, point as {x,y,0,0} and box as {x0,y0,x1,y1}.
wip: Use the new types
2024-01-24 22:01:28 -05:00 · 2024-01-24 21:58:07 -05:00 · 2024-01-24 21:58:07 -05:00 · 2024-01-24 00:33:44 +00:00 · 2024-01-23 11:47:52 +00:00 · 2024-01-23 06:38:32 +00:00
217 changed files with 20201 additions and 7876 deletions
@@ -19,6 +19,7 @@ flatpak build ${builddir} meson \
                --buildtype=debugoptimized \
                -Dx11-backend=true \
                -Dwayland-backend=true \
+                -Dvulkan=disabled \
                -Dbuild-tests=false \
                -Dbuild-testsuite=false \
                -Dbuild-examples=false \
@@ -27,7 +28,7 @@ flatpak build ${builddir} meson \
                -Ddemo-profile=devel \
                _flatpak_build

-flatpak build ${builddir} ninja -C _flatpak_build install
+flatpak build --env=CI_COMMIT_SHORT_SHA=$CI_COMMIT_SHORT_SHA ${builddir} ninja -C _flatpak_build install

 flatpak-builder \
        --user --disable-rofiles-fuse \
@@ -213,7 +213,7 @@ Closes #1234
 `git commit -a --author "Joe Coder <joe@coder.org>"` and `--signoff`.

 - If your commit is addressing an issue, use the
- [GitLab syntax](https://docs.gitlab.com/ce/user/project/issues/automatic_issue_closing.html)
+ [GitLab syntax](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
 to automatically close the issue when merging the commit with the upstream
 repository:

@@ -1,4 +1,7 @@
-Overview of Changes in 4.13.5, 07 01 2024
+Overview of Changes in 4.13.6, xx-xx-xxxx
+=========================================
+
+Overview of Changes in 4.13.5, 07-01-2024
 =========================================

 This release adds two new GSK renderers called vulkan and ngl,
@@ -519,7 +522,7 @@ Overview of Changes in 4.11.4, 03-07-2023
 - Center newly created transient windows

 * Vulkan:
- - Add antialising for gradients
+ - Add antialiasing for gradients
 - Do less work on clipped away nodes
 - Redo image uploading
 - Support different image depths and formats
@@ -1503,7 +1506,7 @@ Overview of Changes in 4.7.0, 07-05-2022
 - Event handling fixes
 - Fix keyboard input on popovers
 - Support OpenGL-based video playback
- - Suport fullscreen
+ - Support fullscreen
 - Improve native filechoooser size allocation
 - Use CALayer and IOSurface for rendering
 - Use a per-monitor CVDisplayLink
@@ -1900,7 +1903,7 @@ Overview of Changes in 4.4.0
 - Activate when moving focus

 * GtkLabel:
- - Propertly ignore double underscores for mnemonics
+ - Properly ignore double underscores for mnemonics

 * GtkPopoverMenu:
 - Fix focus cycling
@@ -2447,7 +2450,7 @@ Overview of Changes in 4.1.0
 - Set sort arrows in CSS
 - Set menu button arrows in CSS
 - Make scrollbars larger
- - Supprt circular menubuttons
+ - Support circular menubuttons

 * CSS:
 - Implement transform-origin
@@ -1586,7 +1586,7 @@ update_font_variations (void)
        }

      gtk_grid_attach (GTK_GRID (demo->variations_grid), combo, 1, -1, 3, 1);
-      g_signal_connect (combo, "notify::selecte", G_CALLBACK (instance_changed), NULL);
+      g_signal_connect (combo, "notify::selected", G_CALLBACK (instance_changed), NULL);
      demo->instance_combo = combo;
   }

@@ -24,7 +24,7 @@
 #include "demos.h"
 #include "fontify.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 static GtkWidget *info_view;
 static GtkWidget *source_view;
@@ -236,7 +236,7 @@ foreach flag: common_cflags
  endif
 endforeach

-gtkdemo_deps += [ demo_conf_h ]
+gtkdemo_deps += [ profile_conf_h ]

 executable('gtk4-demo',
  sources: [demos, demos_h, extra_demo_sources, gtkdemo_resources],
@@ -53,7 +53,9 @@ gtk_nuclear_snapshot (GtkSnapshot   *snapshot,
                      double         rotation)
 {
 #define RADIUS 0.3
-  cairo_t *cr;
+  GskPathBuilder *builder;
+  GskPath *path;
+  GskStroke *stroke;
  double size;

  gtk_snapshot_append_color (snapshot,
@@ -61,24 +63,29 @@ gtk_nuclear_snapshot (GtkSnapshot   *snapshot,
                             &GRAPHENE_RECT_INIT (0, 0, width, height));

  size = MIN (width, height);
-  cr = gtk_snapshot_append_cairo (snapshot,
-                                  &GRAPHENE_RECT_INIT ((width - size) / 2.0,
-                                                       (height - size) / 2.0,
-                                                       size, size));
-  gdk_cairo_set_source_rgba (cr, foreground);
-  cairo_translate (cr, width / 2.0, height / 2.0);
-  cairo_scale (cr, size, size);
-  cairo_rotate (cr, rotation);

-  cairo_arc (cr, 0, 0, 0.1, - G_PI, G_PI);
-  cairo_fill (cr);
+  gtk_snapshot_save (snapshot);

-  cairo_set_line_width (cr, RADIUS);
-  cairo_set_dash (cr, (double[1]) { RADIUS * G_PI / 3 }, 1, 0.0);
-  cairo_arc (cr, 0, 0, RADIUS, - G_PI, G_PI);
-  cairo_stroke (cr);
+  gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (width / 2.0, height / 2.0));
+  gtk_snapshot_scale (snapshot, size, size);
+  gtk_snapshot_rotate (snapshot, rotation);

-  cairo_destroy (cr);
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, graphene_point_zero (), 0.1);
+  path = gsk_path_builder_free_to_path (builder);
+  gtk_snapshot_append_fill (snapshot, path, GSK_FILL_RULE_WINDING, foreground);
+  gsk_path_unref (path);
+
+  stroke = gsk_stroke_new (RADIUS);
+  gsk_stroke_set_dash (stroke, (float[1]) { RADIUS * G_PI / 3 }, 1);
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, graphene_point_zero(), RADIUS);
+  path = gsk_path_builder_free_to_path (builder);
+  gtk_snapshot_append_stroke (snapshot, path, stroke, foreground);
+  gsk_path_unref (path);
+  gsk_stroke_free (stroke);
+
+  gtk_snapshot_restore (snapshot);
 }

 /* Here, we implement the functionality required by the GdkPaintable interface */
@@ -70,7 +70,7 @@ gtk_nuclear_animation_snapshot (GdkPaintable *paintable,
                          ? &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 } /* yellow */
                          : &(GdkRGBA) { 0, 0, 0, 0 }, /* transparent */
                        width, height,
-                        2 * G_PI * nuclear->progress / MAX_PROGRESS);
+                        360 * nuclear->progress / MAX_PROGRESS);
 }

 static GdkPaintable *
@@ -85,7 +85,7 @@ gtk_nuclear_animation_get_current_image (GdkPaintable *paintable)
   * Luckily we added the rotation property to the nuclear icon
   * object previously, so we can just return an instance of that one.
   */
-  return gtk_nuclear_icon_new (2 * G_PI * nuclear->progress / MAX_PROGRESS);
+  return gtk_nuclear_icon_new (360 * nuclear->progress / MAX_PROGRESS);
 }

 static GdkPaintableFlags
@@ -76,7 +76,7 @@ gtk_nuclear_media_stream_snapshot (GdkPaintable *paintable,
                        &(GdkRGBA) { 0, 0, 0, 1 }, /* black */
                        &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 }, /* yellow */
                        width, height,
-                        2 * G_PI * nuclear->progress / DURATION);
+                        360 * nuclear->progress / DURATION);
 }

 static GdkPaintable *
@@ -85,7 +85,7 @@ gtk_nuclear_media_stream_get_current_image (GdkPaintable *paintable)
  GtkNuclearMediaStream *nuclear = GTK_NUCLEAR_MEDIA_STREAM (paintable);

  /* Same thing as with the animation */
-  return gtk_nuclear_icon_new (2 * G_PI * nuclear->progress / DURATION);
+  return gtk_nuclear_icon_new (360 * nuclear->progress / DURATION);
 }

 static GdkPaintableFlags
@@ -4,7 +4,7 @@
 #include "iconbrowserapp.h"
 #include "iconbrowserwin.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 struct _IconBrowserApp
 {
@@ -14,7 +14,7 @@ iconbrowser_resources = gnome.compile_resources('iconbrowser_resources',
 executable('gtk4-icon-browser',
  sources: [iconbrowser_sources, iconbrowser_resources],
  c_args: common_cflags,
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  win_subsystem: 'windows',
  link_args: extra_demo_ldflags,
@@ -1,16 +1,3 @@
-gen_demo_header = find_program('../build-aux/meson/gen-demo-header.py')
-demo_profile = get_option('demo-profile')
-
-demo_conf_h = declare_dependency(
-  sources: custom_target('demo-header',
-    command: [gen_demo_header, meson.project_source_root(), demo_profile],
-    capture: true,
-    output: 'demo_conf.h',
-    build_by_default: true,
-    build_always_stale: true,
-  )
-)
-
 # appdata

 appdata_config = configuration_data()
@@ -12,7 +12,7 @@ node_editor_resources = gnome.compile_resources('node_editor_resources',

 executable('gtk4-node-editor',
  sources: [node_editor_sources, node_editor_resources],
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  c_args: common_cflags,
  win_subsystem: 'windows',
@@ -19,11 +19,13 @@

 #include "config.h"

+#include <glib/gstdio.h>
+
 #include "node-editor-application.h"

 #include "node-editor-window.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 static const char *css =
 "textview.editor {"
@@ -247,11 +249,63 @@ node_editor_application_class_init (NodeEditorApplicationClass *class)
  application_class->open = node_editor_application_open;
 }

+static void
+print_version (void)
+{
+  g_print ("gtk4-node-editor %s%s%s\n",
+           PACKAGE_VERSION,
+           g_strcmp0 (PROFILE, "devel") == 0 ? "-" : "",
+           g_strcmp0 (PROFILE, "devel") == 0 ? VCS_TAG : "");
+}
+
+static int
+local_options (GApplication *app,
+               GVariantDict *options,
+               gpointer      data)
+{
+  gboolean version = FALSE;
+  gboolean reset = FALSE;
+
+  g_variant_dict_lookup (options, "version", "b", &version);
+
+  if (version)
+    {
+      print_version ();
+      return 0;
+    }
+
+  g_variant_dict_lookup (options, "reset", "b", &reset);
+
+  if (reset)
+    {
+      char *path;
+
+      path = get_autosave_path ("-unsafe");
+      g_remove (path);
+      g_free (path);
+      path = get_autosave_path (NULL);
+      g_remove (path);
+      g_free (path);
+    }
+
+  return -1;
+}
+
+
 NodeEditorApplication *
 node_editor_application_new (void)
 {
-  return g_object_new (NODE_EDITOR_APPLICATION_TYPE,
-                       "application-id", "org.gtk.gtk4.NodeEditor",
-                       "flags", G_APPLICATION_HANDLES_OPEN,
-                       NULL);
+  NodeEditorApplication *app;
+
+  app = g_object_new (NODE_EDITOR_APPLICATION_TYPE,
+                      "application-id", "org.gtk.gtk4.NodeEditor",
+                      "flags", G_APPLICATION_HANDLES_OPEN,
+                      NULL);
+
+  g_application_add_main_option (G_APPLICATION (app), "version", 0, 0,G_OPTION_ARG_NONE, "Show program version", NULL);
+  g_application_add_main_option (G_APPLICATION (app), "reset", 0, 0,G_OPTION_ARG_NONE, "Remove autosave content", NULL);
+
+  g_signal_connect (app, "handle-local-options", G_CALLBACK (local_options), NULL);
+
+  return app;
 }
@@ -28,6 +28,8 @@
 #include "gsk/broadway/gskbroadwayrenderer.h"
 #endif

+#include <glib/gstdio.h>
+
 #include <cairo.h>
 #ifdef CAIRO_HAS_SVG_SURFACE
 #include <cairo-svg.h>
@@ -55,6 +57,7 @@ struct _NodeEditorWindow
  GtkWidget *testcase_name_entry;
  GtkWidget *testcase_save_button;
  GtkWidget *scale_scale;
+  GtkWidget *crash_warning;

  GtkWidget *renderer_listbox;
  GListStore *renderers;
@@ -64,6 +67,9 @@ struct _NodeEditorWindow
  GFileMonitor *file_monitor;

  GArray *errors;
+
+  guint update_timeout;
+  gboolean auto_reload;
 };

 struct _NodeEditorWindowClass
@@ -71,6 +77,13 @@ struct _NodeEditorWindowClass
  GtkApplicationWindowClass parent_class;
 };

+enum {
+  PROP_AUTO_RELOAD = 1,
+  NUM_PROPERTIES
+};
+
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
+
 G_DEFINE_TYPE(NodeEditorWindow, node_editor_window, GTK_TYPE_APPLICATION_WINDOW);

 static void
@@ -163,19 +176,84 @@ text_iter_skip_whitespace_backward (GtkTextIter *iter)
 }

 static void
-text_changed (GtkTextBuffer    *buffer,
-              NodeEditorWindow *self)
+highlight_text (NodeEditorWindow *self)
+{
+  GtkTextIter iter;
+  GtkTextIter start, end;
+
+  gtk_text_buffer_get_start_iter (self->text_buffer, &iter);
+
+  while (!gtk_text_iter_is_end (&iter))
+    {
+      gunichar c = gtk_text_iter_get_char (&iter);
+
+      if (c == '{')
+        {
+          GtkTextIter word_end = iter;
+          GtkTextIter word_start;
+
+          gtk_text_iter_backward_char (&word_end);
+          text_iter_skip_whitespace_backward (&word_end);
+
+          word_start = word_end;
+          gtk_text_iter_backward_word_start (&word_start);
+          text_iter_skip_alpha_backward (&word_start);
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "nodename", &word_start, &word_end);
+        }
+      else if (c == ':')
+        {
+          GtkTextIter word_end = iter;
+          GtkTextIter word_start;
+
+          gtk_text_iter_backward_char (&word_end);
+          text_iter_skip_whitespace_backward (&word_end);
+
+          word_start = word_end;
+          gtk_text_iter_backward_word_start (&word_start);
+          text_iter_skip_alpha_backward (&word_start);
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "propname", &word_start, &word_end);
+        }
+      else if (c == '"')
+        {
+          GtkTextIter string_start = iter;
+          GtkTextIter string_end = iter;
+
+          gtk_text_iter_forward_char (&iter);
+          while (!gtk_text_iter_is_end (&iter))
+            {
+              c = gtk_text_iter_get_char (&iter);
+
+              if (c == '"')
+                {
+                  gtk_text_iter_forward_char (&iter);
+                  string_end = iter;
+                  break;
+                }
+
+              gtk_text_iter_forward_char (&iter);
+            }
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "string", &string_start, &string_end);
+        }
+
+      gtk_text_iter_forward_char (&iter);
+    }
+
+  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
+  gtk_text_buffer_apply_tag_by_name (self->text_buffer, "no-hyphens", &start, &end);
+}
+
+static void
+reload (NodeEditorWindow *self)
 {
  char *text;
  GBytes *bytes;
-  GtkTextIter iter;
-  GtkTextIter start, end;
  float scale;
  GskRenderNode *big_node;

-  g_array_remove_range (self->errors, 0, self->errors->len);
  text = get_current_text (self->text_buffer);
-  text_buffer_remove_all_tags (self->text_buffer);
  bytes = g_bytes_new_take (text, strlen (text));

  g_clear_pointer (&self->node, gsk_render_node_unref);
@@ -236,73 +314,19 @@ text_changed (GtkTextBuffer    *buffer,
    }

  g_clear_pointer (&big_node, gsk_render_node_unref);
+}

-  gtk_text_buffer_get_start_iter (self->text_buffer, &iter);
+static void
+text_changed (GtkTextBuffer    *buffer,
+              NodeEditorWindow *self)
+{
+  g_array_remove_range (self->errors, 0, self->errors->len);
+  text_buffer_remove_all_tags (self->text_buffer);

-  while (!gtk_text_iter_is_end (&iter))
-    {
-      gunichar c = gtk_text_iter_get_char (&iter);
+  if (self->auto_reload)
+    reload (self);

-      if (c == '{')
-        {
-          GtkTextIter word_end = iter;
-          GtkTextIter word_start;
-
-          gtk_text_iter_backward_char (&word_end);
-          text_iter_skip_whitespace_backward (&word_end);
-
-          word_start = word_end;
-          gtk_text_iter_backward_word_start (&word_start);
-          text_iter_skip_alpha_backward (&word_start);
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "nodename",
-                                             &word_start, &word_end);
-        }
-      else if (c == ':')
-        {
-          GtkTextIter word_end = iter;
-          GtkTextIter word_start;
-
-          gtk_text_iter_backward_char (&word_end);
-          text_iter_skip_whitespace_backward (&word_end);
-
-          word_start = word_end;
-          gtk_text_iter_backward_word_start (&word_start);
-          text_iter_skip_alpha_backward (&word_start);
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "propname",
-                                             &word_start, &word_end);
-        }
-      else if (c == '"')
-        {
-          GtkTextIter string_start = iter;
-          GtkTextIter string_end = iter;
-
-          gtk_text_iter_forward_char (&iter);
-          while (!gtk_text_iter_is_end (&iter))
-            {
-              c = gtk_text_iter_get_char (&iter);
-
-              if (c == '"')
-                {
-                  gtk_text_iter_forward_char (&iter);
-                  string_end = iter;
-                  break;
-                }
-
-              gtk_text_iter_forward_char (&iter);
-            }
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "string",
-                                             &string_start, &string_end);
-        }
-
-      gtk_text_iter_forward_char (&iter);
-    }
-
-  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
-  gtk_text_buffer_apply_tag_by_name (self->text_buffer, "no-hyphens",
-                                     &start, &end);
+  highlight_text (self);
 }

 static void
@@ -1101,6 +1125,9 @@ node_editor_window_finalize (GObject *object)
 {
  NodeEditorWindow *self = (NodeEditorWindow *)object;

+  if (self->update_timeout)
+    g_source_remove (self->update_timeout);
+
  g_array_free (self->errors, TRUE);

  g_clear_pointer (&self->node, gsk_render_node_unref);
@@ -1540,6 +1567,62 @@ edit_action_cb (GtkWidget  *widget,
  node_editor_window_edit (self, &start);
 }

+static void
+node_editor_window_set_property (GObject      *object,
+                                 guint         prop_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  NodeEditorWindow *self = NODE_EDITOR_WINDOW (object);
+
+  switch (prop_id)
+    {
+    case PROP_AUTO_RELOAD:
+      {
+        gboolean auto_reload = g_value_get_boolean (value);
+        if (self->auto_reload != auto_reload)
+          {
+            self->auto_reload = auto_reload;
+
+            if (self->auto_reload)
+              reload (self);
+          }
+      }
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+node_editor_window_get_property (GObject    *object,
+                                 guint       prop_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  NodeEditorWindow *self = NODE_EDITOR_WINDOW (object);
+
+  switch (prop_id)
+    {
+    case PROP_AUTO_RELOAD:
+      g_value_set_boolean (value, self->auto_reload);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+close_crash_warning (GtkButton        *button,
+                     NodeEditorWindow *self)
+{
+  gtk_revealer_set_reveal_child (GTK_REVEALER (self->crash_warning), FALSE);
+}
+
 static void
 node_editor_window_class_init (NodeEditorWindowClass *class)
 {
@@ -1551,6 +1634,8 @@ node_editor_window_class_init (NodeEditorWindowClass *class)

  object_class->dispose = node_editor_window_dispose;
  object_class->finalize = node_editor_window_finalize;
+  object_class->set_property = node_editor_window_set_property;
+  object_class->get_property = node_editor_window_get_property;

  gtk_widget_class_set_template_from_resource (widget_class,
                                               "/org/gtk/gtk4/node-editor/node-editor-window.ui");
@@ -1558,6 +1643,12 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  widget_class->realize = node_editor_window_realize;
  widget_class->unrealize = node_editor_window_unrealize;

+  properties[PROP_AUTO_RELOAD] = g_param_spec_boolean ("auto-reload", NULL, NULL,
+                                                       TRUE,
+                                                       G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME);
+
+  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, text_view);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, picture);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, renderer_listbox);
@@ -1567,6 +1658,7 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, testcase_name_entry);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, testcase_save_button);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, scale_scale);
+  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, crash_warning);

  gtk_widget_class_bind_template_callback (widget_class, text_view_query_tooltip_cb);
  gtk_widget_class_bind_template_callback (widget_class, open_cb);
@@ -1579,6 +1671,7 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  gtk_widget_class_bind_template_callback (widget_class, on_picture_drag_prepare_cb);
  gtk_widget_class_bind_template_callback (widget_class, on_picture_drop_cb);
  gtk_widget_class_bind_template_callback (widget_class, click_gesture_pressed);
+  gtk_widget_class_bind_template_callback (widget_class, close_crash_warning);

  gtk_widget_class_install_action (widget_class, "smart-edit", NULL, edit_action_cb);

@@ -1630,11 +1723,133 @@ static GActionEntry win_entries[] = {
  { "open", window_open, NULL, NULL, NULL },
 };

+char *
+get_autosave_path (const char *suffix)
+{
+  char *path;
+  char *name;
+
+  name = g_strconcat ("autosave", suffix, NULL);
+  path = g_build_filename (g_get_user_cache_dir (), "gtk4-node-editor", name, NULL);
+  g_free (name);
+
+  return path;
+}
+
+static void
+set_initial_text (NodeEditorWindow *self)
+{
+  char *path, *path1;
+  char *initial_text;
+  gsize len;
+
+  path = get_autosave_path (NULL);
+  path1 = get_autosave_path ("-unsafe");
+
+  if (g_file_get_contents (path, &initial_text, &len, NULL))
+    {
+      gtk_text_buffer_set_text (self->text_buffer, initial_text, len);
+      g_free (initial_text);
+    }
+  else if (g_file_get_contents (path1, &initial_text, &len, NULL))
+    {
+      self->auto_reload = FALSE;
+      gtk_revealer_set_reveal_child (GTK_REVEALER (self->crash_warning), TRUE);
+
+      gtk_text_buffer_set_text (self->text_buffer, initial_text, len);
+      g_free (initial_text);
+    }
+  else
+    {
+      /* Default */
+      gtk_text_buffer_set_text (self->text_buffer,
+         "shadow {\n"
+         "  child: texture {\n"
+         "    bounds: 0 0 128 128;\n"
+         "    texture: url(\"resource:///org/gtk/gtk4/node-editor/icons/apps/org.gtk.gtk4.NodeEditor.svg\");\n"
+         "  }\n"
+         "  shadows: rgba(0,0,0,0.5) 0 1 12;\n"
+         "}\n"
+         "\n"
+         "transform {\n"
+         "  child: text {\n"
+         "    color: rgb(46,52,54);\n"
+         "    font: \"Cantarell Bold 11\";\n"
+         "    glyphs: \"GTK Node Editor\";\n"
+         "    offset: 8 14.418;\n"
+         "  }\n"
+         "  transform: translate(0, 140);\n"
+         "}", -1);
+    }
+
+  g_free (path);
+  g_free (path1);
+}
+
+static void
+autosave_contents (NodeEditorWindow *self)
+{
+  char *path = NULL;
+  char *dir = NULL;
+  char *contents;
+  GtkTextIter start, end;
+
+  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
+  contents = gtk_text_buffer_get_text (self->text_buffer, &start, &end, TRUE);
+  path = get_autosave_path ("-unsafe");
+  dir = g_path_get_dirname (path);
+  g_mkdir_with_parents (dir, 0755);
+  g_file_set_contents (path, contents, -1, NULL);
+
+  g_free (dir);
+  g_free (path);
+  g_free (contents);
+}
+
+static void
+mark_autosave_as_safe (void)
+{
+  char *path1 = NULL;
+  char *path2 = NULL;
+
+  path1 = get_autosave_path ("-unsafe");
+  path2 = get_autosave_path (NULL);
+
+  g_rename (path1, path2);
+}
+
+static gboolean
+update_timeout_cb (gpointer data)
+{
+  NodeEditorWindow *self = data;
+
+  self->update_timeout = 0;
+
+  mark_autosave_as_safe ();
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+initiate_autosave (NodeEditorWindow *self)
+{
+  autosave_contents (self);
+
+  if (self->update_timeout != 0)
+    g_source_remove (self->update_timeout);
+
+  self->update_timeout = g_timeout_add (100, update_timeout_cb, self);
+}
+
 static void
 node_editor_window_init (NodeEditorWindow *self)
 {
+  GAction *action;
+
  gtk_widget_init_template (GTK_WIDGET (self));

+  self->auto_reload = TRUE;
+
  self->renderers = g_list_store_new (GDK_TYPE_PAINTABLE);
  gtk_list_box_bind_model (GTK_LIST_BOX (self->renderer_listbox),
                           G_LIST_MODEL (self->renderers),
@@ -1647,6 +1862,10 @@ node_editor_window_init (NodeEditorWindow *self)

  g_action_map_add_action_entries (G_ACTION_MAP (self), win_entries, G_N_ELEMENTS (win_entries), self);

+  action = G_ACTION (g_property_action_new ("auto-reload", self, "auto-reload"));
+  g_action_map_add_action (G_ACTION_MAP (self), action);
+  g_object_unref (action);
+
  self->tag_table = gtk_text_tag_table_new ();
  gtk_text_tag_table_add (self->tag_table,
                          g_object_new (GTK_TYPE_TEXT_TAG,
@@ -1684,25 +1903,9 @@ node_editor_window_init (NodeEditorWindow *self)
  g_signal_connect (self->scale_scale, "notify::value", G_CALLBACK (scale_changed), self);
  gtk_text_view_set_buffer (GTK_TEXT_VIEW (self->text_view), self->text_buffer);

-  /* Default */
-  gtk_text_buffer_set_text (self->text_buffer,
-         "shadow {\n"
-         "  child: texture {\n"
-         "    bounds: 0 0 128 128;\n"
-         "    texture: url(\"resource:///org/gtk/gtk4/node-editor/icons/apps/org.gtk.gtk4.NodeEditor.svg\");\n"
-         "  }\n"
-         "  shadows: rgba(0,0,0,0.5) 0 1 12;\n"
-         "}\n"
-         "\n"
-         "transform {\n"
-         "  child: text {\n"
-         "    color: rgb(46,52,54);\n"
-         "    font: \"Cantarell Bold 11\";\n"
-         "    glyphs: \"GTK Node Editor\";\n"
-         "    offset: 8 14.418;\n"
-         "  }\n"
-         "  transform: translate(0, 140);\n"
-         "}", -1);
+  set_initial_text (self);
+
+  g_signal_connect_swapped (self->text_buffer, "changed", G_CALLBACK (initiate_autosave), self);

  if (g_getenv ("GSK_RENDERER"))
    {
@@ -37,3 +37,5 @@ NodeEditorWindow *      node_editor_window_new          (NodeEditorApplication

 gboolean                node_editor_window_load         (NodeEditorWindow       *self,
                                                         GFile                  *file);
+
+char *                  get_autosave_path               (const char             *suffix);
@@ -2,6 +2,14 @@
 <interface>
  <menu id="gear_menu">
    <section>
+      <item>
+        <attribute name="label" translatable="yes">_Reload automatically</attribute>
+        <attribute name="action">win.auto-reload</attribute>
+      </item>
+      <item>
+        <attribute name="label" translatable="yes">_Help</attribute>
+        <attribute name="action">app.help</attribute>
+      </item>
      <item>
        <attribute name="label" translatable="yes">_Help</attribute>
        <attribute name="action">app.help</attribute>
@@ -24,7 +32,6 @@
      </item>
    </section>
  </menu>
-
  <object class="GtkPopover" id="testcase_popover">
    <child>
      <object class="GtkGrid">
@@ -39,7 +46,7 @@
          <object class="GtkEntry" id="testcase_name_entry">
            <property name="hexpand">1</property>
            <property name="activates-default">1</property>
-            <signal name="notify::text" handler="testcase_name_entry_changed_cb" />
+            <signal name="notify::text" handler="testcase_name_entry_changed_cb"/>
          </object>
        </child>
        <child>
@@ -52,7 +59,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkLabel">
            <property name="wrap">1</property>
@@ -66,7 +72,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkLabel" id="testcase_error_label">
            <property name="wrap">1</property>
@@ -78,7 +83,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkButton" id="testcase_save_button">
            <property name="label">Save</property>
@@ -86,9 +90,9 @@
            <property name="halign">end</property>
            <property name="receives-default">1</property>
            <property name="sensitive">0</property>
-            <signal name="clicked" handler="testcase_save_clicked_cb" />
+            <signal name="clicked" handler="testcase_save_clicked_cb"/>
            <style>
-              <class name="suggested-action" />
+              <class name="suggested-action"/>
            </style>
            <layout>
              <property name="row">4</property>
@@ -100,7 +104,6 @@
      </object>
    </child>
  </object>
-
  <template class="NodeEditorWindow" parent="GtkApplicationWindow">
    <property name="title" translatable="yes">GTK Node Editor</property>
    <property name="default-width">1024</property>
@@ -185,83 +188,128 @@
      </object>
    </child>
    <child>
-      <object class="GtkPaned">
-        <property name="shrink-start-child">false</property>
-        <property name="shrink-end-child">false</property>
-        <property name="position">400</property>
-        <property name="start-child">
-          <object class="GtkScrolledWindow">
-            <property name="hscrollbar-policy">never</property>
-            <property name="hexpand">1</property>
-            <property name="vexpand">1</property>
-            <child>
-              <object class="GtkTextView" id="text_view">
-                <property name="wrap-mode">word</property>
-                <property name="monospace">1</property>
-                <property name="top-margin">6</property>
-                <property name="left-margin">6</property>
-                <property name="right-margin">6</property>
-                <property name="bottom-margin">6</property>
-                <property name="has-tooltip">1</property>
-                <property name="extra-menu">extra_menu</property>
-                <signal name="query-tooltip" handler="text_view_query_tooltip_cb"/>
+      <object class="GtkOverlay">
+        <child type="overlay">
+          <object class="GtkRevealer" id="crash_warning">
+            <property name="transition-type">slide-down</property>
+            <property name="halign">center</property>
+            <property name="valign">start</property>
+            <property name="child">
+              <object class="GtkFrame">
                <style>
-                  <class name="editor" />
+                  <class name="app-notification"/>
                </style>
+                <property name="child">
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">20</property>
+                    <property name="margin-start">10</property>
+                    <property name="margin-end">10</property>
+                    <property name="margin-top">10</property>
+                    <property name="margin-bottom">10</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="hexpand">1</property>
+                        <property name="halign">1</property>
+                        <property name="label" translatable="1">The application may have crashed.
+As a precaution, auto-loading has been turned off.
+</property>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkButton">
+                        <property name="valign">3</property>
+                        <property name="use-underline">1</property>
+                        <property name="label" translatable="1">_Close</property>
+                        <signal name="clicked" handler="close_crash_warning"/>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </property>
+          </object>
+        </child>
+        <property name="child">
+          <object class="GtkPaned">
+            <property name="shrink-start-child">false</property>
+            <property name="shrink-end-child">false</property>
+            <property name="position">400</property>
+            <property name="start-child">
+              <object class="GtkScrolledWindow">
+                <property name="hscrollbar-policy">never</property>
+                <property name="hexpand">1</property>
+                <property name="vexpand">1</property>
                <child>
-                  <object class="GtkGestureClick">
-                    <property name="button">1</property>
-                    <signal name="pressed" handler="click_gesture_pressed"/>
+                  <object class="GtkTextView" id="text_view">
+                    <property name="wrap-mode">word</property>
+                    <property name="monospace">1</property>
+                    <property name="top-margin">6</property>
+                    <property name="left-margin">6</property>
+                    <property name="right-margin">6</property>
+                    <property name="bottom-margin">6</property>
+                    <property name="has-tooltip">1</property>
+                    <property name="extra-menu">extra_menu</property>
+                    <signal name="query-tooltip" handler="text_view_query_tooltip_cb"/>
+                    <style>
+                      <class name="editor"/>
+                    </style>
+                    <child>
+                      <object class="GtkGestureClick">
+                        <property name="button">1</property>
+                        <signal name="pressed" handler="click_gesture_pressed"/>
+                      </object>
+                    </child>
                  </object>
                </child>
              </object>
-            </child>
-          </object>
-        </property>
-        <property name="end-child">
-          <object class="GtkBox">
-            <child>
-              <object class="GtkScrolledWindow">
-                <property name="hexpand">1</property>
-                <property name="vexpand">1</property>
-                <property name="min-content-height">100</property>
-                <property name="min-content-width">100</property>
+            </property>
+            <property name="end-child">
+              <object class="GtkBox">
                <child>
-                  <object class="GtkViewport">
+                  <object class="GtkScrolledWindow">
+                    <property name="hexpand">1</property>
+                    <property name="vexpand">1</property>
+                    <property name="min-content-height">100</property>
+                    <property name="min-content-width">100</property>
                    <child>
-                      <object class="GtkPicture" id="picture">
-                        <property name="can-shrink">0</property>
-                        <property name="halign">center</property>
-                        <property name="valign">center</property>
+                      <object class="GtkViewport">
                        <child>
-                          <object class="GtkDragSource">
+                          <object class="GtkPicture" id="picture">
+                            <property name="can-shrink">0</property>
+                            <property name="halign">center</property>
+                            <property name="valign">center</property>
+                            <child>
+                              <object class="GtkDragSource">
+                                <property name="actions">copy</property>
+                                <signal name="prepare" handler="on_picture_drag_prepare_cb" swapped="no"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkDropTargetAsync">
                            <property name="actions">copy</property>
-                            <signal name="prepare" handler="on_picture_drag_prepare_cb" swapped="no"/>
+                            <property name="formats">application/x-gtk-render-node</property>
+                            <signal name="drop" handler="on_picture_drop_cb" swapped="no"/>
                          </object>
                        </child>
                      </object>
                    </child>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkScrolledWindow">
+                    <property name="hscrollbar-policy">never</property>
                    <child>
-                      <object class="GtkDropTargetAsync">
-                        <property name="actions">copy</property>
-                        <property name="formats">application/x-gtk-render-node</property>
-                        <signal name="drop" handler="on_picture_drop_cb" swapped="no"/>
+                      <object class="GtkListBox" id="renderer_listbox">
+                        <property name="selection-mode">none</property>
                      </object>
                    </child>
                  </object>
                </child>
              </object>
-            </child>
-            <child>
-              <object class="GtkScrolledWindow">
-                <property name="hscrollbar-policy">never</property>
-                <child>
-                  <object class="GtkListBox" id="renderer_listbox">
-                    <property name="selection-mode">none</property>
-                  </object>
-                </child>
-              </object>
-            </child>
+            </property>
          </object>
        </property>
      </object>
@@ -322,27 +322,39 @@ stroke bounds of the path.

 ### text

-| property | syntax           | default                | printed     |
-| -------- | ---------------- | ---------------------- | ----------- |
-| color    | `<color>`        | black                  | non-default |
-| font     | `<string>`       | "Cantarell 11"         | always      |
-| glyphs   | `<glyphs>`       | "Hello"                | always      |
-| offset   | `<point>`        | 0 0                    | non-default |
+| property | syntax              | default             | printed     |
+| -------- | ------------------- | ------------------- | ----------- |
+| color    | `<color>`           | black               | non-default |
+| font     | `<string>` `<url>`? | "Cantarell 11"      | always      |
+| glyphs   | `<glyphs>`          | "Hello"             | always      |
+| offset   | `<point>`           | 0 0                 | non-default |

 Creates a node like `gsk_text_node_new()` with the given properties.

+If a url is specified for the font, it must point to a font file for the
+font that is specified in the string. It can be either a data url containing
+a base64-encoded font file, or a regular url that points to a font file.
+
+Glyphs can be specified as an ASCII string, or as a comma-separated list of
+their glyph ID and advance width. Optionally, x and y offsets and flags can
+be specified as well, like this: 40 10 0 0 color.
+
 If the given font does not exist or the given glyphs are invalid for the given
 font, an error node will be returned.

 ### texture

-| property | syntax           | default                | printed     |
-| -------- | ---------------- | ---------------------- | ----------- |
-| bounds   | `<rect>`         | 50                     | always      |
-| texture  | `<url>`          | *see below*            | always      |
+| property | syntax              | default                | printed     |
+| -------- | ------------------- | ---------------------- | ----------- |
+| bounds   | `<rect>`            | 50                     | always      |
+| texture  | `<string>`?`<url>`? | *see below*            | always      |

 Creates a node like `gsk_texture_node_new()` with the given properties.

+If a string is specified for the texture, it will be used as a name for the text.
+Textures can be reused by specifying the name of a previously used texture. In
+that case, the url can be omitted.
+
 The default texture is a 10x10 checkerboard with the top left and bottom right
 5x5 being in the color #FF00CC and the other part being transparent. A possible
 representation for this texture is `url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAABmJLR0QA/wD/AP+gvaeTAAAAKUlEQVQYlWP8z3DmPwMaYGQwYUQXY0IXwAUGUCGGoxkYGBiweXAoeAYAz44F3e3U1xUAAAAASUVORK5CYII=")
@@ -1,7 +1,7 @@
 executable('gtk4-print-editor',
  sources: ['print-editor.c'],
  c_args: common_cflags,
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  win_subsystem: 'windows',
  link_args: extra_demo_ldflags,
@@ -4,7 +4,7 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>

-#include "demo_conf.h"
+#include "profile_conf.h"

 static GtkWidget *main_window;
 static GFile *filename = NULL;
@@ -66,7 +66,7 @@ endif
 executable('gtk4-widget-factory',
  sources: ['widget-factory.c', widgetfactory_resources],
  c_args: common_cflags,
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  win_subsystem: 'windows',
  link_args: extra_demo_ldflags,
@@ -25,7 +25,7 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>

-#include "demo_conf.h"
+#include "profile_conf.h"

 static void
 change_dark_state (GSimpleAction *action,
@@ -75,7 +75,7 @@ define colors. Color expressions resemble functions, taking 1 or more colors
 and in some cases a number as arguments.

 `lighter(Color)`
- : produces a brigher variant of Color
+ : produces a brighter variant of Color

 `darker(Color)`
 : produces a darker variant of Color
@@ -11,13 +11,17 @@ Editor render nodes
 SYNOPSIS
 --------

-|   **gtk4-node-editor** [OPTIONS...]
+|   **gtk4-node-editor** [OPTIONS...] [FILE]

 DESCRIPTION
 -----------

 ``gtk4-node-editor`` is a utility to show and edit render node files.
-Such render node files can be obtained e.g. from the GTK inspector.
+Such render node files can be obtained e.g. from the GTK inspector or
+as part of the testsuite in the GTK sources.
+
+``gtk4-node-editor`` is used by GTK developers for debugging and testing,
+and it has built-in support for saving testcases as part of the GTK testsuite.

 OPTIONS
 -------
@@ -25,3 +29,21 @@ OPTIONS
 ``-h, --help``

  Show the application help.
+
+``--version``
+
+  Show the program version.
+
+``--reset``
+
+  Don't restore autosaved content and remove autosave files.
+
+ENVIRONMENT
+-----------
+
+``GTK_SOURCE_DIR``
+
+  can be set to point to the location where the GTK sources reside, so that
+  testcases can be saved to the right location. If unsed, `gtk4-node-editor``
+  checks if the current working directory looks like a GTK checkout, and failing
+  that, saves testcase in the the current working directory.
@@ -12,9 +12,10 @@ SYNOPSIS
 --------
 |   **gtk4-rendernode-tool** <COMMAND> [OPTIONS...] <FILE>
 |
+|   **gtk4-rendernode-tool** benchmark [OPTIONS...] <FILE>
 |   **gtk4-rendernode-tool** info [OPTIONS...] <FILE>
-|   **gtk4-rendernode-tool** show [OPTIONS...] <FILE>
 |   **gtk4-rendernode-tool** render [OPTIONS...] <FILE> [<FILE>]
+|   **gtk4-rendernode-tool** show [OPTIONS...] <FILE>

 DESCRIPTION
 -----------
@@ -50,3 +51,31 @@ The name of the file to write can be specified as a second FILE argument.

  Use the given renderer. Use ``--renderer=help`` to get a information
  about poassible values for the ``RENDERER``.
+
+Benchmark
+^^^^^^^^^
+
+The ``benchmark`` command benchmarks rendering of a node with the existing renderers
+and prints the runtimes.
+
+``--renderer=RENDERER``
+
+  Add the given renderer. This argument can be passed multiple times to test multiple
+  renderers. By default, all major GTK renderers are run.
+
+``--runs=RUNS``
+
+  Number of times to render the node on each renderer. By default, this is 3 times.
+  Keep in mind that the first run is often used to populate caches and might be
+  significantly slower.
+
+``--no-download``
+
+  Do not attempt to download the result. This may cause the measurement to not include
+  the execution of the commands on the GPU. It can be useful to use this flag to test
+  command submission performance.
+
+
+
+
+
@@ -62,7 +62,7 @@ are only available when GTK has been configured with `-Ddebug=true`.
 `layout`
 : Layout managers

-`acccessibility`
+`accessibility`
 : Accessibility state changs

 A number of keys are influencing behavior instead of just logging:
@@ -357,7 +357,7 @@ devices.
 ### `GDK_VULKAN_SKIP`

 This variable can be set to a list of values, which cause GDK to
-disable features of the Vulkan support.  
+disable features of the Vulkan support.
 Note that these features may already be disabled if the Vulkan driver
 does not support them.

@@ -371,7 +371,7 @@ does not support them.
 : Force slow descriptor set layout codepath

 `dynamic-indexing`
-: Hardcode small number of buffer and texure arrays
+: Hardcode small number of buffer and texture arrays

 `nonuniform-indexing`
 : Split draw calls to ensure uniform texture accesses
@@ -415,19 +415,24 @@ using and the GDK backend supports them:
 `vulkan`
 : Selects the Vulkan renderer

-Note that on Windows, if one is running Nahimic 3 on a system with
-nVidia graphics, one needs to stop the "Nahimic service" or insert
-the GTK application into the Nahimic blacklist, as noted in
-https://www.nvidia.com/en-us/geforce/forums/game-ready-drivers/13/297952/nahimic-and-nvidia-drivers-conflict/2334568/, or use the cairo renderer (at the cost of being unable to use
-OpenGL features), or use GDK_DEBUG=gl-gles if you know that GLES
-support is enabled for the build.

-This is a known issue, as the above link indicates, and affects quite
-a number of applications--sadly, since this issue lies within the
-nVidia graphics driver and/or the Nahimic 3 code, we are not able
-to rememdy this on the GTK side; the best bet before trying the above
-workarounds is to try to update your graphics drivers and Nahimic
-installation.
+::: note
+    If you are running the Nahimic 3 service on a Windows system with
+    nVidia graphics, you need to perform one of the following:
+
+     - stop the "Nahimic service"
+     - insert the GTK application into the Nahimic blocklist, as noted in the
+       [nVidia forums](https://www.nvidia.com/en-us/geforce/forums/game-ready-drivers/13/297952/nahimic-and-nvidia-drivers-conflict/2334568/)
+     - use the cairo renderer (at the cost of being unable to use OpenGL features)
+     - use `GDK_DEBUG=gl-gles`, if you know that GLES support is enabled for the build.
+
+    This is a known issue, as the above link indicates, and affects quite
+    a number of applications—sadly, since this issue lies within the
+    nVidia graphics driver and/or the Nahimic 3 code, we are not able
+    to rememdy this on the GTK side; the best bet before trying the above
+    workarounds is to try to update your graphics drivers and Nahimic
+    installation.
+

 ### `GSK_GPU_SKIP`

@@ -207,7 +207,7 @@ you should ensure that:
 GTK will try to fill in some information by using ancillary UI control properties,
 for instance the accessible name will be taken from the label used by the UI control,
 or from its tooltip, if the `GTK_ACCESSIBLE_PROPERTY_LABEL` property or the
-`GTK_ACCESSIBLE_RELATION_LABELLED_BY` relation are unset. Similary for the accessible
+`GTK_ACCESSIBLE_RELATION_LABELLED_BY` relation are unset. Similarly for the accessible
 description. Nevertheless, it is good practice and project hygiene to explicitly specify
 the accessible properties, just like it's good practice to specify tooltips and style classes.

@@ -222,7 +222,6 @@ gdk_parse_debug_var (const char        *variable,
        }
      else
        {
-          char *val = g_strndup (p, q - p);
          for (i = 0; i < nkeys; i++)
            {
              if (strlen (keys[i].key) == q - p &&
@@ -233,8 +232,7 @@ gdk_parse_debug_var (const char        *variable,
                }
            }
          if (i == nkeys)
-            fprintf (stderr, "Unrecognized value \"%s\". Try %s=help\n", val, variable);
-          g_free (val);
+            fprintf (stderr, "Unrecognized value \"%.*s\". Try %s=help\n", (int) (q - p), p, variable);
         }

      p = q;
@@ -289,7 +289,8 @@ gdk_device_class_init (GdkDeviceClass *klass)
   */
  device_props[PROP_MODIFIER_STATE] =
      g_param_spec_flags ("modifier-state", NULL, NULL,
-                          GDK_TYPE_MODIFIER_TYPE, 0,
+                          GDK_TYPE_MODIFIER_TYPE,
+                          GDK_NO_MODIFIER_MASK,
                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

  g_object_class_install_properties (object_class, LAST_PROP, device_props);
@@ -1363,7 +1363,7 @@ gdk_display_init_gl (GdkDisplay *self)
      return;
    }

-  gdk_profiler_end_mark (before2, "realize OpenGL context", NULL);
+  gdk_profiler_end_mark (before2, "Realize OpenGL context", NULL);

  /* Only assign after realize, so GdkGLContext::realize() can use
   * gdk_display_get_gl_context() == NULL to differentiate between
@@ -1373,7 +1373,7 @@ gdk_display_init_gl (GdkDisplay *self)

  gdk_gl_backend_use (GDK_GL_CONTEXT_GET_CLASS (context)->backend_type);

-  gdk_profiler_end_mark (before, "initialize OpenGL", NULL);
+  gdk_profiler_end_mark (before, "Init OpenGL", NULL);
 }

 /**
@@ -1768,7 +1768,6 @@ gdk_display_init_egl (GdkDisplay  *self,
 {
  GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
  G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
-  G_GNUC_UNUSED gint64 start_time2;
  int major, minor;

  if (!gdk_gl_backend_can_be_used (GDK_GL_EGL, error))
@@ -1795,7 +1794,6 @@ gdk_display_init_egl (GdkDisplay  *self,
      return FALSE;
    }

-  start_time2 = GDK_PROFILER_CURRENT_TIME;
  if (!eglInitialize (priv->egl_display, &major, &minor))
    {
      priv->egl_display = NULL;
@@ -1804,7 +1802,6 @@ gdk_display_init_egl (GdkDisplay  *self,
                           _("Could not initialize EGL display"));
      return FALSE;
    }
-  gdk_profiler_end_mark (start_time2, "eglInitialize", NULL);

  if (major < GDK_EGL_MIN_VERSION_MAJOR ||
      (major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
@@ -1894,7 +1891,7 @@ gdk_display_init_egl (GdkDisplay  *self,
      g_free (ext);
    }

-  gdk_profiler_end_mark (start_time, "init EGL", NULL);
+  gdk_profiler_end_mark (start_time, "Init EGL", NULL);

  return TRUE;
 }
@@ -25,7 +25,7 @@
 /**
 * GdkDmabufFormats:
 *
- * The `GdkDmabufFormats struct provides information about
+ * The `GdkDmabufFormats` struct provides information about
 * supported DMA buffer formats.
 *
 * You can query whether a given format is supported with
@@ -57,7 +57,7 @@ struct _GdkDmabufTextureBuilderClass
 *
 * DMA buffers are commonly called **_dma-bufs_**.
 *
- * DMA buffers a feature of the Linux kernel to enable efficient buffer and
+ * DMA buffers are a feature of the Linux kernel to enable efficient buffer and
 * memory sharing between hardware such as codecs, GPUs, displays, cameras and the
 * kernel drivers controlling them. For example, a decoder may want its output to
 * be directly shared with the display server for rendering without a copy.
@@ -67,7 +67,7 @@ struct _GdkDmabufTextureBuilderClass
 *
 * The memory that is shared via DMA buffers is usually stored in non-system memory
 * (maybe in device's local memory or something else not directly accessible by the
- * CPU), and accessing this memory from the CPU may have higher than usual overhead.
+ * CPU), and accessing this memory from the CPU may have higher-than-usual overhead.
 *
 * In particular for graphics data, it is not uncommon that data consists of multiple
 * separate blocks of memory, for example one block for each of the red, green and
@@ -87,7 +87,7 @@ struct _GdkDmabufTextureBuilderClass
 *
 * For historical reasons, some producers of dma-bufs don't provide an explicit modifier, but
 * instead return `DMA_FORMAT_MOD_INVALID` to indicate that their modifier is **_implicit_**.
- * GTK tries to accomodate this situation by accepting `DMA_FORMAT_MOD_INVALID` as modifier.
+ * GTK tries to accommodate this situation by accepting `DMA_FORMAT_MOD_INVALID` as modifier.
 *
 * The operation of `GdkDmabufTextureBuilder` is quite simple: Create a texture builder,
 * set all the necessary properties, and then call [method@Gdk.DmabufTextureBuilder.build]
@@ -56,10 +56,10 @@ static struct {
  GdkCursor    *cursor;
 } drag_cursors[] = {
  { GDK_ACTION_ASK,     "dnd-ask",  NULL },
-  { GDK_ACTION_COPY,    "dnd-copy", NULL },
-  { GDK_ACTION_MOVE,    "dnd-move", NULL },
-  { GDK_ACTION_LINK,    "dnd-link", NULL },
-  { 0,                  "dnd-none", NULL },
+  { GDK_ACTION_COPY,    "copy", NULL },
+  { GDK_ACTION_MOVE,    "move", NULL },
+  { GDK_ACTION_LINK,    "alias", NULL },
+  { 0,                  "no-drop", NULL },
 };

 enum {
@@ -331,7 +331,7 @@ gdk_draw_context_begin_frame (GdkDrawContext       *context,
 *
 * This is only a request and if the GDK backend does not support HDR rendering
 * or does not consider it worthwhile, it may choose to not honor the request.
- * It may also choose to provide a differnet depth even if it was not requested.
+ * It may also choose to provide a different depth even if it was not requested.
 * Typically the steps undertaken by a backend are:
 * 1. Check if high depth is supported by this drawing backend.
 * 2. Check if the compositor supports high depth.
@@ -687,7 +687,7 @@ _gdk_frame_clock_emit_update (GdkFrameClock *frame_clock)

  g_signal_emit (frame_clock, signals[UPDATE], 0);

-  gdk_profiler_end_mark (before, "frameclock update", NULL);
+  gdk_profiler_end_mark (before, "Frameclock update", NULL);
 }

 void
@@ -699,7 +699,7 @@ _gdk_frame_clock_emit_layout (GdkFrameClock *frame_clock)

  g_signal_emit (frame_clock, signals[LAYOUT], 0);

-  gdk_profiler_end_mark (before, "frameclock layout", NULL);
+  gdk_profiler_end_mark (before, "Frameclock layout", NULL);
 }

 void
@@ -711,7 +711,7 @@ _gdk_frame_clock_emit_paint (GdkFrameClock *frame_clock)

  g_signal_emit (frame_clock, signals[PAINT], 0);

-  gdk_profiler_end_mark (before, "frameclock paint", NULL);
+  gdk_profiler_end_mark (before, "Frameclock paint", NULL);
 }

 void
@@ -811,12 +811,12 @@ _gdk_frame_clock_add_timings_to_profiler (GdkFrameClock   *clock,
 {
  if (timings->drawn_time != 0)
    {
-      gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "drawn window", NULL);
+      gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "Drawn window", NULL);
    }

  if (timings->presentation_time != 0)
    {
-      gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "presented window", NULL);
+      gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "Presented window", NULL);
    }

  gdk_profiler_set_counter (fps_counter, gdk_frame_clock_get_fps (clock));
@@ -694,7 +694,7 @@ gdk_frame_clock_paint_idle (void *data)
  if (!gdk_frame_clock_idle_is_frozen (clock_idle))
    priv->sleep_serial = get_sleep_serial ();

-  gdk_profiler_end_mark (before, "frameclock cycle", NULL);
+  gdk_profiler_end_mark (before, "Frameclock cycle", NULL);

  return FALSE;
 }
@@ -386,7 +386,7 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
  else if (epoxy_has_egl_extension (egl_display, "EGL_EXT_swap_buffers_with_damage"))
    priv->eglSwapBuffersWithDamage = (gpointer) epoxy_eglGetProcAddress ("eglSwapBuffersWithDamageEXT");

-  gdk_profiler_end_mark (start_time, "realize GdkWaylandGLContext", NULL);
+  gdk_profiler_end_mark (start_time, "Create EGL context", NULL);

  return api;
 }
@@ -669,7 +669,7 @@ gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,

  egl_surface = gdk_surface_get_egl_surface (surface);

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "EGL", "swap buffers");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "EGL swap buffers", NULL);

  if (priv->eglSwapBuffersWithDamage)
    {
@@ -2042,15 +2042,6 @@ gdk_gl_context_has_sync (GdkGLContext *self)
  return priv->has_sync;
 }

-/* Return if GL_BGRA works with glTexImage2D */
-gboolean
-gdk_gl_context_has_bgra (GdkGLContext *self)
-{
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
-
-  return priv->has_bgra;
-}
-
 /* Return if glGenVertexArrays, glBindVertexArray and glDeleteVertexArrays
 * can be used
 */
@@ -171,8 +171,6 @@ gboolean                gdk_gl_context_has_vertex_half_float    (GdkGLContext

 gboolean                gdk_gl_context_has_sync                 (GdkGLContext    *self) G_GNUC_PURE;

-gboolean                gdk_gl_context_has_bgra                 (GdkGLContext    *self) G_GNUC_PURE;
-
 gboolean                gdk_gl_context_has_vertex_arrays        (GdkGLContext    *self) G_GNUC_PURE;

 double                  gdk_gl_context_get_scale                (GdkGLContext    *self);
@@ -161,7 +161,12 @@ gdk_gl_texture_find_format (GdkGLContext    *context,
      if (!(gdk_gl_context_get_format_flags (context, format) & GDK_GL_FORMAT_RENDERABLE))
        continue;

-      gdk_memory_format_gl_format (format, &q_internal_format, &q_format, &q_type, q_swizzle);
+      gdk_memory_format_gl_format (format,
+                                   gdk_gl_context_get_use_es (context),
+                                   &q_internal_format,
+                                   &q_format,
+                                   &q_type,
+                                   q_swizzle);

      if (q_format != gl_format || q_type != gl_type)
        continue;
@@ -193,6 +198,7 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
      ((gdk_gl_context_get_format_flags (context, format) & GDK_GL_FORMAT_USABLE) == GDK_GL_FORMAT_USABLE))
    {
      gdk_memory_format_gl_format (format,
+                                   gdk_gl_context_get_use_es (context),
                                   &gl_internal_format,
                                   &gl_format, &gl_type, gl_swizzle);
      if (download->stride == expected_stride &&
@@ -255,6 +261,7 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
                actual_format = gdk_memory_format_get_straight (actual_format);

              gdk_memory_format_gl_format (actual_format,
+                                           gdk_gl_context_get_use_es (context),
                                           &gl_internal_format,
                                           &gl_read_format, &gl_read_type, gl_swizzle);
            }
@@ -266,6 +273,7 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
            actual_format = gdk_memory_format_get_straight (actual_format);

          gdk_memory_format_gl_format (actual_format,
+                                       gdk_gl_context_get_use_es (context),
                                       &gl_internal_format,
                                       &gl_read_format, &gl_read_type, gl_swizzle);
        }
@@ -653,7 +661,7 @@ gdk_gl_texture_determine_format (GdkGLTexture *self)
 * Return value: (transfer full) (type GdkGLTexture): A newly-created
 *   `GdkTexture`
 *
- * Deprecated: 4.12: [class@Gdk.GLTextureBuilder] supercedes this function
+ * Deprecated: 4.12: [class@Gdk.GLTextureBuilder] supersedes this function
 *   and provides extended functionality for creating GL textures.
 */
 GdkTexture *
@@ -51,7 +51,7 @@ struct _GdkGLTextureBuilderClass
 /**
 * GdkGLTextureBuilder:
 *
- * `GdkGLTextureBuilder` is a buider used to construct [class@Gdk.Texture] objects from
+ * `GdkGLTextureBuilder` is a builder used to construct [class@Gdk.Texture] objects from
 * GL textures.
 *
 * The operation is quite simple: Create a texture builder, set all the necessary
@@ -335,7 +335,8 @@ struct _GdkMemoryFormatDescription
  GdkMemoryDepth depth;
  const GdkMemoryFormat *fallbacks;
  struct {
-    GLint internal_format;
+    GLint internal_gl_format;
+    GLint internal_gles_format;
    GLenum format;
    GLenum type;
    GLint swizzle[4];
@@ -375,7 +376,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_BGRA,
        .format = GL_BGRA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -402,7 +404,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_BGRA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -429,7 +432,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -455,7 +459,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -482,7 +487,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_BGRA,
        .format = GL_BGRA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -509,7 +515,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_BGRA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -536,7 +543,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -562,7 +570,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -590,7 +599,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_BGRA,
        .format = GL_BGRA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ONE },
@@ -618,7 +628,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_BGRA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ONE },
@@ -646,7 +657,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ONE },
@@ -673,7 +685,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA8,
+        .internal_gl_format = GL_RGBA8,
+        .internal_gles_format = GL_RGBA8,
        .format = GL_RGBA,
        .type = GDK_GL_UNSIGNED_BYTE_FLIPPED,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ONE },
@@ -701,7 +714,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGB8,
+        .internal_gl_format = GL_RGB8,
+        .internal_gles_format = GL_RGB8,
        .format = GL_RGB,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -728,7 +742,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGB8,
+        .internal_gl_format = GL_RGB8,
+        .internal_gles_format = GL_RGB8,
        .format = GL_BGR,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -759,7 +774,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGB16,
+        .internal_gl_format = GL_RGB16,
+        .internal_gles_format = GL_RGB16,
        .format = GL_RGB,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -788,7 +804,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA16,
+        .internal_gl_format = GL_RGBA16,
+        .internal_gles_format = GL_RGBA16,
        .format = GL_RGBA,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -817,7 +834,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA16,
+        .internal_gl_format = GL_RGBA16,
+        .internal_gles_format = GL_RGBA16,
        .format = GL_RGBA,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -846,7 +864,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGB16F,
+        .internal_gl_format = GL_RGB16F,
+        .internal_gles_format = GL_RGB16F,
        .format = GL_RGB,
        .type = GL_HALF_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -874,7 +893,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA16F,
+        .internal_gl_format = GL_RGBA16F,
+        .internal_gles_format = GL_RGBA16F,
        .format = GL_RGBA,
        .type = GL_HALF_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -902,7 +922,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA16F,
+        .internal_gl_format = GL_RGBA16F,
+        .internal_gles_format = GL_RGBA16F,
        .format = GL_RGBA,
        .type = GL_HALF_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -931,7 +952,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGB32F,
+        .internal_gl_format = GL_RGB32F,
+        .internal_gles_format = GL_RGB32F,
        .format = GL_RGB,
        .type = GL_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -959,7 +981,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA32F,
+        .internal_gl_format = GL_RGBA32F,
+        .internal_gles_format = GL_RGBA32F,
        .format = GL_RGBA,
        .type = GL_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -987,7 +1010,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RGBA32F,
+        .internal_gl_format = GL_RGBA32F,
+        .internal_gles_format = GL_RGBA32F,
        .format = GL_RGBA,
        .type = GL_FLOAT,
        .swizzle = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA },
@@ -1014,7 +1038,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RG8,
+        .internal_gl_format = GL_RG8,
+        .internal_gles_format = GL_RG8,
        .format = GL_RG,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_GREEN },
@@ -1041,7 +1066,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RG8,
+        .internal_gl_format = GL_RG8,
+        .internal_gles_format = GL_RG8,
        .format = GL_RG,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_GREEN },
@@ -1068,7 +1094,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R8,
+        .internal_gl_format = GL_R8,
+        .internal_gles_format = GL_R8,
        .format = GL_RED,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_ONE },
@@ -1098,7 +1125,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RG16,
+        .internal_gl_format = GL_RG16,
+        .internal_gles_format = GL_RG16,
        .format = GL_RG,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_GREEN },
@@ -1128,7 +1156,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_RG16,
+        .internal_gl_format = GL_RG16,
+        .internal_gles_format = GL_RG16,
        .format = GL_RG,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_GREEN },
@@ -1158,7 +1187,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R16,
+        .internal_gl_format = GL_R16,
+        .internal_gles_format = GL_R16,
        .format = GL_RED,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_ONE },
@@ -1185,7 +1215,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R8,
+        .internal_gl_format = GL_R8,
+        .internal_gles_format = GL_R8,
        .format = GL_RED,
        .type = GL_UNSIGNED_BYTE,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_RED },
@@ -1215,7 +1246,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R16,
+        .internal_gl_format = GL_R16,
+        .internal_gles_format = GL_R16,
        .format = GL_RED,
        .type = GL_UNSIGNED_SHORT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_RED },
@@ -1244,7 +1276,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R16F,
+        .internal_gl_format = GL_R16F,
+        .internal_gles_format = GL_R16F,
        .format = GL_RED,
        .type = GL_HALF_FLOAT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_RED },
@@ -1273,7 +1306,8 @@ static const GdkMemoryFormatDescription memory_formats[] = {
        -1,
    },
    .gl = {
-        .internal_format = GL_R32F,
+        .internal_gl_format = GL_R32F,
+        .internal_gles_format = GL_R32F,
        .format = GL_RED,
        .type = GL_FLOAT,
        .swizzle = { GL_RED, GL_RED, GL_RED, GL_RED },
@@ -1387,7 +1421,7 @@ gdk_memory_format_get_depth (GdkMemoryFormat format)
 * @depth1: the first depth
 * @depth2: the second depth
 *
- * Returns a depth that can accomodate both given depths
+ * Returns a depth that can accommodate both given depths
 * without any loss of precision.
 *
 * Returns: The merged depth
@@ -1473,12 +1507,16 @@ gdk_memory_depth_get_alpha_format (GdkMemoryDepth depth)

 void
 gdk_memory_format_gl_format (GdkMemoryFormat  format,
+                             gboolean         gles,
                             GLint           *out_internal_format,
                             GLenum          *out_format,
                             GLenum          *out_type,
                             GLint            out_swizzle[4])
 {
-  *out_internal_format = memory_formats[format].gl.internal_format;
+  if (gles)
+    *out_internal_format = memory_formats[format].gl.internal_gles_format;
+  else
+    *out_internal_format = memory_formats[format].gl.internal_gl_format;
  *out_format = memory_formats[format].gl.format;
  *out_type = memory_formats[format].gl.type;
  memcpy (out_swizzle, memory_formats[format].gl.swizzle, sizeof(GLint) * 4);
@@ -1487,6 +1525,7 @@ gdk_memory_format_gl_format (GdkMemoryFormat  format,
 /*
 * gdk_memory_format_gl_rgba_format:
 * @format: The format to query
+ * @gles: TRUE for GLES, FALSE for GL
 * @out_actual_format: The actual RGBA format
 * @out_internal_format: the GL internal format
 * @out_format: the GL format
@@ -1504,6 +1543,7 @@ gdk_memory_format_gl_format (GdkMemoryFormat  format,
 **/
 gboolean
 gdk_memory_format_gl_rgba_format (GdkMemoryFormat  format,
+                                  gboolean         gles,
                                  GdkMemoryFormat *out_actual_format,
                                  GLint           *out_internal_format,
                                  GLenum          *out_format,
@@ -1516,7 +1556,10 @@ gdk_memory_format_gl_rgba_format (GdkMemoryFormat  format,
    return FALSE;

  *out_actual_format = actual;
-  *out_internal_format = memory_formats[actual].gl.internal_format;
+  if (gles)
+    *out_internal_format = memory_formats[actual].gl.internal_gles_format;
+  else
+    *out_internal_format = memory_formats[actual].gl.internal_gl_format;
  *out_format = memory_formats[actual].gl.format;
  *out_type = memory_formats[actual].gl.type;
  memcpy (out_swizzle, memory_formats[format].gl.rgba_swizzle, sizeof(GLint) * 4);
@@ -55,11 +55,13 @@ GdkMemoryDepth          gdk_memory_depth_merge              (GdkMemoryDepth
 GdkMemoryFormat         gdk_memory_depth_get_format         (GdkMemoryDepth              depth) G_GNUC_CONST;
 GdkMemoryFormat         gdk_memory_depth_get_alpha_format   (GdkMemoryDepth              depth) G_GNUC_CONST;
 void                    gdk_memory_format_gl_format         (GdkMemoryFormat             format,
+                                                             gboolean                    gles,
                                                             GLint                      *out_internal_format,
                                                             GLenum                     *out_format,
                                                             GLenum                     *out_type,
                                                             GLint                       out_swizzle[4]);
 gboolean                gdk_memory_format_gl_rgba_format    (GdkMemoryFormat             format,
+                                                             gboolean                    gles,
                                                             GdkMemoryFormat            *out_actual_format,
                                                             GLint                      *out_internal_format,
                                                             GLenum                     *out_format,
@@ -32,6 +32,7 @@
 #include "version/gdkversionmacros.h"
 #include "gdkframeclockprivate.h"

+#define CATEGORY "GTK"

 gboolean
 gdk_profiler_is_running (void)
@@ -50,7 +51,7 @@ void
                         const char *message)
 {
 #ifdef HAVE_SYSPROF
-  sysprof_collector_mark (begin_time, duration, "gtk", name, message);
+  sysprof_collector_mark (begin_time, duration, CATEGORY, name, message);
 #endif
 }

@@ -60,7 +61,7 @@ void
                         const char *message)
 {
 #ifdef HAVE_SYSPROF
-  sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message);
+  sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, CATEGORY, name, message);
 #endif
 }

@@ -74,7 +75,7 @@ void
 #ifdef HAVE_SYSPROF
  va_list args;
  va_start (args, message_format);
-  sysprof_collector_mark_vprintf (begin_time, duration, "gtk", name, message_format, args);
+  sysprof_collector_mark_vprintf (begin_time, duration, CATEGORY, name, message_format, args);
  va_end (args);
 #endif  /* HAVE_SYSPROF */
 }
@@ -88,7 +89,7 @@ void
 #ifdef HAVE_SYSPROF
  va_list args;
  va_start (args, message_format);
-  sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message_format, args);
+  sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, CATEGORY, name, message_format, args);
  va_end (args);
 #endif  /* HAVE_SYSPROF */
 }
@@ -103,7 +104,7 @@ guint
  counter.id = sysprof_collector_request_counters (1);
  counter.type = SYSPROF_CAPTURE_COUNTER_DOUBLE;
  counter.value.vdbl = 0.0;
-  g_strlcpy (counter.category, "gtk", sizeof counter.category);
+  g_strlcpy (counter.category, CATEGORY, sizeof counter.category);
  g_strlcpy (counter.name, name, sizeof counter.name);
  g_strlcpy (counter.description, description, sizeof counter.name);

@@ -125,7 +126,7 @@ guint
  counter.id = sysprof_collector_request_counters (1);
  counter.type = SYSPROF_CAPTURE_COUNTER_INT64;
  counter.value.v64 = 0;
-  g_strlcpy (counter.category, "gtk", sizeof counter.category);
+  g_strlcpy (counter.category, CATEGORY, sizeof counter.category);
  g_strlcpy (counter.name, name, sizeof counter.name);
  g_strlcpy (counter.description, description, sizeof counter.name);

@@ -2839,7 +2839,7 @@ add_event_mark (GdkEvent *event,
  class = g_type_class_ref (GDK_TYPE_EVENT_TYPE);
  value = g_enum_get_value (class, event_type);
  g_type_class_unref (class);
-  kind = value ? value->value_nick : "event";
+  kind = value ? value->value_nick : "Event";

  switch ((int) event_type)
    {
@@ -2909,7 +2909,7 @@ add_event_mark (GdkEvent *event,
      break;
    }

-  gdk_profiler_add_mark (time, end_time - time, "event", message ? message : kind);
+  gdk_profiler_add_mark (time, end_time - time, "Event", message ? message : kind);

  g_free (message);
 #endif
@@ -870,7 +870,7 @@ gdk_texture_download_surface (GdkTexture *texture)
 * cairo_surface_mark_dirty (surface);
 * ```
 *
- * For more flexible download capabilites, see
+ * For more flexible download capabilities, see
 * [struct@Gdk.TextureDownloader].
 */
 void
@@ -22,7 +22,7 @@
 * [class@Gdk.Texture].
 *
 * It is intended to be created as a short-term object for a single download,
- * but can be used for multipe downloads of different textures or with different
+ * but can be used for multiple downloads of different textures or with different
 * settings.
 *
 * `GdkTextureDownloader` can be used to convert data between different formats.
@@ -37,7 +37,7 @@ static const GdkDebugKey gsk_vulkan_feature_keys[] = {
  { "dmabuf", GDK_VULKAN_FEATURE_DMABUF, "Never import Dmabufs" },
  { "ycbcr", GDK_VULKAN_FEATURE_YCBCR, "Do not support Ycbcr textures" },
  { "descriptor-indexing", GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING, "Force slow descriptor set layout codepath" },
-  { "dynamic-indexing", GDK_VULKAN_FEATURE_DYNAMIC_INDEXING, "Hardcode small number of buffer and texure arrays" },
+  { "dynamic-indexing", GDK_VULKAN_FEATURE_DYNAMIC_INDEXING, "Hardcode small number of buffer and texture arrays" },
  { "nonuniform-indexing", GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING, "Split draw calls to ensure uniform texture accesses" },
  { "semaphore-export", GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT, "Disable sync of exported dmabufs" },
  { "semaphore-import", GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT, "Disable sync of imported dmabufs" },
@@ -237,7 +237,7 @@ gdk_load_jpeg (GBytes  *input_bytes,

  g_bytes_unref (bytes);

-  gdk_profiler_end_mark (before, "jpeg load", NULL);
+  gdk_profiler_end_mark (before, "Load jpeg", NULL);
 
  return texture;
 }
@@ -304,7 +304,7 @@ gdk_load_png (GBytes  *bytes,
    {
      gint64 end = GDK_PROFILER_CURRENT_TIME;
      if (end - before > 500000)
-        gdk_profiler_add_mark (before, end - before, "png load", NULL);
+        gdk_profiler_add_mark (before, end - before, "Load png", NULL);
    }

  return texture;
@@ -504,7 +504,7 @@ gdk_load_tiff (GBytes  *input_bytes,
    {
      gint64 end = GDK_PROFILER_CURRENT_TIME;
      if (end - before > 500000)
-        gdk_profiler_add_mark (before, end - before, "tiff load", NULL);
+        gdk_profiler_add_mark (before, end - before, "Load tiff", NULL);
    }

  return texture;
@@ -188,7 +188,7 @@ _edge_snapping_motion (EdgeSnapping   *self,
        edge_snapping_constrain_horizontal (self, change.x, &self->geometry, &new_window);
    }

-  /* Now constrain veritcally */
+  /* Now constrain vertically */
  if (change.y)
    {
      edge_snapping_constrain_vertical (self, change.y, &self->workarea, &new_window, FALSE);
@@ -170,7 +170,7 @@ static int getting_events = 0;
 ************************************************************/

 /* The states in our state machine, see comments in select_thread_func()
- * for descriptiions of each state
+ * for descriptions of each state
 */
 typedef enum {
  BEFORE_START,
@@ -598,7 +598,7 @@ gdk_macos_gl_context_make_current (GdkGLContext *context,
       * are submitted.
       *
       * TODO: investigate if we need this because we may switch contexts
-       *       durring composition and only need it when returning to a
+       *       during composition and only need it when returning to a
       *       previous context that uses the other context.
       */
      if (current != NULL)
@@ -186,7 +186,7 @@ gdk_wayland_cairo_context_end_frame (GdkDrawContext *draw_context,
  gdk_wayland_surface_attach_image (surface, self->paint_surface, painted);
  gdk_wayland_surface_request_frame (surface);

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
  gdk_wayland_surface_commit (surface);
  gdk_wayland_surface_notify_committed (surface);

@@ -206,7 +206,7 @@ gdk_wayland_cairo_context_empty_frame (GdkDrawContext *draw_context)
  gdk_wayland_surface_sync (surface);
  gdk_wayland_surface_request_frame (surface);

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
  gdk_wayland_surface_commit (surface);
  gdk_wayland_surface_notify_committed (surface);
 }
@@ -194,7 +194,7 @@ _gdk_wayland_cursor_get_buffer (GdkWaylandDisplay *display,
          if ((image->width % cursor_scale != 0) ||
              (image->height % cursor_scale != 0))
            {
-              g_warning (G_STRLOC " cursor image size (%dx%d) not an integer"
+              g_warning (G_STRLOC " cursor image size (%dx%d) not an integer "
                         "multiple of scale (%d)", image->width, image->height,
                         cursor_scale);
              cursor_scale = 1;
@@ -1253,7 +1253,7 @@ _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *display_wayland)
  gdk_wayland_display_set_cursor_theme (GDK_DISPLAY (display_wayland), name, size);
  g_value_unset (&v);

-  gdk_profiler_end_mark (before, "wayland", "load cursor theme");
+  gdk_profiler_end_mark (before, "Wayland cursor theme load", NULL);

 }

@@ -1796,6 +1796,7 @@ static TranslationEntry translations[] = {
  { FALSE, "org.gnome.desktop.wm.preferences", "action-right-click-titlebar", "gtk-titlebar-right-click", G_TYPE_STRING, { .s = "menu" } },
  { FALSE, "org.gnome.desktop.a11y", "always-show-text-caret", "gtk-keynav-use-caret", G_TYPE_BOOLEAN, { .b = FALSE } },
  { FALSE, "org.gnome.desktop.a11y.interface", "high-contrast", "high-contast", G_TYPE_NONE, { .b = FALSE } },
+  { FALSE, "org.gnome.desktop.a11y.interface", "show-status-shapes", "gtk-show-status-shapes", G_TYPE_BOOLEAN, { .b = FALSE } },
  /* Note, this setting doesn't exist, the portal and gsd fake it */
  { FALSE, "org.gnome.fontconfig", "serial", "gtk-fontconfig-timestamp", G_TYPE_NONE, { .i = 0 } },
 };
@@ -1845,13 +1846,6 @@ find_translation_entry_by_setting (const char *setting)
  return NULL;
 }

-static void
-high_contrast_changed (GdkDisplay *display)
-{
-  gdk_display_setting_changed (display, "gtk-theme-name");
-  gdk_display_setting_changed (display, "gtk-icon-theme-name");
-}
-
 static void
 settings_changed (GSettings  *settings,
                  const char *key,
@@ -1866,7 +1860,7 @@ settings_changed (GSettings  *settings,
      if (entry->type != G_TYPE_NONE)
        gdk_display_setting_changed (display, entry->setting);
      else if (strcmp (key, "high-contrast") == 0)
-        high_contrast_changed (display);
+        gdk_display_setting_changed (display, "gtk-theme-name");
      else
        update_xft_settings (display);
    }
@@ -1012,7 +1012,7 @@ gdk_wayland_surface_create_xdg_popup (GdkWaylandPopup *wayland_popup,
        }
    }

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
  wl_surface_commit (impl->display_server.wl_surface);

  if (GDK_IS_POPUP (surface))
@@ -2859,6 +2859,7 @@ tablet_tool_handle_proximity_out (void                      *data,

  gdk_device_update_tool (tablet->stylus_device, NULL);
  g_clear_object (&tablet->pointer_info.cursor);
+  tablet->pointer_info.cursor_is_default = FALSE;
 }

 static double *
@@ -274,7 +274,7 @@ gdk_wayland_surface_frame_callback (GdkSurface *surface,
  GdkFrameClock *clock = gdk_surface_get_frame_clock (surface);
  GdkFrameTimings *timings;

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "frame event");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland frame event", NULL);
  GDK_DISPLAY_DEBUG (GDK_DISPLAY (display_wayland), EVENTS, "frame %p", surface);

  g_clear_pointer (&impl->frame_callback, wl_callback_destroy);
@@ -830,7 +830,7 @@ gdk_wayland_surface_create_xdg_toplevel (GdkWaylandToplevel *wayland_toplevel)
  maybe_set_gtk_surface_dbus_properties (wayland_toplevel);
  maybe_set_gtk_surface_modal (wayland_toplevel);

-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
  wl_surface_commit (wayland_surface->display_server.wl_surface);
 }

@@ -1973,8 +1973,10 @@ gdk_wayland_toplevel_titlebar_gesture (GdkToplevel        *toplevel,
    return FALSE;

  seat = gdk_display_get_default_seat (surface->display);
-  wl_seat = gdk_wayland_seat_get_wl_seat (seat);
+  if (!seat)
+    return FALSE;

+  wl_seat = gdk_wayland_seat_get_wl_seat (seat);
  serial = _gdk_wayland_seat_get_last_implicit_grab_serial (GDK_WAYLAND_SEAT (seat), NULL);

  gtk_surface1_titlebar_gesture (wayland_toplevel->display_server.gtk_surface,
@@ -2155,15 +2157,14 @@ gdk_wayland_toplevel_focus (GdkToplevel *toplevel,
  GdkWaylandSurface *wayland_surface = GDK_WAYLAND_SURFACE (toplevel);
  GdkDisplay *display = gdk_surface_get_display (surface);
  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
+  GdkWaylandSeat *seat =
+    GDK_WAYLAND_SEAT (gdk_display_get_default_seat (display));
  gchar *startup_id = NULL;

  startup_id = g_steal_pointer (&display_wayland->startup_notification_id);

-  if (display_wayland->xdg_activation)
+  if (seat && display_wayland->xdg_activation)
    {
-      GdkWaylandSeat *seat =
-        GDK_WAYLAND_SEAT (gdk_display_get_default_seat (display));
-
      /* If the focus request does not have a startup ID associated, get a
       * new token to activate the window.
       */
@@ -28,7 +28,7 @@ GTK has two clipboards - normal clipboard and primary clipboard
 Primary clipboard is only handled
 internally by GTK (it's not portable to Windows).

-("C:" means clipboard client (requestor), "S:" means clipboard server (provider))
+("C:" means clipboard client (requester), "S:" means clipboard server (provider))
 ("transmute" here means "change the format of some data"; this term is used here
 instead of "convert" to avoid clashing with the old g(t|d)k_selection_convert() APIs,
 which are completely unrelated)
@@ -1356,7 +1356,7 @@ inner_clipboard_window_procedure (HWND   hwnd,
        else if (returned_render->main_thread_data_handle)
          {
            BOOL set_data_succeeded;
-            /* The requestor is holding the clipboard, no
+            /* The requester is holding the clipboard, no
             * OpenClipboard() is required/possible
             */
            GDK_NOTE (DND,
@@ -3029,7 +3029,7 @@ gdk_event_translate (MSG *msg,
 	    unset_bits |= GDK_TOPLEVEL_STATE_MAXIMIZED;

      /*
-       * If we are minizing, pause all surface layout computations, and re-start the
+       * If we are minimizing, pause all surface layout computations, and re-start the
       * computation once we are coming out of a minimized state
       */
      if (!(old_state & GDK_TOPLEVEL_STATE_MINIMIZED) && set_bits & GDK_TOPLEVEL_STATE_MINIMIZED)
@@ -3045,7 +3045,7 @@ gdk_event_translate (MSG *msg,

 	  /* Whenever one window changes iconified state we need to also
 	   * change the iconified state in all transient related windows,
-	   * as windows doesn't give icons for transient childrens.
+	   * as windows doesn't give icons for transient children.
 	   */
 	  if ((old_state & GDK_TOPLEVEL_STATE_MINIMIZED) !=
 	      (new_state & GDK_TOPLEVEL_STATE_MINIMIZED))
@@ -211,7 +211,7 @@ struct _GdkW32DragMoveResizeContext
  gboolean           revealed;

  /* Arrays of GdkRectangle pairs, describing the areas of the virtual
-   * desktop that trigger various AeroSnap window transofrmations
+   * desktop that trigger various AeroSnap window transformations
   * Coordinates are GDK screen coordinates.
   */
  GArray            *halfleft_regions;
@@ -39,6 +39,7 @@ static const struct {
  {"Gtk/CursorThemeSize",     "gtk-cursor-theme-size"},
  {"Gtk/ColorScheme",         "gtk-color-scheme"},
  {"Gtk/EnableAnimations",    "gtk-enable-animations"},
+  {"Gtk/ShowStatusStates",    "gtk-show-status-shapes"},
  {"Xft/Antialias",           "gtk-xft-antialias"},
  {"Xft/Hinting",             "gtk-xft-hinting"},
  {"Xft/HintStyle",           "gtk-xft-hintstyle"},
@@ -0,0 +1,479 @@
+#pragma once
+
+#include <graphene.h>
+#include <math.h>
+#include "gsktypesprivate.h"
+#include "scaleprivate.h"
+#include "pointprivate.h"
+
+#ifndef USE_SIMD
+
+struct _Box
+{
+  float x0, y0, x1, y1;
+};
+
+static inline float
+box_x0 (const Box box)
+{
+  return box.x0;
+}
+
+static inline float
+box_y0 (const Box box)
+{
+  return box.y0;
+}
+
+static inline float
+box_x1 (const Box box)
+{
+  return box.x1;
+}
+
+static inline float
+box_y1 (const Box box)
+{
+  return box.y1;
+}
+
+static inline float
+box_width (const Box box)
+{
+  return box.x1 - box.x0;
+}
+
+static inline float
+box_height (const Box box)
+{
+  return box.y1 - box.y0;
+}
+
+/* Assumes x0 <= x1 && y0 <= y1 */
+static inline Box
+box (float x0,
+     float y0,
+     float x1,
+     float y1)
+{
+  return (Box) { .x0 = x0, .y0 = y0, .x1 = x1, .y1 = y1 };
+}
+
+static inline Box
+box_from_rect (float x,
+               float y,
+               float w,
+               float h)
+{
+  return box (x, y, x + w, y + h);
+}
+
+static inline Box
+box_from_graphene (const graphene_rect_t *rect)
+{
+  return box_from_rect (rect->origin.x,
+                        rect->origin.y,
+                        rect->size.width,
+                        rect->size.height);
+}
+
+/* Assumes p0.x <= p1.x && p0.y <= p1.y */
+static inline Box
+box_from_points (Point p0,
+                 Point p1)
+{
+  return box (p0.x, p0.y, p1.x, p1.y);
+}
+
+static inline Point
+box_origin (const Box box)
+{
+  return point (box.x0, box.y0);
+}
+
+static inline Point
+box_opposite (const Box box)
+{
+  return point (box.x1, box.y1);
+}
+
+static inline void
+box_to_float (const Box box,
+              float     v[4])
+{
+  v[0] = box.x0;
+  v[1] = box.y0;
+  v[2] = box.x1 - box.x0;
+  v[3] = box.y1 - box.y0;
+}
+
+static inline Box
+box_inset (const Box box,
+           float     dx,
+           float     dy)
+{
+  return (Box) { .x0 = box.x0 + dx, .y0 = box.y0 + dy,
+                 .x1 = box.x1 - dx, .y1 = box.y1 - dy };
+}
+
+static inline gboolean
+box_intersect (const Box  box1,
+               const Box  box2,
+               Box       *box)
+{
+  Box b;
+
+  b.x0 = MAX (box1.x0, box2.x0);
+  b.y0 = MAX (box1.y0, box2.y0);
+  b.x1 = MIN (box1.x1, box2.x1);
+  b.y1 = MIN (box1.y1, box2.y1);
+
+  if (b.x0 <= b.x1 && b.y0 <= b.x1)
+    {
+      if (box)
+        *box = b;
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static inline gboolean
+box_equal (const Box box1,
+           const Box box2)
+{
+  return memcmp (&box1, &box2, sizeof (Box)) == 0;
+}
+
+static inline gboolean
+box_contains (const Box box1,
+              const Box box2)
+{
+  Box box;
+
+  if (box_intersect (box1, box2, &box))
+    return box_equal (box, box2);
+
+  return FALSE;
+}
+
+static inline gboolean
+box_empty (const Box box)
+{
+  return box.x0 == box.x1 || box.y0 == box.y1;
+}
+
+static inline Box
+box_add (const Box   box,
+         const Point offset)
+{
+  return (Box) { .x0 = box.x0 + offset.x, .y0 = box.y0 + offset.y,
+                 .x1 = box.x1 + offset.x, .y1 = box.y1 + offset.y };
+}
+
+static inline Box
+box_sub (const Box   box,
+         const Point offset)
+{
+  return (Box) { .x0 = box.x0 - offset.x, .y0 = box.y0 - offset.y,
+                 .x1 = box.x1 - offset.x, .y1 = box.y1 - offset.y };
+}
+
+static inline Box
+box_mul (const Box   box,
+         const Scale scale)
+{
+  Box b = (Box) { .x0 = box.x0 * scale.x, .y0 = box.y0 * scale.y,
+                  .x1 = box.x1 * scale.x, .y1 = box.y1 * scale.y };
+
+  if (G_UNLIKELY (scale.x < 0 || scale.y < 0))
+    return (Box) { .x0 = MIN (b.x0, b.x1), .y0 = MIN (b.y0, b.y1),
+                   .x1 = MAX (b.x0, b.x1), .y1 = MAX (b.y0, b.y1) };
+
+  return b;
+}
+
+static inline Box
+box_div (const Box   box,
+         const Scale scale)
+{
+  return box_mul (box, scale_inv (scale));
+}
+
+static inline void
+box_offset_to_float (const Box   box,
+                     const Point offset,
+                     float       v[4])
+{
+  box_to_float (box_add (box, offset), v);
+}
+
+static inline Box
+box_round_larger (const Box box)
+{
+  return (Box) { .x0 = floorf (box.x0), .y0 = floorf (box.y0),
+                 .x1 = ceilf (box.x1), .y1 = ceilf (box.y1) };
+}
+
+static inline Box
+box_round_to_pixels (const Box   box,
+                     const Scale scale,
+                     const Point offset)
+{
+  return box_sub (box_div (box_round_larger (box_mul (box_add (box, offset), scale)), scale), offset);
+}
+
+#else  /* USE_SIMD */
+
+struct _Box
+{
+  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
+};
+
+static inline float
+box_x0 (const Box box)
+{
+  return graphene_simd4f_get_x (box.v);
+}
+
+static inline float
+box_y0 (const Box box)
+{
+  return graphene_simd4f_get_y (box.v);
+}
+
+static inline float
+box_x1 (const Box box)
+{
+  return graphene_simd4f_get_z (box.v);
+}
+
+static inline float
+box_y1 (const Box box)
+{
+  return graphene_simd4f_get_w (box.v);
+}
+
+static inline float
+box_width (const Box box)
+{
+  return box_x1 (box) - box_x0 (box);
+}
+
+static inline float
+box_height (const Box box)
+{
+  return box_y1 (box) - box_y0 (box);
+}
+
+static inline Box
+box (float x0,
+     float y0,
+     float x1,
+     float y1)
+{
+  return (Box) { .v = graphene_simd4f_init (x0, y0, x1, y1) };
+}
+
+static inline Box
+box_from_rect (float x,
+               float y,
+               float w,
+               float h)
+{
+  return box (x, y, x + w, y + h);
+}
+
+static inline Box
+box_from_graphene (const graphene_rect_t *rect)
+{
+  return box_from_rect (rect->origin.x,
+                        rect->origin.y,
+                        rect->size.width,
+                        rect->size.height);
+}
+
+/* { a[0], a[1], b[0], b[1] }  */
+#  define graphene_simd4f_splat_xyxy(a,b) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_shuffle_ps ((a), (b), _MM_SHUFFLE (1, 0, 1, 0)); \
+  }))
+
+static inline Box
+box_from_points (Point p0,
+                 Point p1)
+{
+  return (Box) { .v = graphene_simd4f_splat_xyxy (p0.v, p1.v) };
+}
+
+static inline Point
+box_origin (const Box box)
+{
+  return (Point) { .v = graphene_simd4f_zero_zw (box.v) };
+}
+
+static inline Point
+box_opposite (const Box box)
+{
+  return (Point) { .v = graphene_simd4f_zero_zw (graphene_simd4f_shuffle_zwxy (box.v)) };
+}
+
+static inline void
+box_to_float (const Box box,
+              float     v[4])
+{
+  graphene_simd4f_dup_4f (box.v, v);
+  v[2] -= v[0];
+  v[3] -= v[1];
+}
+
+static inline Box
+box_inset (const Box box,
+           float     dx,
+           float     dy)
+{
+  return (Box) { .v = graphene_simd4f_add (box.v, graphene_simd4f_init (dx, dy, -dx, -dy)) };
+}
+
+/* return  a[0] < b[0] && a[1] < b[1] */
+#ifndef graphene_simd4f_cmple_xy
+#  define graphene_simd4f_cmple_xy(a,b) \
+  (__extension__ ({ \
+    __m128i __res = (__m128i) _mm_cmple_ps ((a), (b)); \
+    (bool) ((_mm_movemask_epi8 (__res) & 0xff) == 0xff); \
+  }))
+#endif
+
+static inline gboolean
+box_intersect (const Box  box1,
+               const Box  box2,
+               Box       *box)
+{
+  graphene_simd4f_t s, t, t1;
+
+  s = graphene_simd4f_max (box1.v, box2.v);
+  t = graphene_simd4f_min (box1.v, box2.v);
+  t1 = graphene_simd4f_shuffle_zwxy (t);
+
+  if (graphene_simd4f_cmple_xy (s, t1))
+    {
+      if (box)
+        box->v = graphene_simd4f_splat_xyxy (s, t);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static inline gboolean
+box_equal (const Box box1,
+           const Box box2)
+{
+  return (gboolean) !!graphene_simd4f_cmp_eq (box1.v, box2.v);
+}
+
+static inline gboolean
+box_contains (const Box box1,
+              const Box box2)
+{
+  Box box;
+
+  if (box_intersect (box1, box2, &box))
+    return box_equal (box, box2);
+
+  return FALSE;
+}
+
+static inline gboolean
+box_empty (const Box box)
+{
+  /* FIXME simd */
+  return box_x0 (box) == box_x1 (box) || box_y0 (box) == box_y1 (box);
+}
+
+/* a splat variation */
+#ifndef graphene_simd4f_shuffle_xyxy
+#  define graphene_simd4f_shuffle_xyxy(v) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_shuffle_ps ((v), (v), _MM_SHUFFLE (1, 0, 1, 0)); \
+  }))
+#endif
+
+static inline Box
+box_add (const Box   box,
+         const Point offset)
+{
+  return (Box) { .v = graphene_simd4f_add (box.v, graphene_simd4f_shuffle_xyxy (offset.v)) };
+}
+
+static inline Box
+box_sub (const Box   box,
+         const Point offset)
+{
+  return (Box) { .v = graphene_simd4f_sub (box.v, graphene_simd4f_shuffle_xyxy (offset.v)) };
+}
+
+static inline Box
+box_mul (const Box   box,
+         const Scale scale)
+{
+  Box b =  (Box) { .v = graphene_simd4f_mul (box.v, graphene_simd4f_shuffle_xyxy (scale.v)) };
+
+  if (G_UNLIKELY (!graphene_simd4f_cmple_xy (graphene_simd4f_init (0, 0, 0, 0), scale.v)))
+    {
+      graphene_simd4f_t v = graphene_simd4f_shuffle_zwxy (b.v);
+      graphene_simd4f_t s = graphene_simd4f_min (b.v, v);
+      graphene_simd4f_t t = graphene_simd4f_max (b.v, v);
+
+      return (Box) { .v = graphene_simd4f_splat_xyxy (s, t) };
+    }
+
+  return b;
+}
+
+static inline Box
+box_div (const Box   box,
+         const Scale scale)
+{
+  return box_mul (box, scale_inv (scale));
+}
+
+static inline void
+box_offset_to_float (const Box   box,
+                     const Point offset,
+                     float       v[4])
+{
+  box_to_float (box_add (box, offset), v);
+}
+
+#ifdef __SSE4_1__
+
+static inline Box
+box_round_larger (const Box box)
+{
+  return { (Box) .v = graphene_simd4f_splat_xyxy (graphene_simd4f_floor (b.v), graphene_simd4f_ceil (b.v)) };
+}
+
+#else
+
+static inline Box
+box_round_larger (const Box b)
+{
+  return box (floorf (box_x0 (b)),
+              floorf (box_y0 (b)),
+              ceilf (box_x1 (b)),
+              ceilf (box_y1 (b)));
+}
+
+#endif
+
+static inline Box
+box_round_to_pixels (const Box   box,
+                     const Scale scale,
+                     const Point offset)
+{
+  return box_sub (box_div (box_round_larger (box_mul (box_add (box, offset), scale)), scale), offset);
+}
+
+#endif
@@ -1504,6 +1504,7 @@ memory_format_gl_format (GskGLCommandQueue *self,
  if ((flags & required_flags) == required_flags)
    {
      gdk_memory_format_gl_format (data_format,
+                                   gdk_gl_context_get_use_es (self->context),
                                   gl_internalformat,
                                   gl_format,
                                   gl_type,
@@ -1514,6 +1515,7 @@ memory_format_gl_format (GskGLCommandQueue *self,

  /* Second, try the potential RGBA format */
  if (gdk_memory_format_gl_rgba_format (data_format,
+                                        gdk_gl_context_get_use_es (self->context),
                                        &alt_format,
                                        gl_internalformat,
                                        gl_format,
@@ -1529,6 +1531,7 @@ memory_format_gl_format (GskGLCommandQueue *self,
            return data_format;

          gdk_memory_format_gl_format (alt_format,
+                                       gdk_gl_context_get_use_es (self->context),
                                       gl_internalformat,
                                       gl_format,
                                       gl_type,
@@ -1546,6 +1549,7 @@ memory_format_gl_format (GskGLCommandQueue *self,
      if (((flags & required_flags) == required_flags))
        {
          gdk_memory_format_gl_format (fallbacks[i],
+                                       gdk_gl_context_get_use_es (self->context),
                                       gl_internalformat,
                                       gl_format,
                                       gl_type,
@@ -1604,8 +1608,8 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,

  if (gdk_profiler_is_running ())
    {
-      gdk_profiler_add_markf (start_time, GDK_PROFILER_CURRENT_TIME-start_time,
-                              "Download Texture chunk",
+      gdk_profiler_end_markf (start_time,
+                              "Download texture chunk",
                              "Tile %dx%d Size %dx%d", x, y, width, height);
      start_time = GDK_PROFILER_CURRENT_TIME;
    }
@@ -1650,8 +1654,8 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
  g_bytes_unref (bytes);

  if (gdk_profiler_is_running ())
-    gdk_profiler_add_markf (start_time, GDK_PROFILER_CURRENT_TIME-start_time,
-                            "Upload Texture chunk",
+    gdk_profiler_end_markf (start_time,
+                            "Upload texture chunk",
                            "Tile %dx%d Size %dx%d", x, y, width, height);
 }

@@ -424,7 +424,7 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
 failure:
  g_clear_object (&compiler);

-  gdk_profiler_end_mark (start_time, "load programs", NULL);
+  gdk_profiler_end_mark (start_time, "Load GL programs", NULL);

  return ret;
 }
@@ -477,7 +477,7 @@ gsk_gl_driver_new (GskGLCommandQueue  *command_queue,
  self->icons_library = gsk_gl_icon_library_new (self);
  self->shadows_library = gsk_gl_shadow_library_new (self);

-  gdk_profiler_end_mark (before, "create GskGLDriver", NULL);
+  gdk_profiler_end_mark (before, "Create GL driver", NULL);

  return g_steal_pointer (&self);
 }
@@ -1236,7 +1236,7 @@ gsk_gl_driver_release_render_target (GskGLDriver       *self,
 * @shader: the shader to lookup or load
 * @error: a location for a `GError`
 *
- * Attepts to load @shader from the shader cache.
+ * Attempts to load @shader from the shader cache.
 *
 * If it has not been loaded, then it will compile the shader on demand.
 *
@@ -119,11 +119,7 @@ gsk_gl_glyph_library_init_atlas (GskGLTextureLibrary *self,

  memset (pixel_data, 255, sizeof pixel_data);

-  if (!gdk_gl_context_has_bgra (gdk_gl_context_get_current ())
-#if G_BYTE_ORDER == G_BIG_ENDIAN
-      || gdk_gl_context_get_use_es (gdk_gl_context_get_current ())
-#endif
-     )
+  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
    {
      gl_format = GL_RGBA;
      gl_type = GL_UNSIGNED_BYTE;
@@ -380,7 +376,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary     *self,
    {
      char message[64];
      g_snprintf (message, sizeof message, "Size %dx%d", width, height);
-      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload Glyph", message);
+      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload glyph", message);
    }
 }

@@ -211,6 +211,6 @@ gsk_gl_icon_library_add (GskGLIconLibrary     *self,
    {
      char message[64];
      g_snprintf (message, sizeof message, "Size %dx%d", width, height);
-      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload Icon", message);
+      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload icon", message);
    }
 }
@@ -830,8 +830,8 @@ rounded_rect_scale_corners (const GskRoundedRect *rect,
 {
  for (guint i = 0; i < G_N_ELEMENTS (out_rect->corner); i++)
    {
-      out_rect->corner[i].width = rect->corner[i].width * fabs (scale_x);
-      out_rect->corner[i].height = rect->corner[i].height * fabs (scale_y);
+      out_rect->corner[i].width = rect->corner[i].width * fabsf (scale_x);
+      out_rect->corner[i].height = rect->corner[i].height * fabsf (scale_y);
    }

  if (scale_x < 0)
@@ -1173,8 +1173,8 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
 {
  float scale_x = job->scale_x;
  float scale_y = job->scale_y;
-  int surface_width = ceilf (node->bounds.size.width * fabs (scale_x));
-  int surface_height = ceilf (node->bounds.size.height * fabs (scale_y));
+  int surface_width = ceilf (node->bounds.size.width * fabsf (scale_x));
+  int surface_height = ceilf (node->bounds.size.height * fabsf (scale_y));
  GdkTexture *texture;
  cairo_surface_t *surface;
  cairo_surface_t *rendered_surface;
@@ -1203,11 +1203,11 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
                                                   surface_width,
                                                   surface_height);

-    cairo_surface_set_device_scale (rendered_surface, fabs (scale_x), fabs (scale_y));
+    cairo_surface_set_device_scale (rendered_surface, fabsf (scale_x), fabsf (scale_y));
    cr = cairo_create (rendered_surface);

    cairo_save (cr);
-    cairo_translate (cr, - floorf (node->bounds.origin.x), - floorf (node->bounds.origin.y));
+    cairo_translate (cr, - node->bounds.origin.x, - node->bounds.origin.y);
    /* Render nodes don't modify state, so casting away the const is fine here */
    gsk_render_node_draw_fallback ((GskRenderNode *)node, cr);
    cairo_restore (cr);
@@ -1217,16 +1217,16 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
                                        surface_width,
                                        surface_height);
-  cairo_surface_set_device_scale (surface, fabs (scale_x), fabs (scale_y));
+  cairo_surface_set_device_scale (surface, fabsf (scale_x), fabsf (scale_y));
  cr = cairo_create (surface);

  /* We draw upside down here, so it matches what GL does. */
  cairo_save (cr);
  cairo_scale (cr, scale_x < 0 ? -1 : 1, scale_y < 0 ? 1 : -1);
-  cairo_translate (cr, scale_x < 0 ? - surface_width / fabs (scale_x) : 0,
-                       scale_y < 0 ? 0 : - surface_height / fabs (scale_y));
+  cairo_translate (cr, scale_x < 0 ? - surface_width / fabsf (scale_x) : 0,
+                       scale_y < 0 ? 0 : - surface_height / fabsf (scale_y));
  cairo_set_source_surface (cr, rendered_surface, 0, 0);
-  cairo_rectangle (cr, 0, 0, surface_width / fabs (scale_x), surface_height / fabs (scale_y));
+  cairo_rectangle (cr, 0, 0, surface_width / fabsf (scale_x), surface_height / fabsf (scale_y));
  cairo_fill (cr);
  cairo_restore (cr);
  cairo_destroy (cr);
@@ -1432,10 +1432,10 @@ blur_node (GskGLRenderJob       *job,

      offscreen->texture_id = blur_offscreen (job,
                                              offscreen,
-                                              texture_width * fabs (scale_x),
-                                              texture_height * fabs (scale_y),
-                                              blur_radius * fabs (scale_x),
-                                              blur_radius * fabs (scale_y));
+                                              texture_width * fabsf (scale_x),
+                                              texture_height * fabsf (scale_y),
+                                              blur_radius * fabsf (scale_x),
+                                              blur_radius * fabsf (scale_y));
      init_full_texture_region (offscreen);
    }

@@ -2019,9 +2019,9 @@ result_is_axis_aligned (GskTransform          *transform,
  for (guint i = 0; i < 4; i++)
    {
      p = graphene_quad_get_point (&q, i);
-      if (fabs (p->x - b1.x) > FLT_EPSILON && fabs (p->x - b2.x) > FLT_EPSILON)
+      if (fabsf (p->x - b1.x) > FLT_EPSILON && fabsf (p->x - b2.x) > FLT_EPSILON)
        return FALSE;
-      if (fabs (p->y - b1.y) > FLT_EPSILON && fabs (p->y - b2.y) > FLT_EPSILON)
+      if (fabsf (p->y - b1.y) > FLT_EPSILON && fabsf (p->y - b2.y) > FLT_EPSILON)
        return FALSE;
    }

@@ -2304,8 +2304,8 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob      *job,
                                           &offscreen,
                                           texture_width,
                                           texture_height,
-                                           blur_radius * fabs (scale_x),
-                                           blur_radius * fabs (scale_y));
+                                           blur_radius * fabsf (scale_x),
+                                           blur_radius * fabsf (scale_y));

      gsk_gl_driver_release_render_target (job->driver, render_target, TRUE);

@@ -2501,8 +2501,8 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
      do_slicing = TRUE;
    }

-  texture_width = (int)ceil ((scaled_outline.bounds.size.width + blur_extra) * scale_x);
-  texture_height = (int)ceil ((scaled_outline.bounds.size.height + blur_extra) * scale_y);
+  texture_width = (int)ceilf ((scaled_outline.bounds.size.width + blur_extra) * scale_x);
+  texture_height = (int)ceilf ((scaled_outline.bounds.size.height + blur_extra) * scale_y);

  scaled_outline.bounds.origin.x = extra_blur_pixels_x;
  scaled_outline.bounds.origin.y = extra_blur_pixels_y;
@@ -2577,8 +2577,8 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
                                           &offscreen,
                                           texture_width,
                                           texture_height,
-                                           blur_radius * fabs (scale_x),
-                                           blur_radius * fabs (scale_y));
+                                           blur_radius * fabsf (scale_x),
+                                           blur_radius * fabsf (scale_y));

      gsk_gl_shadow_library_insert (job->driver->shadows_library,
                                    &scaled_outline,
@@ -2834,7 +2834,7 @@ gsk_gl_render_job_visit_cross_fade_node (GskGLRenderJob      *job,
  offscreen_end.reset_clip = TRUE;
  offscreen_end.bounds = &node->bounds;

-  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabs (job->scale_x), fabs (job->scale_y)));
+  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabsf (job->scale_x), fabsf (job->scale_y)));

  if (!gsk_gl_render_job_visit_node_with_offscreen (job, start_node, &offscreen_start))
    {
@@ -2964,7 +2964,7 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
  const PangoFont *font = gsk_text_node_get_font (node);
  const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
  const graphene_point_t *offset = gsk_text_node_get_offset (node);
-  float text_scale = MAX (fabs (job->scale_x), fabs (job->scale_y)); /* TODO: Fix for uneven scales? */
+  float text_scale = MAX (fabsf (job->scale_x), fabsf (job->scale_y)); /* TODO: Fix for uneven scales? */
  guint num_glyphs = gsk_text_node_get_num_glyphs (node);
  float x = offset->x + job->offset_x;
  float y = offset->y + job->offset_y;
@@ -3263,7 +3263,7 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob      *job,
  bottom_offscreen.force_offscreen = TRUE;
  bottom_offscreen.reset_clip = TRUE;

-  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabs (job->scale_x), fabs (job->scale_y)));
+  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabsf (job->scale_x), fabsf (job->scale_y)));

  /* TODO: We create 2 textures here as big as the blend node, but both the
   * start and the end node might be a lot smaller than that. */
@@ -3344,8 +3344,8 @@ gsk_gl_render_job_texture_mask_for_color (GskGLRenderJob        *job,
      gboolean use_mipmap;
      guint16 cc[4];

-      use_mipmap = (scale_x * fabs (job->scale_x)) < 0.5 ||
-                   (scale_y * fabs (job->scale_y)) < 0.5;
+      use_mipmap = (scale_x * fabsf (job->scale_x)) < 0.5 ||
+                   (scale_y * fabsf (job->scale_y)) < 0.5;

      rgba_to_half (rgba, cc);
      gsk_gl_render_job_upload_texture (job, texture, use_mipmap, &offscreen);
@@ -3396,7 +3396,7 @@ gsk_gl_render_job_visit_mask_node (GskGLRenderJob      *job,
  mask_offscreen.reset_clip = TRUE;
  mask_offscreen.do_not_cache = TRUE;

-  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabs (job->scale_x), fabs (job->scale_y)));
+  gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, fabsf (job->scale_x), fabsf (job->scale_y)));

  /* TODO: We create 2 textures here as big as the mask node, but both
   * nodes might be a lot smaller than that.
@@ -3664,8 +3664,8 @@ gsk_gl_render_job_visit_texture (GskGLRenderJob        *job,
  float scale_y = bounds->size.height / texture->height;
  gboolean use_mipmap;

-  use_mipmap = (scale_x * fabs (job->scale_x)) < 0.5 ||
-               (scale_y * fabs (job->scale_y)) < 0.5;
+  use_mipmap = (scale_x * fabsf (job->scale_x)) < 0.5 ||
+               (scale_y * fabsf (job->scale_y)) < 0.5;

  if G_LIKELY (texture->width <= max_texture_size &&
               texture->height <= max_texture_size)
@@ -4544,7 +4544,7 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
  gsk_gl_render_job_visit_node (job, root);
  gdk_gl_context_pop_debug_group (job->command_queue->context);

-  gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Build GL command queue", "");
+  gdk_profiler_end_mark (start_time, "Build GL command queue", "");

 #if 0
  /* At this point the atlases have uploaded content while we processed
@@ -4562,7 +4562,7 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
  gdk_gl_context_push_debug_group (job->command_queue->context, "Executing command queue");
  gsk_gl_command_queue_execute (job->command_queue, surface_height, scale, job->region, job->default_framebuffer);
  gdk_gl_context_pop_debug_group (job->command_queue->context);
-  gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Execute GL command queue", "");
+  gdk_profiler_end_mark (start_time, "Execute GL command queue", "");
 }

 static int
@@ -117,9 +117,8 @@ gsk_gl_texture_library_real_compact (GskGLTextureLibrary *self,
                  g_hash_table_iter_remove (&iter);
                  dropped++;
                }
-
-              if (periodic_scan)
-                  entry->accessed = FALSE;
+              else if (periodic_scan)
+                entry->accessed = FALSE;
            }
        }

@@ -440,7 +439,6 @@ gsk_gl_texture_library_pack (GskGLTextureLibrary *self,

      entry->texture = texture;
      entry->is_atlased = FALSE;
-      entry->accessed = TRUE;
      entry->area.x = padding / (float) (padding + width + padding);
      entry->area.y = padding / (float) (padding + height + padding);
      entry->area.x2 = (padding + width) / (float) (padding + width + padding);
@@ -10,8 +10,8 @@ void main() {
  vUv = vec2(aUv.x, aUv.y);

  // We use this shader for both plain glyphs (used as mask)
-  // and color glpyhs (used as source). The renderer sets
-  // aColor to vec4(-1) for color glyhs.
+  // and color glyphs (used as source). The renderer sets
+  // aColor to vec4(-1) for color glyphs.
  if (distance(aColor,vec4(-1)) < 0.1)
    use_color = 0.0;
  else
@@ -119,7 +119,7 @@ gsk_gl_device_create_atlas_image (GskGpuDevice *device,
  GskGLDevice *self = GSK_GL_DEVICE (device);

  return gsk_gl_image_new (self,
-                           GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
+                           GDK_MEMORY_DEFAULT,
                           GSK_GPU_IMAGE_RENDERABLE,
                           width,
                           height);
@@ -638,6 +638,7 @@ gsk_gl_device_find_gl_format (GskGLDevice      *self,
      *out_format = format;
      *out_flags = flags;
      gdk_memory_format_gl_format (format,
+                                   gdk_gl_context_get_use_es (context),
                                   out_gl_internal_format,
                                   out_gl_format,
                                   out_gl_type,
@@ -647,6 +648,7 @@ gsk_gl_device_find_gl_format (GskGLDevice      *self,

  /* Second, try the potential RGBA format */
  if (gdk_memory_format_gl_rgba_format (format,
+                                        gdk_gl_context_get_use_es (context),
                                        &alt_format,
                                        out_gl_internal_format,
                                        out_gl_format,
@@ -670,6 +672,7 @@ gsk_gl_device_find_gl_format (GskGLDevice      *self,
          *out_format = fallbacks[i];
          *out_flags = flags;
          gdk_memory_format_gl_format (fallbacks[i],
+                                       gdk_gl_context_get_use_es (context),
                                       out_gl_internal_format,
                                       out_gl_format,
                                       out_gl_type,
@@ -14,6 +14,14 @@ gsk_gpu_clip_init_empty (GskGpuClip            *clip,
  gsk_rounded_rect_init_from_rect (&clip->rect, rect, 0);
 }

+void
+gsk_gpu_clip_init_contained (GskGpuClip            *clip,
+                             const graphene_rect_t *rect)
+{
+  clip->type = GSK_GPU_CLIP_CONTAINED;
+  gsk_rounded_rect_init_from_rect (&clip->rect, rect, 0);
+}
+
 void
 gsk_gpu_clip_init_rect (GskGpuClip            *clip,
                        const graphene_rect_t *rect)
@@ -54,17 +62,6 @@ gsk_gpu_clip_intersect_rect (GskGpuClip            *dest,
 {
  GskRoundedRectIntersection res;

-  if (gsk_rect_contains_rect (rect, &src->rect.bounds))
-    {
-      gsk_gpu_clip_init_copy (dest, src);
-      return TRUE;
-    }
-  if (!gsk_rect_intersects (rect, &src->rect.bounds))
-    {
-      dest->type = GSK_GPU_CLIP_ALL_CLIPPED;
-      return TRUE;
-    }
-
  switch (src->type)
    {
    case GSK_GPU_CLIP_ALL_CLIPPED:
@@ -72,6 +69,14 @@ gsk_gpu_clip_intersect_rect (GskGpuClip            *dest,
      break;

    case GSK_GPU_CLIP_NONE:
+      if (gsk_rect_contains_rect (rect, &src->rect.bounds))
+        {
+          gsk_gpu_clip_init_copy (dest, src);
+          return TRUE;
+        }
+      G_GNUC_FALLTHROUGH;
+
+    case GSK_GPU_CLIP_CONTAINED:
      gsk_gpu_clip_init_copy (dest, src);
      if (gsk_rect_intersection (&dest->rect.bounds, rect, &dest->rect.bounds))
        dest->type = GSK_GPU_CLIP_RECT;
@@ -124,6 +129,7 @@ gsk_gpu_clip_intersect_rounded_rect (GskGpuClip           *dest,
      break;

    case GSK_GPU_CLIP_NONE:
+    case GSK_GPU_CLIP_CONTAINED:
    case GSK_GPU_CLIP_RECT:
      res = gsk_rounded_rect_intersect_with_rect (rounded, &src->rect.bounds, &dest->rect);
      if (!gsk_gpu_clip_init_after_intersection (dest, res))
@@ -174,6 +180,7 @@ gsk_gpu_clip_transform (GskGpuClip            *dest,
      return TRUE;

    case GSK_GPU_CLIP_NONE:
+    case GSK_GPU_CLIP_CONTAINED:
    case GSK_GPU_CLIP_RECT:
    case GSK_GPU_CLIP_ROUNDED:
      switch (gsk_transform_get_category (transform))
@@ -246,6 +253,7 @@ gsk_gpu_clip_may_intersect_rect (const GskGpuClip       *self,
      return FALSE;

    case GSK_GPU_CLIP_NONE:
+    case GSK_GPU_CLIP_CONTAINED:
    case GSK_GPU_CLIP_RECT:
    case GSK_GPU_CLIP_ROUNDED:
      return gsk_rect_intersects (&self->rect.bounds, &r);
@@ -269,6 +277,7 @@ gsk_gpu_clip_contains_rect (const GskGpuClip       *self,
      return FALSE;

    case GSK_GPU_CLIP_NONE:
+    case GSK_GPU_CLIP_CONTAINED:
    case GSK_GPU_CLIP_RECT:
      return gsk_rect_contains_rect (&self->rect.bounds, &r);

@@ -283,6 +292,7 @@ gsk_gpu_clip_get_shader_clip (const GskGpuClip       *self,
                              const graphene_rect_t  *rect)
 {
  if (self->type == GSK_GPU_CLIP_NONE ||
+      self->type == GSK_GPU_CLIP_CONTAINED ||
      gsk_gpu_clip_contains_rect (self, offset, rect))
    return GSK_GPU_SHADER_CLIP_NONE;
  else if (self->type == GSK_GPU_CLIP_RECT)
@@ -291,3 +301,42 @@ gsk_gpu_clip_get_shader_clip (const GskGpuClip       *self,
    return GSK_GPU_SHADER_CLIP_ROUNDED;
 }

+gboolean
+gsk_gpu_clip_contains_box (const GskGpuClip *self,
+                           const Point      *offset,
+                           const Box        *box)
+{
+  Box b = box_add (*box, *offset);
+
+  switch (self->type)
+    {
+    default:
+      g_assert_not_reached();
+    case GSK_GPU_CLIP_ALL_CLIPPED:
+      return FALSE;
+
+    case GSK_GPU_CLIP_NONE:
+    case GSK_GPU_CLIP_CONTAINED:
+    case GSK_GPU_CLIP_RECT:
+      return box_contains (box_from_graphene (&self->rect.bounds), b);
+
+    case GSK_GPU_CLIP_ROUNDED:
+      return gsk_rounded_rect_contains_rect (&self->rect, &GRAPHENE_RECT_INIT (box_x0 (b), box_y0 (b), box_width (b), box_height (b)));
+    }
+}
+
+GskGpuShaderClip
+gsk_gpu_clip_get_shader_clip2 (const GskGpuClip *self,
+                               const Point      *offset,
+                               const Box        *box)
+{
+  if (self->type == GSK_GPU_CLIP_NONE ||
+      self->type == GSK_GPU_CLIP_CONTAINED ||
+      gsk_gpu_clip_contains_box (self, offset, box))
+    return GSK_GPU_SHADER_CLIP_NONE;
+  else if (self->type == GSK_GPU_CLIP_RECT)
+    return GSK_GPU_SHADER_CLIP_RECT;
+  else
+    return GSK_GPU_SHADER_CLIP_ROUNDED;
+}
+
@@ -5,6 +5,7 @@
 #include <gdk/gdk.h>
 #include <graphene.h>
 #include <gsk/gskroundedrect.h>
+#include "boxprivate.h"

 G_BEGIN_DECLS

@@ -18,6 +19,9 @@ typedef enum {
   * to the actual bounds of the underlying framebuffer
   */
  GSK_GPU_CLIP_NONE,
+  /* The clip exists outside the rect, so clipping must
+   * happen if rendering can't be proven to stay in the rect */
+  GSK_GPU_CLIP_CONTAINED,
  /* The clip is a rectangular area */
  GSK_GPU_CLIP_RECT,
  /* The clip is a rounded rectangle */
@@ -34,6 +38,8 @@ struct _GskGpuClip

 void                    gsk_gpu_clip_init_empty                         (GskGpuClip          *clip,
                                                                         const graphene_rect_t  *rect);
+void                    gsk_gpu_clip_init_contained                     (GskGpuClip          *clip,
+                                                                         const graphene_rect_t  *rect);
 void                    gsk_gpu_clip_init_copy                          (GskGpuClip          *self,
                                                                         const GskGpuClip    *src);
 void                    gsk_gpu_clip_init_rect                          (GskGpuClip          *clip,
@@ -60,9 +66,16 @@ gboolean                gsk_gpu_clip_contains_rect                      (const G
 gboolean                gsk_gpu_clip_may_intersect_rect                 (const GskGpuClip    *self,
                                                                         const graphene_point_t *offset,
                                                                         const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip    *self,
+GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip       *self,
                                                                         const graphene_point_t *offset,
                                                                         const graphene_rect_t  *rect);

+gboolean                gsk_gpu_clip_contains_box                       (const GskGpuClip       *self,
+                                                                         const Point            *offset,
+                                                                         const Box              *box) G_GNUC_WARN_UNUSED_RESULT;
+GskGpuShaderClip        gsk_gpu_clip_get_shader_clip2                   (const GskGpuClip       *self,
+                                                                         const Point            *offset,
+                                                                         const Box              *box);
+
 G_END_DECLS

@@ -48,7 +48,7 @@ struct _GskGpuCachedClass
                                                         GskGpuCached           *cached);
  gboolean              (* should_collect)              (GskGpuDevice           *device,
                                                         GskGpuCached           *cached,
-                                                         gint64                  timestsamp);
+                                                         gint64                  timestamp);
 };

 struct _GskGpuCached
@@ -285,7 +285,7 @@ gsk_gpu_cached_glyph_free (GskGpuDevice *device,
 static gboolean
 gsk_gpu_cached_glyph_should_collect (GskGpuDevice *device,
                                     GskGpuCached *cached,
-                                     gint64        timestsamp)
+                                     gint64        timestamp)
 {
  /* FIXME */
  return FALSE;
@@ -336,7 +336,7 @@ gsk_gpu_device_gc (GskGpuDevice *self,
    {
      next = cached->next;
      if (gsk_gpu_cached_should_collect (self, cached, timestamp))
-        gsk_gpu_cached_free (self, priv->first_cached);
+        gsk_gpu_cached_free (self, cached);
    }
 }

@@ -517,15 +517,21 @@ gsk_gpu_cached_atlas_allocate (GskGpuCachedAtlas *atlas,

  if (best_slice >= i && i == atlas->n_slices)
    {
+      gsize slice_height;
+
      if (!can_add_slice)
        return FALSE;

+      slice_height = round_up_atlas_size (MAX (height, 4));
+      if (slice_height > ATLAS_SIZE - y)
+        return FALSE;
+
      atlas->n_slices++;
      if (atlas->n_slices == MAX_SLICES_PER_ATLAS)
-        atlas->slices[i].height = ATLAS_SIZE - y;
-      else
-        atlas->slices[i].height = round_up_atlas_size (MAX (height, 4));
+        slice_height = ATLAS_SIZE - y;
+
      atlas->slices[i].width = 0;
+      atlas->slices[i].height = slice_height;
      best_y = y;
      best_slice = i;
    }
@@ -650,6 +656,7 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
  graphene_point_t origin;
  GskGpuImage *image;
  gsize atlas_x, atlas_y, padding;
+  float subpixel_x, subpixel_y;

  cache = g_hash_table_lookup (priv->glyph_cache, &lookup);
  if (cache)
@@ -661,12 +668,13 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
      return cache->image;
    }

-  cache = g_new (GskGpuCachedGlyph, 1);
+  subpixel_x = (flags & 3) / 4.f;
+  subpixel_y = ((flags >> 2) & 3) / 4.f;
  pango_font_get_glyph_extents (font, glyph, &ink_rect, NULL);
-  origin.x = floor (ink_rect.x * scale / PANGO_SCALE);
-  origin.y = floor (ink_rect.y * scale / PANGO_SCALE);
-  rect.size.width = ceil ((ink_rect.x + ink_rect.width) * scale / PANGO_SCALE) - origin.x;
-  rect.size.height = ceil ((ink_rect.y + ink_rect.height) * scale / PANGO_SCALE) - origin.y;
+  origin.x = floor (ink_rect.x * scale / PANGO_SCALE + subpixel_x);
+  origin.y = floor (ink_rect.y * scale / PANGO_SCALE + subpixel_y);
+  rect.size.width = ceil ((ink_rect.x + ink_rect.width) * scale / PANGO_SCALE + subpixel_x) - origin.x;
+  rect.size.height = ceil ((ink_rect.y + ink_rect.height) * scale / PANGO_SCALE + subpixel_y) - origin.y;
  padding = 1;

  image = gsk_gpu_device_add_atlas_image (self,
@@ -695,8 +703,8 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
  cache->scale = scale,
  cache->bounds = rect,
  cache->image = image,
-  cache->origin = GRAPHENE_POINT_INIT (- origin.x + (flags & 3) / 4.f,
-                                       - origin.y + ((flags >> 2) & 3) / 4.f);
+  cache->origin = GRAPHENE_POINT_INIT (- origin.x + subpixel_x,
+                                       - origin.y + subpixel_y);

  gsk_gpu_upload_glyph_op (frame,
                           cache->image,
@@ -709,8 +717,8 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
                               .height = rect.size.height + 2 * padding,
                           },
                           scale,
-                           &GRAPHENE_POINT_INIT (cache->origin.x + 1,
-                                                 cache->origin.y + 1));
+                           &GRAPHENE_POINT_INIT (cache->origin.x + padding,
+                                                 cache->origin.y + padding));

  g_hash_table_insert (priv->glyph_cache, cache, cache);
  gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));
@@ -721,3 +729,4 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
 }

 /* }}} */
+/* vim:set foldmethod=marker expandtab: */
@@ -514,6 +514,29 @@ copy_texture (gpointer    user_data,
  *target = g_object_ref (texture);
 }

+static void
+gsk_gpu_frame_record_rect (GskGpuFrame                 *self,
+                           GskGpuImage                 *target,
+                           const cairo_rectangle_int_t *clip,
+                           GskRenderNode               *node,
+                           const graphene_rect_t       *viewport)
+{
+  gsk_gpu_render_pass_begin_op (self,
+                                target,
+                                clip,
+                                GSK_RENDER_PASS_PRESENT);
+
+  gsk_gpu_node_processor_process (self,
+                                  target,
+                                  clip,
+                                  node,
+                                  viewport);
+
+  gsk_gpu_render_pass_end_op (self,
+                              target,
+                              GSK_RENDER_PASS_PRESENT);
+}
+
 static void
 gsk_gpu_frame_record (GskGpuFrame            *self,
                      gint64                  timestamp,
@@ -524,38 +547,34 @@ gsk_gpu_frame_record (GskGpuFrame            *self,
                      GdkTexture            **texture)
 {
  GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self);
-  cairo_rectangle_int_t extents;

  priv->timestamp = timestamp;

  if (clip)
    {
-      cairo_region_get_extents (clip, &extents);
+      int i;
+
+      for (i = 0; i < cairo_region_num_rectangles (clip); i++)
+        {
+          cairo_rectangle_int_t rect;
+
+          cairo_region_get_rectangle (clip, i, &rect);
+          gsk_gpu_frame_record_rect (self, target, &rect, node, viewport);
+        }
    }
  else
    {
-      extents = (cairo_rectangle_int_t) {
-                    0, 0,
-                    gsk_gpu_image_get_width (target),
-                    gsk_gpu_image_get_height (target)
-                };
+      gsk_gpu_frame_record_rect (self,
+                                 target,
+                                 &(cairo_rectangle_int_t) {
+                                     0, 0,
+                                     gsk_gpu_image_get_width (target),
+                                     gsk_gpu_image_get_height (target)
+                                 },
+                                 node,
+                                 viewport);
    }

-  gsk_gpu_render_pass_begin_op (self,
-                                target,
-                                &extents,
-                                GSK_RENDER_PASS_PRESENT);
-
-  gsk_gpu_node_processor_process (self,
-                                  target,
-                                  &extents,
-                                  node,
-                                  viewport);
-
-  gsk_gpu_render_pass_end_op (self,
-                              target,
-                              GSK_RENDER_PASS_PRESENT);
-
  if (texture)
    gsk_gpu_download_op (self, target, TRUE, copy_texture, texture);
 }
@@ -43,6 +43,10 @@

 #include "gdk/gdkrgbaprivate.h"

+#include "scaleprivate.h"
+#include "pointprivate.h"
+#include "boxprivate.h"
+
 /* A note about coordinate systems
 *
 * The rendering code keeps track of multiple coordinate systems to optimize rendering as
@@ -156,6 +160,11 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
                             const cairo_rectangle_int_t *clip,
                             const graphene_rect_t       *viewport)
 {
+  gsize width, height;
+
+  width = gsk_gpu_image_get_width (target);
+  height = gsk_gpu_image_get_height (target);
+
  self->frame = frame;
  if (desc)
    self->desc = g_object_ref (desc);
@@ -164,12 +173,28 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,

  self->scissor = *clip;
  self->blend = GSK_GPU_BLEND_OVER;
-  gsk_gpu_clip_init_empty (&self->clip, &GRAPHENE_RECT_INIT (0, 0, viewport->size.width, viewport->size.height));
+  if (clip->x == 0 && clip->y == 0 && clip->width == width && clip->height == height)
+    {
+      gsk_gpu_clip_init_empty (&self->clip, &GRAPHENE_RECT_INIT (0, 0, viewport->size.width, viewport->size.height));
+    }
+  else
+    {
+      float scale_x = viewport->size.width / width;
+      float scale_y = viewport->size.height / height;
+      gsk_gpu_clip_init_rect (&self->clip,
+                              &GRAPHENE_RECT_INIT (
+                                  scale_x * clip->x,
+                                  scale_y * clip->y,
+                                  scale_x * clip->width,
+                                  scale_y * clip->height
+                              ));
+    }

  self->modelview = NULL;
  gsk_gpu_image_get_projection_matrix (target, &self->projection);
-  graphene_vec2_init (&self->scale, gsk_gpu_image_get_width (target) / viewport->size.width,
-                                    gsk_gpu_image_get_height (target) / viewport->size.height);
+  graphene_vec2_init (&self->scale,
+                      width / viewport->size.width,
+                      height / viewport->size.height);
  self->offset = GRAPHENE_POINT_INIT (-viewport->origin.x,
                                      -viewport->origin.y);
  self->opacity = 1.0;
@@ -284,9 +309,10 @@ gsk_gpu_node_processor_add_images (GskGpuNodeProcessor *self,
 }

 static void
-rect_round_to_pixels (const graphene_rect_t *src,
-                      const graphene_vec2_t *pixel_scale,
-                      graphene_rect_t       *dest)
+rect_round_to_pixels (const graphene_rect_t  *src,
+                      const graphene_vec2_t  *pixel_scale,
+                      const graphene_point_t *pixel_offset,
+                      graphene_rect_t        *dest)
 {
  float x, y, xscale, yscale, inv_xscale, inv_yscale;

@@ -295,13 +321,13 @@ rect_round_to_pixels (const graphene_rect_t *src,
  inv_xscale = 1.0f / xscale;
  inv_yscale = 1.0f / yscale;

-  x = floorf (src->origin.x * xscale);
-  y = floorf (src->origin.y * yscale);
+  x = floorf ((src->origin.x + pixel_offset->x) * xscale);
+  y = floorf ((src->origin.y + pixel_offset->y) * yscale);
  *dest = GRAPHENE_RECT_INIT (
-      x * inv_xscale,
-      y * inv_yscale,
-      (ceil ((src->origin.x + src->size.width) * xscale) - x) * inv_xscale,
-      (ceil ((src->origin.y + src->size.height) * yscale) - y) * inv_yscale);
+      x * inv_xscale - pixel_offset->x,
+      y * inv_yscale - pixel_offset->y,
+      (ceilf ((src->origin.x + pixel_offset->x + src->size.width) * xscale) - x) * inv_xscale,
+      (ceilf ((src->origin.y + pixel_offset->y + src->size.height) * yscale) - y) * inv_yscale);
 }

 static GskGpuImage *
@@ -316,8 +342,8 @@ gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor   *self,

  area.x = 0;
  area.y = 0;
-  area.width = ceil (graphene_vec2_get_x (scale) * viewport->size.width);
-  area.height = ceil (graphene_vec2_get_y (scale) * viewport->size.height);
+  area.width = ceilf (graphene_vec2_get_x (scale) * viewport->size.width);
+  area.height = ceilf (graphene_vec2_get_y (scale) * viewport->size.height);

  image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                 FALSE,
@@ -476,6 +502,18 @@ gsk_gpu_pattern_writer_append_rect (GskGpuPatternWriter    *self,
  gsk_gpu_pattern_writer_append (self, G_ALIGNOF (float), (guchar *) f, sizeof (f));
 }

+static void
+gsk_gpu_pattern_writer_append_box (GskGpuPatternWriter *self,
+                                   const Box            box,
+                                   const Point          offset)
+{
+  float f[4];
+
+  box_offset_to_float (box, offset, f);
+
+  gsk_gpu_pattern_writer_append (self, G_ALIGNOF (float), (guchar *) f, sizeof (f));
+}
+
 static void
 gsk_gpu_pattern_writer_append_rgba (GskGpuPatternWriter *self,
                                    const GdkRGBA       *rgba)
@@ -766,7 +804,6 @@ gsk_gpu_get_node_as_image (GskGpuFrame            *frame,
      gsk_rect_intersection (clip_bounds, &node->bounds, &clipped);
      if (gsk_rect_is_empty (&clipped))
        return NULL;
-      rect_round_to_pixels (&clipped, scale, &clipped);

      result = gsk_gpu_upload_cairo_op (frame,
                                        scale,
@@ -787,7 +824,6 @@ gsk_gpu_get_node_as_image (GskGpuFrame            *frame,
  gsk_rect_intersection (clip_bounds, &node->bounds, &clipped);
  if (gsk_rect_is_empty (&clipped))
    return NULL;
-  rect_round_to_pixels (&clipped, scale, &clipped);

  GSK_DEBUG (FALLBACK, "Offscreening node '%s'", g_type_name_from_instance ((GTypeInstance *) node));
  result = gsk_gpu_render_pass_op_offscreen (frame,
@@ -910,17 +946,18 @@ gsk_gpu_node_processor_get_node_as_image (GskGpuNodeProcessor   *self,
                                          graphene_rect_t       *out_bounds)
 {
  GskGpuImage *image, *ensure;
-  graphene_rect_t default_clip;
+  graphene_rect_t clip;

  if (clip_bounds == NULL)
    {
-      if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &default_clip))
+      if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip))
        return NULL;
-      clip_bounds = &default_clip;
+      clip_bounds = &clip;
    }
+  rect_round_to_pixels (clip_bounds, &self->scale, &self->offset, &clip);

  image = gsk_gpu_get_node_as_image (self->frame,
-                                     clip_bounds,
+                                     &clip,
                                     &self->scale,
                                     node,
                                     out_bounds);
@@ -973,8 +1010,8 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
  if (!gsk_rect_intersection (rect, &clip_rect, &intermediate_rect))
    return;

-  width = ceil (graphene_vec2_get_x (&self->scale) * intermediate_rect.size.width);
-  height = ceil (graphene_vec2_get_y (&self->scale) * intermediate_rect.size.height);
+  width = ceilf (graphene_vec2_get_x (&self->scale) * intermediate_rect.size.width);
+  height = ceilf (graphene_vec2_get_y (&self->scale) * intermediate_rect.size.height);

  intermediate = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (self->frame),
                                                        FALSE,
@@ -1052,6 +1089,8 @@ gsk_gpu_node_processor_add_fallback_node (GskGpuNodeProcessor *self,
  if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clipped_bounds))
    return;

+  rect_round_to_pixels (&clipped_bounds, &self->scale, &self->offset, &clipped_bounds);
+
  gsk_gpu_node_processor_sync_globals (self, 0);

  image = gsk_gpu_upload_cairo_op (self->frame,
@@ -1405,7 +1444,7 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel

  if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
    return;
-  rect_round_to_pixels (&clip_bounds, &self->scale, &clip_bounds);
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);

  child_image = gsk_gpu_node_processor_get_node_as_image (self,
                                                          0,
@@ -1568,7 +1607,7 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,

        if (gsk_gpu_clip_contains_rect (&self->clip, &self->offset, &node->bounds))
          {
-            gsk_gpu_clip_init_empty (&self->clip, &child->bounds);
+            gsk_gpu_clip_init_contained (&self->clip, &child->bounds);
          }
        else if (old_clip.type == GSK_GPU_CLIP_NONE)
          {
@@ -1577,7 +1616,7 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
            inverse = gsk_transform_invert (gsk_transform_ref (clip_transform));
            gsk_transform_transform_bounds (inverse, &old_clip.rect.bounds, &new_bounds);
            gsk_transform_unref (inverse);
-            gsk_gpu_clip_init_empty (&self->clip, &new_bounds);
+            gsk_gpu_clip_init_contained (&self->clip, &new_bounds);
          }
        else if (!gsk_gpu_clip_transform (&self->clip, &old_clip, clip_transform, &child->bounds))
          {
@@ -1791,10 +1830,10 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
          if (shader_clip != GSK_GPU_SHADER_CLIP_NONE)
            {
              gsk_rounded_rect_get_largest_cover (&self->clip.rect, &clipped, &cover);
-              int_clipped.x = ceil (cover.origin.x * scale_x);
-              int_clipped.y = ceil (cover.origin.y * scale_y);
-              int_clipped.width = floor ((cover.origin.x + cover.size.width) * scale_x) - int_clipped.x;
-              int_clipped.height = floor ((cover.origin.y + cover.size.height) * scale_y) - int_clipped.y;
+              int_clipped.x = ceilf (cover.origin.x * scale_x);
+              int_clipped.y = ceilf (cover.origin.y * scale_y);
+              int_clipped.width = floorf ((cover.origin.x + cover.size.width) * scale_x) - int_clipped.x;
+              int_clipped.height = floorf ((cover.origin.y + cover.size.height) * scale_y) - int_clipped.y;
              if (int_clipped.width == 0 || int_clipped.height == 0)
                {
                  gsk_gpu_color_op (self->frame,
@@ -1879,7 +1918,7 @@ gsk_gpu_node_processor_add_border_node (GskGpuNodeProcessor *self,
                     &self->offset,
                     graphene_point_zero (),
                     gsk_border_node_get_widths (node),
-                     gsk_border_node_get_colors (node));
+                     colors);
 }

 static void
@@ -2229,7 +2268,7 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self,

  if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &bounds))
    return;
-  rect_round_to_pixels (&bounds, &self->scale, &bounds);
+  rect_round_to_pixels (&bounds, &self->scale, &self->offset, &bounds);

  image = gsk_gpu_node_processor_init_draw (&other,
                                            self->frame,
@@ -2951,10 +2990,11 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
  GskGpuDevice *device;
  const PangoGlyphInfo *glyphs;
  PangoFont *font;
-  graphene_point_t offset;
+  Point offset;
+  Scale scale, s4, pango_scale;
  guint i, num_glyphs;
-  float scale, inv_scale;
  GdkRGBA color;
+  gboolean glyph_align;

  if (self->opacity < 1.0 &&
      gsk_text_node_has_color_glyphs (node))
@@ -2963,59 +3003,83 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
      return;
    }

+  glyph_align = gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_GLYPH_ALIGN) &&
+                gsk_transform_get_category (self->modelview) >= GSK_TRANSFORM_CATEGORY_2D;
  device = gsk_gpu_frame_get_device (self->frame);
  color = *gsk_text_node_get_color (node);
  color.alpha *= self->opacity;
  num_glyphs = gsk_text_node_get_num_glyphs (node);
  glyphs = gsk_text_node_get_glyphs (node, NULL);
  font = gsk_text_node_get_font (node);
-  offset = *gsk_text_node_get_offset (node);
-  offset.x += self->offset.x;
-  offset.y += self->offset.y;

-  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
-  inv_scale = 1.f / scale;
+  offset = point_add (point_from_graphene (gsk_text_node_get_offset (node)),
+                      point_from_graphene (&self->offset));
+  scale = scale_max (scale_from_graphene (&self->scale));
+  s4 = scale_mul (scale, scale_from_float (4));
+  pango_scale = scale_from_float (PANGO_SCALE);

  for (i = 0; i < num_glyphs; i++)
    {
      GskGpuImage *image;
-      graphene_rect_t glyph_bounds, glyph_tex_rect;
-      graphene_point_t glyph_offset;
+      graphene_rect_t glyph_bds;
+      graphene_point_t glyph_ofs;
+      Box glyph_bounds, glyph_tex_rect;
+      Point g_ofs, glyph_origin;
      guint32 descriptor;
+      GskGpuGlyphLookupFlags flags;
+
+      glyph_origin = point_add (offset, point_div (point (glyphs[i].geometry.x_offset, glyphs[i].geometry.y_offset), pango_scale));
+
+      if (glyph_align)
+        {
+          glyph_origin = point_round (point_mul (glyph_origin, s4));
+
+          flags = ((int) point_x (glyph_origin) & 3) |
+                  (((int) point_y (glyph_origin) & 3) << 2);
+
+          glyph_origin = point_div (glyph_origin, s4);
+        }
+      else
+        {
+          flags = 0;
+        }

      image = gsk_gpu_device_lookup_glyph_image (device,
                                                 self->frame,
                                                 font,
                                                 glyphs[i].glyph,
-                                                 0,
-                                                 scale,
-                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 flags,
+                                                 scale_x (scale),
+                                                 &glyph_bds,
+                                                 &glyph_ofs);
+
+      glyph_tex_rect = box_div (box_from_rect (-glyph_bds.origin.x, -glyph_bds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), scale);
+
+      glyph_bounds = box_div (box_from_rect (0, 0, glyph_bds.size.width, glyph_bds.size.height), scale);
+
+      g_ofs = point_from_graphene (&glyph_ofs);
+      glyph_origin = point_sub (glyph_origin, point_div (g_ofs, scale));

-      graphene_rect_scale (&GRAPHENE_RECT_INIT (-glyph_bounds.origin.x, -glyph_bounds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), inv_scale, inv_scale, &glyph_tex_rect);
-      graphene_rect_scale (&GRAPHENE_RECT_INIT(0, 0, glyph_bounds.size.width, glyph_bounds.size.height), inv_scale, inv_scale, &glyph_bounds);
-      glyph_offset = GRAPHENE_POINT_INIT (offset.x - glyph_offset.x * inv_scale + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
-                                          offset.y - glyph_offset.y * inv_scale + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);
      descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
-      if (gsk_text_node_has_color_glyphs (node))
+      if (glyphs[i].attr.is_color)
        gsk_gpu_texture_op (self->frame,
-                            gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
+                            gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
                            self->desc,
                            descriptor,
-                            &glyph_bounds,
-                            &glyph_offset,
-                            &glyph_tex_rect);
+                            &GRAPHENE_RECT_INIT (box_x0 (glyph_bounds), box_y0 (glyph_bounds), box_width (glyph_bounds), box_height (glyph_bounds)),
+                            &GRAPHENE_POINT_INIT (point_x (glyph_origin), point_y (glyph_origin)),
+                            &GRAPHENE_RECT_INIT (box_x0 (glyph_tex_rect), box_y0 (glyph_tex_rect), box_width (glyph_tex_rect), box_height (glyph_tex_rect)));
      else
        gsk_gpu_colorize_op (self->frame,
-                             gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
+                             gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
                             self->desc,
                             descriptor,
-                             &glyph_bounds,
-                             &glyph_offset,
-                             &glyph_tex_rect,
+                             &GRAPHENE_RECT_INIT (box_x0 (glyph_bounds), box_y0 (glyph_bounds), box_width (glyph_bounds), box_height (glyph_bounds)),
+                             &GRAPHENE_POINT_INIT (point_x (glyph_origin), point_y (glyph_origin)),
+                             &GRAPHENE_RECT_INIT (box_x0 (glyph_tex_rect), box_y0 (glyph_tex_rect), box_width (glyph_tex_rect), box_height (glyph_tex_rect)),
                             &color);

-      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
+      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
    }
 }

@@ -3028,10 +3092,10 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
  PangoFont *font;
  guint num_glyphs;
  gsize i;
-  float scale, inv_scale;
+  Scale scale, pango_scale;
  guint32 tex_id;
  GskGpuImage *last_image;
-  graphene_point_t offset;
+  Point offset;

  if (gsk_text_node_has_color_glyphs (node))
    return FALSE;
@@ -3040,12 +3104,11 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
  num_glyphs = gsk_text_node_get_num_glyphs (node);
  glyphs = gsk_text_node_get_glyphs (node, NULL);
  font = gsk_text_node_get_font (node);
-  offset = *gsk_text_node_get_offset (node);
-  offset.x += self->offset.x;
-  offset.y += self->offset.y;

-  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
-  inv_scale = 1.f / scale;
+  offset = point_add (point_from_graphene (gsk_text_node_get_offset (node)),
+                      point_from_graphene (&self->offset));
+  scale = scale_max (scale_from_graphene (&self->scale));
+  pango_scale = scale_from_float (PANGO_SCALE);

  gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_GLYPHS);
  gsk_gpu_pattern_writer_append_rgba (self, gsk_text_node_get_color (node));
@@ -3055,17 +3118,20 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
  for (i = 0; i < num_glyphs; i++)
    {
      GskGpuImage *image;
-      graphene_rect_t glyph_bounds;
-      graphene_point_t glyph_offset;
+      graphene_rect_t glyph_bds;
+      graphene_point_t glyph_ofs;
+      Point glyph_offset;
+      Box glyph_bounds;
+      Box glyph_tex_rect;

      image = gsk_gpu_device_lookup_glyph_image (device,
                                                 self->frame,
                                                 font,
                                                 glyphs[i].glyph,
                                                 0,
-                                                 scale,
-                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 scale_x (scale),
+                                                 &glyph_bds,
+                                                 &glyph_ofs);

      if (image != last_image)
        {
@@ -3075,23 +3141,15 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
          last_image = image;
        }

-      graphene_rect_scale (&glyph_bounds, inv_scale, inv_scale, &glyph_bounds);
-      glyph_offset = GRAPHENE_POINT_INIT (offset.x - glyph_offset.x * inv_scale + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
-                                          offset.y - glyph_offset.y * inv_scale + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);
+      glyph_offset = point_add (point_sub (offset, point_div (glyph_offset, scale)), point_div (point (glyphs[i].geometry.x_offset, glyphs[i].geometry.y_offset), pango_scale));

+      glyph_bounds = box_div (box_from_rect (0, 0, glyph_bds.size.width, glyph_bds.size.height), scale);
+      glyph_tex_rect = box_div (box_from_rect (-glyph_bds.origin.x, - glyph_bds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), scale);
      gsk_gpu_pattern_writer_append_uint (self, tex_id);
-      gsk_gpu_pattern_writer_append_rect (self,
-                                         &glyph_bounds,
-                                         &glyph_offset);
-      gsk_gpu_pattern_writer_append_rect (self,
-                                         &GRAPHENE_RECT_INIT (
-                                             0, 0,
-                                             gsk_gpu_image_get_width (image) * inv_scale,
-                                             gsk_gpu_image_get_height (image) * inv_scale
-                                         ),
-                                         &glyph_offset);
+      gsk_gpu_pattern_writer_append_box (self, glyph_bounds, glyph_offset);
+      gsk_gpu_pattern_writer_append_box (self, glyph_tex_rect, glyph_offset);

-      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
+      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
    }

  return TRUE;
@@ -3219,8 +3277,8 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor    *self,
                      rect,
                      &self->offset,
                      &GRAPHENE_RECT_INIT (
-                          clipped_child_bounds.origin.x - x * child_bounds->size.width,
-                          clipped_child_bounds.origin.y - y * child_bounds->size.height,
+                          clipped_child_bounds.origin.x + x * child_bounds->size.width,
+                          clipped_child_bounds.origin.y + y * child_bounds->size.height,
                          clipped_child_bounds.size.width,
                          clipped_child_bounds.size.height
                      ));
@@ -3455,6 +3513,7 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self,

  if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
    return;
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);

  child = gsk_fill_node_get_child (node);

@@ -3496,9 +3555,9 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self,
                                     descriptors);

  gsk_gpu_mask_op (self->frame,
-                   gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
+                   gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds),
                   self->desc,
-                   &node->bounds,
+                   &clip_bounds,
                   &self->offset,
                   self->opacity,
                   GSK_MASK_MODE_ALPHA,
@@ -3551,6 +3610,7 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self,

  if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
    return;
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);

  child = gsk_stroke_node_get_child (node);

@@ -3592,9 +3652,9 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self,
                                     descriptors);

  gsk_gpu_mask_op (self->frame,
-                   gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
+                   gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds),
                   self->desc,
-                   &node->bounds,
+                   &clip_bounds,
                   &self->offset,
                   self->opacity,
                   GSK_MASK_MODE_ALPHA,
@@ -3892,7 +3952,7 @@ gsk_gpu_node_processor_add_node (GskGpuNodeProcessor *self,
  node_type = gsk_render_node_get_node_type (node);
  if (node_type >= G_N_ELEMENTS (nodes_vtable))
    {
-      g_critical ("unkonwn node type %u for %s", node_type, g_type_name_from_instance ((GTypeInstance *) node));
+      g_critical ("unknown node type %u for %s", node_type, g_type_name_from_instance ((GTypeInstance *) node));
      gsk_gpu_node_processor_add_fallback_node (self, node);
      return;
    }
@@ -3933,7 +3993,7 @@ gsk_gpu_node_processor_create_node_pattern (GskGpuPatternWriter *self,
  node_type = gsk_render_node_get_node_type (node);
  if (node_type >= G_N_ELEMENTS (nodes_vtable))
    {
-      g_critical ("unkonwn node type %u for %s", node_type, g_type_name_from_instance ((GTypeInstance *) node));
+      g_critical ("unknown node type %u for %s", node_type, g_type_name_from_instance ((GTypeInstance *) node));
      return FALSE;
    }

@@ -3949,13 +4009,17 @@ gsk_gpu_node_processor_create_node_pattern (GskGpuPatternWriter *self,
        gsk_gpu_descriptors_set_size (self->desc, images_before, buffers_before);
    }

+  rect_round_to_pixels (&GRAPHENE_RECT_INIT (
+                            self->bounds.origin.x - self->offset.x,
+                            self->bounds.origin.y - self->offset.y,
+                            self->bounds.size.width,
+                            self->bounds.size.height
+                        ),
+                        &self->scale,
+                        &self->offset,
+                        &bounds);
  image = gsk_gpu_get_node_as_image (self->frame,
-                                     &GRAPHENE_RECT_INIT (
-                                         self->bounds.origin.x - self->offset.x,
-                                         self->bounds.origin.y - self->offset.y,
-                                         self->bounds.size.width,
-                                         self->bounds.size.height
-                                     ),
+                                     &bounds,
                                     &self->scale,
                                     node,
                                     &bounds);
@@ -74,7 +74,7 @@ struct _GskGpuOpClass
                                                                         GskGLCommandState      *state);
 };

-/* ensures alignment of ops to multipes of 16 bytes - and that makes graphene happy */
+/* ensures alignment of ops to multiples of 16 bytes - and that makes graphene happy */
 #define GSK_GPU_OP_SIZE(struct_name) ((sizeof(struct_name) + 15) & ~15)

 GskGpuOp *              gsk_gpu_op_alloc                                (GskGpuFrame            *frame,
@@ -30,6 +30,7 @@ static const GdkDebugKey gsk_gpu_optimization_keys[] = {
  { "blit", GSK_GPU_OPTIMIZE_BLIT, "Use shaders instead of vkCmdBlit()/glBlitFramebuffer()" },
  { "gradients", GSK_GPU_OPTIMIZE_GRADIENTS, "Don't supersample gradients" },
  { "mipmap", GSK_GPU_OPTIMIZE_MIPMAP, "Avoid creating mipmaps" },
+  { "glyph-align", GSK_GPU_OPTIMIZE_GLYPH_ALIGN, "Never align glyphs to the subpixel grid" },

  { "gl-baseinstance", GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE, "Assume no ARB/EXT_base_instance support" },
 };
@@ -117,7 +117,8 @@ typedef enum {
  GSK_GPU_OPTIMIZE_BLIT                 = 1 <<  3,
  GSK_GPU_OPTIMIZE_GRADIENTS            = 1 <<  4,
  GSK_GPU_OPTIMIZE_MIPMAP               = 1 <<  5,
+  GSK_GPU_OPTIMIZE_GLYPH_ALIGN          = 1 <<  6,
  /* These require hardware support */
-  GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE     = 1 <<  6,
+  GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE     = 1 <<  7,
 } GskGpuOptimizations;

@@ -75,6 +75,12 @@ gsk_ngl_renderer_make_current (GskGpuRenderer *renderer)
  gdk_gl_context_make_current (GDK_GL_CONTEXT (gsk_gpu_renderer_get_context (renderer)));
 }

+static void
+gsk_ngl_renderer_free_backbuffer (GskNglRenderer *self)
+{
+  g_clear_object (&self->backbuffer);
+}
+
 static GskGpuImage *
 gsk_ngl_renderer_get_backbuffer (GskGpuRenderer *renderer)
 {
@@ -91,7 +97,7 @@ gsk_ngl_renderer_get_backbuffer (GskGpuRenderer *renderer)
      gsk_gpu_image_get_width (self->backbuffer) != ceil (gdk_surface_get_width (surface) * scale) ||
      gsk_gpu_image_get_height (self->backbuffer) != ceil (gdk_surface_get_height (surface) * scale))
    {
-      g_clear_object (&self->backbuffer);
+      gsk_ngl_renderer_free_backbuffer (self);
      self->backbuffer = gsk_gl_image_new_backbuffer (GSK_GL_DEVICE (gsk_gpu_renderer_get_device (renderer)),
                                                      GDK_MEMORY_DEFAULT /* FIXME */,
                                                      ceil (gdk_surface_get_width (surface) * scale),
@@ -124,10 +130,21 @@ gsk_ngl_renderer_get_dmabuf_formats (GskGpuRenderer *renderer)
  return display->egl_dmabuf_formats;
 }

+static void
+gsk_ngl_renderer_unrealize (GskRenderer *renderer)
+{
+  GskNglRenderer *self = GSK_NGL_RENDERER (renderer);
+
+  gsk_ngl_renderer_free_backbuffer (self);
+
+  GSK_RENDERER_CLASS (gsk_ngl_renderer_parent_class)->unrealize (renderer);
+}
+
 static void
 gsk_ngl_renderer_class_init (GskNglRendererClass *klass)
 {
  GskGpuRendererClass *gpu_renderer_class = GSK_GPU_RENDERER_CLASS (klass);
+  GskRendererClass *renderer_class = GSK_RENDERER_CLASS (klass);

  gpu_renderer_class->frame_type = GSK_TYPE_GL_FRAME;

@@ -138,6 +155,8 @@ gsk_ngl_renderer_class_init (GskNglRendererClass *klass)
  gpu_renderer_class->wait = gsk_ngl_renderer_wait;
  gpu_renderer_class->get_scale = gsk_ngl_renderer_get_scale;
  gpu_renderer_class->get_dmabuf_formats = gsk_ngl_renderer_get_dmabuf_formats;
+
+  renderer_class->unrealize = gsk_ngl_renderer_unrealize;
 }

 static void
@@ -1819,7 +1819,7 @@ gsk_rect_contour_get_stroke_bounds (const GskContour *contour,
  graphene_rect_t rect;

  graphene_rect_init (&rect, self->x, self->y, self->width, self->height);
-  graphene_rect_inset (&rect, - stroke->line_width, - stroke->line_width);
+  graphene_rect_inset (&rect, - 0.5 * stroke->line_width, - 0.5 * stroke->line_width);
  gsk_bounding_box_init_from_rect (bounds, &rect);

  return TRUE;
@@ -40,7 +40,7 @@
 * new `GskPath` objects have to be created. The [struct@Gsk.PathBuilder]
 * structure is meant to help in this endeavor.
 *
- * Conceptually, a path consists of zero or more contours (continous, connected
+ * Conceptually, a path consists of zero or more contours (continuous, connected
 * curves), each of which may or may not be closed. Contours are typically
 * constructed from Bézier segments.
 *
@@ -132,3 +132,20 @@ gsk_rect_round_larger (graphene_rect_t *rect)
                              ceil (rect->origin.y + rect->size.height) - y);
 }

+static inline void
+gsk_rect_scale (const graphene_rect_t *r,
+                float                  sx,
+                float                  sy,
+                graphene_rect_t       *res)
+{
+  if (G_UNLIKELY (sx < 0 || sy < 0))
+    {
+      graphene_rect_scale (r, sx, sy, res);
+      return;
+    }
+
+  res->origin.x = r->origin.x * sx;
+  res->origin.y = r->origin.y * sy;
+  res->size.width = r->size.width * sx;
+  res->size.height = r->size.height * sy;
+}
@@ -3335,6 +3335,7 @@ gsk_container_node_new (GskRenderNode **children,
      self->children = g_malloc_n (n_children, sizeof (GskRenderNode *));

      self->children[0] = gsk_render_node_ref (children[0]);
+      node->offscreen_for_opacity = children[0]->offscreen_for_opacity;
      gsk_rect_init_from_rect (&bounds, &(children[0]->bounds));
      node->preferred_depth = gdk_memory_depth_merge (node->preferred_depth,
                                                      gsk_render_node_get_preferred_depth (children[0]));
@@ -4091,6 +4092,7 @@ gsk_repeat_node_draw_tiled (cairo_t                *cr,
                            const graphene_rect_t  *child_bounds)
 {
  cairo_pattern_t *pattern;
+  cairo_matrix_t matrix;

  cairo_save (cr);
  /* reset the clip so we get an unclipped pattern for repeating */
@@ -4107,6 +4109,11 @@ gsk_repeat_node_draw_tiled (cairo_t                *cr,
  cairo_restore (cr);

  cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+  cairo_pattern_get_matrix (pattern, &matrix);
+  cairo_matrix_translate (&matrix,
+                          - x * child_bounds->size.width,
+                          - y * child_bounds->size.height);
+  cairo_pattern_set_matrix (pattern, &matrix);
  cairo_set_source (cr, pattern);
  cairo_pattern_destroy (pattern);

@@ -5658,6 +5665,7 @@ struct _GskTextNode
 {
  GskRenderNode render_node;

+  PangoFontMap *fontmap;
  PangoFont *font;
  gboolean has_color_glyphs;

@@ -5675,6 +5683,7 @@ gsk_text_node_finalize (GskRenderNode *node)
  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_TEXT_NODE));

  g_object_unref (self->font);
+  g_object_unref (self->fontmap);
  g_free (self->glyphs);

  parent_class->finalize (node);
@@ -5788,6 +5797,7 @@ gsk_text_node_new (PangoFont              *font,
  node = (GskRenderNode *) self;
  node->offscreen_for_opacity = FALSE;

+  self->fontmap = g_object_ref (pango_font_get_font_map (font));
  self->font = g_object_ref (font);
  self->color = *color;
  self->offset = *offset;
@@ -46,12 +46,20 @@
 #include <cairo-script-interpreter.h>
 #endif

+#include <pango/pangocairo.h>
+#ifdef HAVE_PANGOFT
+#include <pango/pangofc-fontmap.h>
+#endif
+
+#include <glib/gstdio.h>
+
 typedef struct _Context Context;

 struct _Context
 {
  GHashTable *named_nodes;
  GHashTable *named_textures;
+  PangoFontMap *fontmap;
 };

 typedef struct _Declaration Declaration;
@@ -65,7 +73,7 @@ struct _Declaration
 };

 static void
-context_init (Context    *context)
+context_init (Context *context)
 {
  memset (context, 0, sizeof (Context));
 }
@@ -75,6 +83,7 @@ context_finish (Context *context)
 {
  g_clear_pointer (&context->named_nodes, g_hash_table_unref);
  g_clear_pointer (&context->named_textures, g_hash_table_unref);
+  g_clear_object (&context->fontmap);
 }

 static gboolean
@@ -844,20 +853,35 @@ parse_mask_mode (GtkCssParser *parser,
 }

 static PangoFont *
-font_from_string (const char *string)
+font_from_string (PangoFontMap *fontmap,
+                  const char   *string)
 {
  PangoFontDescription *desc;
-  PangoFontMap *font_map;
-  PangoContext *context;
+  PangoContext *ctx;
  PangoFont *font;

  desc = pango_font_description_from_string (string);
-  font_map = pango_cairo_font_map_get_default ();
-  context = pango_font_map_create_context (font_map);
-  font = pango_font_map_load_font (font_map, context, desc);
+  ctx = pango_font_map_create_context (fontmap);
+  font = pango_font_map_load_font (fontmap, ctx, desc);
+  g_object_unref (ctx);
+
+  if (font)
+    {
+      PangoFontDescription *desc2;
+      const char *family, *family2;
+
+      desc2 = pango_font_describe (font);
+
+      family = pango_font_description_get_family (desc);
+      family2 = pango_font_description_get_family (desc2);
+
+      if (g_strcmp0 (family, family2) != 0)
+        g_clear_object (&font);
+
+      pango_font_description_free (desc2);
+    }

  pango_font_description_free (desc);
-  g_object_unref (context);

  return font;
 }
@@ -926,30 +950,229 @@ create_ascii_glyphs (PangoFont *font)
  return result;
 }

+#ifdef HAVE_PANGOFT
+
+static void
+delete_file (gpointer data)
+{
+  char *path = data;
+
+  g_remove (path);
+  g_free (path);
+}
+
+static void
+ensure_fontmap (Context *context)
+{
+  FcConfig *config;
+  GPtrArray *files;
+
+  if (context->fontmap)
+    return;
+
+  context->fontmap = pango_cairo_font_map_new ();
+
+  config = FcInitLoadConfig ();
+  pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (context->fontmap), config);
+  FcConfigDestroy (config);
+
+  files = g_ptr_array_new_with_free_func (delete_file);
+
+  g_object_set_data_full (G_OBJECT (context->fontmap), "font-files", files, (GDestroyNotify) g_ptr_array_unref);
+}
+
+static gboolean
+add_font_from_file (Context     *context,
+                    const char  *path,
+                    GError     **error)
+{
+  FcConfig *config;
+  GPtrArray *files;
+
+  ensure_fontmap (context);
+
+  if (!PANGO_IS_FC_FONT_MAP (context->fontmap))
+    {
+      g_set_error (error,
+                   GTK_CSS_PARSER_ERROR,
+                   GTK_CSS_PARSER_ERROR_FAILED,
+                   "Custom fonts are not implemented for %s", G_OBJECT_TYPE_NAME (context->fontmap));
+      return FALSE;
+    }
+
+  config = pango_fc_font_map_get_config (PANGO_FC_FONT_MAP (context->fontmap));
+
+  if (!FcConfigAppFontAddFile (config, (FcChar8 *) path))
+    {
+      g_set_error (error,
+                   GTK_CSS_PARSER_ERROR,
+                   GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
+                   "Failed to load font");
+      return FALSE;
+    }
+
+  files = (GPtrArray *) g_object_get_data (G_OBJECT (context->fontmap), "font-files");
+  g_ptr_array_add (files, g_strdup (path));
+
+  pango_fc_font_map_config_changed (PANGO_FC_FONT_MAP (context->fontmap));
+
+  return TRUE;
+}
+
+static gboolean
+add_font_from_bytes (Context  *context,
+                     GBytes   *bytes,
+                     GError  **error)
+{
+  GFile *file;
+  GIOStream *iostream;
+  GOutputStream *ostream;
+  gboolean result;
+
+  file = g_file_new_tmp ("gtk4-font-XXXXXX.ttf", (GFileIOStream **) &iostream, error);
+  if (!file)
+    return FALSE;
+
+  ostream = g_io_stream_get_output_stream (iostream);
+  if (g_output_stream_write_bytes (ostream, bytes, NULL, error) == -1)
+    {
+      g_object_unref (file);
+      g_object_unref (iostream);
+
+      return FALSE;
+    }
+
+  g_io_stream_close (iostream, NULL, NULL);
+  g_object_unref (iostream);
+
+  result = add_font_from_file (context, g_file_peek_path (file), error);
+
+  g_object_unref (file);
+
+  return result;
+}
+
+#else /* !HAVE_PANGOFT */
+
+static gboolean
+add_font_from_bytes (Context  *context,
+                     GBytes   *bytes,
+                     GError  **error)
+{
+  g_set_error (error,
+               GTK_CSS_PARSER_ERROR,
+               GTK_CSS_PARSER_ERROR_FAILED,
+               "Not implemented");
+  return FALSE;
+}
+
+#endif
+
 static gboolean
 parse_font (GtkCssParser *parser,
            Context      *context,
            gpointer      out_font)
 {
-  PangoFont *font;
-  char *s;
+  PangoFont *font = NULL;
+  char *font_name;

-  s = gtk_css_parser_consume_string (parser);
-  if (s == NULL)
+  font_name = gtk_css_parser_consume_string (parser);
+  if (font_name == NULL)
    return FALSE;

-  font = font_from_string (s);
-  if (font == NULL)
+  if (context->fontmap)
+    font = font_from_string (context->fontmap, font_name);
+
+  if (gtk_css_parser_has_url (parser))
    {
-      gtk_css_parser_error_syntax (parser, "This font does not exist.");
-      return FALSE;
+      char *url;
+
+      if (font != NULL)
+        {
+          gtk_css_parser_error_value (parser, "A font with this name already exists.");
+          /* consume the url to avoid more errors */
+          url = gtk_css_parser_consume_url (parser);
+          g_free (url);
+        }
+      else
+        {
+          char *scheme;
+          GBytes *bytes;
+          GError *error = NULL;
+          GtkCssLocation start_location;
+          gboolean success = FALSE;
+
+          start_location = *gtk_css_parser_get_start_location (parser);
+          url = gtk_css_parser_consume_url (parser);
+
+          if (url != NULL)
+            {
+              scheme = g_uri_parse_scheme (url);
+              if (scheme && g_ascii_strcasecmp (scheme, "data") == 0)
+                {
+                  bytes = gtk_css_data_url_parse (url, NULL, &error);
+                }
+              else
+                {
+                  GFile *file;
+
+                  file = g_file_new_for_uri (url);
+                  bytes = g_file_load_bytes (file, NULL, NULL, &error);
+                  g_object_unref (file);
+                }
+
+              g_free (scheme);
+              g_free (url);
+              if (bytes != NULL)
+                {
+                  success = add_font_from_bytes (context, bytes, &error);
+                  g_bytes_unref (bytes);
+                }
+
+              if (!success)
+                {
+                  gtk_css_parser_emit_error (parser,
+                                             &start_location,
+                                             gtk_css_parser_get_end_location (parser),
+                                             error);
+                }
+            }
+
+          if (success)
+            {
+              font = font_from_string (context->fontmap, font_name);
+              if (!font)
+                {
+                  gtk_css_parser_error (parser,
+                                        GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
+                                        &start_location,
+                                        gtk_css_parser_get_end_location (parser),
+                                        "The given url does not define a font named \"%s\"",
+                                        font_name);
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!font)
+        font = font_from_string (pango_cairo_font_map_get_default (), font_name);
+
+      if (!font)
+        gtk_css_parser_error_value (parser, "The font \"%s\" does not exist", font_name);
    }

-  *((PangoFont**)out_font) = font;
+  g_free (font_name);

-  g_free (s);
-
-  return TRUE;
+  if (font)
+    {
+      *((PangoFont**)out_font) = font;
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
 }

 static void
@@ -2013,7 +2236,7 @@ parse_text_node (GtkCssParser *parser,

  if (font == NULL)
    {
-      font = font_from_string ("Cantarell 11");
+      font = font_from_string (pango_cairo_font_map_get_default (), "Cantarell 11");
      g_assert (font);
    }

@@ -2629,6 +2852,7 @@ typedef struct
  gsize named_node_counter;
  GHashTable *named_textures;
  gsize named_texture_counter;
+  GHashTable *serialized_fonts;
 } Printer;

 static void
@@ -2781,6 +3005,7 @@ printer_init (Printer       *self,
  self->named_node_counter = 0;
  self->named_textures = g_hash_table_new_full (NULL, NULL, NULL, g_free);
  self->named_texture_counter = 0;
+  self->serialized_fonts = g_hash_table_new (g_str_hash, g_str_equal);

  printer_init_duplicates_for_node (self, node);
 }
@@ -2792,6 +3017,7 @@ printer_clear (Printer *self)
    g_string_free (self->str, TRUE);
  g_hash_table_unref (self->named_nodes);
  g_hash_table_unref (self->named_textures);
+  g_hash_table_unref (self->serialized_fonts);
 }

 #define IDENT_LEVEL 2 /* Spaces per level */
@@ -3235,6 +3461,59 @@ append_texture_param (Printer    *p,
  g_bytes_unref (bytes);
 }

+static void
+gsk_text_node_serialize_font (GskRenderNode *node,
+                              Printer       *p)
+{
+  PangoFont *font = gsk_text_node_get_font (node);
+  PangoFontMap *fontmap = pango_font_get_font_map (font);
+  PangoFontDescription *desc;
+  char *s;
+
+  desc = pango_font_describe (font);
+  s = pango_font_description_to_string (desc);
+  g_string_append_printf (p->str, "\"%s\"", s);
+  g_free (s);
+  pango_font_description_free (desc);
+
+  /* Check if this is  a custom font that we created from a url */
+  if (!g_object_get_data (G_OBJECT (fontmap), "font-files"))
+    return;
+
+#ifdef HAVE_PANGOFT
+  {
+    FcPattern *pat;
+    FcResult res;
+    const char *file;
+    char *data;
+    gsize len;
+    char *b64;
+
+    pat = pango_fc_font_get_pattern (PANGO_FC_FONT (font));
+    res = FcPatternGetString (pat, FC_FILE, 0, (FcChar8 **)&file);
+    if (res != FcResultMatch)
+      return;
+
+    if (g_hash_table_contains (p->serialized_fonts, file))
+      return;
+
+    if (!g_file_get_contents (file, &data, &len, NULL))
+      return;
+
+    g_hash_table_add (p->serialized_fonts, (gpointer) file);
+
+    b64 = base64_encode_with_linebreaks ((const guchar *) data, len);
+
+    g_string_append (p->str, " url(\"data:font/ttf;base64,");
+    append_escaping_newlines (p->str, b64);
+    g_string_append (p->str, "\")");
+
+    g_free (b64);
+    g_free (data);
+  }
+#endif
+}
+
 void
 gsk_text_node_serialize_glyphs (GskRenderNode *node,
                                GString       *p)
@@ -3788,29 +4067,21 @@ render_node_print (Printer       *p,
      {
        const graphene_point_t *offset = gsk_text_node_get_offset (node);
        const GdkRGBA *color = gsk_text_node_get_color (node);
-        PangoFont *font = gsk_text_node_get_font (node);
-        PangoFontDescription *desc;
-        char *font_name;

        start_node (p, "text", node_name);

-        if (!gdk_rgba_equal (color, &GDK_RGBA("000000")))
+        if (!gdk_rgba_equal (color, &GDK_RGBA ("000000")))
          append_rgba_param (p, "color", color);

        _indent (p);
-        desc = pango_font_describe (font);
-        font_name = pango_font_description_to_string (desc);
-        g_string_append_printf (p->str, "font: \"%s\";\n", font_name);
-        g_free (font_name);
-        pango_font_description_free (desc);
+        g_string_append (p->str, "font: ");
+        gsk_text_node_serialize_font (node, p);
+        g_string_append (p->str, ";\n");

        _indent (p);
        g_string_append (p->str, "glyphs: ");
-
        gsk_text_node_serialize_glyphs (node, p->str);
-
-        g_string_append_c (p->str, ';');
-        g_string_append_c (p->str, '\n');
+        g_string_append (p->str, ";\n");

        if (!graphene_point_equal (offset, graphene_point_zero ()))
          append_point_param (p, "offset", offset);
@@ -6,4 +6,3 @@
 GskRenderNode * gsk_render_node_deserialize_from_bytes  (GBytes            *bytes,
                                                         GskParseErrorFunc  error_func,
                                                         gpointer           user_data);
-
@@ -311,8 +311,8 @@ gsk_rounded_rect_scale_affine (GskRoundedRect       *dest,
  graphene_rect_scale (&src->bounds, scale_x, scale_y, &dest->bounds);
  graphene_rect_offset (&dest->bounds, dx, dy);

-  scale_x = fabs (scale_x);
-  scale_y = fabs (scale_y);
+  scale_x = fabsf (scale_x);
+  scale_y = fabsf (scale_y);

  for (guint i = 0; i < 4; i++)
    {
@@ -0,0 +1,22 @@
+/* GSK - The GTK Scene Kit
+ * Copyright 2024 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+typedef struct _Scale   Scale;
+typedef struct _Point   Point;
+typedef struct _Box     Box;
@@ -0,0 +1,252 @@
+#pragma once
+
+#include "gsktypesprivate.h"
+#include <graphene.h>
+#include <math.h>
+#include <smmintrin.h>
+
+#include "scaleprivate.h"
+
+#ifndef USE_SIMD
+
+struct _Point
+{
+  float x, y;
+};
+
+static inline float
+point_x (const Point p)
+{
+  return p.x;
+}
+
+static inline float
+point_y (const Point p)
+{
+  return p.y;
+}
+
+static inline Point
+point (float x,
+       float y)
+{
+  return (Point) { .x = x, .y = y };
+}
+
+static inline Point
+point_from_graphene (const graphene_point_t *p)
+{
+  return point (p->x, p->y);
+}
+
+static inline void
+point_to_float (const Point p,
+                float       v[2])
+{
+  v[0] = p.x;
+  v[1] = p.y;
+}
+
+static inline Point
+point_zero (void)
+{
+  return point (0, 0);
+}
+
+static inline Point
+point_neg (const Point p)
+{
+  return (Point) { .x = -p.x, .y = -p.y };
+}
+
+static inline Point
+point_mul (const Point p,
+           const Scale s)
+{
+  return (Point) { .x = p.x * s.x, .y = p.y * s.y };
+}
+
+static inline Point
+point_div (const Point p,
+           const Scale s)
+{
+  return (Point) { .x = p.x / s.x, .y = p.y / s.y };
+}
+
+static inline Point
+point_add (const Point p1,
+           const Point p2)
+{
+  return (Point) { .x = p1.x + p2.x, .y = p1.y + p2.y };
+}
+
+static inline Point
+point_sub (const Point p1,
+           const Point p2)
+{
+  return (Point) { .x = p1.x - p2.x, .y = p1.y - p2.y };
+}
+
+static inline Point
+point_floor (const Point p)
+{
+  return (Point) { .x = floorf (p.x), .y = floorf (p.y) };
+}
+
+static inline Point
+point_ceil (const Point p)
+{
+  return (Point) { .x = ceilf (p.x), .y = ceilf (p.y) };
+}
+
+static inline Point
+point_round (const Point p)
+{
+  return (Point) { .x = roundf (p.x), .y = roundf (p.y) };
+}
+
+#else  /* USE_SIMD */
+
+#include <smmintrin.h>
+
+struct _Point
+{
+  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
+};
+
+static inline float
+point_x (const Point p)
+{
+  return graphene_simd4f_get_x (p.v);
+}
+
+static inline float
+point_y (const Point p)
+{
+  return graphene_simd4f_get_y (p.v);
+}
+
+static inline Point
+point (float x,
+       float y)
+{
+  return (Point) { .v = graphene_simd4f_init (x, y, 0.f, 0.f) };
+}
+
+static inline Point
+point_from_graphene (const graphene_point_t *p)
+{
+  return point (p->x, p->y);
+}
+
+static inline void
+point_to_float (const Point p,
+                float       v[2])
+{
+  graphene_simd4f_dup_2f (p.v, v);
+}
+
+static inline Point
+point_zero (void)
+{
+  return point (0, 0);
+}
+
+static inline Point
+point_neg (const Point p)
+{
+  return (Point) { .v = graphene_simd4f_neg (p.v) };
+}
+
+static inline Point
+point_mul (const Point p,
+           const Scale s)
+{
+  return (Point) { .v = graphene_simd4f_mul (p.v, s.v) };
+}
+
+static inline Point
+point_div (const Point p,
+           const Scale s)
+{
+  return (Point) { .v = graphene_simd4f_div (p.v, s.v) };
+}
+
+static inline Point
+point_add (const Point p1,
+           const Point p2)
+{
+  return (Point) { .v = graphene_simd4f_add (p1.v, p2.v) };
+}
+
+static inline Point
+point_sub (const Point p1,
+           const Point p2)
+{
+  return (Point) { .v = graphene_simd4f_sub (p1.v, p2.v) };
+}
+
+#ifdef __SSE4_1__
+
+#ifndef graphene_simd4f_floor
+#  define graphene_simd4f_floor(v) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_floor_ps ((v)); \
+  }))
+#endif
+
+#ifndef graphene_simd4f_ceil
+#  define graphene_simd4f_ceil(v) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_ceil_ps ((v)); \
+  }))
+#endif
+
+#ifndef graphene_simd4f_round
+#  define graphene_simd4f_round(v) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_round_ps ((v)); \
+  }))
+#endif
+
+static inline Point
+point_floor (const Point p)
+{
+  return (Point) { .v = graphene_simd4f_floor (p.v) };
+}
+
+static inline Point
+point_ceil (const Point p)
+{
+  return (Point) { .v = graphene_simd4f_ceil (p.v) };
+}
+
+static inline Point
+point_round (const Point p)
+{
+  return (Point) { .v = graphene_simd4f_round (p.v) };
+}
+
+#else
+
+static inline Point
+point_floor (const Point p)
+{
+  return point (floorf (point_x (p)), floorf (point_y (p)));
+}
+
+static inline Point
+point_ceil (const Point p)
+{
+  return point (ceilf (point_x (p)), ceilf (point_y (p)));
+}
+
+static inline Point
+point_round (const Point p)
+{
+  return point (roundf (point_x (p)), roundf (point_y (p)));
+}
+
+#endif
+
+#endif
@@ -0,0 +1,183 @@
+#pragma once
+
+#include "gsktypesprivate.h"
+#include <graphene.h>
+#include <math.h>
+
+#ifndef USE_SIMD
+
+struct _Scale
+{
+  float x, y;
+};
+
+static inline float
+scale_x (const Scale s)
+{
+  return s.x;
+}
+
+static inline float
+scale_y (const Scale s)
+{
+  return s.y;
+}
+
+static inline Scale
+scale (float x,
+       float y)
+{
+  return (Scale) { .x = x, .y = y };
+}
+
+static inline Scale
+scale_from_float (float s)
+{
+  return scale (s, s);
+}
+
+static inline Scale
+scale_from_graphene (const graphene_vec2_t *v)
+{
+  return (Scale) { .x = graphene_vec2_get_x (v), .y = graphene_vec2_get_y (v) };
+}
+
+static inline void
+scale_to_float (const Scale s,
+                float       v[2])
+{
+  v[0] = s.x;
+  v[1] = s.y;
+}
+
+static inline gboolean
+scale_equal (const Scale s1,
+             const Scale s2)
+{
+  return (gboolean) (s1.x == s2.x && s1.y == s2.y);
+}
+
+static inline Scale
+scale_one (void)
+{
+  return scale (1, 1);
+}
+
+static inline Scale
+scale_inv (const Scale s)
+{
+  return (Scale) { .x = 1 / s.x, .y = 1 / s.y };
+}
+
+static inline Scale
+scale_mul (const Scale s1,
+           const Scale s2)
+{
+  return (Scale) { .x = s1.x * s2.x, .y = s1.y * s2.y };
+}
+
+static inline Scale
+scale_div (const Scale s1,
+           const Scale s2)
+{
+  return (Scale) { .x = s1.x / s2.x, .y = s1.y / s2.y };
+}
+
+static inline Scale
+scale_max (const Scale s)
+{
+  return (Scale) { .x = MAX (s.x, s.y), .y = MAX (s.x, s.y) };
+}
+
+#else  /* USE_SIMD */
+
+struct _Scale
+{
+  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
+};
+
+static inline float
+scale_x (const Scale s)
+{
+  return graphene_simd4f_get_x (s.v);
+}
+
+static inline float
+scale_y (const Scale s)
+{
+  return graphene_simd4f_get_y (s.v);
+}
+
+static inline Scale
+scale (float x,
+       float y)
+{
+  return (Scale) { .v = graphene_simd4f_init (x, y, 0.f, 0.f) };
+}
+
+static inline Scale
+scale_from_float (float s)
+{
+  return scale (s, s);
+}
+
+static inline Scale
+scale_from_graphene (const graphene_vec2_t *v)
+{
+  return (Scale) { .v = v->__graphene_private_value };
+}
+
+static inline void
+scale_to_float (const Scale s,
+                float       v[2])
+{
+  graphene_simd4f_dup_2f (s.v, v);
+}
+
+static inline gboolean
+scale_equal (const Scale s1,
+             const Scale s2)
+{
+  return (gboolean) graphene_simd4f_cmp_eq (s1.v, s2.v);
+}
+
+static inline Scale
+scale_one (void)
+{
+  return scale (1, 1);
+}
+
+static inline Scale
+scale_inv (const Scale s)
+{
+  return (Scale) { .v = graphene_simd4f_reciprocal (s.v) };
+}
+
+static inline Scale
+scale_mul (const Scale s1,
+           const Scale s2)
+{
+  return (Scale) { .v = graphene_simd4f_mul (s1.v, s2.v) };
+}
+
+static inline Scale
+scale_div (const Scale s1,
+           const Scale s2)
+{
+  return (Scale) { .v = graphene_simd4f_div (s1.v, s2.v) };
+}
+
+#ifndef graphene_simd4f_shuffle_yxzw
+#  define graphene_simd4f_shuffle_yxzw(v) \
+  (__extension__ ({ \
+    (graphene_simd4f_t) _mm_shuffle_ps ((v), (v), _MM_SHUFFLE (3, 2, 0, 1)); \
+  }))
+#endif
+
+static inline Scale
+scale_max (const Scale s)
+{
+  return (Scale) { .v = graphene_simd4f_max (graphene_simd4f_shuffle_yxzw (s.v), s.v) };
+}
+
+#endif
@@ -957,6 +957,14 @@ gtk_css_parser_parse_url_arg (GtkCssParser *parser,
  return 1;
 }

+gboolean
+gtk_css_parser_has_url (GtkCssParser *self)
+{
+  return gtk_css_parser_has_token (self, GTK_CSS_TOKEN_URL)
+      || gtk_css_parser_has_token (self, GTK_CSS_TOKEN_BAD_URL)
+      || gtk_css_parser_has_function (self, "url");
+}
+
 /**
 * gtk_css_parser_consume_url:
 * @self: a `GtkCssParser`
@@ -116,6 +116,7 @@ gboolean                gtk_css_parser_has_token                (GtkCssParser
                                                                 GtkCssTokenType                 token_type);
 gboolean                gtk_css_parser_has_ident                (GtkCssParser                   *self,
                                                                 const char                     *ident);
+gboolean                gtk_css_parser_has_url                  (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_number               (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_integer              (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_function             (GtkCssParser                   *self,
@@ -191,7 +191,7 @@ gtk_cell_renderer_accel_class_init (GtkCellRendererAccelClass *cell_accel_class)
                                   PROP_ACCEL_MODS,
                                   g_param_spec_flags ("accel-mods", NULL, NULL,
                                                       GDK_TYPE_MODIFIER_TYPE,
-                                                       0,
+                                                       GDK_NO_MODIFIER_MASK,
                                                       GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));

  /**
@@ -226,10 +226,10 @@ gtk_cell_renderer_accel_class_init (GtkCellRendererAccelClass *cell_accel_class)

  /**
   * GtkCellRendererAccel::accel-edited:
-   * @accel: the object reveiving the signal
+   * @accel: the object receiving the signal
   * @path_string: the path identifying the row of the edited cell
   * @accel_key: the new accelerator keyval
-   * @accel_mods: the new acclerator modifier mask
+   * @accel_mods: the new accelerator modifier mask
   * @hardware_keycode: the keycode of the new accelerator
   *
   * Gets emitted when the user has selected a new accelerator.
@@ -248,7 +248,7 @@ gtk_cell_renderer_accel_class_init (GtkCellRendererAccelClass *cell_accel_class)

  /**
   * GtkCellRendererAccel::accel-cleared:
-   * @accel: the object reveiving the signal
+   * @accel: the object receiving the signal
   * @path_string: the path identifying the row of the edited cell
   *
   * Gets emitted when the user has removed the accelerator.
@@ -724,7 +724,7 @@ gtk_cell_editable_widget_new (GtkCellRenderer          *cell,
  gtk_widget_set_state_flags (box->label, GTK_STATE_FLAG_SELECTED, TRUE);

  /* This label is displayed in a treeview cell displaying an accelerator
-   * when the cell is clicked to change the acelerator.
+   * when the cell is clicked to change the accelerator.
   */
  gtk_label_set_text (GTK_LABEL (box->label), _("New accelerator…"));

@@ -403,7 +403,7 @@ gtk_file_chooser_set_current_folder (GtkFileChooser  *chooser,
                                     GError         **error)
 {
  g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE);
-  g_return_val_if_fail (G_IS_FILE (file), FALSE);
+  g_return_val_if_fail (file == NULL || G_IS_FILE (file), FALSE);
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  return GTK_FILE_CHOOSER_GET_IFACE (chooser)->set_current_folder (chooser, file, error);
@@ -2427,7 +2427,7 @@ gtk_tree_view_size_allocate_columns (GtkWidget *widget)
 	{
 	  if (number_of_expand_columns == 1)
 	    {
-	      /* We add the remander to the last column as
+	      /* We add the remainder to the last column as
 	       * */
 	      column_width += extra;
 	    }
@@ -67,7 +67,7 @@ gboolean        gtk_accessible_role_is_abstract       (GtkAccessibleRole role);
 * @GTK_ACCESSIBLE_NAME_ALLOWED:
 *   The role allows an accessible name and description
 * @GTK_ACCESSIBLE_NAME_PROHIBITED:
- *   The role does not allow an accessible name and descirption
+ *   The role does not allow an accessible name and description
 * @GTK_ACCESSIBLE_NAME_REQUIRED:
 *   The role requires an accessible name and description
 * @GTK_ACCESSIBLE_NAME_RECOMMENDED:
@@ -21,7 +21,7 @@
 *
 * If that is not the case, a warning will be issued at run time.
 *
- * In addition to this interface, its implementors are expected to provide the
+ * In addition to this interface, its implementers are expected to provide the
 * correct values for the following properties:
 *
 * - `GTK_ACCESSIBLE_PROPERTY_VALUE_MAX`
--- a/Show More
+++ b/Show More