Add a GskPoint type and use it for offsets

This has a tremendous ripple effect and is kind of disastrous.

.gitlab-ci/flatpak-build.sh

@@ -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 \

CONTRIBUTING.md

@@ -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:
 

NEWS

@@ -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

demos/gtk-demo/font_features.c

@@ -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;
    }
 

demos/gtk-demo/main.c

@@ -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;

demos/gtk-demo/meson.build

@@ -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],

demos/gtk-demo/paintable.c

@@ -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 */

demos/gtk-demo/paintable_animated.c

@@ -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

demos/gtk-demo/paintable_mediastream.c

@@ -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

demos/icon-browser/iconbrowserapp.c

@@ -4,7 +4,7 @@
 #include "iconbrowserapp.h"
 #include "iconbrowserwin.h"
 
-#include "demo_conf.h"
+#include "profile_conf.h"
 
 struct _IconBrowserApp
 {

demos/icon-browser/meson.build

@@ -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,

demos/meson.build

@@ -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()

demos/node-editor/meson.build

@@ -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',

demos/node-editor/node-editor-application.c

@@ -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;
 }

demos/node-editor/node-editor-window.c

@@ -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,79 @@ edit_action_cb (GtkWidget  *widget,
   node_editor_window_edit (self, &start);
 }
 
+static void
+node_editor_window_map (GtkWidget *widget)
+{
+  char *path;
+
+  GTK_WIDGET_CLASS (node_editor_window_parent_class)->map (widget);
+
+  path = get_autosave_path (NULL);
+  if (g_file_test (path, G_FILE_TEST_EXISTS))
+    {
+      g_free (path);
+      return;
+    }
+
+  g_free (path);
+}
+
+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 +1651,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 +1660,14 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
   widget_class->realize = node_editor_window_realize;
   widget_class->unrealize = node_editor_window_unrealize;
 
+  widget_class->map = node_editor_window_map;
+
+  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 +1677,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 +1690,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 +1742,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 +1881,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 +1922,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"))
     {

demos/node-editor/node-editor-window.h

@@ -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);

demos/node-editor/node-editor-window.ui

@@ -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>

demos/node-editor/node-format.md

@@ -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=")

demos/print-editor/meson.build

@@ -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,

demos/print-editor/print-editor.c

@@ -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;

demos/widget-factory/meson.build

@@ -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,

demos/widget-factory/widget-factory.c

@@ -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,

docs/reference/gtk/css-properties.md

@@ -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

docs/reference/gtk/gtk4-node-editor.rst

@@ -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.

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

@@ -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.
+
+
+
+
+

docs/reference/gtk/running.md

@@ -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`
 

docs/reference/gtk/section-accessibility.md

@@ -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.
 

gdk/gdkdevice.c

@@ -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);

gdk/gdkdmabufformats.c

@@ -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

gdk/gdkdmabuftexturebuilder.c

@@ -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]

gdk/gdkdrag.c

@@ -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 {

gdk/gdkdrawcontext.c

@@ -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.

gdk/gdkgltexture.c

@@ -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 *

gdk/gdkgltexturebuilder.c

@@ -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

gdk/gdkmemoryformat.c

@@ -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);

gdk/gdkmemoryformatprivate.h

@@ -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,

gdk/gdktexture.c

@@ -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

gdk/gdktexturedownloader.c

@@ -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.

gdk/gdkvulkancontext.c

@@ -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" },

gdk/macos/edgesnapping.c

@@ -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);

gdk/macos/gdkmacoseventsource.c

@@ -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,

gdk/macos/gdkmacosglcontext.c

@@ -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)

gdk/wayland/gdkcursor-wayland.c

@@ -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;

gdk/wayland/gdkdisplay-wayland.c

@@ -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);
     }

gdk/wayland/gdkseat-wayland.c

@@ -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 *

gdk/wayland/gdktoplevel-wayland.c

@@ -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.
        */

gdk/win32/gdkclipdrop-win32.c

@@ -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,

gdk/win32/gdkevents-win32.c

@@ -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))

gdk/win32/gdksurface-win32.h

@@ -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;

gdk/x11/gdksettings.c

@@ -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"},

gsk/gl/gskglcommandqueue.c

@@ -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,

gsk/gl/gskgldriver.c

@@ -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.
  *

gsk/gl/gskglrenderjob.c

@@ -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)

gsk/gl/gskgltexturelibrary.c

@@ -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);

gsk/gl/resources/coloring.glsl

@@ -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

gsk/gpu/gskgldevice.c

@@ -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,

gsk/gpu/gskgpublendmodeop.c

@@ -60,7 +60,7 @@ gsk_gpu_blend_mode_op (GskGpuFrame            *frame,
                        GskGpuShaderClip        clip,
                        GskGpuDescriptors      *desc,
                        const graphene_rect_t  *rect,
-                       const graphene_point_t *offset,
+                       const GskPoint         *offset,
                        float                   opacity,
                        GskBlendMode            blend_mode,
                        guint32                 bottom_descriptor,

gsk/gpu/gskgpublendmodeopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_blend_mode_op                           (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          float                           opacity,
                                                                          GskBlendMode                    blend_mode,
                                                                          guint32                         start_descriptor,

gsk/gpu/gskgpublurop.c

@@ -63,9 +63,9 @@ gsk_gpu_blur_op_full (GskGpuFrame            *frame,
                       GskGpuDescriptors      *desc,
                       guint32                 descriptor,
                       const graphene_rect_t  *rect,
-                      const graphene_point_t *offset,
+                      const GskPoint         *offset,
                       const graphene_rect_t  *tex_rect,
-                      const graphene_vec2_t  *blur_direction,
+                      const graphene_point_t *blur_direction,
                       const GdkRGBA          *blur_color)
 {
   GskGpuBlurInstance *instance;
@@ -79,7 +79,8 @@ gsk_gpu_blur_op_full (GskGpuFrame            *frame,
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  graphene_vec2_to_float (blur_direction, instance->blur_direction);
+  instance->blur_direction[0] = blur_direction->x;
+  instance->blur_direction[1] = blur_direction->y;
   gsk_gpu_rgba_to_float (blur_color, instance->blur_color);
   instance->tex_id = descriptor;
 }
@@ -90,9 +91,9 @@ gsk_gpu_blur_op (GskGpuFrame            *frame,
                  GskGpuDescriptors      *desc,
                  guint32                 descriptor,
                  const graphene_rect_t  *rect,
-                 const graphene_point_t *offset,
+                 const GskPoint         *offset,
                  const graphene_rect_t  *tex_rect,
-                 const graphene_vec2_t  *blur_direction)
+                 const graphene_point_t *blur_direction)
 {
   gsk_gpu_blur_op_full (frame,
                         0,
@@ -112,9 +113,9 @@ gsk_gpu_blur_shadow_op (GskGpuFrame            *frame,
                         GskGpuDescriptors      *desc,
                         guint32                 descriptor,
                         const graphene_rect_t  *rect,
-                        const graphene_point_t *offset,
+                        const GskPoint         *offset,
                         const graphene_rect_t  *tex_rect,
-                        const graphene_vec2_t  *blur_direction,
+                        const graphene_point_t *blur_direction,
                         const GdkRGBA          *shadow_color)
 {
   gsk_gpu_blur_op_full (frame,

gsk/gpu/gskgpubluropprivate.h

@@ -11,18 +11,18 @@ void                    gsk_gpu_blur_op                                 (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect,
-                                                                         const graphene_vec2_t          *blur_direction);
+                                                                         const graphene_point_t         *blur_direction);
 
 void                    gsk_gpu_blur_shadow_op                          (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect,
-                                                                         const graphene_vec2_t          *blur_direction,
+                                                                         const graphene_point_t         *blur_direction,
                                                                          const GdkRGBA                  *shadow_color);
 
 

gsk/gpu/gskgpuborderop.c

@@ -103,7 +103,7 @@ void
 gsk_gpu_border_op (GskGpuFrame            *frame,
                    GskGpuShaderClip        clip,
                    const GskRoundedRect   *outline,
-                   const graphene_point_t *offset,
+                   const GskPoint         *offset,
                    const graphene_point_t *inside_offset,
                    const float             widths[4],
                    const GdkRGBA           colors[4])
@@ -118,7 +118,7 @@ gsk_gpu_border_op (GskGpuFrame            *frame,
                            NULL,
                            &instance);
 
-  gsk_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
 
   for (i = 0; i < 4; i++)
     {

gsk/gpu/gskgpuborderopprivate.h

@@ -10,7 +10,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_border_op                               (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          const GskRoundedRect           *outline,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_point_t         *inside_offset,
                                                                          const float                     widths[4],
                                                                          const GdkRGBA                   colors[4]);

gsk/gpu/gskgpuboxshadowop.c

@@ -86,7 +86,7 @@ gsk_gpu_box_shadow_op (GskGpuFrame            *frame,
                        const graphene_point_t *shadow_offset,
                        float                   spread,
                        float                   blur_radius,
-                       const graphene_point_t *offset,
+                       const GskPoint         *offset,
                        const GdkRGBA          *color)
 {
   GskGpuBoxshadowInstance *instance;
@@ -102,11 +102,10 @@ gsk_gpu_box_shadow_op (GskGpuFrame            *frame,
                            &instance);
 
   gsk_gpu_rect_to_float (bounds, offset, instance->bounds);
-  gsk_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
   gsk_gpu_rgba_to_float (color, instance->color);
   instance->shadow_offset[0] = shadow_offset->x;
   instance->shadow_offset[1] = shadow_offset->y;
   instance->shadow_spread = spread;
   instance->blur_radius = blur_radius;
 }
-

gsk/gpu/gskgpuboxshadowopprivate.h

@@ -15,7 +15,7 @@ void                    gsk_gpu_box_shadow_op                                  (
                                                                                 const graphene_point_t         *shadow_offset,
                                                                                 float                           spread,
                                                                                 float                           blur_radius,
-                                                                                const graphene_point_t         *offset,
+                                                                                const GskPoint                 *offset,
                                                                                 const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpuclip.c

@@ -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))
@@ -231,12 +238,10 @@ gsk_gpu_clip_transform (GskGpuClip            *dest,
 
 gboolean
 gsk_gpu_clip_may_intersect_rect (const GskGpuClip       *self,
-                                 const graphene_point_t *offset,
+                                 const GskPoint         *offset,
                                  const graphene_rect_t  *rect)
 {
-  graphene_rect_t r = *rect;
-  r.origin.x += offset->x;
-  r.origin.y += offset->y;
+  graphene_rect_t r = gsk_rect_add_offset (*rect, *offset);
 
   switch (self->type)
     {
@@ -246,6 +251,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);
@@ -254,12 +260,10 @@ gsk_gpu_clip_may_intersect_rect (const GskGpuClip       *self,
 
 gboolean
 gsk_gpu_clip_contains_rect (const GskGpuClip       *self,
-                            const graphene_point_t *offset,
+                            const GskPoint         *offset,
                             const graphene_rect_t  *rect)
 {
-  graphene_rect_t r = *rect;
-  r.origin.x += offset->x;
-  r.origin.y += offset->y;
+  graphene_rect_t r = gsk_rect_add_offset (*rect, *offset);
 
   switch (self->type)
     {
@@ -269,6 +273,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);
 
@@ -279,10 +284,11 @@ gsk_gpu_clip_contains_rect (const GskGpuClip       *self,
 
 GskGpuShaderClip
 gsk_gpu_clip_get_shader_clip (const GskGpuClip       *self,
-                              const graphene_point_t *offset,
+                              const GskPoint         *offset,
                               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)

gsk/gpu/gskgpuclipprivate.h

@@ -18,6 +18,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 +37,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,
@@ -54,15 +59,15 @@ gboolean                gsk_gpu_clip_transform                          (GskGpuC
                                                                          GskTransform           *transform,
                                                                          const graphene_rect_t  *viewport) G_GNUC_WARN_UNUSED_RESULT;
 
-gboolean                gsk_gpu_clip_contains_rect                      (const GskGpuClip    *self,
-                                                                         const graphene_point_t *offset,
+gboolean                gsk_gpu_clip_contains_rect                      (const GskGpuClip       *self,
+                                                                         const GskPoint         *offset,
                                                                          const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-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,
-                                                                         const graphene_point_t *offset,
-                                                                         const graphene_rect_t  *rect);
+gboolean                gsk_gpu_clip_may_intersect_rect                 (const GskGpuClip      *self,
+                                                                         const GskPoint        *offset,
+                                                                         const graphene_rect_t *rect) G_GNUC_WARN_UNUSED_RESULT;
+GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip      *self,
+                                                                         const GskPoint        *offset,
+                                                                         const graphene_rect_t *rect);
 
 G_END_DECLS
 

gsk/gpu/gskgpucolorizeop.c

@@ -59,7 +59,7 @@ gsk_gpu_colorize_op (GskGpuFrame            *frame,
                      GskGpuDescriptors      *descriptors,
                      guint32                 descriptor,
                      const graphene_rect_t  *rect,
-                     const graphene_point_t *offset,
+                     const GskPoint         *offset,
                      const graphene_rect_t  *tex_rect,
                      const GdkRGBA          *color)
 {

gsk/gpu/gskgpucolorizeopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_colorize_op                             (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          const GdkRGBA                  *color);
 

gsk/gpu/gskgpucolormatrixop.c

@@ -58,7 +58,7 @@ gsk_gpu_color_matrix_op (GskGpuFrame             *frame,
                          GskGpuDescriptors       *desc,
                          guint32                  descriptor,
                          const graphene_rect_t   *rect,
-                         const graphene_point_t  *offset,
+                         const GskPoint          *offset,
                          const graphene_rect_t   *tex_rect,
                          const graphene_matrix_t *color_matrix,
                          const graphene_vec4_t   *color_offset)
@@ -85,7 +85,7 @@ gsk_gpu_color_matrix_op_opacity (GskGpuFrame             *frame,
                                  GskGpuDescriptors       *desc,
                                  guint32                  descriptor,
                                  const graphene_rect_t   *rect,
-                                 const graphene_point_t  *offset,
+                                 const GskPoint          *offset,
                                  const graphene_rect_t   *tex_rect,
                                  float                    opacity)
 {

gsk/gpu/gskgpucolormatrixopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_color_matrix_op                         (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          const graphene_matrix_t        *color_matrix,
                                                                          const graphene_vec4_t          *color_offset);
@@ -21,7 +21,7 @@ void                    gsk_gpu_color_matrix_op_opacity                 (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          float                           opacity);
 

gsk/gpu/gskgpucolorop.c

@@ -57,7 +57,7 @@ void
 gsk_gpu_color_op (GskGpuFrame            *frame,
                   GskGpuShaderClip        clip,
                   const graphene_rect_t  *rect,
-                  const graphene_point_t *offset,
+                  const GskPoint         *offset,
                   const GdkRGBA          *color)
 {
   GskGpuColorInstance *instance;

gsk/gpu/gskgpucoloropprivate.h

@@ -9,7 +9,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_color_op                                (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpuconicgradientop.c

@@ -59,7 +59,7 @@ gsk_gpu_conic_gradient_op (GskGpuFrame            *frame,
                            const graphene_rect_t  *rect,
                            const graphene_point_t *center,
                            float                   angle,
-                           const graphene_point_t *offset,
+                           const GskPoint         *offset,
                            const GskColorStop     *stops,
                            gsize                   n_stops)
 {

gsk/gpu/gskgpuconicgradientopprivate.h

@@ -13,7 +13,7 @@ void                    gsk_gpu_conic_gradient_op                       (GskGpuF
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *center,
                                                                          float                           angle,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpucrossfadeop.c

@@ -59,7 +59,7 @@ gsk_gpu_cross_fade_op (GskGpuFrame            *frame,
                        GskGpuShaderClip        clip,
                        GskGpuDescriptors      *desc,
                        const graphene_rect_t  *rect,
-                       const graphene_point_t *offset,
+                       const GskPoint         *offset,
                        float                   opacity,
                        float                   progress,
                        guint32                 start_descriptor,

gsk/gpu/gskgpucrossfadeopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_cross_fade_op                           (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          float                           opacity,
                                                                          float                           progress,
                                                                          guint32                         start_descriptor,

gsk/gpu/gskgpudevice.c

@@ -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);
     }
 }
 
@@ -661,7 +661,6 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
       return cache->image;
     }
 
-  cache = g_new (GskGpuCachedGlyph, 1);
   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);
@@ -709,8 +708,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 +720,4 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
 }
 
 /* }}} */
+/* vim:set foldmethod=marker expandtab: */

gsk/gpu/gskgpuframe.c

@@ -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);
 }

gsk/gpu/gskgpuglobalsop.c

@@ -12,6 +12,8 @@
 #include "gskvulkandescriptorsprivate.h"
 #endif
 
+#include "gskrectprivate.h"
+
 typedef struct _GskGpuGlobalsOp GskGpuGlobalsOp;
 
 struct _GskGpuGlobalsOp
@@ -87,15 +89,16 @@ static const GskGpuOpClass GSK_GPU_GLOBALS_OP_CLASS = {
 
 void
 gsk_gpu_globals_op (GskGpuFrame             *frame,
-                    const graphene_vec2_t   *scale,
+                    const GskScale          *scale,
                     const graphene_matrix_t *mvp,
                     const GskRoundedRect    *clip)
 {
   GskGpuGlobalsOp *self;
+  GskPoint zero = gsk_point_init (0, 0);
 
   self = (GskGpuGlobalsOp *) gsk_gpu_op_alloc (frame, &GSK_GPU_GLOBALS_OP_CLASS);
 
   graphene_matrix_to_float (mvp, self->instance.mvp);
-  gsk_rounded_rect_to_float (clip, graphene_point_zero (), self->instance.clip);
-  graphene_vec2_to_float (scale, self->instance.scale);
+  gsk_gpu_rounded_rect_to_float (clip, &zero, self->instance.clip);
+  gsk_scale_to_float (scale, self->instance.scale);
 }

gsk/gpu/gskgpuglobalsopprivate.h

@@ -3,6 +3,7 @@
 #include "gskgpuopprivate.h"
 
 #include <gsk/gskroundedrect.h>
+#include "gsk/gskscaleprivate.h"
 #include <graphene.h>
 
 G_BEGIN_DECLS
@@ -17,7 +18,7 @@ struct _GskGpuGlobalsInstance
 };
 
 void                    gsk_gpu_globals_op                              (GskGpuFrame                    *frame,
-                                                                         const graphene_vec2_t          *scale,
+                                                                         const GskScale                 *scale,
                                                                          const graphene_matrix_t        *mvp,
                                                                          const GskRoundedRect           *clip);
 

gsk/gpu/gskgpulineargradientop.c

@@ -64,7 +64,7 @@ gsk_gpu_linear_gradient_op (GskGpuFrame            *frame,
                             const graphene_rect_t  *rect,
                             const graphene_point_t *start,
                             const graphene_point_t *end,
-                            const graphene_point_t *offset,
+                            const GskPoint         *offset,
                             const GskColorStop     *stops,
                             gsize                   n_stops)
 {

gsk/gpu/gskgpulineargradientopprivate.h

@@ -14,7 +14,7 @@ void                    gsk_gpu_linear_gradient_op                      (GskGpuF
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *start,
                                                                          const graphene_point_t         *end,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpumaskop.c

@@ -58,7 +58,7 @@ gsk_gpu_mask_op (GskGpuFrame            *frame,
                  GskGpuShaderClip        clip,
                  GskGpuDescriptors      *desc,
                  const graphene_rect_t  *rect,
-                 const graphene_point_t *offset,
+                 const GskPoint         *offset,
                  float                   opacity,
                  GskMaskMode             mask_mode,
                  guint32                 source_descriptor,

gsk/gpu/gskgpumaskopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_mask_op                                 (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          float                           opacity,
                                                                          GskMaskMode                     mask_mode,
                                                                          guint32                         source_descriptor,

gsk/gpu/gskgpuopprivate.h

@@ -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,

gsk/gpu/gskgpuradialgradientop.c

@@ -66,11 +66,12 @@ gsk_gpu_radial_gradient_op (GskGpuFrame            *frame,
                             const graphene_point_t *radius,
                             float                   start,
                             float                   end,
-                            const graphene_point_t *offset,
+                            const GskPoint         *offset,
                             const GskColorStop     *stops,
                             gsize                   n_stops)
 {
   GskGpuRadialgradientInstance *instance;
+  GskPoint zero = gsk_point_init (0, 0);
 
   g_assert (n_stops > 1);
   g_assert (n_stops <= 7);
@@ -85,7 +86,7 @@ gsk_gpu_radial_gradient_op (GskGpuFrame            *frame,
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   gsk_gpu_point_to_float (center, offset, instance->center_radius);
-  gsk_gpu_point_to_float (radius, graphene_point_zero(), &instance->center_radius[2]);
+  gsk_gpu_point_to_float (radius, &zero, &instance->center_radius[2]);
   instance->startend[0] = start;
   instance->startend[1] = end;
   gsk_gpu_rgba_to_float (&stops[MIN (n_stops - 1, 6)].color, instance->color6);

gsk/gpu/gskgpuradialgradientopprivate.h

@@ -16,7 +16,7 @@ void                    gsk_gpu_radial_gradient_op                      (GskGpuF
                                                                          const graphene_point_t         *radius,
                                                                          float                           start,
                                                                          float                           end,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpurenderpassop.c

@@ -335,16 +335,16 @@ gsk_gpu_render_pass_end_op (GskGpuFrame       *frame,
 }
 
 GskGpuImage *
-gsk_gpu_render_pass_op_offscreen (GskGpuFrame           *frame,
-                                  const graphene_vec2_t *scale,
-                                  const graphene_rect_t *viewport,
-                                  GskRenderNode         *node)
+gsk_gpu_render_pass_op_offscreen (GskGpuFrame            *frame,
+                                  const GskScale         *scale,
+                                  const graphene_rect_t  *viewport,
+                                  GskRenderNode          *node)
 {
   GskGpuImage *image;
   int width, height;
 
-  width = ceil (graphene_vec2_get_x (scale) * viewport->size.width);
-  height = ceil (graphene_vec2_get_y (scale) * viewport->size.height);
+  width = ceil (gsk_scale_get_x (*scale) * viewport->size.width);
+  height = ceil (gsk_scale_get_y (*scale) * viewport->size.height);
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,

gsk/gpu/gskgpurenderpassopprivate.h

@@ -6,6 +6,8 @@
 
 #include <graphene.h>
 
+#include "gsk/gskscaleprivate.h"
+
 G_BEGIN_DECLS
 
 /* We only need this for the final VkImageLayout, but don't tell anyone */
@@ -24,7 +26,7 @@ void                    gsk_gpu_render_pass_end_op                      (GskGpuF
                                                                          GskRenderPassType               pass_type);
 
 GskGpuImage *           gsk_gpu_render_pass_op_offscreen                (GskGpuFrame                    *frame,
-                                                                         const graphene_vec2_t          *scale,
+                                                                         const GskScale                 *scale,
                                                                          const graphene_rect_t          *viewport,
                                                                          GskRenderNode                  *node);
 

gsk/gpu/gskgpuroundedcolorop.c

@@ -57,7 +57,7 @@ void
 gsk_gpu_rounded_color_op (GskGpuFrame            *frame,
                           GskGpuShaderClip        clip,
                           const GskRoundedRect   *outline,
-                          const graphene_point_t *offset,
+                          const GskPoint         *offset,
                           const GdkRGBA          *color)
 {
   GskGpuRoundedcolorInstance *instance;
@@ -69,7 +69,7 @@ gsk_gpu_rounded_color_op (GskGpuFrame            *frame,
                            NULL,
                            &instance);
 
-  gsk_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
   gsk_gpu_rgba_to_float (color, instance->color);
 }
 

gsk/gpu/gskgpuroundedcoloropprivate.h

@@ -10,7 +10,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_rounded_color_op                               (GskGpuFrame                    *frame,
                                                                                 GskGpuShaderClip                clip,
                                                                                 const GskRoundedRect           *outline,
-                                                                                const graphene_point_t         *offset,
+                                                                                const GskPoint                 *offset,
                                                                                 const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpushaderopprivate.h

@@ -3,6 +3,7 @@
 #include "gskgpuopprivate.h"
 
 #include "gskgputypesprivate.h"
+#include "gskpointprivate.h"
 
 G_BEGIN_DECLS
 
@@ -69,11 +70,11 @@ gsk_gpu_rgba_to_float (const GdkRGBA *rgba,
 
 static inline void
 gsk_gpu_point_to_float (const graphene_point_t *point,
-                        const graphene_point_t *offset,
+                        const GskPoint         *offset,
                         float                   values[2])
 {
-  values[0] = point->x + offset->x;
-  values[1] = point->y + offset->y;
+  values[0] = point->x + gsk_point_get_x (*offset);
+  values[1] = point->y + gsk_point_get_y (*offset);
 }
 
 G_END_DECLS

gsk/gpu/gskgpustraightalphaop.c

@@ -62,7 +62,7 @@ gsk_gpu_straight_alpha_op (GskGpuFrame            *frame,
                            GskGpuDescriptors      *desc,
                            guint32                 descriptor,
                            const graphene_rect_t  *rect,
-                           const graphene_point_t *offset,
+                           const GskPoint         *offset,
                            const graphene_rect_t  *tex_rect)
 {
   GskGpuStraightalphaInstance *instance;

gsk/gpu/gskgpustraightalphaopprivate.h

@@ -12,7 +12,7 @@ void                    gsk_gpu_straight_alpha_op                       (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect);
 
 

gsk/gpu/gskgputextureop.c

@@ -58,7 +58,7 @@ gsk_gpu_texture_op (GskGpuFrame            *frame,
                     GskGpuDescriptors      *desc,
                     guint32                 descriptor,
                     const graphene_rect_t  *rect,
-                    const graphene_point_t *offset,
+                    const GskPoint         *offset,
                     const graphene_rect_t  *tex_rect)
 {
   GskGpuTextureInstance *instance;

gsk/gpu/gskgputextureopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_texture_op                              (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
+                                                                         const GskPoint                 *offset,
                                                                          const graphene_rect_t          *tex_rect);
 
 

gsk/gpu/gskgputypesprivate.h

@@ -2,6 +2,7 @@
 
 #include <gdk/gdk.h>
 #include "gsk/gskenums.h"
+#include "gsk/gsktypes.h"
 
 #include "gdk/gdkmemoryformatprivate.h"
 

gsk/gpu/gskgpuuberop.c

@@ -56,7 +56,7 @@ void
 gsk_gpu_uber_op (GskGpuFrame             *frame,
                  GskGpuShaderClip         clip,
                  const graphene_rect_t   *rect,
-                 const graphene_point_t  *offset,
+                 const GskPoint          *offset,
                  GskGpuDescriptors       *desc,
                  guint32                  pattern_id)
 {