css parser: Small optimization

Avoid creating a GFile until it is needed.

demos/gtk-demo/fontify.c

@@ -363,7 +363,9 @@ insert_markup_idle (gpointer data)
 
       if (g_get_monotonic_time () - begin > G_TIME_SPAN_MILLISECOND)
         {
-          g_idle_add (insert_markup_idle, data);
+          guint id;
+          id = g_idle_add (insert_markup_idle, data);
+          g_source_set_name_by_id (id, "[gtk-demo] insert_markup_idle");
           return G_SOURCE_REMOVE;
         }
 
@@ -398,7 +400,9 @@ parse_markup_idle (gpointer data)
   do {
     if (g_get_monotonic_time () - begin > G_TIME_SPAN_MILLISECOND)
       {
-        g_idle_add (parse_markup_idle, data);
+        guint id;
+        id = g_idle_add (parse_markup_idle, data);
+        g_source_set_name_by_id (id, "[gtk-demo] parse_markup_idle");
         return G_SOURCE_REMOVE;
       }
 

demos/gtk-demo/main.c

@@ -20,6 +20,7 @@
 #include "config.h"
 #include <gtk/gtk.h>
 #include <glib/gstdio.h>
+#include <glib/gi18n.h>
 
 #include "demos.h"
 #include "fontify.h"
@@ -923,6 +924,34 @@ clear_search (GtkSearchBar *bar)
     }
 }
 
+static void
+search_results_update (GObject    *filter_model,
+                       GParamSpec *pspec,
+                       GtkEntry   *entry)
+{
+  gsize n_items = g_list_model_get_n_items (G_LIST_MODEL (filter_model));
+
+  if (strlen (gtk_editable_get_text (GTK_EDITABLE (entry))) > 0)
+    {
+      char *text;
+
+      if (n_items > 0)
+        text = g_strdup_printf (ngettext ("%ld search result", "%ld search results", n_items), n_items);
+      else
+        text = g_strdup (_("No search results"));
+
+      gtk_accessible_update_property (GTK_ACCESSIBLE (entry),
+                                      GTK_ACCESSIBLE_PROPERTY_DESCRIPTION, text,
+                                      -1);
+
+      g_free (text);
+    }
+  else
+    {
+      gtk_accessible_reset_property (GTK_ACCESSIBLE (entry), GTK_ACCESSIBLE_PROPERTY_DESCRIPTION);
+    }
+}
+
 static void
 activate (GApplication *app)
 {
@@ -970,6 +999,7 @@ activate (GApplication *app)
 
   search_entry = GTK_WIDGET (gtk_builder_get_object (builder, "search-entry"));
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (demo_search_changed_cb), filter);
+  g_signal_connect (filter_model, "notify::n-items", G_CALLBACK (search_results_update), search_entry);
 
   selection = gtk_single_selection_new (G_LIST_MODEL (filter_model));
   g_signal_connect (selection, "notify::selected-item", G_CALLBACK (selection_cb), NULL);

demos/node-editor/node-format.md

@@ -330,6 +330,7 @@ stroke bounds of the path.
 | offset       | `<point>`           | 0 0                 | non-default |
 | hint-style   | `<hint style>`      | slight              | non-default |
 | antialias    | `<antialias>`       | gray                | non-default |
+| hint-metrics | `<hint metrics>`    | off                 | non-default |
 
 Creates a node like `gsk_text_node_new()` with the given properties.
 
@@ -346,6 +347,7 @@ font, an error node will be returned.
 
 Possible values for hint-style are none, slight or full.
 Possible value for antialias are none or gray.
+Possible value for hint-metrics are on or off.
 
 ### texture
 

docs/reference/gdk/cairo.md

@@ -5,8 +5,11 @@ Title: Cairo interaction
 [Cairo](http://cairographics.org) is a graphics library that supports vector
 graphics and image compositing that can be used with GTK.
 
-GDK does not wrap the Cairo API; instead it allows to create Cairo
-drawing contexts which can be used to draw on [class@Gdk.Surface]s.
+GDK does not wrap the Cairo API and it is not possible to use cairo directly
+to draw on a [class@Gdk.Surface]. You can either use a
+[GtkDrawingArea](../gtk4/class.DrawingArea.html) widget or
+[gtk_snapshot_append_cairo](../gtk4/func.Snapshot.append_cairo.html)
+for drawing with cairo in a GTK4 application.
 
 Additional functions allow use [struct@Gdk.Rectangle]s with Cairo
 and to use [struct@Gdk.RGBA], `GdkPixbuf`, and [class@Gdk.Surface]

docs/reference/gtk/css-properties.md

@@ -56,6 +56,30 @@ follows:
 1 value:
 : all
 
+## Custom Properties
+
+GTK supports custom properties as defined in the
+[CSS Custom Properties for Cascading Variables](https://www.w3.org/TR/css-variables-1)
+spec.
+
+Custom properties are defined as follows:
+
+```css
+--prop: red;
+```
+
+and used via the `var` keyword:
+
+```css
+color: var(--prop);
+```
+
+Custom properties can have a fallback for when the referred property is invalid:
+
+```css
+color: var(--prop, green);
+```
+
 ## Colors
 
 GTK extends the CSS syntax with several additional ways to specify colors.

docs/reference/gtk/section-accessibility.md

@@ -155,6 +155,7 @@ Each property name is part of the `GtkAccessibleProperty` enumeration.
 | %GTK_ACCESSIBLE_PROPERTY_VALUE_MIN | “aria-valuemin” | double |
 | %GTK_ACCESSIBLE_PROPERTY_VALUE_NOW | “aria-valuenow” | double |
 | %GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT | “aria-valuetext” | translatable string |
+| %GTK_ACCESSIBLE_PROPERTY_HELP_TEXT | N/A | translatable string |
 
 #### List of accessible relations
 
@@ -216,6 +217,10 @@ are accessible as part of the development process. The GTK Inspector shows
 the accessible attributes of each widget, and also provides an overlay that
 can highlight accessibility issues.
 
+If you support some non-standard keyboard interactions for a widget, you
+**should** set an appropriate `GTK_ACCESSIBLE_PROPERTY_HELP_TEXT` to help
+discoverability of the behavior.
+
 It is possible to set accessible attributes in UI files as well:
 ```xml
 <object class="GtkButton" id="button1">

gdk/gdk.c

@@ -143,31 +143,50 @@ static const GdkDebugKey gdk_debug_keys[] = {
 
 #ifdef G_HAS_CONSTRUCTORS
 #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
-#pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(stash_desktop_startup_notification_id)
+#pragma G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(stash_and_unset_environment)
 #endif
-G_DEFINE_CONSTRUCTOR(stash_desktop_startup_notification_id)
+G_DEFINE_CONSTRUCTOR(stash_and_unset_environment)
 #endif
 
 static char *startup_notification_id = NULL;
+static char *xdg_activation_token = NULL;
 
 static void
-stash_desktop_startup_notification_id (void)
+stash_and_unset_environment (void)
 {
-  const char *desktop_startup_id;
-
-  desktop_startup_id = g_getenv ("DESKTOP_STARTUP_ID");
-  if (desktop_startup_id && *desktop_startup_id != '\0')
-    {
-      if (!g_utf8_validate (desktop_startup_id, -1, NULL))
-        g_warning ("DESKTOP_STARTUP_ID contains invalid UTF-8");
-      else
-        startup_notification_id = g_strdup (desktop_startup_id);
-    }
-
-  /* Clear the environment variable so it won't be inherited by
+  /* Copies environment variables and unsets them so they won't be inherited by
    * child processes and confuse things.
+   *
+   * Changing environment variables can be racy so we try to do this as early as
+   * possible in the program flow and before any printing that might involve
+   * environment variables.
    */
-  g_unsetenv ("DESKTOP_STARTUP_ID");
+  struct {
+    const char *key;
+    char **dst;
+  } vars[] = {
+    { "DESKTOP_STARTUP_ID", &startup_notification_id },
+    { "XDG_ACTIVATION_TOKEN", &xdg_activation_token },
+  };
+  size_t i;
+
+  for (i = 0; i < G_N_ELEMENTS (vars); i++)
+    *vars[i].dst = g_strdup (g_getenv (vars[i].key));
+
+  for (i = 0; i < G_N_ELEMENTS (vars); i++)
+    g_unsetenv (vars[i].key);
+
+  for (i = 0; i < G_N_ELEMENTS (vars); i++)
+    {
+      if (*vars[i].dst == NULL)
+        continue;
+
+      if (!g_utf8_validate (*vars[i].dst, -1, NULL))
+        {
+          g_warning ("%s contains invalid UTF-8", vars[i].key);
+          g_clear_pointer (vars[i].dst, g_free);
+        }
+    }
 }
 
 static gpointer
@@ -292,7 +311,7 @@ gdk_pre_parse (void)
     gdk_gl_backend_use (GDK_GL_WGL);
 
 #ifndef G_HAS_CONSTRUCTORS
-  stash_desktop_startup_notification_id ();
+  stash_and_unset_environment ();
 #endif
 }
 
@@ -326,15 +345,20 @@ gdk_display_open_default (void)
 /*< private >
  * gdk_get_startup_notification_id:
  *
- * Returns the original value of the DESKTOP_STARTUP_ID environment
- * variable if it was defined and valid, or %NULL otherwise.
+ * Returns the original value of the XDG_ACTIVATION_TOKEN environment
+ * variable if it was defined and valid, otherwise it returns the original
+ * value of the DESKTOP_STARTUP_ID environment variable if it was defined
+ * and valid, or %NULL if neither of them were defined and valid.
  *
  * Returns: (nullable) (transfer none): the original value of the
- *   DESKTOP_STARTUP_ID environment variable
+ *   XDG_ACTIVATION_TOKEN or DESKTOP_STARTUP_ID environment variable
  */
 const char *
 gdk_get_startup_notification_id (void)
 {
+  if (xdg_activation_token)
+    return xdg_activation_token;
+
   return startup_notification_id;
 }
 

gdk/gdkdmabuf.c

@@ -144,8 +144,8 @@ struct _YUVCoefficients
 };
 
 /* multiplied by 65536 */
-//static const YUVCoefficients itu601_narrow = { 104597, -25675, -53279, 132201 };
-static const YUVCoefficients itu601_wide = { 74711, -25864, -38050, 133176 };
+static const YUVCoefficients itu601_narrow = { 104597, -25675, -53279, 132201 };
+//static const YUVCoefficients itu601_wide = { 74711, -25864, -38050, 133176 };
 
 static inline void
 get_uv_values (const YUVCoefficients *coeffs,
@@ -229,7 +229,7 @@ download_nv12 (guchar          *dst_data,
           int r, g, b;
           gsize xs, ys;
 
-          get_uv_values (&itu601_wide, uv_data[x / X_SUB * 2 + U], uv_data[x / X_SUB * 2 + V], &r, &g, &b);
+          get_uv_values (&itu601_narrow, uv_data[x / X_SUB * 2 + U], uv_data[x / X_SUB * 2 + V], &r, &g, &b);
 
           for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
             for (xs = 0; xs < X_SUB && x + xs < width; xs++)
@@ -309,7 +309,7 @@ download_yuv_3 (guchar          *dst_data,
           int r, g, b;
           gsize xs, ys;
 
-          get_uv_values (&itu601_wide, u_data[x / X_SUB], v_data[x / X_SUB], &r, &g, &b);
+          get_uv_values (&itu601_narrow, u_data[x / X_SUB], v_data[x / X_SUB], &r, &g, &b);
 
           for (ys = 0; ys < Y_SUB && y + ys < height; ys++)
             for (xs = 0; xs < X_SUB && x + xs < width; xs++)
@@ -365,7 +365,7 @@ download_yuyv (guchar          *dst_data,
         {
           int r, g, b;
 
-          get_uv_values (&itu601_wide, src_data[2 * x + U], src_data[2 * x + V], &r, &g, &b);
+          get_uv_values (&itu601_narrow, src_data[2 * x + U], src_data[2 * x + V], &r, &g, &b);
           set_rgb_values (&dst_data[3 * x], src_data[2 * x + Y1], r, g, b);
           if (x + 1 < width)
             set_rgb_values (&dst_data[3 * (x + 1)], src_data[2 * x + Y2], r, g, b);

gdk/gdkdmabufegl.c

@@ -239,7 +239,7 @@ gdk_dmabuf_egl_create_image (GdkDisplay      *display,
   attribs[i++] = EGL_YUV_COLOR_SPACE_HINT_EXT;
   attribs[i++] = EGL_ITU_REC601_EXT;
   attribs[i++] = EGL_SAMPLE_RANGE_HINT_EXT;
-  attribs[i++] = EGL_YUV_FULL_RANGE_EXT;
+  attribs[i++] = EGL_YUV_NARROW_RANGE_EXT;
 
 #define ADD_PLANE(plane) \
   { \
@@ -265,6 +265,7 @@ gdk_dmabuf_egl_create_image (GdkDisplay      *display,
   if (dmabuf->n_planes > 3) ADD_PLANE (3);
 
   attribs[i++] = EGL_NONE;
+  g_assert (i < G_N_ELEMENTS (attribs));
 
   image = eglCreateImageKHR (egl_display,
                              EGL_NO_CONTEXT,

gdk/gdkframeclockidle.c

@@ -192,13 +192,6 @@ compute_smooth_frame_time (GdkFrameClock *clock,
    *        and new_frame_time >= old_frame_time. */
   frames_passed = (new_frame_time - smoothed_frame_time_base + frame_interval / 2) / frame_interval;
 
-  if (frames_passed > 1)
-    gdk_profiler_add_markf ((smoothed_frame_time_base - (frame_interval * (frames_passed-1))) * 1000L,
-                            frame_interval * (frames_passed-1) * 1000L,
-                            "Dropped Frames",
-                            "%u frames may have been dropped",
-                            frames_passed-1);
-
   /* We use an approximately whole number of frames in the future from
    * last smoothed frame time. This way we avoid minor jitter in the
    * frame times making the animation speed uneven, but still animate

gdk/gdkglcontext.c

@@ -2198,12 +2198,78 @@ gdk_gl_context_import_dmabuf (GdkGLContext    *self,
 
   gdk_display_init_dmabuf (display);
 
-  if (!gdk_dmabuf_formats_contains (display->egl_external_formats, dmabuf->fourcc, dmabuf->modifier))
+  if (gdk_dmabuf_formats_contains (display->egl_dmabuf_formats, dmabuf->fourcc, dmabuf->modifier))
     {
+      /* This is the path for modern drivers that support modifiers */
+
+      if (!gdk_dmabuf_formats_contains (display->egl_external_formats, dmabuf->fourcc, dmabuf->modifier))
+        {
+          texture_id = gdk_gl_context_import_dmabuf_for_target (self,
+                                                                width, height,
+                                                                dmabuf,
+                                                                GL_TEXTURE_2D);
+          if (texture_id == 0)
+            {
+              GDK_DISPLAY_DEBUG (display, DMABUF,
+                                 "Import of %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf failed",
+                                 width, height,
+                                 (char *) &dmabuf->fourcc, dmabuf->modifier);
+              return 0;
+            }
+
+          GDK_DISPLAY_DEBUG (display, DMABUF,
+                             "Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_2D texture",
+                             width, height,
+                             (char *) &dmabuf->fourcc, dmabuf->modifier);
+          *external = FALSE;
+          return texture_id;
+        }
+
+      if (!gdk_gl_context_get_use_es (self))
+        {
+          GDK_DISPLAY_DEBUG (display, DMABUF,
+                             "Can't import external_only %.4s:%#" G_GINT64_MODIFIER "x outside of GLES",
+                             (char *) &dmabuf->fourcc, dmabuf->modifier);
+          return 0;
+        }
+
       texture_id = gdk_gl_context_import_dmabuf_for_target (self,
                                                             width, height,
                                                             dmabuf,
-                                                            GL_TEXTURE_2D);
+                                                            GL_TEXTURE_EXTERNAL_OES);
+      if (texture_id == 0)
+        {
+          GDK_DISPLAY_DEBUG (display, DMABUF,
+                             "Import of external_only %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf failed",
+                             width, height,
+                             (char *) &dmabuf->fourcc, dmabuf->modifier);
+          return 0;
+        }
+
+      GDK_DISPLAY_DEBUG (display, DMABUF,
+                         "Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_EXTERNAL_OES texture",
+                         width, height,
+                         (char *) &dmabuf->fourcc, dmabuf->modifier);
+      *external = TRUE;
+      return texture_id;
+    }
+  else
+    {
+      /* This is the opportunistic path.
+       * We hit it both for drivers that do not support modifiers as well as for dmabufs
+       * that the driver did not explicitly advertise. */
+      int target;
+
+      if (gdk_gl_context_get_use_es (self))
+        target = GL_TEXTURE_EXTERNAL_OES;
+      else
+        target = GL_TEXTURE_2D;
+
+      texture_id = gdk_gl_context_import_dmabuf_for_target (self,
+                                                            width, height,
+                                                            dmabuf,
+                                                            target);
+
       if (texture_id == 0)
         {
           GDK_DISPLAY_DEBUG (display, DMABUF,
@@ -2214,40 +2280,13 @@ gdk_gl_context_import_dmabuf (GdkGLContext    *self,
         }
 
       GDK_DISPLAY_DEBUG (display, DMABUF,
-                         "Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_2D texture",
+                         "Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as %s texture",
                          width, height,
-                         (char *) &dmabuf->fourcc, dmabuf->modifier);
-      *external = FALSE;
+                         (char *) &dmabuf->fourcc, dmabuf->modifier,
+                         target == GL_TEXTURE_EXTERNAL_OES ? "GL_TEXTURE_EXTERNAL_OES" : "GL_TEXTURE_2D");
+      *external = target == GL_TEXTURE_EXTERNAL_OES;
       return texture_id;
     }
-
-  if (!gdk_gl_context_get_use_es (self))
-    {
-      GDK_DISPLAY_DEBUG (display, DMABUF,
-                         "Can't import external_only %.4s:%#" G_GINT64_MODIFIER "x outside of GLES",
-                         (char *) &dmabuf->fourcc, dmabuf->modifier);
-      return 0;
-    }
-
-  texture_id = gdk_gl_context_import_dmabuf_for_target (self,
-                                                        width, height,
-                                                        dmabuf,
-                                                        GL_TEXTURE_EXTERNAL_OES);
-  if (texture_id == 0)
-    {
-      GDK_DISPLAY_DEBUG (display, DMABUF,
-                         "Import of external_only %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf failed",
-                         width, height,
-                         (char *) &dmabuf->fourcc, dmabuf->modifier);
-      return 0;
-    }
-
-  GDK_DISPLAY_DEBUG (display, DMABUF,
-                     "Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_EXTERNAL_OES texture",
-                     width, height,
-                     (char *) &dmabuf->fourcc, dmabuf->modifier);
-  *external = TRUE;
-  return texture_id;
 }
 
 gboolean

gdk/gdktexture.c

@@ -563,7 +563,7 @@ gdk_texture_new_from_bytes_internal (GBytes  *bytes,
 {
   if (gdk_is_png (bytes))
     {
-      return gdk_load_png (bytes, error);
+      return gdk_load_png (bytes, NULL, error);
     }
   else if (gdk_is_jpeg (bytes))
     {

gdk/gdkvulkancontext.c

@@ -29,6 +29,7 @@
 #include "gdkdmabuffourccprivate.h"
 #include "gdkdmabuftextureprivate.h"
 #include "gdkdisplayprivate.h"
+#include "gdkprofilerprivate.h"
 #include <glib/gi18n-lib.h>
 #include <math.h>
 
@@ -1110,6 +1111,7 @@ gdk_display_load_pipeline_cache (GdkDisplay *display)
 static gboolean
 gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
 {
+  G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
   GError *error = NULL;
   VkDevice device;
   VkPipelineCache cache;
@@ -1124,14 +1126,13 @@ gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
   GDK_VK_CHECK (vkGetPipelineCacheData, device, cache, &size, NULL);
   if (size == 0)
     return TRUE;
-  
+
   if (size == display->vk_pipeline_cache_size)
     {
       GDK_DEBUG (VULKAN, "pipeline cache size (%zu bytes) unchanged, skipping save", size);
       return TRUE;
     }
 
-
   data = g_malloc (size);
   if (GDK_VK_CHECK (vkGetPipelineCacheData, device, cache, &size, data) != VK_SUCCESS)
     {
@@ -1151,7 +1152,7 @@ gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
 
   file = gdk_vulkan_get_pipeline_cache_file (display);
 
-  GDK_DEBUG (VULKAN, "Saving pipeline cache to %s", g_file_peek_path (file));
+  GDK_DEBUG (VULKAN, "Saving pipeline cache of size %lu to %s", size, g_file_peek_path (file));
 
   if (!g_file_replace_contents (file,
                                 data,
@@ -1166,7 +1167,7 @@ gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WRONG_ETAG))
         {
           VkPipelineCache new_cache;
-          
+
           GDK_DEBUG (VULKAN, "Pipeline cache file modified, merging into current");
           new_cache = gdk_display_load_pipeline_cache (display);
           if (new_cache)
@@ -1193,10 +1194,15 @@ gdk_vulkan_save_pipeline_cache (GdkDisplay *display)
       return FALSE;
     }
 
+  gdk_profiler_end_markf (begin_time,
+                          "Save Vulkan pipeline cache", "%s size %lu",
+                          g_file_peek_path (file), size);
+
   g_object_unref (file);
   g_free (data);
   g_free (display->vk_pipeline_cache_etag);
   display->vk_pipeline_cache_etag = etag;
+  display->vk_pipeline_cache_size = size;
 
   return TRUE;
 }
@@ -1236,6 +1242,11 @@ gdk_display_create_pipeline_cache (GdkDisplay *display)
                                            },
                                            NULL,
                                            &display->vk_pipeline_cache);
+      GDK_DEBUG (VULKAN, "Creating empty pipeline cache");
+    }
+  else
+    {
+      GDK_DEBUG (VULKAN, "Loading pipeline cache (%lu bytes)", display->vk_pipeline_cache_size);
     }
 }
 
@@ -1345,6 +1356,7 @@ static gboolean
 gdk_display_create_vulkan_device (GdkDisplay  *display,
                                   GError     **error)
 {
+  G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
   uint32_t i, j, k;
   const char *override;
   gboolean list_devices;
@@ -1553,6 +1565,8 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
                                        "Hum, what? This should not happen.")));
                 }
 
+              gdk_profiler_end_mark (start_time, "Create Vulkan device", NULL);
+
               return TRUE;
             }
         }
@@ -1591,6 +1605,7 @@ static gboolean
 gdk_display_create_vulkan_instance (GdkDisplay  *display,
                                     GError     **error)
 {
+  G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
   uint32_t i;
   GPtrArray *used_extensions;
   GPtrArray *used_layers;
@@ -1752,6 +1767,8 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
 
   display->vk_shader_modules = g_hash_table_new (g_str_hash, g_str_equal);
 
+  gdk_profiler_end_mark (start_time, "Create Vulkan instance", NULL);
+
   return TRUE;
 }
 

gdk/loaders/gdkpng.c

@@ -127,15 +127,18 @@ png_simple_warning_callback (png_structp     png,
 }
 
 /* }}} */
-/* {{{ Public API */ 
+/* {{{ Public API */
 
 GdkTexture *
-gdk_load_png (GBytes  *bytes,
-              GError **error)
+gdk_load_png (GBytes      *bytes,
+              GHashTable  *options,
+              GError     **error)
 {
   png_io io;
   png_struct *png = NULL;
   png_info *info;
+  png_textp text;
+  int num_texts;
   guint width, height;
   gsize i, stride;
   int depth, color_type;
@@ -297,6 +300,17 @@ gdk_load_png (GBytes  *bytes,
   texture = gdk_memory_texture_new (width, height, format, out_bytes, stride);
   g_bytes_unref (out_bytes);
 
+  if (options && png_get_text (png, info, &text, &num_texts))
+    {
+      for (i = 0; i < num_texts; i++)
+        {
+          if (text->compression != -1)
+            continue;
+
+          g_hash_table_insert (options, g_strdup (text->key), g_strdup (text->text));
+        }
+    }
+
   g_free (row_pointers);
   png_destroy_read_struct (&png, &info, NULL);
 

gdk/loaders/gdkpngprivate.h

@@ -23,6 +23,7 @@
 #define PNG_SIGNATURE "\x89PNG"
 
 GdkTexture *gdk_load_png        (GBytes         *bytes,
+                                 GHashTable     *options,
                                  GError        **error);
 
 GBytes     *gdk_save_png        (GdkTexture     *texture);

gdk/wayland/gdkdisplay-wayland.c

@@ -287,97 +287,6 @@ static const struct wl_shm_listener wl_shm_listener = {
   wl_shm_format
 };
 
-static void
-linux_dmabuf_done (void *data,
-                   struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1)
-{
-  GDK_DEBUG (MISC, "dmabuf feedback done");
-}
-
-static void
-linux_dmabuf_format_table (void *data,
-                           struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1,
-                           int32_t fd,
-                           uint32_t size)
-{
-  GdkWaylandDisplay *display_wayland = data;
-
-  display_wayland->linux_dmabuf_n_formats = size / 16;
-  display_wayland->linux_dmabuf_formats = mmap (NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
-
-  GDK_DEBUG (MISC, "got dmabuf format table (%lu entries)", display_wayland->linux_dmabuf_n_formats);
-}
-
-static void
-linux_dmabuf_main_device (void *data,
-                          struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1,
-                          struct wl_array *device)
-{
-  dev_t dev G_GNUC_UNUSED;
-
-  memcpy (&dev, device->data, sizeof (dev_t));
-
-  GDK_DEBUG (MISC, "got dmabuf main device: %u %u", major (dev), minor (dev));
-}
-
-static void
-linux_dmabuf_tranche_done (void *data,
-                           struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1)
-{
-  GDK_DEBUG (MISC, "dmabuf feedback tranche done");
-}
-
-static void
-linux_dmabuf_tranche_target_device (void *data,
-                                    struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1,
-                                    struct wl_array *device)
-{
-  dev_t dev G_GNUC_UNUSED;
-
-  memcpy (&dev, device->data, sizeof (dev_t));
-
-  GDK_DEBUG (MISC, "got dmabuf tranche target device: %u %u", major (dev), minor (dev));
-}
-
-static void
-linux_dmabuf_tranche_formats (void *data,
-                              struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1,
-                              struct wl_array *indices)
-{
-  GdkWaylandDisplay *display_wayland = data;
-
-  GDK_DEBUG (MISC, "got dmabuf tranche formats (%lu entries):", indices->size / sizeof (guint16));
-  guint16 *pos;
-
-  wl_array_for_each (pos, indices)
-    {
-      LinuxDmabufFormat *fmt G_GNUC_UNUSED = &display_wayland->linux_dmabuf_formats[*pos];
-      uint32_t f G_GNUC_UNUSED = fmt->fourcc;
-      uint64_t m G_GNUC_UNUSED = fmt->modifier;
-      GDK_DEBUG (MISC, "  %.4s:%#" G_GINT64_MODIFIER "x", (char *) &f, m);
-    }
-}
-
-static void
-linux_dmabuf_tranche_flags (void *data,
-                            struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1,
-                            uint32_t flags)
-{
-  GDK_DEBUG (MISC,
-             "got dmabuf tranche flags: %s",
-             flags & ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT ? "scanout" : "");
-}
-
-static const struct zwp_linux_dmabuf_feedback_v1_listener linux_dmabuf_feedback_listener = {
-  linux_dmabuf_done,
-  linux_dmabuf_format_table,
-  linux_dmabuf_main_device,
-  linux_dmabuf_tranche_done,
-  linux_dmabuf_tranche_target_device,
-  linux_dmabuf_tranche_formats,
-  linux_dmabuf_tranche_flags,
-};
-
 static void
 server_decoration_manager_default_mode (void                                          *data,
                                         struct org_kde_kwin_server_decoration_manager *manager,
@@ -454,12 +363,14 @@ gdk_registry_handle_global (void               *data,
     }
   else if (strcmp (interface, "zwp_linux_dmabuf_v1") == 0 && version >= 4)
     {
+      struct zwp_linux_dmabuf_feedback_v1 *feedback;
+
       display_wayland->linux_dmabuf =
         wl_registry_bind (display_wayland->wl_registry, id, &zwp_linux_dmabuf_v1_interface, version);
-      display_wayland->linux_dmabuf_feedback =
-        zwp_linux_dmabuf_v1_get_default_feedback (display_wayland->linux_dmabuf);
-     zwp_linux_dmabuf_feedback_v1_add_listener (display_wayland->linux_dmabuf_feedback,
-                                                &linux_dmabuf_feedback_listener, display_wayland);
+      feedback = zwp_linux_dmabuf_v1_get_default_feedback (display_wayland->linux_dmabuf);
+      display_wayland->dmabuf_formats_info = dmabuf_formats_info_new (GDK_DISPLAY (display_wayland),
+                                                                      "default",
+                                                                      feedback);
       _gdk_wayland_display_async_roundtrip (display_wayland);
     }
   else if (strcmp (interface, "xdg_wm_base") == 0)
@@ -832,9 +743,7 @@ gdk_wayland_display_dispose (GObject *object)
   g_clear_pointer (&display_wayland->presentation, wp_presentation_destroy);
   g_clear_pointer (&display_wayland->single_pixel_buffer, wp_single_pixel_buffer_manager_v1_destroy);
   g_clear_pointer (&display_wayland->linux_dmabuf, zwp_linux_dmabuf_v1_destroy);
-  g_clear_pointer (&display_wayland->linux_dmabuf_feedback, zwp_linux_dmabuf_feedback_v1_destroy);
-  if (display_wayland->linux_dmabuf_formats)
-    munmap (display_wayland->linux_dmabuf_formats, display_wayland->linux_dmabuf_n_formats * 16);
+  g_clear_pointer (&display_wayland->dmabuf_formats_info, dmabuf_formats_info_free);
 
   g_clear_pointer (&display_wayland->shm, wl_shm_destroy);
   g_clear_pointer (&display_wayland->wl_registry, wl_registry_destroy);

gdk/wayland/gdkdisplay-wayland.h

@@ -49,6 +49,7 @@
 
 #include "gdkdisplayprivate.h"
 #include "gdkwaylanddevice.h"
+#include "gdkdmabuf-wayland-private.h"
 #include "cursor/wayland-cursor.h"
 
 #include <epoxy/egl.h>
@@ -73,13 +74,6 @@ typedef enum _GdkWaylandShellVariant
   GDK_WAYLAND_SHELL_VARIANT_ZXDG_SHELL_V6
 } GdkWaylandShellVariant;
 
-typedef struct
-{
-  uint32_t fourcc;
-  uint32_t padding;
-  uint64_t modifier;
-} LinuxDmabufFormat;
-
 struct _GdkWaylandDisplay
 {
   GdkDisplay parent_instance;
@@ -105,9 +99,7 @@ struct _GdkWaylandDisplay
   struct wl_compositor *compositor;
   struct wl_shm *shm;
   struct zwp_linux_dmabuf_v1 *linux_dmabuf;
-  struct zwp_linux_dmabuf_feedback_v1 *linux_dmabuf_feedback;
-  gsize linux_dmabuf_n_formats;
-  LinuxDmabufFormat *linux_dmabuf_formats;
+  DmabufFormatsInfo *dmabuf_formats_info;
   struct xdg_wm_base *xdg_wm_base;
   struct zxdg_shell_v6 *zxdg_shell_v6;
   struct gtk_shell1 *gtk_shell;

gdk/wayland/gdkdmabuf-wayland-private.h

@@ -0,0 +1,77 @@
+/*
+ * gdkdmabuf-wayland.h
+ *
+ * Copyright 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "config.h"
+
+#include <stdint.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+
+#include <glib.h>
+#include <gdk/gdkkeys.h>
+#include <gdk/gdksurface.h>
+
+G_BEGIN_DECLS
+
+typedef struct
+{
+  uint32_t fourcc;
+  uint32_t padding;
+  uint64_t modifier;
+} DmabufFormat;
+
+typedef struct
+{
+  dev_t target_device;
+  guint32 flags;
+  gsize n_formats;
+  DmabufFormat *formats;
+} DmabufTranche;
+
+typedef struct
+{
+  dev_t main_device;
+  GPtrArray *tranches;
+} DmabufFormats;
+
+typedef struct DmabufFormatsInfo DmabufFormatsInfo;
+
+struct DmabufFormatsInfo
+{
+  GdkDisplay *display;
+  char *name;
+  struct zwp_linux_dmabuf_feedback_v1 *feedback;
+
+  gsize n_dmabuf_formats;
+  DmabufFormat *dmabuf_format_table;
+
+  DmabufFormats *dmabuf_formats;
+  DmabufFormats *pending_dmabuf_formats;
+  DmabufTranche *pending_tranche;
+};
+
+DmabufFormatsInfo * dmabuf_formats_info_new  (GdkDisplay                          *display,
+                                              const char                          *name,
+                                              struct zwp_linux_dmabuf_feedback_v1 *feedback);
+
+void                dmabuf_formats_info_free (DmabufFormatsInfo                   *info);
+
+G_END_DECLS

gdk/wayland/gdkdmabuf-wayland.c

@@ -0,0 +1,241 @@
+#include "config.h"
+
+#include "gdkdmabuf-wayland-private.h"
+
+#include "gdkdebugprivate.h"
+#include "gdkdmabufformatsprivate.h"
+#include "gdkdmabufformatsbuilderprivate.h"
+#include "gdkdmabufformatsprivate.h"
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/sysmacros.h>
+
+#include "linux-dmabuf-unstable-v1-client-protocol.h"
+
+
+static DmabufTranche *
+dmabuf_tranche_new (void)
+{
+  return g_new0 (DmabufTranche, 1);
+}
+
+static void
+dmabuf_tranche_free (DmabufTranche *tranche)
+{
+  g_free (tranche->formats);
+  g_free (tranche);
+}
+
+static DmabufFormats *
+dmabuf_formats_new (void)
+{
+  DmabufFormats *formats;
+
+  formats = g_new0 (DmabufFormats, 1);
+  formats->tranches = g_ptr_array_new_with_free_func ((GDestroyNotify) dmabuf_tranche_free);
+
+  return formats;
+}
+
+static void
+dmabuf_formats_free (DmabufFormats *formats)
+{
+  g_ptr_array_unref (formats->tranches);
+  g_free (formats);
+}
+
+static void
+update_dmabuf_formats (DmabufFormatsInfo *info)
+{
+  DmabufFormats *formats = info->dmabuf_formats;
+
+  GDK_DISPLAY_DEBUG (info->display, MISC,
+                     "dmabuf format table (%lu entries)", info->n_dmabuf_formats);
+  GDK_DISPLAY_DEBUG (info->display, MISC,
+                     "dmabuf main device: %u %u",
+                     major (formats->main_device),
+                     minor (formats->main_device));
+
+  for (gsize i = 0; i < formats->tranches->len; i++)
+    {
+      DmabufTranche *tranche = g_ptr_array_index (formats->tranches, i);
+
+      GDK_DISPLAY_DEBUG (info->display, MISC,
+                         "dmabuf tranche target device: %u %u",
+                         major (tranche->target_device),
+                         minor (tranche->target_device));
+
+      GDK_DISPLAY_DEBUG (info->display, MISC,
+                         "dmabuf%s tranche (%lu entries):",
+                         tranche->flags & ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT ? " scanout" : "",
+                         tranche->n_formats);
+
+      for (gsize j = 0; j < tranche->n_formats; j++)
+        {
+          GDK_DISPLAY_DEBUG (info->display, MISC,
+                             "  %.4s:%#" G_GINT64_MODIFIER "x",
+                             (char *) &(tranche->formats[j].fourcc),
+                             tranche->formats[j].modifier);
+        }
+    }
+}
+
+static void
+linux_dmabuf_done (void *data,
+                   struct zwp_linux_dmabuf_feedback_v1 *feedback)
+{
+  DmabufFormatsInfo *info = data;
+
+  g_clear_pointer (&info->dmabuf_formats, dmabuf_formats_free);
+
+  info->dmabuf_formats = info->pending_dmabuf_formats;
+  info->pending_dmabuf_formats = NULL;
+
+  update_dmabuf_formats (info);
+}
+
+static void
+linux_dmabuf_format_table (void *data,
+                           struct zwp_linux_dmabuf_feedback_v1 *feedback,
+                           int32_t fd,
+                           uint32_t size)
+{
+  DmabufFormatsInfo *info = data;
+
+  if (info->dmabuf_formats)
+    munmap (info->dmabuf_formats, sizeof (DmabufFormat) * info->n_dmabuf_formats);
+
+  info->n_dmabuf_formats = size / 16;
+  info->dmabuf_format_table = mmap (NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+}
+
+static void
+linux_dmabuf_main_device (void *data,
+                          struct zwp_linux_dmabuf_feedback_v1 *feedback,
+                          struct wl_array *device)
+{
+  DmabufFormatsInfo *info = data;
+  dev_t dev;
+
+  memcpy (&dev, device->data, sizeof (dev_t));
+
+  g_assert (info->pending_dmabuf_formats == NULL);
+
+  info->pending_dmabuf_formats = dmabuf_formats_new ();
+  info->pending_dmabuf_formats->main_device = dev;
+}
+
+static void
+linux_dmabuf_tranche_done (void *data,
+                           struct zwp_linux_dmabuf_feedback_v1 *feedback)
+{
+  DmabufFormatsInfo *info = data;
+
+  g_ptr_array_add (info->pending_dmabuf_formats->tranches,
+                   info->pending_tranche);
+
+  info->pending_tranche = NULL;
+}
+
+static void
+linux_dmabuf_tranche_target_device (void *data,
+                                    struct zwp_linux_dmabuf_feedback_v1 *feedback,
+                                    struct wl_array *device)
+{
+  DmabufFormatsInfo *info = data;
+  dev_t dev;
+  DmabufTranche *tranche;
+
+  memcpy (&dev, device->data, sizeof (dev_t));
+
+  g_assert (info->pending_tranche == NULL);
+
+  tranche = dmabuf_tranche_new ();
+  tranche->target_device = dev;
+
+  info->pending_tranche = tranche;
+}
+
+static void
+linux_dmabuf_tranche_formats (void *data,
+                              struct zwp_linux_dmabuf_feedback_v1 *feedback,
+                              struct wl_array *indices)
+{
+  DmabufFormatsInfo *info = data;
+  DmabufTranche *tranche;
+  int i;
+  guint16 *pos;
+
+  g_assert (info->pending_tranche != NULL);
+  tranche = info->pending_tranche;
+
+  tranche->n_formats = indices->size / sizeof (guint16);
+  tranche->formats = g_new (DmabufFormat, tranche->n_formats);
+
+  i = 0;
+  wl_array_for_each (pos, indices)
+    {
+      tranche->formats[i++] = info->dmabuf_format_table[*pos];
+    }
+}
+
+static void
+linux_dmabuf_tranche_flags (void *data,
+                            struct zwp_linux_dmabuf_feedback_v1 *feedback,
+                            uint32_t flags)
+{
+  DmabufFormatsInfo *info = data;
+  DmabufTranche *tranche;
+
+  g_assert (info->pending_tranche != NULL);
+  tranche = info->pending_tranche;
+  tranche->flags = flags;
+}
+
+static const struct zwp_linux_dmabuf_feedback_v1_listener feedback_listener = {
+  linux_dmabuf_done,
+  linux_dmabuf_format_table,
+  linux_dmabuf_main_device,
+  linux_dmabuf_tranche_done,
+  linux_dmabuf_tranche_target_device,
+  linux_dmabuf_tranche_formats,
+  linux_dmabuf_tranche_flags,
+};
+
+DmabufFormatsInfo *
+dmabuf_formats_info_new (GdkDisplay                          *display,
+                         const char                          *name,
+                         struct zwp_linux_dmabuf_feedback_v1 *feedback)
+{
+  DmabufFormatsInfo *info;
+
+  info = g_new0 (DmabufFormatsInfo, 1);
+
+  info->display = display;
+  info->name = g_strdup (name);
+  info->feedback = feedback;
+
+  if (info->feedback)
+    zwp_linux_dmabuf_feedback_v1_add_listener (info->feedback,
+                                               &feedback_listener, info);
+
+  return info;
+}
+
+void
+dmabuf_formats_info_free (DmabufFormatsInfo *info)
+{
+  g_free (info->name);
+  g_clear_pointer (&info->feedback, zwp_linux_dmabuf_feedback_v1_destroy);
+  if (info->dmabuf_format_table)
+    {
+      munmap (info->dmabuf_format_table, info->n_dmabuf_formats * 16);
+      info->dmabuf_format_table = NULL;
+    }
+  g_clear_pointer (&info->dmabuf_formats, dmabuf_formats_free);
+  g_clear_pointer (&info->pending_dmabuf_formats, dmabuf_formats_free);
+  g_clear_pointer (&info->pending_tranche, dmabuf_tranche_free);
+
+  g_free (info);
+}

gdk/wayland/meson.build

@@ -8,6 +8,7 @@ gdk_wayland_sources = files([
   'gdkdevice-wayland.c',
   'gdkdevicepad-wayland.c',
   'gdkdisplay-wayland.c',
+  'gdkdmabuf-wayland.c',
   'gdkdrag-wayland.c',
   'gdkdragsurface-wayland.c',
   'gdkdrop-wayland.c',

gdk/x11/gdkvulkancontext-x11.c

@@ -68,6 +68,11 @@ gdk_x11_vulkan_context_end_frame (GdkDrawContext *context,
   GDK_DRAW_CONTEXT_CLASS (gdk_x11_vulkan_context_parent_class)->end_frame (context, painted);
 }
 
+static void
+gdk_x11_vulkan_context_empty_frame (GdkDrawContext *draw_context)
+{
+}
+
 static void
 gdk_x11_vulkan_context_class_init (GdkX11VulkanContextClass *klass)
 {
@@ -75,6 +80,7 @@ gdk_x11_vulkan_context_class_init (GdkX11VulkanContextClass *klass)
   GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
 
   draw_context_class->end_frame = gdk_x11_vulkan_context_end_frame;
+  draw_context_class->empty_frame = gdk_x11_vulkan_context_empty_frame;
 
   context_class->create_surface = gdk_x11_vulkan_context_create_surface;
 }

gsk/gpu/gskgpubuffer.c

@@ -19,7 +19,7 @@ static gint64 profiler_buffer_uploads;
 static void
 gsk_gpu_buffer_class_init (GskGpuBufferClass *klass)
 {
-  profiler_buffer_uploads_id = gdk_profiler_define_int_counter ("ngl-buffer-uploads", "Number of bytes uploaded to GPU");
+  profiler_buffer_uploads_id = gdk_profiler_define_int_counter ("buffer-uploads", "Number of bytes uploaded to GPU");
 }
 
 static void

gsk/gpu/gskgpunodeprocessor.c

@@ -345,8 +345,8 @@ gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor   *self,
 
   area.x = 0;
   area.y = 0;
-  area.width = ceilf (graphene_vec2_get_x (scale) * viewport->size.width - EPSILON);
-  area.height = ceilf (graphene_vec2_get_y (scale) * viewport->size.height - EPSILON);
+  area.width = MAX (1, ceilf (graphene_vec2_get_x (scale) * viewport->size.width - EPSILON));
+  area.height = MAX (1, ceilf (graphene_vec2_get_y (scale) * viewport->size.height - EPSILON));
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,

gsk/gpu/gskgpuuploadop.c

@@ -313,6 +313,11 @@ gsk_gpu_upload_texture_op_try (GskGpuFrame *frame,
     {
       GEnumClass *enum_class = g_type_class_ref (GDK_TYPE_MEMORY_FORMAT);
 
+      if (!GDK_IS_MEMORY_TEXTURE (texture))
+        {
+          gdk_debug_message ("Unoptimized upload for %s", G_OBJECT_TYPE_NAME (texture));
+        }
+
       if (gdk_texture_get_format (texture) != gsk_gpu_image_get_format (image))
         {
           gdk_debug_message ("Unsupported format %s, converting on CPU to %s",

gsk/gpu/gskvulkandevice.c

@@ -787,7 +787,7 @@ gsk_vulkan_device_get_vk_conversion (GskVulkanDevice *self,
                                                     .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
                                                     .format = vk_format,
                                                     .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
-                                                    .ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+                                                    .ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
                                                     .components = (VkComponentMapping) {
                                                         VK_COMPONENT_SWIZZLE_IDENTITY,
                                                         VK_COMPONENT_SWIZZLE_IDENTITY,
@@ -951,6 +951,8 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice           *self,
   const char *version_string;
   char *vertex_shader_name, *fragment_shader_name;
   G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
+  const char *clip_name[] = { "NONE", "RECT", "ROUNDED" };
+  const char *blend_name[] = { "OVER", "ADD", "CLEAR" };
 
   cache_key = (PipelineCacheKey) {
     .op_class = op_class,
@@ -1128,8 +1130,25 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice           *self,
                                            &pipeline);
 
   gdk_profiler_end_markf (begin_time,
-                          "Create Vulkan pipeline frag=%s vert=%s",
-                          fragment_shader_name, vertex_shader_name);
+                          "Create Vulkan pipeline", "%s version=%s variation=%u clip=%s blend=%s format=%u",
+                          op_class->shader_name,
+                          version_string + 1,
+                          variation,
+                          clip_name[clip],
+                          blend_name[blend],
+                          format);
+
+  GSK_DEBUG (SHADERS,
+             "Create Vulkan pipeline (%s %s, %u/%s/%s/%u) for layout (%lu/%lu/%lu)",
+             op_class->shader_name,
+             version_string + 1,
+             variation,
+             clip_name[clip],
+             blend_name[blend],
+             format,
+             layout->setup.n_buffers,
+             layout->setup.n_samplers,
+             layout->setup.n_immutable_samplers);
 
   g_free (fragment_shader_name);
   g_free (vertex_shader_name);

gsk/gskpathbuilder.c

@@ -1143,10 +1143,10 @@ gsk_path_builder_rel_conic_to (GskPathBuilder *self,
  * @x2: x coordinate of second control point
  * @y2: y coordinate of second control point
  *
- * Adds an elliptical arc from the current point to @x3, @y3
+ * Adds an elliptical arc from the current point to @x2, @y2
  * with @x1, @y1 determining the tangent directions.
  *
- * After this, @x3, @y3 will be the new current point.
+ * After this, @x2, @y2 will be the new current point.
  *
  * Note: Two points and their tangents do not determine
  * a unique ellipse, so GSK just picks one. If you need more
@@ -1180,7 +1180,7 @@ gsk_path_builder_arc_to (GskPathBuilder *self,
  * @x2: x coordinate of second control point
  * @y2: y coordinate of second control point
  *
- * Adds an elliptical arc from the current point to @x3, @y3
+ * Adds an elliptical arc from the current point to @x2, @y2
  * with @x1, @y1 determining the tangent directions.
  *
  * All coordinates are given relative to the current point.

gsk/gskpathprivate.h

@@ -28,7 +28,9 @@ G_BEGIN_DECLS
 
 typedef enum
 {
+  /* path has only lines */
   GSK_PATH_FLAT,
+  /* all contours are closed */
   GSK_PATH_CLOSED
 } GskPathFlags;
 

gsk/gskrenderer.c

@@ -428,21 +428,6 @@ gsk_renderer_render_texture (GskRenderer           *renderer,
 
   texture = GSK_RENDERER_GET_CLASS (renderer)->render_texture (renderer, root, viewport);
 
-  if (GSK_RENDERER_DEBUG_CHECK (renderer, RENDERER))
-    {
-      GString *buf = g_string_new ("*** Texture stats ***\n\n");
-
-      gsk_profiler_append_counters (priv->profiler, buf);
-      g_string_append_c (buf, '\n');
-
-      gsk_profiler_append_timers (priv->profiler, buf);
-      g_string_append_c (buf, '\n');
-
-      g_print ("%s\n***\n\n", buf->str);
-
-      g_string_free (buf, TRUE);
-    }
-
   return texture;
 }
 
@@ -509,21 +494,6 @@ gsk_renderer_render (GskRenderer          *renderer,
 
   renderer_class->render (renderer, root, clip);
 
-  if (GSK_RENDERER_DEBUG_CHECK (renderer, RENDERER))
-    {
-      GString *buf = g_string_new ("*** Frame stats ***\n\n");
-
-      gsk_profiler_append_counters (priv->profiler, buf);
-      g_string_append_c (buf, '\n');
-
-      gsk_profiler_append_timers (priv->profiler, buf);
-      g_string_append_c (buf, '\n');
-
-      g_print ("%s\n***\n\n", buf->str);
-
-      g_string_free (buf, TRUE);
-    }
-
   g_clear_pointer (&priv->prev_node, gsk_render_node_unref);
   cairo_region_destroy (clip);
   g_clear_pointer (&offload, gsk_offload_free);
@@ -609,12 +579,17 @@ get_renderer_for_display (GdkSurface *surface)
 static GType
 get_renderer_for_env_var (GdkSurface *surface)
 {
-  static GType env_var_type = G_TYPE_NONE;
+  static GType env_var_type = G_TYPE_INVALID;
 
-  if (env_var_type == G_TYPE_NONE)
+  if (env_var_type == G_TYPE_INVALID)
     {
       const char *renderer_name = g_getenv ("GSK_RENDERER");
       env_var_type = get_renderer_for_name (renderer_name);
+      if (env_var_type != G_TYPE_INVALID)
+        GSK_DEBUG (RENDERER,
+                   "Environment variable GSK_RENDERER=%s set, trying %s",
+                   renderer_name,
+                   g_type_name (env_var_type));
     }
 
   return env_var_type;
@@ -632,83 +607,115 @@ get_renderer_for_backend (GdkSurface *surface)
 }
 
 static gboolean
-gl_software_rendering (GdkSurface *surface)
+gl_supported_platform (GdkSurface *surface,
+                       GType       renderer_type,
+                       gboolean    as_fallback)
 {
   GdkDisplay *display = gdk_surface_get_display (surface);
   GdkGLContext *context;
+  GError *error = NULL;
 
-  if (!gdk_display_prepare_gl (display, NULL))
-    return G_TYPE_INVALID;
+  if (!gdk_display_prepare_gl (display, &error))
+    {
+      if (!as_fallback)
+        GSK_DEBUG (RENDERER, "Not using GL: %s", error->message);
+      g_clear_error (&error);
+      return FALSE;
+    }
+
+  if (as_fallback)
+    return TRUE;
 
   context = gdk_display_get_gl_context (display);
   gdk_gl_context_make_current (context);
 
-  return strstr ((const char *) glGetString (GL_RENDERER), "llvmpipe") != NULL;
+  if (strstr ((const char *) glGetString (GL_RENDERER), "llvmpipe") != NULL)
+    {
+      GSK_DEBUG (RENDERER, "Not using '%s': renderer is llvmpipe", g_type_name (renderer_type));
+      return FALSE;
+    }
+
+  return TRUE;
 }
 
 static GType
 get_renderer_for_gl (GdkSurface *surface)
 {
-  if (gl_software_rendering (surface))
+  if (!gl_supported_platform (surface, gsk_ngl_renderer_get_type (), FALSE))
     return G_TYPE_INVALID;
 
   return gsk_ngl_renderer_get_type ();
 }
 
+static GType
+get_renderer_for_gl_fallback (GdkSurface *surface)
+{
+  if (!gl_supported_platform (surface, GSK_TYPE_GL_RENDERER, TRUE))
+    return G_TYPE_INVALID;
+
+  return GSK_TYPE_GL_RENDERER;
+}
+
 #ifdef GDK_RENDERING_VULKAN
 static gboolean
-vulkan_software_rendering (GdkSurface *surface)
+vulkan_supported_platform (GdkSurface *surface,
+                           GType       renderer_type,
+                           gboolean    as_fallback)
 {
   GdkDisplay *display = gdk_surface_get_display (surface);
   VkPhysicalDeviceProperties props;
+  GError *error = NULL;
 
-  if (!gdk_display_init_vulkan (display, NULL))
-    return G_TYPE_INVALID;
+  if (!gdk_display_init_vulkan (display, &error))
+    {
+      if (!as_fallback)
+        GSK_DEBUG (RENDERER, "Not using Vulkan: %s", error->message);
+      g_clear_error (&error);
+      return FALSE;
+    }
 
   vkGetPhysicalDeviceProperties (display->vk_physical_device, &props);
 
-  return props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
-}
-#endif
+  if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
+    {
+      if (!as_fallback)
+        GSK_DEBUG (RENDERER,
+                   "Not using '%s': device is CPU",
+                   g_type_name (renderer_type));
+      return FALSE;
+    }
 
-static GType
-get_renderer_for_vulkan (GdkSurface *surface)
-{
-#ifdef GDK_RENDERING_VULKAN
-  if (vulkan_software_rendering (surface))
-    return G_TYPE_INVALID;
+  if (as_fallback)
+    return TRUE;
 
-  return GSK_TYPE_VULKAN_RENDERER;
-#else
-  return G_TYPE_INVALID;
-#endif
-}
-
-static gboolean
-vulkan_friendly_platform (GdkSurface *surface)
-{
 #ifdef GDK_WINDOWING_WAYLAND
   if (GDK_IS_WAYLAND_DISPLAY (gdk_surface_get_display (surface)))
     return TRUE;
 #endif
 
+  GSK_DEBUG (RENDERER, "Not using '%s': platform is not Wayland", g_type_name (renderer_type));
+
   return FALSE;
 }
 
 static GType
-get_renderer_for_vulkan_friendly_platform (GdkSurface *surface)
+get_renderer_for_vulkan (GdkSurface *surface)
 {
-  if (vulkan_friendly_platform (surface))
-    return get_renderer_for_vulkan (surface);
+  if (!vulkan_supported_platform (surface, GSK_TYPE_VULKAN_RENDERER, FALSE))
+    return G_TYPE_INVALID;
 
-  return G_TYPE_INVALID;
+  return GSK_TYPE_VULKAN_RENDERER;
 }
 
 static GType
-get_renderer_for_gles2 (GdkSurface *surface)
+get_renderer_for_vulkan_fallback (GdkSurface *surface)
 {
-  return GSK_TYPE_GL_RENDERER;
+  if (!vulkan_supported_platform (surface, GSK_TYPE_VULKAN_RENDERER, TRUE))
+    return G_TYPE_INVALID;
+
+  return GSK_TYPE_VULKAN_RENDERER;
 }
+#endif
 
 static GType
 get_renderer_fallback (GdkSurface *surface)
@@ -722,10 +729,14 @@ static struct {
   { get_renderer_for_display },
   { get_renderer_for_env_var },
   { get_renderer_for_backend },
-  { get_renderer_for_vulkan_friendly_platform },
-  { get_renderer_for_gl },
+#ifdef GDK_RENDERING_VULKAN
   { get_renderer_for_vulkan },
-  { get_renderer_for_gles2 },
+#endif
+  { get_renderer_for_gl },
+#ifdef GDK_RENDERING_VULKAN
+  { get_renderer_for_vulkan_fallback },
+#endif
+  { get_renderer_for_gl_fallback },
   { get_renderer_fallback },
 };
 
@@ -763,17 +774,19 @@ gsk_renderer_new_for_surface (GdkSurface *surface)
 
       if (gsk_renderer_realize (renderer, surface, &error))
         {
-          GSK_RENDERER_DEBUG (renderer, RENDERER,
-                              "Using renderer of type '%s' for surface '%s'",
-                              G_OBJECT_TYPE_NAME (renderer),
-                              G_OBJECT_TYPE_NAME (surface));
+          GSK_DEBUG (RENDERER,
+                     "Using renderer '%s' for surface '%s'",
+                     G_OBJECT_TYPE_NAME (renderer),
+                     G_OBJECT_TYPE_NAME (surface));
           return renderer;
         }
 
-      g_message ("Failed to realize renderer of type '%s' for surface '%s': %s\n",
+      GSK_DEBUG (RENDERER,
+                 "Failed to realize renderer '%s' for surface '%s': %s",
                  G_OBJECT_TYPE_NAME (renderer),
                  G_OBJECT_TYPE_NAME (surface),
                  error->message);
+
       g_object_unref (renderer);
       g_clear_error (&error);
     }

gsk/gskrendernodeparser.c

@@ -2312,6 +2312,25 @@ parse_antialias (GtkCssParser *parser,
   return TRUE;
 }
 
+static gboolean
+parse_hint_metrics (GtkCssParser *parser,
+                    Context      *context,
+                    gpointer      out)
+{
+  if (!parse_enum (parser, CAIRO_GOBJECT_TYPE_HINT_METRICS, out))
+    return FALSE;
+
+  if (*(cairo_hint_metrics_t *) out != CAIRO_HINT_METRICS_OFF &&
+      *(cairo_hint_metrics_t *) out != CAIRO_HINT_METRICS_ON)
+    {
+      gtk_css_parser_error_value (parser, "Unsupported value for enum \"%s\"",
+                                  g_type_name (CAIRO_GOBJECT_TYPE_HINT_METRICS));
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
 static GskRenderNode *
 parse_text_node (GtkCssParser *parser,
                  Context      *context)
@@ -2322,6 +2341,7 @@ parse_text_node (GtkCssParser *parser,
   PangoGlyphString *glyphs = NULL;
   cairo_hint_style_t hint_style = CAIRO_HINT_STYLE_SLIGHT;
   cairo_antialias_t antialias = CAIRO_ANTIALIAS_GRAY;
+  cairo_hint_metrics_t hint_metrics = CAIRO_HINT_METRICS_OFF;
   PangoFont *hinted;
   const Declaration declarations[] = {
     { "font", parse_font, clear_font, &font },
@@ -2330,6 +2350,7 @@ parse_text_node (GtkCssParser *parser,
     { "glyphs", parse_glyphs, clear_glyphs, &glyphs },
     { "hint-style", parse_hint_style, NULL, &hint_style },
     { "antialias", parse_antialias, NULL, &antialias },
+    { "hint-metrics", parse_hint_metrics, NULL, &hint_metrics },
   };
   GskRenderNode *result;
 
@@ -2341,7 +2362,7 @@ parse_text_node (GtkCssParser *parser,
       g_assert (font);
     }
 
-  hinted = gsk_reload_font (font, 1.0, CAIRO_HINT_METRICS_OFF, hint_style, antialias);
+  hinted = gsk_reload_font (font, 1.0, hint_metrics, hint_style, antialias);
   g_object_unref (font);
   font = hinted;
 
@@ -3623,11 +3644,13 @@ gsk_text_node_serialize_font_options (GskRenderNode *node,
   cairo_font_options_t *options;
   cairo_hint_style_t hint_style;
   cairo_antialias_t antialias;
+  cairo_hint_metrics_t hint_metrics;
 
   options = cairo_font_options_create ();
   cairo_scaled_font_get_font_options (sf, options);
   hint_style = cairo_font_options_get_hint_style (options);
   antialias = cairo_font_options_get_antialias (options);
+  hint_metrics = cairo_font_options_get_hint_metrics (options);
   cairo_font_options_destroy (options);
 
   /* medium and full are identical in the absence of subpixel modes */
@@ -3643,6 +3666,12 @@ gsk_text_node_serialize_font_options (GskRenderNode *node,
    */
   if (antialias == CAIRO_ANTIALIAS_NONE)
     append_enum_param (p, "antialias", CAIRO_GOBJECT_TYPE_ANTIALIAS, antialias);
+
+  /* CAIRO_HINT_METRICS_ON is the only value we ever emit here, since off is the default,
+   * and we don't accept any other values.
+   */
+  if (hint_metrics == CAIRO_HINT_METRICS_ON)
+    append_enum_param (p, "hint-metrics", CAIRO_GOBJECT_TYPE_HINT_METRICS, CAIRO_HINT_METRICS_ON);
 }
 
 void

gtk/a11y/atspi/Event.xml

@@ -184,10 +184,4 @@
         </signal>
 </interface>
 
-<interface name="org.a11y.atspi.Event.Focus">
-	<signal name="Focus"><arg direction="in" type="(suuv)"/>
-          <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QSpiEvent"/>
-        </signal>
-</interface>
-
 </node>

gtk/a11y/gtkatspicontext.c

@@ -720,6 +720,16 @@ handle_accessible_get_property (GDBusConnection       *connection,
     res = get_parent_context_ref (accessible);
   else if (g_strcmp0 (property_name, "ChildCount") == 0)
     res = g_variant_new_int32 (gtk_at_spi_context_get_child_count (self));
+  else if (g_strcmp0 (property_name, "HelpText"))
+    {
+      if (gtk_at_context_has_accessible_property (GTK_AT_CONTEXT (self), GTK_ACCESSIBLE_PROPERTY_HELP_TEXT))
+        {
+          GtkAccessibleValue *value = gtk_at_context_get_accessible_property (GTK_AT_CONTEXT (self), GTK_ACCESSIBLE_PROPERTY_HELP_TEXT);
+          res = g_variant_new_string (gtk_string_accessible_value_get (value));
+        }
+      else
+        res = g_variant_new_string ("");
+    }
   else
     g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                  "Unknown property '%s'", property_name);
@@ -899,24 +909,6 @@ emit_children_changed (GtkAtSpiContext         *self,
                                     context_ref);
 }
 
-static void
-emit_focus (GtkAtSpiContext *self,
-            gboolean         focus_in)
-{
-  if (self->connection == NULL)
-    return;
-
-  if (focus_in)
-    g_dbus_connection_emit_signal (self->connection,
-                                   NULL,
-                                   self->context_path,
-                                   "org.a11y.atspi.Event.Focus",
-                                   "Focus",
-                                   g_variant_new ("(siiva{sv})",
-                                                  "", 0, 0, g_variant_new_string ("0"), NULL),
-                                   NULL);
-}
-
 static void
 emit_window_event (GtkAtSpiContext *self,
                    const char      *event_type)
@@ -1154,7 +1146,7 @@ gtk_at_spi_context_state_change (GtkATContext                *ctx,
     }
 
   if (changed_properties & GTK_ACCESSIBLE_PROPERTY_CHANGE_DESCRIPTION)
-  {
+    {
       char *label = gtk_at_context_get_description (GTK_AT_CONTEXT (self));
       GVariant *v = g_variant_new_take_string (label);
       emit_property_changed (self, "accessible-description", v);
@@ -1167,6 +1159,14 @@ gtk_at_spi_context_state_change (GtkATContext                *ctx,
                              "accessible-value",
                              g_variant_new_double (gtk_number_accessible_value_get (value)));
     }
+
+  if (changed_properties & GTK_ACCESSIBLE_PROPERTY_CHANGE_HELP_TEXT)
+    {
+      value = gtk_accessible_attribute_set_get_value (properties, GTK_ACCESSIBLE_PROPERTY_HELP_TEXT);
+      emit_property_changed (self,
+                             "accessible-help-text",
+                             g_variant_new_string (gtk_string_accessible_value_get (value)));
+    }
 }
 
 static void
@@ -1196,7 +1196,6 @@ gtk_at_spi_context_platform_change (GtkATContext                *ctx,
       gboolean state = gtk_accessible_get_platform_state (GTK_ACCESSIBLE (widget),
                                                           GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED);
       emit_state_changed (self, "focused", state);
-      emit_focus (self, state);
     }
 
   if (changed_platform & GTK_ACCESSIBLE_PLATFORM_CHANGE_ACTIVE)

gtk/a11y/gtkatspiutils.c

@@ -97,7 +97,7 @@ gtk_accessible_role_to_atspi_role (GtkAccessibleRole role)
       return ATSPI_ROLE_FORM;
 
     case GTK_ACCESSIBLE_ROLE_GENERIC:
-      return ATSPI_ROLE_FILLER;
+      return ATSPI_ROLE_PANEL;
 
     case GTK_ACCESSIBLE_ROLE_GRID:
       return ATSPI_ROLE_TABLE;
@@ -106,7 +106,7 @@ gtk_accessible_role_to_atspi_role (GtkAccessibleRole role)
       return ATSPI_ROLE_TABLE_CELL;
 
     case GTK_ACCESSIBLE_ROLE_GROUP:
-      return ATSPI_ROLE_PANEL;
+      return ATSPI_ROLE_GROUPING;
 
     case GTK_ACCESSIBLE_ROLE_HEADING:
       return ATSPI_ROLE_HEADING;

gtk/css/gtkcssparser.c

@@ -27,22 +27,7 @@
 #include "gtkcsslocationprivate.h"
 
 typedef struct _GtkCssParserBlock GtkCssParserBlock;
-
-struct _GtkCssParser
-{
-  volatile int ref_count;
-
-  GtkCssTokenizer *tokenizer;
-  GFile *file;
-  GFile *directory;
-  GtkCssParserErrorFunc error_func;
-  gpointer user_data;
-  GDestroyNotify user_destroy;
-
-  GArray *blocks;
-  GtkCssLocation location;
-  GtkCssToken token;
-};
+typedef struct _GtkCssParserTokenStreamData GtkCssParserTokenStreamData;
 
 struct _GtkCssParserBlock
 {
@@ -52,6 +37,52 @@ struct _GtkCssParserBlock
   GtkCssTokenType alternative_token;
 };
 
+#define GDK_ARRAY_NAME gtk_css_parser_blocks
+#define GDK_ARRAY_TYPE_NAME GtkCssParserBlocks
+#define GDK_ARRAY_ELEMENT_TYPE GtkCssParserBlock
+#define GDK_ARAY_PREALLOC 32
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+static inline GtkCssParserBlock *
+gtk_css_parser_blocks_get_last (GtkCssParserBlocks *blocks)
+{
+  return gtk_css_parser_blocks_index (blocks, gtk_css_parser_blocks_get_size (blocks) - 1);
+}
+
+static inline void
+gtk_css_parser_blocks_drop_last (GtkCssParserBlocks *blocks)
+{
+  gtk_css_parser_blocks_set_size (blocks, gtk_css_parser_blocks_get_size (blocks) - 1);
+}
+
+struct _GtkCssParser
+{
+  volatile int ref_count;
+
+  GPtrArray *tokenizers;
+  GFile *file;
+  GFile *directory;
+  GtkCssParserErrorFunc error_func;
+  gpointer user_data;
+  GDestroyNotify user_destroy;
+
+  GtkCssParserBlocks blocks;
+  GtkCssLocation location;
+  GtkCssToken token;
+
+  GtkCssVariableValue **refs;
+  gsize n_refs;
+  gsize next_ref;
+  gboolean var_fallback;
+};
+
+static inline GtkCssTokenizer *
+get_tokenizer (GtkCssParser *self)
+{
+  return g_ptr_array_index (self->tokenizers, self->tokenizers->len - 1);
+}
+
 static GtkCssParser *
 gtk_css_parser_new (GtkCssTokenizer       *tokenizer,
                     GFile                 *file,
@@ -64,17 +95,17 @@ gtk_css_parser_new (GtkCssTokenizer       *tokenizer,
   self = g_new0 (GtkCssParser, 1);
 
   self->ref_count = 1;
-  self->tokenizer = gtk_css_tokenizer_ref (tokenizer);
+
+  self->tokenizers = g_ptr_array_new_with_free_func ((GDestroyNotify) gtk_css_tokenizer_unref);
+  g_ptr_array_add (self->tokenizers, gtk_css_tokenizer_ref (tokenizer));
+
   if (file)
-    {
-      self->file = g_object_ref (file);
-      self->directory = g_file_get_parent (file);
-    }
+    self->file = g_object_ref (file);
 
   self->error_func = error_func;
   self->user_data = user_data;
   self->user_destroy = user_destroy;
-  self->blocks = g_array_new (FALSE, FALSE, sizeof (GtkCssParserBlock));
+  gtk_css_parser_blocks_init (&self->blocks);
 
   return self;
 }
@@ -117,18 +148,42 @@ gtk_css_parser_new_for_bytes (GBytes                *bytes,
   return result;
 }
 
+GtkCssParser *
+gtk_css_parser_new_for_token_stream (GtkCssVariableValue    *value,
+                                     GFile                  *file,
+                                     GtkCssVariableValue   **refs,
+                                     gsize                   n_refs,
+                                     GtkCssParserErrorFunc   error_func,
+                                     gpointer                user_data,
+                                     GDestroyNotify          user_destroy)
+{
+  GtkCssTokenizer *tokenizer;
+  GtkCssParser *result;
+
+  tokenizer = gtk_css_tokenizer_new_for_range (value->bytes, value->offset,
+                                               value->end_offset - value->offset);
+  result = gtk_css_parser_new (tokenizer, file, error_func, user_data, user_destroy);
+  gtk_css_tokenizer_unref (tokenizer);
+
+  result->refs = refs;
+  result->n_refs = n_refs;
+  result->next_ref = 0;
+
+  return result;
+}
+
 static void
 gtk_css_parser_finalize (GtkCssParser *self)
 {
   if (self->user_destroy)
     self->user_destroy (self->user_data);
 
-  g_clear_pointer (&self->tokenizer, gtk_css_tokenizer_unref);
+  g_clear_pointer (&self->tokenizers, g_ptr_array_unref);
   g_clear_object (&self->file);
   g_clear_object (&self->directory);
-  if (self->blocks->len)
-    g_critical ("Finalizing CSS parser with %u remaining blocks", self->blocks->len);
-  g_array_free (self->blocks, TRUE);
+  if (gtk_css_parser_blocks_get_size (&self->blocks) > 0)
+    g_critical ("Finalizing CSS parser with %lu remaining blocks", gtk_css_parser_blocks_get_size (&self->blocks));
+  gtk_css_parser_blocks_clear (&self->blocks);
 
   g_free (self);
 }
@@ -188,7 +243,12 @@ gtk_css_parser_resolve_url (GtkCssParser *self,
     }
 
   if (self->directory == NULL)
-    return NULL;
+    {
+      if (self->file)
+        self->directory = g_file_get_parent (self->file);
+      if (self->directory == NULL)
+        return NULL;
+    }
 
   return g_file_resolve_relative_path (self->directory, url);
 }
@@ -239,7 +299,7 @@ gtk_css_parser_get_start_location (GtkCssParser *self)
 const GtkCssLocation *
 gtk_css_parser_get_end_location (GtkCssParser *self)
 {
-  return gtk_css_tokenizer_get_location (self->tokenizer);
+  return gtk_css_tokenizer_get_location (get_tokenizer (self));
 }
 
 /**
@@ -259,13 +319,13 @@ gtk_css_parser_get_block_location (GtkCssParser *self)
 {
   const GtkCssParserBlock *block;
 
-  if (self->blocks->len == 0)
+  if (gtk_css_parser_blocks_get_size (&self->blocks) == 0)
     {
       static const GtkCssLocation start_of_document = { 0, };
       return &start_of_document;
     }
 
-  block = &g_array_index (self->blocks, GtkCssParserBlock, self->blocks->len - 1);
+  block = gtk_css_parser_blocks_get_last (&self->blocks);
   return &block->start_location;
 }
 
@@ -273,12 +333,14 @@ static void
 gtk_css_parser_ensure_token (GtkCssParser *self)
 {
   GError *error = NULL;
+  GtkCssTokenizer *tokenizer;
 
   if (!gtk_css_token_is (&self->token, GTK_CSS_TOKEN_EOF))
     return;
 
-  self->location = *gtk_css_tokenizer_get_location (self->tokenizer);
-  if (!gtk_css_tokenizer_read_token (self->tokenizer, &self->token, &error))
+  tokenizer = get_tokenizer (self);
+  self->location = *gtk_css_tokenizer_get_location (tokenizer);
+  if (!gtk_css_tokenizer_read_token (tokenizer, &self->token, &error))
     {
       /* We ignore the error here, because the resulting token will
        * likely already trigger an error in the parsing code and
@@ -286,6 +348,44 @@ gtk_css_parser_ensure_token (GtkCssParser *self)
        */
       g_clear_error (&error);
     }
+
+  if (self->tokenizers->len > 1 && gtk_css_token_is (&self->token, GTK_CSS_TOKEN_EOF))
+    {
+      g_ptr_array_remove_index_fast (self->tokenizers, self->tokenizers->len - 1);
+      gtk_css_parser_ensure_token (self);
+      return;
+    }
+
+  /* Resolve var(--name): skip it and insert the resolved reference instead */
+  if (self->n_refs > 0 && gtk_css_token_is_function (&self->token, "var") && self->var_fallback == 0)
+    {
+      GtkCssVariableValue *ref;
+      GtkCssTokenizer *ref_tokenizer;
+
+      gtk_css_parser_start_block (self);
+
+      g_assert (gtk_css_parser_has_token (self, GTK_CSS_TOKEN_IDENT));
+
+      char *var_name = gtk_css_parser_consume_ident (self);
+      g_assert (var_name[0] == '-' && var_name[1] == '-');
+      g_free (var_name);
+
+      /* If we encounter var() in a fallback when we can already resolve the
+       * actual variable, skip it */
+      self->var_fallback++;
+      gtk_css_parser_skip (self);
+      gtk_css_parser_end_block (self);
+      self->var_fallback--;
+
+      g_assert (self->next_ref < self->n_refs);
+
+      ref = self->refs[self->next_ref++];
+      ref_tokenizer = gtk_css_tokenizer_new_for_range (ref->bytes, ref->offset,
+                                                       ref->end_offset - ref->offset);
+      g_ptr_array_add (self->tokenizers, ref_tokenizer);
+
+      gtk_css_parser_ensure_token (self);
+    }
 }
 
 const GtkCssToken *
@@ -295,9 +395,9 @@ gtk_css_parser_peek_token (GtkCssParser *self)
 
   gtk_css_parser_ensure_token (self);
 
-  if (self->blocks->len)
+  if (gtk_css_parser_blocks_get_size (&self->blocks) > 0)
     {
-      const GtkCssParserBlock *block = &g_array_index (self->blocks, GtkCssParserBlock, self->blocks->len - 1);
+      const GtkCssParserBlock *block = gtk_css_parser_blocks_get_last (&self->blocks);
       if (gtk_css_token_is (&self->token, block->end_token) ||
           gtk_css_token_is (&self->token, block->inherited_end_token) ||
           gtk_css_token_is (&self->token, block->alternative_token))
@@ -352,7 +452,7 @@ gtk_css_parser_start_block (GtkCssParser *self)
   block.inherited_end_token = GTK_CSS_TOKEN_EOF;
   block.alternative_token = GTK_CSS_TOKEN_EOF;
   block.start_location = self->location;
-  g_array_append_val (self->blocks, block);
+  gtk_css_parser_blocks_append (&self->blocks, block);
 
   gtk_css_token_clear (&self->token);
 }
@@ -364,13 +464,13 @@ gtk_css_parser_start_semicolon_block (GtkCssParser    *self,
   GtkCssParserBlock block;
 
   block.end_token = GTK_CSS_TOKEN_SEMICOLON;
-  if (self->blocks->len)
-    block.inherited_end_token = g_array_index (self->blocks, GtkCssParserBlock, self->blocks->len - 1).end_token;
+  if (gtk_css_parser_blocks_get_size (&self->blocks) > 0)
+    block.inherited_end_token = gtk_css_parser_blocks_get_last (&self->blocks)->end_token;
   else
     block.inherited_end_token = GTK_CSS_TOKEN_EOF;
   block.alternative_token = alternative_token;
   block.start_location = self->location;
-  g_array_append_val (self->blocks, block);
+  gtk_css_parser_blocks_append (&self->blocks, block);
 }
 
 void
@@ -378,9 +478,9 @@ gtk_css_parser_end_block_prelude (GtkCssParser *self)
 {
   GtkCssParserBlock *block;
 
-  g_return_if_fail (self->blocks->len > 0);
+  g_return_if_fail (gtk_css_parser_blocks_get_size (&self->blocks) > 0);
 
-  block = &g_array_index (self->blocks, GtkCssParserBlock, self->blocks->len - 1);
+  block = gtk_css_parser_blocks_get_last (&self->blocks);
 
   if (block->alternative_token == GTK_CSS_TOKEN_EOF)
     return;
@@ -405,11 +505,11 @@ gtk_css_parser_end_block (GtkCssParser *self)
 {
   GtkCssParserBlock *block;
 
-  g_return_if_fail (self->blocks->len > 0);
+  g_return_if_fail (gtk_css_parser_blocks_get_size (&self->blocks) > 0);
 
   gtk_css_parser_skip_until (self, GTK_CSS_TOKEN_EOF);
 
-  block = &g_array_index (self->blocks, GtkCssParserBlock, self->blocks->len - 1);
+  block = gtk_css_parser_blocks_get_last (&self->blocks);
 
   if (gtk_css_token_is (&self->token, GTK_CSS_TOKEN_EOF))
     {
@@ -418,7 +518,7 @@ gtk_css_parser_end_block (GtkCssParser *self)
                            gtk_css_parser_get_block_location (self),
                            gtk_css_parser_get_start_location (self),
                            "Unterminated block at end of document");
-      g_array_set_size (self->blocks, self->blocks->len - 1);
+      gtk_css_parser_blocks_drop_last (&self->blocks);
     }
   else if (gtk_css_token_is (&self->token, block->inherited_end_token))
     {
@@ -428,11 +528,11 @@ gtk_css_parser_end_block (GtkCssParser *self)
                            gtk_css_parser_get_block_location (self),
                            gtk_css_parser_get_start_location (self),
                            "Expected ';' at end of block");
-      g_array_set_size (self->blocks, self->blocks->len - 1);
+      gtk_css_parser_blocks_drop_last (&self->blocks);
     }
   else
     {
-      g_array_set_size (self->blocks, self->blocks->len - 1);
+      gtk_css_parser_blocks_drop_last (&self->blocks);
       if (gtk_css_token_is_preserved (&self->token, NULL))
         {
           gtk_css_token_clear (&self->token);
@@ -1112,3 +1212,275 @@ gtk_css_parser_consume_any (GtkCssParser            *parser,
 
   return result;
 }
+
+gboolean
+gtk_css_parser_has_references (GtkCssParser *self)
+{
+  GtkCssTokenizer *tokenizer = get_tokenizer (self);
+  gboolean ret = FALSE;
+  int inner_blocks = 0, i;
+
+  gtk_css_tokenizer_save (tokenizer);
+
+  do {
+      const GtkCssToken *token;
+
+      token = gtk_css_parser_get_token (self);
+
+      if (inner_blocks == 0)
+        {
+          if (gtk_css_token_is (token, GTK_CSS_TOKEN_EOF))
+            break;
+
+          if (gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_PARENS) ||
+              gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_SQUARE))
+            {
+              goto error;
+            }
+        }
+
+      if (gtk_css_token_is_preserved (token, NULL))
+        {
+          if (inner_blocks > 0 && gtk_css_token_is (token, GTK_CSS_TOKEN_EOF))
+            {
+              gtk_css_parser_end_block (self);
+              inner_blocks--;
+            }
+          else
+            {
+              gtk_css_parser_consume_token (self);
+            }
+        }
+      else
+        {
+          gboolean is_var = gtk_css_token_is_function (token, "var");
+
+          inner_blocks++;
+          gtk_css_parser_start_block (self);
+
+          if (!ret && is_var)
+            {
+              token = gtk_css_parser_get_token (self);
+
+              if (gtk_css_token_is (token, GTK_CSS_TOKEN_IDENT))
+                {
+                  const char *var_name = gtk_css_token_get_string (token);
+
+                  if (var_name[0] != '-' || var_name[1] != '-')
+                    goto error;
+
+                  gtk_css_parser_consume_token (self);
+
+                  if (!gtk_css_parser_has_token (self, GTK_CSS_TOKEN_EOF) &&
+                      !gtk_css_parser_has_token (self, GTK_CSS_TOKEN_COMMA))
+                    {
+                      goto error;
+                    }
+
+                  ret = TRUE;
+                }
+            }
+        }
+    }
+  while (!gtk_css_parser_has_token (self, GTK_CSS_TOKEN_SEMICOLON) &&
+         !gtk_css_parser_has_token (self, GTK_CSS_TOKEN_CLOSE_CURLY));
+
+  if (inner_blocks > 0)
+    goto error;
+
+  gtk_css_tokenizer_restore (tokenizer);
+  self->location = *gtk_css_tokenizer_get_location (tokenizer);
+  gtk_css_tokenizer_read_token (tokenizer, &self->token, NULL);
+
+  return ret;
+
+error:
+  for (i = 0; i < inner_blocks; i++)
+    gtk_css_parser_end_block (self);
+
+  gtk_css_tokenizer_restore (tokenizer);
+  self->location = *gtk_css_tokenizer_get_location (tokenizer);
+  gtk_css_tokenizer_read_token (tokenizer, &self->token, NULL);
+
+  return FALSE;
+}
+
+static void
+clear_ref (GtkCssVariableValueReference *ref)
+{
+  g_free (ref->name);
+  if (ref->fallback)
+    gtk_css_variable_value_unref (ref->fallback);
+}
+
+GtkCssVariableValue *
+gtk_css_parser_parse_value_into_token_stream (GtkCssParser *self)
+{
+  GBytes *bytes = gtk_css_tokenizer_get_bytes (get_tokenizer (self));
+  const GtkCssToken *token;
+  gsize offset;
+  gsize length = 0;
+  GArray *refs;
+  GtkCssVariableValueReference *out_refs;
+  gsize n_refs;
+  int inner_blocks = 0, i;
+  gboolean is_initial = FALSE;
+
+  refs = g_array_new (FALSE, TRUE, sizeof (GtkCssVariableValueReference));
+
+  g_array_set_clear_func (refs, (GDestroyNotify) clear_ref);
+
+  for (token = gtk_css_parser_peek_token (self);
+       gtk_css_token_is (token, GTK_CSS_TOKEN_WHITESPACE);
+       token = gtk_css_parser_peek_token (self))
+    {
+      gtk_css_parser_consume_token (self);
+    }
+
+  offset = self->location.bytes;
+
+  do {
+      token = gtk_css_parser_get_token (self);
+
+      if (length == 0 && gtk_css_token_is_ident (token, "initial"))
+        is_initial = TRUE;
+
+      if (gtk_css_token_is (token, GTK_CSS_TOKEN_BAD_STRING) ||
+          gtk_css_token_is (token, GTK_CSS_TOKEN_BAD_URL))
+        {
+          gtk_css_parser_error_syntax (self, "Invalid property value");
+          goto error;
+        }
+
+      if (inner_blocks == 0)
+        {
+          if (gtk_css_token_is (token, GTK_CSS_TOKEN_EOF))
+            break;
+
+          if (gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_PARENS) ||
+              gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_SQUARE))
+            {
+              gtk_css_parser_error_syntax (self, "Invalid property value");
+              goto error;
+            }
+        }
+
+      if (gtk_css_token_is_preserved (token, NULL))
+        {
+          if (inner_blocks > 0 && gtk_css_token_is (token, GTK_CSS_TOKEN_EOF))
+            {
+              length++;
+              gtk_css_parser_end_block (self);
+
+              inner_blocks--;
+            }
+          else
+            {
+              length++;
+              gtk_css_parser_consume_token (self);
+            }
+        }
+      else
+        {
+          gboolean is_var = gtk_css_token_is_function (token, "var");
+
+          length++;
+          inner_blocks++;
+
+          gtk_css_parser_start_block (self);
+
+          if (is_var)
+            {
+              token = gtk_css_parser_get_token (self);
+
+              if (gtk_css_token_is (token, GTK_CSS_TOKEN_IDENT))
+                {
+                  GtkCssVariableValueReference ref;
+                  char *var_name = g_strdup (gtk_css_token_get_string (token));
+
+                  if (var_name[0] != '-' || var_name[1] != '-')
+                    {
+                      gtk_css_parser_error_value (self, "Invalid variable name: %s", var_name);
+                      g_free (var_name);
+                      goto error;
+                    }
+
+                  length++;
+                  gtk_css_parser_consume_token (self);
+
+                  if (!gtk_css_parser_has_token (self, GTK_CSS_TOKEN_EOF) &&
+                      !gtk_css_parser_has_token (self, GTK_CSS_TOKEN_COMMA))
+                    {
+                      gtk_css_parser_error_syntax (self, "Invalid property value");
+                      g_free (var_name);
+                      goto error;
+                    }
+
+                  ref.name = var_name;
+
+                  if (gtk_css_parser_has_token (self, GTK_CSS_TOKEN_EOF))
+                    {
+                      ref.length = 3;
+                      ref.fallback = NULL;
+                    }
+                  else
+                    {
+                      length++;
+                      gtk_css_parser_consume_token (self);
+
+                      ref.fallback = gtk_css_parser_parse_value_into_token_stream (self);
+
+                      if (ref.fallback == NULL)
+                        {
+                          gtk_css_parser_error_value (self, "Invalid fallback for: %s", var_name);
+                          g_free (var_name);
+                          goto error;
+                        }
+
+                      ref.length = 4 + ref.fallback->length;
+                      length += ref.fallback->length;
+                    }
+
+                  g_array_append_val (refs, ref);
+                }
+            }
+        }
+    }
+  while (!gtk_css_parser_has_token (self, GTK_CSS_TOKEN_SEMICOLON) &&
+         !gtk_css_parser_has_token (self, GTK_CSS_TOKEN_CLOSE_CURLY));
+
+  if (inner_blocks > 0)
+    {
+      gtk_css_parser_error_syntax (self, "Invalid property value");
+      goto error;
+    }
+
+  if (is_initial && length == 1)
+    {
+      g_array_unref (refs);
+
+      return gtk_css_variable_value_new_initial (bytes,
+                                                 offset,
+                                                 self->location.bytes);
+    }
+  else
+    {
+      out_refs = g_array_steal (refs, &n_refs);
+      g_array_unref (refs);
+
+      return gtk_css_variable_value_new (bytes,
+                                         offset,
+                                         self->location.bytes,
+                                         length,
+                                         out_refs,
+                                         n_refs);
+    }
+
+error:
+  for (i = 0; i < inner_blocks; i++)
+    gtk_css_parser_end_block (self);
+
+  g_array_unref (refs);
+
+  return NULL;
+}

gtk/css/gtkcssparserprivate.h

@@ -22,6 +22,7 @@
 
 #include "gtkcssenums.h"
 #include "gtkcsstokenizerprivate.h"
+#include "gtkcssvariablevalueprivate.h"
 
 #include <gio/gio.h>
 
@@ -58,6 +59,13 @@ GtkCssParser *          gtk_css_parser_new_for_bytes            (GBytes
                                                                  GtkCssParserErrorFunc           error_func,
                                                                  gpointer                        user_data,
                                                                  GDestroyNotify                  user_destroy);
+GtkCssParser *          gtk_css_parser_new_for_token_stream     (GtkCssVariableValue            *value,
+                                                                 GFile                          *file,
+                                                                 GtkCssVariableValue           **refs,
+                                                                 gsize                           n_refs,
+                                                                 GtkCssParserErrorFunc           error_func,
+                                                                 gpointer                        user_data,
+                                                                 GDestroyNotify                  user_destroy);
 GtkCssParser *          gtk_css_parser_ref                      (GtkCssParser                   *self);
 void                    gtk_css_parser_unref                    (GtkCssParser                   *self);
 
@@ -150,5 +158,9 @@ gsize                   gtk_css_parser_consume_any              (GtkCssParser
                                                                  gsize                           n_options,
                                                                  gpointer                        user_data);
 
+gboolean                gtk_css_parser_has_references           (GtkCssParser                   *parser);
+
+GtkCssVariableValue *   gtk_css_parser_parse_value_into_token_stream (GtkCssParser              *parser);
+
 G_END_DECLS
 

gtk/css/gtkcsstokenizer.c

@@ -26,6 +26,20 @@
 #include <math.h>
 #include <string.h>
 
+typedef struct
+{
+  GtkCssLocation         position;
+  const char            *data;
+} GtkCssTokenizerSavedState;
+
+#define GDK_ARRAY_NAME gtk_css_tokenizer_states
+#define GDK_ARRAY_TYPE_NAME GtkCssTokenizerStates
+#define GDK_ARRAY_ELEMENT_TYPE GtkCssTokenizerSavedState
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 16
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
 struct _GtkCssTokenizer
 {
   int                    ref_count;
@@ -36,6 +50,7 @@ struct _GtkCssTokenizer
   const char            *end;
 
   GtkCssLocation         position;
+  GtkCssTokenizerStates  state_stack;
 };
 
 void
@@ -568,6 +583,14 @@ gtk_css_token_init_dimension (GtkCssToken     *token,
 
 GtkCssTokenizer *
 gtk_css_tokenizer_new (GBytes *bytes)
+{
+  return gtk_css_tokenizer_new_for_range (bytes, 0, g_bytes_get_size (bytes));
+}
+
+GtkCssTokenizer *
+gtk_css_tokenizer_new_for_range (GBytes *bytes,
+                                 gsize   offset,
+                                 gsize   length)
 {
   GtkCssTokenizer *tokenizer;
 
@@ -576,10 +599,11 @@ gtk_css_tokenizer_new (GBytes *bytes)
   tokenizer->bytes = g_bytes_ref (bytes);
   tokenizer->name_buffer = g_string_new (NULL);
 
-  tokenizer->data = g_bytes_get_data (bytes, NULL);
-  tokenizer->end = tokenizer->data + g_bytes_get_size (bytes);
+  tokenizer->data = g_bytes_get_region (bytes, 1, offset, length);
+  tokenizer->end = tokenizer->data + length;
 
   gtk_css_location_init (&tokenizer->position);
+  gtk_css_tokenizer_states_init (&tokenizer->state_stack);
 
   return tokenizer;
 }
@@ -604,6 +628,12 @@ gtk_css_tokenizer_unref (GtkCssTokenizer *tokenizer)
   g_free (tokenizer);
 }
 
+GBytes *
+gtk_css_tokenizer_get_bytes (GtkCssTokenizer *tokenizer)
+{
+  return tokenizer->bytes;
+}
+
 const GtkCssLocation *
 gtk_css_tokenizer_get_location (GtkCssTokenizer *tokenizer)
 {
@@ -1484,3 +1514,30 @@ gtk_css_tokenizer_read_token (GtkCssTokenizer  *tokenizer,
     }
 }
 
+void
+gtk_css_tokenizer_save (GtkCssTokenizer *tokenizer)
+{
+  GtkCssTokenizerSavedState state;
+
+  state.position = tokenizer->position;
+  state.data = tokenizer->data;
+
+  gtk_css_tokenizer_states_append (&tokenizer->state_stack, &state);
+}
+
+void
+gtk_css_tokenizer_restore (GtkCssTokenizer *tokenizer)
+{
+  GtkCssTokenizerSavedState *state;
+
+  int index = gtk_css_tokenizer_states_get_size (&tokenizer->state_stack) - 1;
+
+  g_assert (index >= 0);
+
+  state = gtk_css_tokenizer_states_get (&tokenizer->state_stack, index);
+
+  tokenizer->position = state->position;
+  tokenizer->data = state->data;
+
+  gtk_css_tokenizer_states_splice (&tokenizer->state_stack, index, 1, FALSE, NULL, 0);
+}

gtk/css/gtkcsstokenizerprivate.h

@@ -138,15 +138,22 @@ void                    gtk_css_token_print                     (const GtkCssTok
 char *                  gtk_css_token_to_string                 (const GtkCssToken      *token);
 
 GtkCssTokenizer *       gtk_css_tokenizer_new                   (GBytes                 *bytes);
+GtkCssTokenizer *       gtk_css_tokenizer_new_for_range         (GBytes                 *bytes,
+                                                                 gsize                   offset,
+                                                                 gsize                   length);
 
 GtkCssTokenizer *       gtk_css_tokenizer_ref                   (GtkCssTokenizer        *tokenizer);
 void                    gtk_css_tokenizer_unref                 (GtkCssTokenizer        *tokenizer);
 
+GBytes *                gtk_css_tokenizer_get_bytes             (GtkCssTokenizer        *tokenizer);
 const GtkCssLocation *  gtk_css_tokenizer_get_location          (GtkCssTokenizer        *tokenizer) G_GNUC_CONST;
 
 gboolean                gtk_css_tokenizer_read_token            (GtkCssTokenizer        *tokenizer,
                                                                  GtkCssToken            *token,
                                                                  GError                **error);
 
+void                     gtk_css_tokenizer_save                 (GtkCssTokenizer        *tokenizer);
+void                     gtk_css_tokenizer_restore              (GtkCssTokenizer        *tokenizer);
+
 G_END_DECLS
 

gtk/css/gtkcssvariablevalue.c

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#include "gtkcssvariablevalueprivate.h"
+
+GtkCssVariableValue *
+gtk_css_variable_value_new (GBytes                       *bytes,
+                            gsize                         offset,
+                            gsize                         end_offset,
+                            gsize                         length,
+                            GtkCssVariableValueReference *references,
+                            gsize                         n_references)
+{
+  GtkCssVariableValue *self = g_new0 (GtkCssVariableValue, 1);
+
+  self->ref_count = 1;
+
+  self->bytes = g_bytes_ref (bytes);
+  self->offset = offset;
+  self->end_offset = end_offset;
+  self->length = length;
+
+  self->references = references;
+  self->n_references = n_references;
+
+  return self;
+}
+
+GtkCssVariableValue *
+gtk_css_variable_value_new_initial (GBytes *bytes,
+                                    gsize   offset,
+                                    gsize   end_offset)
+{
+  GtkCssVariableValue *self = gtk_css_variable_value_new (bytes, offset, end_offset, 1, NULL, 0);
+
+  self->is_invalid = TRUE;
+
+  return self;
+}
+
+GtkCssVariableValue *
+gtk_css_variable_value_ref (GtkCssVariableValue *self)
+{
+  self->ref_count++;
+
+  return self;
+}
+
+void
+gtk_css_variable_value_unref (GtkCssVariableValue *self)
+{
+  gsize i;
+
+  self->ref_count--;
+  if (self->ref_count > 0)
+    return;
+
+  g_bytes_unref (self->bytes);
+
+  for (i = 0; i < self->n_references; i++)
+    {
+      GtkCssVariableValueReference *ref = &self->references[i];
+
+      g_free (ref->name);
+      if (ref->fallback)
+        gtk_css_variable_value_unref (ref->fallback);
+    }
+
+  if (self->section)
+    gtk_css_section_unref (self->section);
+
+  g_free (self->references);
+  g_free (self);
+}
+
+void
+gtk_css_variable_value_print (GtkCssVariableValue *self,
+                              GString             *string)
+{
+  gsize len = self->end_offset - self->offset;
+  gconstpointer data = g_bytes_get_region (self->bytes, 1, self->offset, len);
+
+  g_assert (data != NULL);
+
+  g_string_append_len (string, (const char *) data, len);
+}
+
+char *
+gtk_css_variable_value_to_string (GtkCssVariableValue *self)
+{
+  GString *string = g_string_new (NULL);
+  gtk_css_variable_value_print (self, string);
+  return g_string_free (string, FALSE);
+}
+
+gboolean
+gtk_css_variable_value_equal (const GtkCssVariableValue *value1,
+                              const GtkCssVariableValue *value2)
+{
+  if (value1 == value2)
+    return TRUE;
+
+  if (value1 == NULL || value2 == NULL)
+    return FALSE;
+
+  if (value1->bytes != value2->bytes)
+    return FALSE;
+
+  if (value1->offset != value2->offset)
+    return FALSE;
+
+  if (value1->end_offset != value2->end_offset)
+    return FALSE;
+
+  return TRUE;
+}
+
+GtkCssVariableValue *
+gtk_css_variable_value_transition  (GtkCssVariableValue *start,
+                                    GtkCssVariableValue *end,
+                                    double               progress)
+{
+  GtkCssVariableValue *ret = progress < 0.5 ? start : end;
+
+  if (ret == NULL)
+    return NULL;
+
+  return gtk_css_variable_value_ref (ret);
+}
+
+void
+gtk_css_variable_value_set_section (GtkCssVariableValue *self,
+                                    GtkCssSection       *section)
+{
+  self->section = gtk_css_section_ref (section);
+}
+
+void
+gtk_css_variable_value_taint (GtkCssVariableValue *self)
+{
+  self->is_animation_tainted = TRUE;
+}

gtk/css/gtkcssvariablevalueprivate.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#pragma once
+
+#include "gtkcss.h"
+#include "gtkcsstokenizerprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GtkCssVariableValueReference GtkCssVariableValueReference;
+typedef struct _GtkCssVariableValue GtkCssVariableValue;
+
+struct _GtkCssVariableValueReference
+{
+  char *name;
+  gsize length;
+  GtkCssVariableValue *fallback;
+};
+
+struct _GtkCssVariableValue
+{
+  int ref_count;
+
+  GBytes *bytes;
+  gsize offset;
+  gsize end_offset;
+  gsize length;
+
+  GtkCssVariableValueReference *references;
+  gsize n_references;
+
+  GtkCssSection *section;
+  gboolean is_invalid;
+  gboolean is_animation_tainted;
+};
+
+GtkCssVariableValue *gtk_css_variable_value_new         (GBytes                       *bytes,
+                                                         gsize                         offset,
+                                                         gsize                         end_offset,
+                                                         gsize                         length,
+                                                         GtkCssVariableValueReference *references,
+                                                         gsize                         n_references);
+GtkCssVariableValue *gtk_css_variable_value_new_initial (GBytes                       *bytes,
+                                                         gsize                         offset,
+                                                         gsize                         end_offset);
+GtkCssVariableValue *gtk_css_variable_value_ref         (GtkCssVariableValue          *self);
+void                 gtk_css_variable_value_unref       (GtkCssVariableValue          *self);
+void                 gtk_css_variable_value_print       (GtkCssVariableValue          *self,
+                                                         GString                      *string);
+char *               gtk_css_variable_value_to_string   (GtkCssVariableValue          *self);
+gboolean             gtk_css_variable_value_equal       (const GtkCssVariableValue    *value1,
+                                                         const GtkCssVariableValue    *value2) G_GNUC_PURE;
+GtkCssVariableValue *gtk_css_variable_value_transition  (GtkCssVariableValue          *start,
+                                                         GtkCssVariableValue          *end,
+                                                         double                        progress);
+void                 gtk_css_variable_value_set_section (GtkCssVariableValue          *self,
+                                                         GtkCssSection                *section);
+void                 gtk_css_variable_value_taint       (GtkCssVariableValue          *self);
+
+G_END_DECLS

gtk/css/meson.build

@@ -6,8 +6,9 @@ gtk_css_public_sources = files([
 gtk_css_private_sources = files([
   'gtkcssdataurl.c',
   'gtkcssparser.c',
-  'gtkcsstokenizer.c',
   'gtkcssserializer.c',
+  'gtkcsstokenizer.c',
+  'gtkcssvariablevalue.c',
 ])
 
 gtk_css_public_headers = files([

gtk/gdktextureutils.c

@@ -21,9 +21,16 @@
 #include "gtkscalerprivate.h"
 
 #include "gdk/gdktextureprivate.h"
+#include "gdk/loaders/gdkpngprivate.h"
 
 /* {{{ Pixbuf helpers */
 
+static inline gboolean
+pixbuf_is_only_fg (GdkPixbuf *pixbuf)
+{
+  return gdk_pixbuf_get_option (pixbuf, "tEXt::only-foreground") != NULL;
+}
+
 static GdkPixbuf *
 load_from_stream (GdkPixbufLoader  *loader,
                   GInputStream     *stream,
@@ -199,6 +206,7 @@ _gdk_pixbuf_new_from_resource_at_scale (const char   *resource_path,
 
 static GdkPixbuf *
 load_symbolic_svg (const char     *escaped_file_data,
+                   gsize           len,
                    int             width,
                    int             height,
                    const char     *icon_width_str,
@@ -214,37 +222,38 @@ load_symbolic_svg (const char     *escaped_file_data,
   char *data;
 
   data = g_strconcat ("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
-                      "<svg version=\"1.1\"\n"
-                      "     xmlns=\"http://www.w3.org/2000/svg\"\n"
-                      "     xmlns:xi=\"http://www.w3.org/2001/XInclude\"\n"
-                      "     width=\"", icon_width_str, "\"\n"
-                      "     height=\"", icon_height_str, "\">\n"
-                      "  <style type=\"text/css\">\n"
-                      "    rect,circle,path {\n"
-                      "      fill: ", fg_string," !important;\n"
-                      "    }\n"
-                      "    .warning {\n"
-                      "      fill: ", warning_color_string, " !important;\n"
-                      "    }\n"
-                      "    .error {\n"
-                      "      fill: ", error_color_string ," !important;\n"
-                      "    }\n"
-                      "    .success {\n"
-                      "      fill: ", success_color_string, " !important;\n"
-                      "    }\n"
-                      "  </style>\n"
-                      "  <xi:include href=\"data:text/xml;base64,", escaped_file_data, "\"/>\n"
-                      "</svg>",
+                      "<svg version=\"1.1\" "
+                           "xmlns=\"http://www.w3.org/2000/svg\" "
+                           "xmlns:xi=\"http://www.w3.org/2001/XInclude\" "
+                           "width=\"", icon_width_str, "\" "
+                           "height=\"", icon_height_str, "\">"
+                        "<style type=\"text/css\">"
+                          "rect,circle,path {"
+                            "fill: ", fg_string," !important;"
+                          "}\n"
+                          ".warning {"
+                             "fill: ", warning_color_string, " !important;"
+                          "}\n"
+                          ".error {"
+                            "fill: ", error_color_string ," !important;"
+                          "}\n"
+                          ".success {"
+                            "fill: ", success_color_string, " !important;"
+                          "}"
+                        "</style>"
+                        "<xi:include href=\"data:text/xml;base64,",
                       NULL);
 
   stream = g_memory_input_stream_new_from_data (data, -1, g_free);
+  g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (stream), escaped_file_data, len, NULL);
+  g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (stream), "\"/></svg>", strlen ("\"/></svg>"), NULL);
   pixbuf = gdk_pixbuf_new_from_stream_at_scale (stream, width, height, TRUE, NULL, error);
   g_object_unref (stream);
 
   return pixbuf;
 }
 
-static void
+static gboolean
 extract_plane (GdkPixbuf *src,
                GdkPixbuf *dst,
                int        from_plane,
@@ -255,6 +264,7 @@ extract_plane (GdkPixbuf *src,
   gsize src_stride, dst_stride;
   guchar *src_row, *dst_row;
   int x, y;
+  gboolean all_clear = TRUE;
 
   width = gdk_pixbuf_get_width (src);
   height = gdk_pixbuf_get_height (src);
@@ -274,11 +284,109 @@ extract_plane (GdkPixbuf *src,
       dst_row = dst_data + dst_stride * y;
       for (x = 0; x < width; x++)
         {
+          if (src_row[from_plane] != 0)
+            all_clear = FALSE;
+
           dst_row[to_plane] = src_row[from_plane];
           src_row += 4;
           dst_row += 4;
         }
     }
+
+  return all_clear;
+}
+
+static void
+keep_alpha (GdkPixbuf *src)
+{
+  guchar *data;
+  int width, height;
+  gsize stride;
+
+  data = gdk_pixbuf_get_pixels (src);
+  width = gdk_pixbuf_get_width (src);
+  height = gdk_pixbuf_get_height (src);
+  stride = gdk_pixbuf_get_rowstride (src);
+
+  for (int y = 0; y < height; y++)
+    {
+      guchar *row = data + stride * y;
+      for (int x = 0; x < width; x++)
+        {
+          row[0] = row[1] = row[2] = 0;
+          row += 4;
+        }
+    }
+}
+
+static void
+svg_find_size_strings (const char  *data,
+                       gsize        len,
+                       char       **width,
+                       char       **height)
+{
+  gsize i, j, k, l;
+
+  *width = NULL;
+  *height = NULL;
+
+  for (i = 0; i < len - 4; i++)
+    {
+      if (strncmp (data + i, "<svg", 4) == 0)
+        {
+          for (j = i + strlen ("<svg"); j < len - 9; j++)
+            {
+              if (strncmp (data + j, "height=\"", strlen ("height=\"")) == 0)
+                {
+                  k = l = j + strlen ("height=\"");
+                  while (l < len && data[l] != '\"')
+                    l++;
+
+                  *height = g_strndup (data + k, l - k);
+
+                  if (*width && *height)
+                    return;
+
+                  j = l;
+                }
+              else if (strncmp (data + j, "width=\"", strlen ("width=\"")) == 0)
+                {
+                  k = l = j + strlen ("width=\"");
+                  while (l < len && data[l] != '\"')
+                    l++;
+
+                  *width = g_strndup (data + k, l - k);
+
+                  if (*width && *height)
+                    return;
+
+                  j = l;
+                }
+              else if (data[j] == '>')
+                {
+                  break;
+                }
+            }
+
+          break;
+        }
+    }
+
+  *width = g_strdup ("16px");
+  *height = g_strdup ("16px");
+}
+
+static gboolean
+svg_has_symbolic_classes (const char *data,
+                          gsize       len)
+{
+#ifdef HAVE_MEMMEM
+  return memmem (data, len, "class=\"error\"", strlen ("class=\"error\"")) != NULL ||
+         memmem (data, len, "class=\"warning\"", strlen ("class=\"warning\"")) != NULL ||
+         memmem (data, len, "class=\"success\"", strlen ("class=\"success\"")) != NULL;
+#else
+  return TRUE;
+#endif
 }
 
 GdkPixbuf *
@@ -293,38 +401,46 @@ gtk_make_symbolic_pixbuf_from_data (const char  *file_data,
 {
   const char *r_string = "rgb(255,0,0)";
   const char *g_string = "rgb(0,255,0)";
-  char *icon_width_str;
-  char *icon_height_str;
-  GdkPixbuf *loaded;
+  char *icon_width_str = NULL;
+  char *icon_height_str = NULL;
+  char *escaped_file_data = NULL;
+  gsize len;
   GdkPixbuf *pixbuf = NULL;
-  int plane;
-  int icon_width, icon_height;
-  char *escaped_file_data;
+  gboolean has_symbolic_classes;
+  gboolean only_fg = TRUE;
+
+  has_symbolic_classes = svg_has_symbolic_classes (file_data, file_len);
 
   /* Fetch size from the original icon */
-  GInputStream *stream = g_memory_input_stream_new_from_data (file_data, file_len, NULL);
-  GdkPixbuf *reference = gdk_pixbuf_new_from_stream (stream, NULL, error);
-
-  g_object_unref (stream);
-
-  if (!reference)
-    return NULL;
-
-  icon_width = gdk_pixbuf_get_width (reference);
-  icon_height = gdk_pixbuf_get_height (reference);
-  g_object_unref (reference);
-
-  escaped_file_data = g_base64_encode ((guchar *) file_data, file_len);
-  icon_width_str = g_strdup_printf ("%d", icon_width);
-  icon_height_str = g_strdup_printf ("%d", icon_height);
+  if (has_symbolic_classes || width == 0 || height == 0)
+    svg_find_size_strings (file_data, file_len, &icon_width_str, &icon_height_str);
 
   if (width == 0)
-    width = icon_width * scale;
+    width = (int) (g_ascii_strtoull (icon_width_str, NULL, 0) * scale);
   if (height == 0)
-    height = icon_height * scale;
+    height = (int) (g_ascii_strtoull (icon_height_str, NULL, 0) * scale);
 
-  for (plane = 0; plane < 3; plane++)
+  if (!has_symbolic_classes)
     {
+      GInputStream *stream;
+
+      stream = g_memory_input_stream_new_from_data (file_data, file_len, NULL);
+      pixbuf = gdk_pixbuf_new_from_stream_at_scale (stream, width, height, TRUE, NULL, error);
+      g_object_unref (stream);
+
+      if (pixbuf)
+        keep_alpha (pixbuf);
+
+      goto out;
+    }
+
+  escaped_file_data = g_base64_encode ((guchar *) file_data, file_len);
+  len = strlen (escaped_file_data);
+
+  for (int plane = 0; plane < 3; plane++)
+    {
+      GdkPixbuf *loaded;
+
       /* Here we render the svg with all colors solid, this should
        * always make the alpha channel the same and it should match
        * the final alpha channel for all possible renderings. We
@@ -337,7 +453,7 @@ gtk_make_symbolic_pixbuf_from_data (const char  *file_data,
        * channels, with the color of the fg being implicitly
        * the "rest", as all color fractions should add up to 1.
        */
-      loaded = load_symbolic_svg (escaped_file_data, width, height,
+      loaded = load_symbolic_svg (escaped_file_data, len, width, height,
                                   icon_width_str,
                                   icon_height_str,
                                   g_string,
@@ -358,25 +474,26 @@ gtk_make_symbolic_pixbuf_from_data (const char  *file_data,
           g_free (filename);
         }
 
-      if (pixbuf == NULL)
+      if (plane == 0)
         {
           pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
                                    gdk_pixbuf_get_width (loaded),
                                    gdk_pixbuf_get_height (loaded));
-          gdk_pixbuf_fill (pixbuf, 0);
+          memset (gdk_pixbuf_get_pixels (pixbuf), 0, gdk_pixbuf_get_byte_length (pixbuf));
+
+          extract_plane (loaded, pixbuf, 3, 3);
         }
 
-      if (plane == 0)
-        extract_plane (loaded, pixbuf, 3, 3);
-
-      extract_plane (loaded, pixbuf, 0, plane);
+      only_fg &= extract_plane (loaded, pixbuf, 0, plane);
 
       g_object_unref (loaded);
     }
 
-  g_free (escaped_file_data);
-
 out:
+  if (only_fg && pixbuf)
+    gdk_pixbuf_set_option (pixbuf, "tEXt::only-foreground", "true");
+
+  g_free (escaped_file_data);
   g_free (icon_width_str);
   g_free (icon_height_str);
 
@@ -409,17 +526,17 @@ make_symbolic_pixbuf_from_resource (const char  *path,
 }
 
 static GdkPixbuf *
-make_symbolic_pixbuf_from_path (const char  *path,
-                                int          width,
-                                int          height,
-                                double       scale,
-                                GError     **error)
+make_symbolic_pixbuf_from_filename (const char  *filename,
+                                    int          width,
+                                    int          height,
+                                    double       scale,
+                                    GError     **error)
 {
   char *data;
   gsize size;
   GdkPixbuf *pixbuf;
 
-  if (!g_file_get_contents (path, &data, &size, error))
+  if (!g_file_get_contents (filename, &data, &size, error))
     return NULL;
 
   pixbuf = gtk_make_symbolic_pixbuf_from_data (data, size, width, height, scale, NULL, error);
@@ -453,11 +570,85 @@ make_symbolic_pixbuf_from_file (GFile       *file,
 /* }}} */
 /* {{{ Texture API */
 
+static GdkTexture *
+texture_new_from_bytes (GBytes    *bytes,
+                        gboolean  *only_fg,
+                        GError   **error)
+{
+  GHashTable *options;
+  GdkTexture *texture;
+
+  if (!gdk_is_png (bytes))
+    return gdk_texture_new_from_bytes (bytes, error);
+
+  options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+  texture = gdk_load_png (bytes, options, error);
+  *only_fg = g_hash_table_contains (options, "foreground-only");
+  g_hash_table_unref (options);
+
+  return texture;
+}
+
+GdkTexture *
+gdk_texture_new_from_filename_with_fg (const char    *filename,
+                                       gboolean      *only_fg,
+                                       GError       **error)
+{
+  GFile *file;
+  GBytes *bytes;
+  GdkTexture *texture = NULL;
+
+  file = g_file_new_for_path (filename);
+  bytes = g_file_load_bytes (file, NULL, NULL, error);
+  if (bytes)
+    texture = texture_new_from_bytes (bytes, only_fg, error);
+  g_bytes_unref (bytes);
+  g_object_unref (file);
+
+  return texture;
+}
+
+GdkTexture *
+gdk_texture_new_from_resource_with_fg (const char *path,
+                                       gboolean   *only_fg)
+{
+  GBytes *bytes;
+  GdkTexture *texture = NULL;
+
+  bytes = g_resources_lookup_data (path, 0, NULL);
+  if (bytes)
+    texture = texture_new_from_bytes (bytes, only_fg, NULL);
+  g_bytes_unref (bytes);
+
+  return texture;
+}
+
+GdkTexture *
+gdk_texture_new_from_stream_with_fg (GInputStream  *stream,
+                                     gboolean      *only_fg,
+                                     GCancellable  *cancellable,
+                                     GError       **error)
+{
+  GdkPixbuf *pixbuf;
+  GdkTexture *texture = NULL;
+
+  pixbuf = _gdk_pixbuf_new_from_stream_scaled (stream, 0, cancellable, error);
+  if (pixbuf)
+    {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
+      texture = gdk_texture_new_for_pixbuf (pixbuf);
+      g_object_unref (pixbuf);
+    }
+
+  return texture;
+}
+
 GdkTexture *
 gdk_texture_new_from_stream_at_scale (GInputStream  *stream,
                                       int            width,
                                       int            height,
                                       gboolean       aspect,
+                                      gboolean      *only_fg,
                                       GCancellable  *cancellable,
                                       GError       **error)
 {
@@ -467,24 +658,7 @@ gdk_texture_new_from_stream_at_scale (GInputStream  *stream,
   pixbuf = _gdk_pixbuf_new_from_stream_at_scale (stream, width, height, aspect, cancellable, error);
   if (pixbuf)
     {
-      texture = gdk_texture_new_for_pixbuf (pixbuf);
-      g_object_unref (pixbuf);
-    }
-
-  return texture;
-}
-
-GdkTexture *
-gdk_texture_new_from_stream (GInputStream  *stream,
-                             GCancellable  *cancellable,
-                             GError       **error)
-{
-  GdkPixbuf *pixbuf;
-  GdkTexture *texture = NULL;
-
-  pixbuf = _gdk_pixbuf_new_from_stream_scaled (stream, 0, cancellable, error);
-  if (pixbuf)
-    {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
       texture = gdk_texture_new_for_pixbuf (pixbuf);
       g_object_unref (pixbuf);
     }
@@ -497,6 +671,7 @@ gdk_texture_new_from_resource_at_scale (const char    *path,
                                         int            width,
                                         int            height,
                                         gboolean       preserve_aspect,
+                                        gboolean      *only_fg,
                                         GError       **error)
 {
   GdkPixbuf *pixbuf;
@@ -505,6 +680,7 @@ gdk_texture_new_from_resource_at_scale (const char    *path,
   pixbuf = _gdk_pixbuf_new_from_resource_at_scale (path, width, height, preserve_aspect, error);
   if (pixbuf)
     {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
       texture = gdk_texture_new_for_pixbuf (pixbuf);
       g_object_unref (pixbuf);
     }
@@ -516,18 +692,20 @@ gdk_texture_new_from_resource_at_scale (const char    *path,
 /* {{{ Symbolic texture API */
 
 GdkTexture *
-gdk_texture_new_from_path_symbolic (const char    *path,
-                                    int            width,
-                                    int            height,
-                                    double         scale,
-                                    GError       **error)
+gdk_texture_new_from_filename_symbolic (const char    *filename,
+                                        int            width,
+                                        int            height,
+                                        double         scale,
+                                        gboolean      *only_fg,
+                                        GError       **error)
 {
   GdkPixbuf *pixbuf;
   GdkTexture *texture = NULL;
 
-  pixbuf = make_symbolic_pixbuf_from_path (path, width, height, scale, error);
+  pixbuf = make_symbolic_pixbuf_from_filename (filename, width, height, scale, error);
   if (pixbuf)
     {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
       texture = gdk_texture_new_for_pixbuf (pixbuf);
       g_object_unref (pixbuf);
     }
@@ -546,6 +724,7 @@ gdk_texture_new_from_resource_symbolic (const char  *path,
                                         int          width,
                                         int          height,
                                         double       scale,
+                                        gboolean    *only_fg,
                                         GError     **error)
 {
   GdkPixbuf *pixbuf;
@@ -554,6 +733,7 @@ gdk_texture_new_from_resource_symbolic (const char  *path,
   pixbuf = make_symbolic_pixbuf_from_resource (path, width, height, scale, error);
   if (pixbuf)
     {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
       texture = gdk_texture_new_for_pixbuf (pixbuf);
       g_object_unref (pixbuf);
     }
@@ -588,14 +768,19 @@ gdk_texture_new_from_file_symbolic (GFile       *file,
                                     int          width,
                                     int          height,
                                     double       scale,
+                                    gboolean    *only_fg,
                                     GError     **error)
 {
   GdkPixbuf *pixbuf;
-  GdkTexture *texture;
+  GdkTexture *texture = NULL;
 
   pixbuf = make_symbolic_pixbuf_from_file (file, width, height, scale, error);
-  texture = gdk_texture_new_for_pixbuf (pixbuf);
-  g_object_unref (pixbuf);
+  if (pixbuf)
+    {
+      *only_fg = pixbuf_is_only_fg (pixbuf);
+      texture = gdk_texture_new_for_pixbuf (pixbuf);
+      g_object_unref (pixbuf);
+    }
 
   return texture;
 }
@@ -604,7 +789,7 @@ gdk_texture_new_from_file_symbolic (GFile       *file,
 /* {{{ Scaled paintable API */
 
 typedef struct {
-  int scale_factor;
+  double scale;
 } LoaderData;
 
 static void
@@ -620,24 +805,24 @@ on_loader_size_prepared (GdkPixbufLoader *loader,
   format = gdk_pixbuf_loader_get_format (loader);
   if (!gdk_pixbuf_format_is_scalable (format))
     {
-      loader_data->scale_factor = 1;
+      loader_data->scale = 1.0;
       return;
     }
 
   gdk_pixbuf_loader_set_size (loader,
-                              width * loader_data->scale_factor,
-                              height * loader_data->scale_factor);
+                              width * loader_data->scale,
+                              height * loader_data->scale);
 }
 
 static GdkPaintable *
 gdk_paintable_new_from_bytes_scaled (GBytes *bytes,
-                                     int     scale_factor)
+                                     double  scale)
 {
   LoaderData loader_data;
   GdkTexture *texture;
   GdkPaintable *paintable;
 
-  loader_data.scale_factor = scale_factor;
+  loader_data.scale = scale;
 
   if (gdk_texture_can_load (bytes))
     {
@@ -667,8 +852,8 @@ gdk_paintable_new_from_bytes_scaled (GBytes *bytes,
       texture = gdk_texture_new_for_pixbuf (gdk_pixbuf_loader_get_pixbuf (loader));
       g_object_unref (loader);
 
-      if (loader_data.scale_factor != 1)
-        paintable = gtk_scaler_new (GDK_PAINTABLE (texture), loader_data.scale_factor);
+      if (loader_data.scale != 1.0)
+        paintable = gtk_scaler_new (GDK_PAINTABLE (texture), loader_data.scale);
       else
         paintable = g_object_ref (GDK_PAINTABLE (texture));
 
@@ -679,20 +864,20 @@ gdk_paintable_new_from_bytes_scaled (GBytes *bytes,
 }
 
 GdkPaintable *
-gdk_paintable_new_from_path_scaled (const char *path,
-                                    int         scale_factor)
+gdk_paintable_new_from_filename_scaled (const char *filename,
+                                        double      scale)
 {
   char *contents;
   gsize length;
   GBytes *bytes;
   GdkPaintable *paintable;
 
-  if (!g_file_get_contents (path, &contents, &length, NULL))
+  if (!g_file_get_contents (filename, &contents, &length, NULL))
     return NULL;
 
   bytes = g_bytes_new_take (contents, length);
 
-  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale_factor);
+  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale);
 
   g_bytes_unref (bytes);
 
@@ -701,7 +886,7 @@ gdk_paintable_new_from_path_scaled (const char *path,
 
 GdkPaintable *
 gdk_paintable_new_from_resource_scaled (const char *path,
-                                        int         scale_factor)
+                                        double      scale)
 {
   GBytes *bytes;
   GdkPaintable *paintable;
@@ -710,15 +895,16 @@ gdk_paintable_new_from_resource_scaled (const char *path,
   if (!bytes)
     return NULL;
 
-  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale_factor);
+  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale);
+
   g_bytes_unref (bytes);
 
   return paintable;
 }
 
 GdkPaintable *
-gdk_paintable_new_from_file_scaled (GFile *file,
-                                    int    scale_factor)
+gdk_paintable_new_from_file_scaled (GFile  *file,
+                                    double  scale)
 {
   GBytes *bytes;
   GdkPaintable *paintable;
@@ -727,7 +913,7 @@ gdk_paintable_new_from_file_scaled (GFile *file,
   if (!bytes)
     return NULL;
 
-  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale_factor);
+  paintable = gdk_paintable_new_from_bytes_scaled (bytes, scale);
 
   g_bytes_unref (bytes);
 

gtk/gdktextureutilsprivate.h

@@ -29,45 +29,56 @@ GdkPixbuf *gtk_make_symbolic_pixbuf_from_data       (const char    *data,
                                                      const char    *debug_output_to,
                                                      GError       **error);
 
-GdkTexture *gdk_texture_new_from_stream             (GInputStream  *stream,
+GdkTexture *gdk_texture_new_from_filename_with_fg   (const char    *filename,
+                                                     gboolean      *only_fg,
+                                                     GError       **error);
+GdkTexture *gdk_texture_new_from_resource_with_fg   (const char    *path,
+                                                     gboolean      *only_fg);
+GdkTexture *gdk_texture_new_from_stream_with_fg     (GInputStream  *stream,
+                                                     gboolean      *only_fg,
                                                      GCancellable  *cancellable,
                                                      GError       **error);
 GdkTexture *gdk_texture_new_from_stream_at_scale    (GInputStream  *stream,
                                                      int            width,
                                                      int            height,
                                                      gboolean       aspect,
+                                                     gboolean      *only_fg,
                                                      GCancellable  *cancellable,
                                                      GError       **error);
 GdkTexture *gdk_texture_new_from_resource_at_scale  (const char    *path,
                                                      int            width,
                                                      int            height,
                                                      gboolean       aspect,
+                                                     gboolean      *only_fg,
                                                      GError       **error);
 
-GdkTexture *gdk_texture_new_from_path_symbolic      (const char    *path,
+GdkTexture *gdk_texture_new_from_filename_symbolic  (const char    *path,
                                                      int            width,
                                                      int            height,
                                                      double         scale,
+                                                     gboolean      *only_fg,
                                                      GError       **error);
 GdkTexture *gdk_texture_new_from_file_symbolic      (GFile         *file,
                                                      int            width,
                                                      int            height,
                                                      double         scale,
+                                                     gboolean      *only_fg,
                                                      GError       **error);
 GdkTexture *gdk_texture_new_from_resource_symbolic  (const char    *path,
                                                      int            width,
                                                      int            height,
                                                      double         scale,
+                                                     gboolean      *only_fg,
                                                      GError       **error);
 
 GdkTexture *gtk_load_symbolic_texture_from_file     (GFile         *file);
-GdkTexture *gtk_load_symbolic_texture_from_resource (const char    *data);
+GdkTexture *gtk_load_symbolic_texture_from_resource (const char    *path);
 
-GdkPaintable *gdk_paintable_new_from_path_scaled     (const char    *path,
-                                                      int            scale_factor);
+GdkPaintable *gdk_paintable_new_from_filename_scaled (const char    *filename,
+                                                      double         scale);
 GdkPaintable *gdk_paintable_new_from_resource_scaled (const char    *path,
-                                                      int            scale_factor);
+                                                      double         scale);
 GdkPaintable *gdk_paintable_new_from_file_scaled     (GFile         *file,
-                                                      int            scale_factor);
+                                                      double         scale);
 
 G_END_DECLS

gtk/gtkaccessiblevalue.c

@@ -808,6 +808,11 @@ static const GtkAccessibleCollect collect_props[] = {
     .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
     .name = "valuetext"
   },
+  [GTK_ACCESSIBLE_PROPERTY_HELP_TEXT] = {
+    .value = GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
+    .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+    .name = "helptext"
+  },
 };
 
 /* § 6.6.4 Relationship Attributes */
@@ -1662,7 +1667,7 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property)
 {
   const GtkAccessibleCollect *cstate = &collect_props[property];
 
-  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, NULL);
+  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT, NULL);
 
   switch (cstate->value)
     {
@@ -1692,6 +1697,7 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property)
     case GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER:
     case GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION:
     case GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT:
+    case GTK_ACCESSIBLE_PROPERTY_HELP_TEXT:
       return gtk_undefined_accessible_value_new ();
 
     /* Token properties */
@@ -1732,7 +1738,7 @@ gtk_accessible_value_collect_for_property (GtkAccessibleProperty   property,
 {
   const GtkAccessibleCollect *cstate = &collect_props[property];
 
-  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, NULL);
+  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT, NULL);
 
   return gtk_accessible_value_collect_valist (cstate, error, args);
 }
@@ -1760,7 +1766,7 @@ gtk_accessible_value_collect_for_property_value (GtkAccessibleProperty   propert
 {
   const GtkAccessibleCollect *cstate = &collect_props[property];
 
-  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, NULL);
+  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT, NULL);
 
   return gtk_accessible_value_collect_value (cstate, value, error);
 }
@@ -1773,7 +1779,7 @@ gtk_accessible_value_parse_for_property (GtkAccessibleProperty   property,
 {
   const GtkAccessibleCollect *cstate = &collect_props[property];
 
-  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, NULL);
+  g_return_val_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT, NULL);
 
   return gtk_accessible_value_parse (cstate, str, len, error);
 }
@@ -1794,7 +1800,7 @@ gtk_accessible_property_init_value (GtkAccessibleProperty  property,
 {
   const GtkAccessibleCollect *cstate = &collect_props[property];
 
-  g_return_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT);
+  g_return_if_fail (property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT);
 
   gtk_accessible_attribute_init_value (cstate, value);
 }

gtk/gtkatcontext.c

@@ -328,6 +328,7 @@ static const char *property_attrs[] = {
   [GTK_ACCESSIBLE_PROPERTY_VALUE_MIN]           = "valuemin",
   [GTK_ACCESSIBLE_PROPERTY_VALUE_NOW]           = "valuenow",
   [GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT]          = "valuetext",
+  [GTK_ACCESSIBLE_PROPERTY_HELP_TEXT]           = "helptext",
 };
 
 /*< private >
@@ -342,7 +343,7 @@ const char *
 gtk_accessible_property_get_attribute_name (GtkAccessibleProperty property)
 {
   g_return_val_if_fail (property >= GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE &&
-                        property <= GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
+                        property <= GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
                         "<none>");
 
   return property_attrs[property];
@@ -1055,6 +1056,7 @@ gtk_at_context_get_accessible_relation (GtkATContext          *self,
 static guint8 naming[] = {
   [GTK_ACCESSIBLE_ROLE_ALERT] = NAME_FROM_AUTHOR,
   [GTK_ACCESSIBLE_ROLE_ALERT_DIALOG] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
+  [GTK_ACCESSIBLE_ROLE_APPLICATION] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_ARTICLE] = NAME_FROM_AUTHOR,
   [GTK_ACCESSIBLE_ROLE_BANNER] = GTK_ACCESSIBLE_NAME_PROHIBITED,
   [GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE] = NAME_FROM_AUTHOR,
@@ -1099,6 +1101,7 @@ static guint8 naming[] = {
   [GTK_ACCESSIBLE_ROLE_NONE] = GTK_ACCESSIBLE_NAME_PROHIBITED,
   [GTK_ACCESSIBLE_ROLE_NOTE] = NAME_FROM_AUTHOR,
   [GTK_ACCESSIBLE_ROLE_OPTION] = NAME_FROM_AUTHOR|NAME_FROM_CONTENT|GTK_ACCESSIBLE_NAME_REQUIRED,
+  [GTK_ACCESSIBLE_ROLE_PARAGRAPH] = GTK_ACCESSIBLE_NAME_PROHIBITED,
   [GTK_ACCESSIBLE_ROLE_PRESENTATION] = GTK_ACCESSIBLE_NAME_PROHIBITED,
   [GTK_ACCESSIBLE_ROLE_PROGRESS_BAR] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_RADIO] = NAME_FROM_AUTHOR|NAME_FROM_CONTENT|GTK_ACCESSIBLE_NAME_REQUIRED,
@@ -1124,9 +1127,11 @@ static guint8 naming[] = {
   [GTK_ACCESSIBLE_ROLE_TABLE] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_TAB_LIST] = NAME_FROM_AUTHOR,
   [GTK_ACCESSIBLE_ROLE_TAB_PANEL] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
+  [GTK_ACCESSIBLE_ROLE_TERMINAL] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_TEXT_BOX] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_TIME] = GTK_ACCESSIBLE_NAME_PROHIBITED,
   [GTK_ACCESSIBLE_ROLE_TIMER] = NAME_FROM_AUTHOR,
+  [GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_TOOLBAR] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_RECOMMENDED,
   [GTK_ACCESSIBLE_ROLE_TOOLTIP] = NAME_FROM_AUTHOR|NAME_FROM_CONTENT,
   [GTK_ACCESSIBLE_ROLE_TREE] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
@@ -1134,9 +1139,6 @@ static guint8 naming[] = {
   [GTK_ACCESSIBLE_ROLE_TREE_ITEM] = NAME_FROM_AUTHOR|NAME_FROM_CONTENT|GTK_ACCESSIBLE_NAME_REQUIRED,
   [GTK_ACCESSIBLE_ROLE_WIDGET] = NAME_FROM_AUTHOR|NAME_FROM_CONTENT,
   [GTK_ACCESSIBLE_ROLE_WINDOW] = NAME_FROM_AUTHOR,
-  [GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
-  [GTK_ACCESSIBLE_ROLE_APPLICATION] = NAME_FROM_AUTHOR|GTK_ACCESSIBLE_NAME_REQUIRED,
-  [GTK_ACCESSIBLE_ROLE_PARAGRAPH] = GTK_ACCESSIBLE_NAME_PROHIBITED,
 };
 
 /* < private >

gtk/gtkatcontextprivate.h

@@ -47,7 +47,8 @@ typedef enum {
   GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_MAX        = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
   GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_MIN        = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
   GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_NOW        = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
-  GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_TEXT       = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT
+  GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_TEXT       = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
+  GTK_ACCESSIBLE_PROPERTY_CHANGE_HELP_TEXT        = 1 << GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
 } GtkAccessiblePropertyChange;
 
 typedef enum {

gtk/gtkcssanimatedstyle.c

@@ -33,13 +33,59 @@
 #include "gtkcssstringvalueprivate.h"
 #include "gtkcssstylepropertyprivate.h"
 #include "gtkcsstransitionprivate.h"
+#include "gtkcssvaluesprivate.h"
 #include "gtkprivate.h"
 #include "gtkstyleanimationprivate.h"
 #include "gtkstylepropertyprivate.h"
 #include "gtkstyleproviderprivate.h"
+#include "gtkcsscustompropertypoolprivate.h"
 
 G_DEFINE_TYPE (GtkCssAnimatedStyle, gtk_css_animated_style, GTK_TYPE_CSS_STYLE)
 
+#define DEFINE_VALUES(ENUM, TYPE, NAME) \
+static inline void \
+gtk_css_ ## NAME ## _values_recompute (GtkCssAnimatedStyle *animated) \
+{ \
+  GtkCssStyle *style = (GtkCssStyle *)animated; \
+  GtkCssValue **values = (GtkCssValue **)((guint8*)(animated->style->NAME) + sizeof (GtkCssValues)); \
+  int i; \
+\
+  for (i = 0; i < G_N_ELEMENTS (NAME ## _props); i++) \
+    { \
+      guint id = NAME ## _props[i]; \
+      GtkCssValue *original, *computed; \
+\
+      if (values[i] == NULL) \
+        continue; \
+\
+      original = gtk_css_style_get_original_value (style, id); \
+      if (original == NULL) \
+        continue; \
+\
+      computed = _gtk_css_value_compute (original, \
+                                         id, \
+                                         animated->provider, \
+                                         style, \
+                                         animated->parent_style, \
+                                         NULL); \
+      if (computed == NULL) \
+        continue; \
+\
+      gtk_css_animated_style_set_animated_value (animated, id, computed); \
+    } \
+}
+
+DEFINE_VALUES (CORE, Core, core)
+DEFINE_VALUES (BACKGROUND, Background, background)
+DEFINE_VALUES (BORDER, Border, border)
+DEFINE_VALUES (ICON, Icon, icon)
+DEFINE_VALUES (OUTLINE, Outline, outline)
+DEFINE_VALUES (FONT, Font, font)
+DEFINE_VALUES (FONT_VARIANT, FontVariant, font_variant)
+DEFINE_VALUES (ANIMATION, Animation, animation)
+DEFINE_VALUES (TRANSITION, Transition, transition)
+DEFINE_VALUES (SIZE, Size, size)
+DEFINE_VALUES (OTHER, Other, other)
 
 static GtkCssSection *
 gtk_css_animated_style_get_section (GtkCssStyle *style,
@@ -74,6 +120,15 @@ gtk_css_animated_style_get_static_style (GtkCssStyle *style)
   return (GtkCssStaticStyle *)animated->style;
 }
 
+static GtkCssValue *
+gtk_css_animated_style_get_original_value (GtkCssStyle *style,
+                                           guint        id)
+{
+  GtkCssAnimatedStyle *animated = GTK_CSS_ANIMATED_STYLE (style);
+
+  return gtk_css_style_get_original_value (animated->style, id);
+}
+
 static void
 gtk_css_animated_style_dispose (GObject *object)
 {
@@ -96,6 +151,9 @@ gtk_css_animated_style_finalize (GObject *object)
   GtkCssAnimatedStyle *style = GTK_CSS_ANIMATED_STYLE (object);
 
   g_object_unref (style->style);
+  if (style->parent_style)
+    g_object_unref (style->parent_style);
+  g_object_unref (style->provider);
 
   G_OBJECT_CLASS (gtk_css_animated_style_parent_class)->finalize (object);
 }
@@ -112,6 +170,7 @@ gtk_css_animated_style_class_init (GtkCssAnimatedStyleClass *klass)
   style_class->get_section = gtk_css_animated_style_get_section;
   style_class->is_static = gtk_css_animated_style_is_static;
   style_class->get_static_style = gtk_css_animated_style_get_static_style;
+  style_class->get_original_value = gtk_css_animated_style_get_original_value;
 }
 
 static void
@@ -546,6 +605,51 @@ gtk_css_animated_style_get_intrinsic_value (GtkCssAnimatedStyle *style,
   return gtk_css_style_get_value (style->style, id);
 }
 
+void
+gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
+                                                  int                  id,
+                                                  GtkCssVariableValue *value)
+{
+  GtkCssStyle *style = (GtkCssStyle *)animated;
+
+  gtk_internal_return_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style));
+  gtk_internal_return_if_fail (value != NULL);
+
+  if (style->variables == NULL)
+    {
+      style->variables = gtk_css_variable_set_new ();
+      if (animated->parent_style)
+        gtk_css_variable_set_set_parent (style->variables,
+                                         animated->parent_style->variables);
+    }
+  else if (style->variables == animated->style->variables)
+    {
+      gtk_css_variable_set_unref (style->variables);
+      style->variables = gtk_css_variable_set_copy (animated->style->variables);
+    }
+
+  gtk_css_variable_set_add (style->variables, id, value);
+
+  gtk_css_core_values_recompute (animated);
+  gtk_css_background_values_recompute (animated);
+  gtk_css_border_values_recompute (animated);
+  gtk_css_icon_values_recompute (animated);
+  gtk_css_outline_values_recompute (animated);
+  gtk_css_font_values_recompute (animated);
+  gtk_css_font_variant_values_recompute (animated);
+  gtk_css_animation_values_recompute (animated);
+  gtk_css_transition_values_recompute (animated);
+  gtk_css_size_values_recompute (animated);
+  gtk_css_other_values_recompute (animated);
+}
+
+GtkCssVariableValue *
+gtk_css_animated_style_get_intrinsic_custom_value (GtkCssAnimatedStyle *style,
+                                                   int                  id)
+{
+  return gtk_css_style_get_custom_property (style->style, id);
+}
+
 static GPtrArray *
 gtk_css_animated_style_create_dynamic (GPtrArray   *animations,
                                        GtkCssStyle *style,
@@ -770,7 +874,6 @@ gtk_css_animated_style_find_animation (GtkStyleAnimation **animations,
 static GPtrArray *
 gtk_css_animated_style_create_css_animations (GPtrArray        *animations,
                                               GtkCssStyle      *base_style,
-                                              GtkCssStyle      *parent_style,
                                               gint64            timestamp,
                                               GtkStyleProvider *provider,
                                               GtkCssStyle      *source)
@@ -832,8 +935,6 @@ gtk_css_animated_style_create_css_animations (GPtrArray        *animations,
           if (keyframes == NULL)
             continue;
 
-          keyframes = _gtk_css_keyframes_compute (keyframes, provider, base_style, parent_style);
-
           animation = _gtk_css_animation_new (name,
                                               keyframes,
                                               timestamp,
@@ -844,7 +945,6 @@ gtk_css_animated_style_create_css_animations (GPtrArray        *animations,
                                               _gtk_css_play_state_value_get (_gtk_css_array_value_get_nth (play_states, i)),
                                               _gtk_css_fill_mode_value_get (_gtk_css_array_value_get_nth (fill_modes, i)),
                                               _gtk_css_number_value_get (_gtk_css_array_value_get_nth (iteration_counts, i), 100));
-          _gtk_css_keyframes_unref (keyframes);
         }
 
       if (!animations)
@@ -893,7 +993,7 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
   if (previous_style != NULL)
     animations = gtk_css_animated_style_create_css_transitions (animations, base_style, timestamp, previous_style);
 
-  animations = gtk_css_animated_style_create_css_animations (animations, base_style, parent_style, timestamp, provider, previous_style);
+  animations = gtk_css_animated_style_create_css_animations (animations, base_style, timestamp, provider, previous_style);
   animations = gtk_css_animated_style_create_dynamic (animations, base_style, timestamp);
 
   if (animations == NULL)
@@ -902,6 +1002,9 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
   result = g_object_new (GTK_TYPE_CSS_ANIMATED_STYLE, NULL);
 
   result->style = g_object_ref (base_style);
+  if (parent_style)
+    result->parent_style = g_object_ref (parent_style);
+  result->provider = g_object_ref (provider);
   result->current_time = timestamp;
   result->n_animations = animations->len;
   result->animations = g_ptr_array_free (animations, FALSE);
@@ -918,6 +1021,8 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
   style->transition = (GtkCssTransitionValues *)gtk_css_values_ref ((GtkCssValues *)base_style->transition);
   style->size = (GtkCssSizeValues *)gtk_css_values_ref ((GtkCssValues *)base_style->size);
   style->other = (GtkCssOtherValues *)gtk_css_values_ref ((GtkCssValues *)base_style->other);
+  if (base_style->variables)
+    style->variables = gtk_css_variable_set_ref (base_style->variables);
 
   gtk_css_animated_style_apply_animations (result);
 
@@ -927,7 +1032,9 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
 GtkCssStyle *
 gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
                                     GtkCssStyle         *base_style,
-                                    gint64               timestamp)
+                                    GtkCssStyle         *parent_style,
+                                    gint64               timestamp,
+                                    GtkStyleProvider    *provider)
 {
   GtkCssAnimatedStyle *result;
   GtkCssStyle *style;
@@ -936,6 +1043,8 @@ gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
 
   gtk_internal_return_val_if_fail (GTK_IS_CSS_ANIMATED_STYLE (source), NULL);
   gtk_internal_return_val_if_fail (GTK_IS_CSS_STYLE (base_style), NULL);
+  gtk_internal_return_val_if_fail (parent_style == NULL || GTK_IS_CSS_STYLE (parent_style), NULL);
+  gtk_internal_return_val_if_fail (GTK_IS_STYLE_PROVIDER (provider), NULL);
 
   if (timestamp == 0)
     return g_object_ref (source->style);
@@ -966,6 +1075,9 @@ gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
   result = g_object_new (GTK_TYPE_CSS_ANIMATED_STYLE, NULL);
 
   result->style = g_object_ref (base_style);
+  if (parent_style)
+    result->parent_style = g_object_ref (parent_style);
+  result->provider = g_object_ref (provider);
   result->current_time = timestamp;
   result->n_animations = animations->len;
   result->animations = g_ptr_array_free (animations, FALSE);
@@ -982,8 +1094,34 @@ gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
   style->transition = (GtkCssTransitionValues *)gtk_css_values_ref ((GtkCssValues *)base_style->transition);
   style->size = (GtkCssSizeValues *)gtk_css_values_ref ((GtkCssValues *)base_style->size);
   style->other = (GtkCssOtherValues *)gtk_css_values_ref ((GtkCssValues *)base_style->other);
+  if (base_style->variables)
+    style->variables = gtk_css_variable_set_ref (base_style->variables);
 
   gtk_css_animated_style_apply_animations (result);
 
   return GTK_CSS_STYLE (result);
 }
+
+GtkCssStyle *
+gtk_css_animated_style_get_base_style (GtkCssAnimatedStyle *style)
+{
+  gtk_internal_return_val_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style), NULL);
+
+  return style->style;
+}
+
+GtkCssStyle *
+gtk_css_animated_style_get_parent_style (GtkCssAnimatedStyle *style)
+{
+  gtk_internal_return_val_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style), NULL);
+
+  return style->parent_style;
+}
+
+GtkStyleProvider *
+gtk_css_animated_style_get_provider (GtkCssAnimatedStyle *style)
+{
+  gtk_internal_return_val_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style), NULL);
+
+  return style->provider;
+}

gtk/gtkcssanimatedstyleprivate.h

@@ -38,6 +38,8 @@ struct _GtkCssAnimatedStyle
   GtkCssStyle parent;
 
   GtkCssStyle           *style;                /* the style if we weren't animating */
+  GtkCssStyle           *parent_style;
+  GtkStyleProvider      *provider;
 
   gint64                 current_time;         /* the current time in our world */
   gpointer              *animations;           /* GtkStyleAnimation**, least important one first */
@@ -57,15 +59,26 @@ GtkCssStyle *           gtk_css_animated_style_new              (GtkCssStyle
                                                                  GtkStyleProvider       *provider,
                                                                  GtkCssStyle            *previous_style);
 GtkCssStyle *           gtk_css_animated_style_new_advance      (GtkCssAnimatedStyle    *source,
-                                                                 GtkCssStyle            *base,
-                                                                 gint64                  timestamp);
+                                                                 GtkCssStyle            *base_style,
+                                                                 GtkCssStyle            *parent_style,
+                                                                 gint64                  timestamp,
+                                                                 GtkStyleProvider       *provider);
 
 void                    gtk_css_animated_style_set_animated_value(GtkCssAnimatedStyle   *style,
                                                                  guint                   id,
                                                                  GtkCssValue            *value);
-
 GtkCssValue *           gtk_css_animated_style_get_intrinsic_value (GtkCssAnimatedStyle *style,
                                                                  guint                   id);
 
+void                    gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
+                                                                 int                     id,
+                                                                 GtkCssVariableValue    *value);
+GtkCssVariableValue *   gtk_css_animated_style_get_intrinsic_custom_value (GtkCssAnimatedStyle *style,
+                                                                 int                     id);
+
+GtkCssStyle *           gtk_css_animated_style_get_base_style   (GtkCssAnimatedStyle    *style);
+GtkCssStyle *           gtk_css_animated_style_get_parent_style (GtkCssAnimatedStyle    *style);
+GtkStyleProvider *      gtk_css_animated_style_get_provider     (GtkCssAnimatedStyle    *style);
+
 G_END_DECLS
 

gtk/gtkcssanimation.c

@@ -90,6 +90,9 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
                                 GtkCssAnimatedStyle  *style)
 {
   GtkCssAnimation *animation = (GtkCssAnimation *)style_animation;
+  GtkCssStyle *base_style, *parent_style;
+  GtkStyleProvider *provider;
+  GtkCssKeyframes *resolved_keyframes;
   double progress;
   guint i;
 
@@ -99,19 +102,49 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
   progress = gtk_css_animation_get_progress (animation);
   progress = _gtk_css_ease_value_transform (animation->ease, progress);
 
-  for (i = 0; i < _gtk_css_keyframes_get_n_properties (animation->keyframes); i++)
+  base_style = gtk_css_animated_style_get_base_style (style);
+  parent_style = gtk_css_animated_style_get_parent_style (style);
+  provider = gtk_css_animated_style_get_provider (style);
+  resolved_keyframes = _gtk_css_keyframes_compute (animation->keyframes,
+                                                   provider,
+                                                   base_style,
+                                                   parent_style);
+
+  for (i = 0; i < _gtk_css_keyframes_get_n_variables (resolved_keyframes); i++)
+    {
+      GtkCssVariableValue *value;
+      int variable_id;
+
+      variable_id = _gtk_css_keyframes_get_variable_id (resolved_keyframes, i);
+
+      value = _gtk_css_keyframes_get_variable (resolved_keyframes,
+                                               i,
+                                               progress,
+                                               gtk_css_animated_style_get_intrinsic_custom_value (style, variable_id));
+
+      if (!value)
+        continue;
+
+      gtk_css_animated_style_set_animated_custom_value (style, variable_id, value);
+
+      gtk_css_variable_value_unref (value);
+    }
+
+  for (i = 0; i < _gtk_css_keyframes_get_n_properties (resolved_keyframes); i++)
     {
       GtkCssValue *value;
       guint property_id;
       
-      property_id = _gtk_css_keyframes_get_property_id (animation->keyframes, i);
+      property_id = _gtk_css_keyframes_get_property_id (resolved_keyframes, i);
 
-      value = _gtk_css_keyframes_get_value (animation->keyframes,
+      value = _gtk_css_keyframes_get_value (resolved_keyframes,
                                             i,
                                             progress,
                                             gtk_css_animated_style_get_intrinsic_value (style, property_id));
       gtk_css_animated_style_set_animated_value (style, property_id, value);
     }
+
+  _gtk_css_keyframes_unref (resolved_keyframes);
 }
 
 static gboolean

gtk/gtkcssarrayvalue.c

@@ -41,11 +41,12 @@ gtk_css_value_array_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_array_compute (GtkCssValue      *value,
-                             guint             property_id,
-                             GtkStyleProvider *provider,
-                             GtkCssStyle      *style,
-                             GtkCssStyle      *parent_style)
+gtk_css_value_array_compute (GtkCssValue       *value,
+                             guint              property_id,
+                             GtkStyleProvider  *provider,
+                             GtkCssStyle       *style,
+                             GtkCssStyle       *parent_style,
+                             GtkCssVariableSet *variables)
 {
   GtkCssValue *result;
   GtkCssValue *i_value;
@@ -54,7 +55,7 @@ gtk_css_value_array_compute (GtkCssValue      *value,
   result = NULL;
   for (i = 0; i < value->n_values; i++)
     {
-      i_value =  _gtk_css_value_compute (value->values[i], property_id, provider, style, parent_style);
+      i_value =  _gtk_css_value_compute (value->values[i], property_id, provider, style, parent_style, variables);
 
       if (result == NULL &&
 	  i_value != value->values[i])
@@ -402,10 +403,13 @@ _gtk_css_array_value_new_from_array (GtkCssValue **values,
   for (i = 0; i < n_values; i ++)
     {
       if (!gtk_css_value_is_computed (values[i]))
-        {
-          result->is_computed = FALSE;
-          break;
-        }
+        result->is_computed = FALSE;
+
+      if (gtk_css_value_contains_variables (values[i]))
+        result->contains_variables = TRUE;
+
+      if (!result->is_computed && result->contains_variables)
+        break;
     }
 
   return result;
@@ -467,3 +471,4 @@ _gtk_css_array_value_get_n_values (const GtkCssValue *value)
   return value->n_values;
 }
 
+

gtk/gtkcssbgsizevalue.c

@@ -41,11 +41,12 @@ gtk_css_value_bg_size_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_bg_size_compute (GtkCssValue      *value,
-                               guint             property_id,
-                               GtkStyleProvider *provider,
-                               GtkCssStyle      *style,
-                               GtkCssStyle      *parent_style)
+gtk_css_value_bg_size_compute (GtkCssValue       *value,
+                               guint              property_id,
+                               GtkStyleProvider  *provider,
+                               GtkCssStyle       *style,
+                               GtkCssStyle       *parent_style,
+                               GtkCssVariableSet *variables)
 {
   GtkCssValue *x, *y;
 
@@ -55,10 +56,10 @@ gtk_css_value_bg_size_compute (GtkCssValue      *value,
   x = y = NULL;
 
   if (value->x)
-    x = _gtk_css_value_compute (value->x, property_id, provider, style, parent_style);
+    x = _gtk_css_value_compute (value->x, property_id, provider, style, parent_style, variables);
 
   if (value->y)
-    y = _gtk_css_value_compute (value->y, property_id, provider, style, parent_style);
+    y = _gtk_css_value_compute (value->y, property_id, provider, style, parent_style, variables);
 
   if (x == value->x && y == value->y)
     {
@@ -163,9 +164,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_BG_SIZE = {
   gtk_css_value_bg_size_print
 };
 
-static GtkCssValue auto_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, FALSE, FALSE, NULL, NULL };
-static GtkCssValue cover_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, TRUE, FALSE, NULL, NULL };
-static GtkCssValue contain_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, FALSE, TRUE, NULL, NULL };
+static GtkCssValue auto_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, FALSE, FALSE, FALSE, NULL, NULL };
+static GtkCssValue cover_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, FALSE, TRUE, FALSE, NULL, NULL };
+static GtkCssValue contain_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, TRUE, FALSE, FALSE, TRUE, NULL, NULL };
 
 GtkCssValue *
 _gtk_css_bg_size_value_new (GtkCssValue *x,

gtk/gtkcssbordervalue.c

@@ -42,11 +42,12 @@ gtk_css_value_border_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_border_compute (GtkCssValue      *value,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_border_compute (GtkCssValue       *value,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssValue *values[4];
   GtkCssValue *computed;
@@ -57,7 +58,7 @@ gtk_css_value_border_compute (GtkCssValue      *value,
     {
       if (value->values[i])
         {
-          values[i] = _gtk_css_value_compute (value->values[i], property_id, provider, style, parent_style);
+          values[i] = _gtk_css_value_compute (value->values[i], property_id, provider, style, parent_style, variables);
           changed |= (values[i] != value->values[i]);
         }
       else
@@ -260,3 +261,4 @@ _gtk_css_border_value_get_left (const GtkCssValue *value)
   return value->values[GTK_CSS_LEFT];
 }
 
+

gtk/gtkcsscolorvalue.c

@@ -94,10 +94,11 @@ gtk_css_value_color_free (GtkCssValue *color)
 }
 
 static GtkCssValue *
-gtk_css_value_color_get_fallback (guint             property_id,
-                                  GtkStyleProvider *provider,
-                                  GtkCssStyle      *style,
-                                  GtkCssStyle      *parent_style)
+gtk_css_value_color_get_fallback (guint              property_id,
+                                  GtkStyleProvider  *provider,
+                                  GtkCssStyle       *style,
+                                  GtkCssStyle       *parent_style,
+                                  GtkCssVariableSet *variables)
 {
   switch (property_id)
     {
@@ -120,7 +121,8 @@ gtk_css_value_color_get_fallback (guint             property_id,
                                        property_id,
                                        provider,
                                        style,
-                                       parent_style);
+                                       parent_style,
+                                       variables);
       case GTK_CSS_PROPERTY_ICON_PALETTE:
         return _gtk_css_value_ref (style->core->color);
       default:
@@ -132,11 +134,12 @@ gtk_css_value_color_get_fallback (guint             property_id,
 }
 
 static GtkCssValue *
-gtk_css_value_color_compute (GtkCssValue      *value,
-                             guint             property_id,
-                             GtkStyleProvider *provider,
-                             GtkCssStyle      *style,
-                             GtkCssStyle      *parent_style)
+gtk_css_value_color_compute (GtkCssValue       *value,
+                             guint              property_id,
+                             GtkStyleProvider  *provider,
+                             GtkCssStyle       *style,
+                             GtkCssStyle       *parent_style,
+                             GtkCssVariableSet *variables)
 {
   GtkCssValue *resolved;
 
@@ -173,7 +176,7 @@ gtk_css_value_color_compute (GtkCssValue      *value,
     }
 
   if (resolved == NULL)
-    return gtk_css_value_color_get_fallback (property_id, provider, style, parent_style);
+    return gtk_css_value_color_get_fallback (property_id, provider, style, parent_style, variables);
 
   return resolved;
 }
@@ -484,9 +487,9 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
   return value;
 }
 
-static GtkCssValue transparent_black_singleton = { &GTK_CSS_VALUE_COLOR, 1, TRUE, COLOR_TYPE_LITERAL, NULL,
+static GtkCssValue transparent_black_singleton = { &GTK_CSS_VALUE_COLOR, 1, TRUE, FALSE, COLOR_TYPE_LITERAL, NULL,
                                                    .sym_col.rgba = {0, 0, 0, 0} };
-static GtkCssValue white_singleton             = { &GTK_CSS_VALUE_COLOR, 1, TRUE, COLOR_TYPE_LITERAL, NULL,
+static GtkCssValue white_singleton             = { &GTK_CSS_VALUE_COLOR, 1, TRUE, FALSE, COLOR_TYPE_LITERAL, NULL,
                                                    .sym_col.rgba = {1, 1, 1, 1} };
 
 
@@ -620,7 +623,7 @@ _gtk_css_color_value_new_mix (GtkCssValue *color1,
 GtkCssValue *
 _gtk_css_color_value_new_current_color (void)
 {
-  static GtkCssValue current_color = { &GTK_CSS_VALUE_COLOR, 1, FALSE, COLOR_TYPE_CURRENT_COLOR, NULL, };
+  static GtkCssValue current_color = { &GTK_CSS_VALUE_COLOR, 1, FALSE, FALSE, COLOR_TYPE_CURRENT_COLOR, NULL, };
 
   return _gtk_css_value_ref (&current_color);
 }

gtk/gtkcsscornervalue.c

@@ -37,16 +37,17 @@ gtk_css_value_corner_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_corner_compute (GtkCssValue      *corner,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_corner_compute (GtkCssValue       *corner,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssValue *x, *y;
 
-  x = _gtk_css_value_compute (corner->x, property_id, provider, style, parent_style);
-  y = _gtk_css_value_compute (corner->y, property_id, provider, style, parent_style);
+  x = _gtk_css_value_compute (corner->x, property_id, provider, style, parent_style, variables);
+  y = _gtk_css_value_compute (corner->y, property_id, provider, style, parent_style, variables);
   if (x == corner->x && y == corner->y)
     {
       _gtk_css_value_unref (x);
@@ -110,14 +111,14 @@ static const GtkCssValueClass GTK_CSS_VALUE_CORNER = {
 };
 
 static GtkCssValue corner_singletons[] = {
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, TRUE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
+  { &GTK_CSS_VALUE_CORNER, 1, TRUE, FALSE, NULL, NULL },
 };
 
 static inline void
@@ -226,3 +227,4 @@ gtk_css_corner_value_is_zero (const GtkCssValue *corner)
   return gtk_css_dimension_value_is_zero (corner->x) &&
          gtk_css_dimension_value_is_zero (corner->y);
 }
+

gtk/gtkcsscustompropertypool.c

@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#include "gtkcsscustompropertypoolprivate.h"
+
+struct _GtkCssCustomPropertyPool
+{
+  GObject parent_instance;
+
+  GArray *names;
+  GHashTable *name_mappings;
+};
+
+struct _GtkCssCustomPropertyName
+{
+  int ref_count;
+  char *name;
+};
+
+typedef struct _GtkCssCustomPropertyName GtkCssCustomPropertyName;
+
+static GtkCssCustomPropertyPool *instance = NULL;
+
+G_DEFINE_FINAL_TYPE (GtkCssCustomPropertyPool, gtk_css_custom_property_pool, G_TYPE_OBJECT)
+
+static void
+clear_custom_property_name (GtkCssCustomPropertyName *name)
+{
+  g_clear_pointer (&name->name, g_free);
+}
+
+static void
+gtk_css_custom_property_pool_finalize (GObject *object)
+{
+  GtkCssCustomPropertyPool *self = (GtkCssCustomPropertyPool *)object;
+
+  g_hash_table_unref (self->name_mappings);
+  g_array_unref (self->names);
+
+  G_OBJECT_CLASS (gtk_css_custom_property_pool_parent_class)->finalize (object);
+}
+
+static void
+gtk_css_custom_property_pool_class_init (GtkCssCustomPropertyPoolClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = gtk_css_custom_property_pool_finalize;
+}
+
+static void
+gtk_css_custom_property_pool_init (GtkCssCustomPropertyPool *self)
+{
+  self->name_mappings = g_hash_table_new (g_str_hash, g_str_equal);
+  self->names = g_array_new (FALSE, FALSE, sizeof (GtkCssCustomPropertyName));
+
+  g_array_set_clear_func (self->names, (GDestroyNotify) clear_custom_property_name);
+}
+
+GtkCssCustomPropertyPool *
+gtk_css_custom_property_pool_get (void)
+{
+  if (instance == NULL)
+    instance = g_object_new (GTK_TYPE_CSS_CUSTOM_PROPERTY_POOL, NULL);
+
+  return instance;
+}
+
+int
+gtk_css_custom_property_pool_add (GtkCssCustomPropertyPool *self,
+                                  const char               *str)
+{
+  GtkCssCustomPropertyName name;
+  int id;
+
+  id = gtk_css_custom_property_pool_lookup (self, str);
+  if (id > 0)
+    return gtk_css_custom_property_pool_ref (self, id);
+
+  name.ref_count = 1;
+  name.name = g_strdup (str);
+
+  // TODO reuse slots after they're gone
+  g_array_append_val (self->names, name);
+
+  id = self->names->len;
+
+  g_hash_table_insert (self->name_mappings, (char *) name.name, GINT_TO_POINTER (id));
+
+  return id;
+}
+
+int
+gtk_css_custom_property_pool_lookup (GtkCssCustomPropertyPool *self,
+                                     const char               *str)
+{
+  gpointer id;
+
+  id = g_hash_table_lookup (self->name_mappings, str);
+
+  return GPOINTER_TO_INT (id);
+}
+
+int
+gtk_css_custom_property_pool_ref (GtkCssCustomPropertyPool *self,
+                                  int                       id)
+{
+  GtkCssCustomPropertyName *name;
+
+  name = &g_array_index (self->names, GtkCssCustomPropertyName, id - 1);
+
+  name->ref_count++;
+
+  return id;
+}
+
+void
+gtk_css_custom_property_pool_unref (GtkCssCustomPropertyPool *self,
+                                    int                       id)
+{
+  GtkCssCustomPropertyName *name;
+
+  name = &g_array_index (self->names, GtkCssCustomPropertyName, id - 1);
+
+  g_assert (name->ref_count > 0);
+
+  name->ref_count--;
+
+  if (name->ref_count == 0)
+    {
+      g_hash_table_remove (self->name_mappings, name->name);
+      clear_custom_property_name (name);
+    }
+}
+
+const char *
+gtk_css_custom_property_pool_get_name (GtkCssCustomPropertyPool *self,
+                                       int                       id)
+{
+  GtkCssCustomPropertyName *name;
+
+  name = &g_array_index (self->names, GtkCssCustomPropertyName, id - 1);
+
+  return name->name;
+}

gtk/gtkcsscustompropertypoolprivate.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_CSS_CUSTOM_PROPERTY_POOL (gtk_css_custom_property_pool_get_type())
+
+G_DECLARE_FINAL_TYPE (GtkCssCustomPropertyPool, gtk_css_custom_property_pool, GTK, CSS_CUSTOM_PROPERTY_POOL, GObject)
+
+GtkCssCustomPropertyPool *gtk_css_custom_property_pool_get      (void);
+
+int                       gtk_css_custom_property_pool_add      (GtkCssCustomPropertyPool *self,
+                                                                 const char               *str);
+int                       gtk_css_custom_property_pool_lookup   (GtkCssCustomPropertyPool *self,
+                                                                 const char               *str);
+const char *              gtk_css_custom_property_pool_get_name (GtkCssCustomPropertyPool *self,
+                                                                 int                       id);
+int                       gtk_css_custom_property_pool_ref      (GtkCssCustomPropertyPool *self,
+                                                                 int                       id);
+void                      gtk_css_custom_property_pool_unref    (GtkCssCustomPropertyPool *self,
+                                                                 int                       id);
+
+G_END_DECLS

gtk/gtkcsseasevalue.c

@@ -50,11 +50,12 @@ gtk_css_value_ease_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_ease_compute (GtkCssValue      *value,
-                            guint             property_id,
-                            GtkStyleProvider *provider,
-                            GtkCssStyle      *style,
-                            GtkCssStyle      *parent_style)
+gtk_css_value_ease_compute (GtkCssValue       *value,
+                            guint              property_id,
+                            GtkStyleProvider  *provider,
+                            GtkCssStyle       *style,
+                            GtkCssStyle       *parent_style,
+                            GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (value);
 }
@@ -407,3 +408,4 @@ _gtk_css_ease_value_transform (const GtkCssValue *ease,
 }
 
 
+

gtk/gtkcssenumvalue.c

@@ -41,11 +41,12 @@ gtk_css_value_enum_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_enum_compute (GtkCssValue      *value,
-                            guint             property_id,
-                            GtkStyleProvider *provider,
-                            GtkCssStyle      *style,
-                            GtkCssStyle      *parent_style)
+gtk_css_value_enum_compute (GtkCssValue       *value,
+                            guint              property_id,
+                            GtkStyleProvider  *provider,
+                            GtkCssStyle       *style,
+                            GtkCssStyle       *parent_style,
+                            GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (value);
 }
@@ -87,16 +88,16 @@ static const GtkCssValueClass GTK_CSS_VALUE_BORDER_STYLE = {
 };
 
 static GtkCssValue border_style_values[] = {
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_NONE, "none" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_SOLID, "solid" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_INSET, "inset" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_OUTSET, "outset" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_HIDDEN, "hidden" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_DOTTED, "dotted" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_DASHED, "dashed" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_DOUBLE, "double" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_GROOVE, "groove" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, GTK_BORDER_STYLE_RIDGE, "ridge" }
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_NONE, "none" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_SOLID, "solid" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_INSET, "inset" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_OUTSET, "outset" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_HIDDEN, "hidden" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_DOTTED, "dotted" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_DASHED, "dashed" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_DOUBLE, "double" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_GROOVE, "groove" },
+  { &GTK_CSS_VALUE_BORDER_STYLE, 1, TRUE, FALSE, GTK_BORDER_STYLE_RIDGE, "ridge" }
 };
 
 GtkCssValue *
@@ -145,22 +146,22 @@ static const GtkCssValueClass GTK_CSS_VALUE_BLEND_MODE = {
 };
 
 static GtkCssValue blend_mode_values[] = {
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_DEFAULT, "normal" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_MULTIPLY, "multiply" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_SCREEN, "screen" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_OVERLAY, "overlay" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_DARKEN, "darken" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_LIGHTEN, "lighten" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_COLOR_DODGE, "color-dodge" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_COLOR_BURN, "color-burn" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_HARD_LIGHT, "hard-light" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_SOFT_LIGHT, "soft-light" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_DIFFERENCE, "difference" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_EXCLUSION, "exclusion" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_COLOR, "color" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_HUE, "hue" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_SATURATION, "saturation" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, GSK_BLEND_MODE_LUMINOSITY, "luminosity" }
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_DEFAULT, "normal" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_MULTIPLY, "multiply" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_SCREEN, "screen" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_OVERLAY, "overlay" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_DARKEN, "darken" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_LIGHTEN, "lighten" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_COLOR_DODGE, "color-dodge" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_COLOR_BURN, "color-burn" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_HARD_LIGHT, "hard-light" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_SOFT_LIGHT, "soft-light" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_DIFFERENCE, "difference" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_EXCLUSION, "exclusion" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_COLOR, "color" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_HUE, "hue" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_SATURATION, "saturation" },
+  { &GTK_CSS_VALUE_BLEND_MODE, 1, TRUE, FALSE, GSK_BLEND_MODE_LUMINOSITY, "luminosity" }
 };
 
 GtkCssValue *
@@ -229,11 +230,12 @@ gtk_css_font_size_get_default_px (GtkStyleProvider *provider,
 }
 
 static GtkCssValue *
-gtk_css_value_font_size_compute (GtkCssValue      *value,
-                                 guint             property_id,
-                                 GtkStyleProvider *provider,
-                                 GtkCssStyle      *style,
-                                 GtkCssStyle      *parent_style)
+gtk_css_value_font_size_compute (GtkCssValue       *value,
+                                 guint              property_id,
+                                 GtkStyleProvider  *provider,
+                                 GtkCssStyle       *style,
+                                 GtkCssStyle       *parent_style,
+                                 GtkCssVariableSet *variables)
 {
   double font_size;
 
@@ -296,15 +298,15 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_SIZE = {
 };
 
 static GtkCssValue font_size_values[] = {
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_SMALLER, "smaller" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_LARGER, "larger" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_XX_SMALL, "xx-small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_X_SMALL, "x-small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_SMALL, "small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_MEDIUM, "medium" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_LARGE, "large" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_X_LARGE, "x-large" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, GTK_CSS_FONT_SIZE_XX_LARGE, "xx-large" }
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_SMALLER, "smaller" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_LARGER, "larger" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_XX_SMALL, "xx-small" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_X_SMALL, "x-small" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_SMALL, "small" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_MEDIUM, "medium" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_LARGE, "large" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_X_LARGE, "x-large" },
+  { &GTK_CSS_VALUE_FONT_SIZE, 1, FALSE, FALSE, GTK_CSS_FONT_SIZE_XX_LARGE, "xx-large" }
 };
 
 GtkCssValue *
@@ -353,9 +355,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_STYLE = {
 };
 
 static GtkCssValue font_style_values[] = {
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, PANGO_STYLE_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, PANGO_STYLE_OBLIQUE, "oblique" },
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, PANGO_STYLE_ITALIC, "italic" }
+  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, FALSE, PANGO_STYLE_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, FALSE, PANGO_STYLE_OBLIQUE, "oblique" },
+  { &GTK_CSS_VALUE_FONT_STYLE, 1, TRUE, FALSE, PANGO_STYLE_ITALIC, "italic" }
 };
 
 GtkCssValue *
@@ -396,11 +398,12 @@ _gtk_css_font_style_value_get (const GtkCssValue *value)
 #define LIGHTER -2
 
 static GtkCssValue *
-gtk_css_value_font_weight_compute (GtkCssValue      *value,
-                                   guint             property_id,
-                                   GtkStyleProvider *provider,
-                                   GtkCssStyle      *style,
-                                   GtkCssStyle      *parent_style)
+gtk_css_value_font_weight_compute (GtkCssValue       *value,
+                                   guint              property_id,
+                                   GtkStyleProvider  *provider,
+                                   GtkCssStyle       *style,
+                                   GtkCssStyle       *parent_style,
+                                   GtkCssVariableSet *variables)
 {
   PangoWeight new_weight;
   int parent_value;
@@ -452,8 +455,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_WEIGHT = {
 };
 
 static GtkCssValue font_weight_values[] = {
-  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, BOLDER, "bolder" },
-  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, LIGHTER, "lighter" },
+  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, FALSE, BOLDER, "bolder" },
+  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, FALSE, LIGHTER, "lighter" },
 };
 
 GtkCssValue *
@@ -502,15 +505,15 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_STRETCH = {
 };
 
 static GtkCssValue font_stretch_values[] = {
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_ULTRA_CONDENSED, "ultra-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_EXTRA_CONDENSED, "extra-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_CONDENSED, "condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_SEMI_CONDENSED, "semi-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_SEMI_EXPANDED, "semi-expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_EXPANDED, "expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_EXTRA_EXPANDED, "extra-expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, PANGO_STRETCH_ULTRA_EXPANDED, "ultra-expanded" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_ULTRA_CONDENSED, "ultra-condensed" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_EXTRA_CONDENSED, "extra-condensed" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_CONDENSED, "condensed" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_SEMI_CONDENSED, "semi-condensed" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_SEMI_EXPANDED, "semi-expanded" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_EXPANDED, "expanded" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_EXTRA_EXPANDED, "extra-expanded" },
+  { &GTK_CSS_VALUE_FONT_STRETCH, 1, TRUE, FALSE, PANGO_STRETCH_ULTRA_EXPANDED, "ultra-expanded" },
 };
 
 GtkCssValue *
@@ -559,9 +562,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_TEXT_DECORATION_STYLE = {
 };
 
 static GtkCssValue text_decoration_style_values[] = {
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, GTK_CSS_TEXT_DECORATION_STYLE_SOLID, "solid" },
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, GTK_CSS_TEXT_DECORATION_STYLE_DOUBLE, "double" },
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, GTK_CSS_TEXT_DECORATION_STYLE_WAVY, "wavy" },
+  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, FALSE, GTK_CSS_TEXT_DECORATION_STYLE_SOLID, "solid" },
+  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, FALSE, GTK_CSS_TEXT_DECORATION_STYLE_DOUBLE, "double" },
+  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, TRUE, FALSE, GTK_CSS_TEXT_DECORATION_STYLE_WAVY, "wavy" },
 };
 
 GtkCssValue *
@@ -610,9 +613,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_AREA = {
 };
 
 static GtkCssValue area_values[] = {
-  { &GTK_CSS_VALUE_AREA, 1, TRUE, GTK_CSS_AREA_BORDER_BOX, "border-box" },
-  { &GTK_CSS_VALUE_AREA, 1, TRUE, GTK_CSS_AREA_PADDING_BOX, "padding-box" },
-  { &GTK_CSS_VALUE_AREA, 1, TRUE, GTK_CSS_AREA_CONTENT_BOX, "content-box" }
+  { &GTK_CSS_VALUE_AREA, 1, TRUE, FALSE, GTK_CSS_AREA_BORDER_BOX, "border-box" },
+  { &GTK_CSS_VALUE_AREA, 1, TRUE, FALSE, GTK_CSS_AREA_PADDING_BOX, "padding-box" },
+  { &GTK_CSS_VALUE_AREA, 1, TRUE, FALSE, GTK_CSS_AREA_CONTENT_BOX, "content-box" }
 };
 
 GtkCssValue *
@@ -667,10 +670,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_DIRECTION = {
 };
 
 static GtkCssValue direction_values[] = {
-  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, GTK_CSS_DIRECTION_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, GTK_CSS_DIRECTION_REVERSE, "reverse" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, GTK_CSS_DIRECTION_ALTERNATE, "alternate" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, GTK_CSS_DIRECTION_ALTERNATE_REVERSE, "alternate-reverse" }
+  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, FALSE, GTK_CSS_DIRECTION_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, FALSE, GTK_CSS_DIRECTION_REVERSE, "reverse" },
+  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, FALSE, GTK_CSS_DIRECTION_ALTERNATE, "alternate" },
+  { &GTK_CSS_VALUE_DIRECTION, 1, TRUE, FALSE, GTK_CSS_DIRECTION_ALTERNATE_REVERSE, "alternate-reverse" }
 };
 
 GtkCssValue *
@@ -728,8 +731,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_PLAY_STATE = {
 };
 
 static GtkCssValue play_state_values[] = {
-  { &GTK_CSS_VALUE_PLAY_STATE, 1, TRUE, GTK_CSS_PLAY_STATE_RUNNING, "running" },
-  { &GTK_CSS_VALUE_PLAY_STATE, 1, TRUE, GTK_CSS_PLAY_STATE_PAUSED, "paused" }
+  { &GTK_CSS_VALUE_PLAY_STATE, 1, TRUE, FALSE, GTK_CSS_PLAY_STATE_RUNNING, "running" },
+  { &GTK_CSS_VALUE_PLAY_STATE, 1, TRUE, FALSE, GTK_CSS_PLAY_STATE_PAUSED, "paused" }
 };
 
 GtkCssValue *
@@ -784,10 +787,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_FILL_MODE = {
 };
 
 static GtkCssValue fill_mode_values[] = {
-  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, GTK_CSS_FILL_NONE, "none" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, GTK_CSS_FILL_FORWARDS, "forwards" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, GTK_CSS_FILL_BACKWARDS, "backwards" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, GTK_CSS_FILL_BOTH, "both" }
+  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, FALSE, GTK_CSS_FILL_NONE, "none" },
+  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, FALSE, GTK_CSS_FILL_FORWARDS, "forwards" },
+  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, FALSE, GTK_CSS_FILL_BACKWARDS, "backwards" },
+  { &GTK_CSS_VALUE_FILL_MODE, 1, TRUE, FALSE, GTK_CSS_FILL_BOTH, "both" }
 };
 
 GtkCssValue *
@@ -842,9 +845,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_ICON_STYLE = {
 };
 
 static GtkCssValue icon_style_values[] = {
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, GTK_CSS_ICON_STYLE_REQUESTED, "requested" },
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, GTK_CSS_ICON_STYLE_REGULAR, "regular" },
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, GTK_CSS_ICON_STYLE_SYMBOLIC, "symbolic" }
+  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, FALSE, GTK_CSS_ICON_STYLE_REQUESTED, "requested" },
+  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, FALSE, GTK_CSS_ICON_STYLE_REGULAR, "regular" },
+  { &GTK_CSS_VALUE_ICON_STYLE, 1, TRUE, FALSE, GTK_CSS_ICON_STYLE_SYMBOLIC, "symbolic" }
 };
 
 GtkCssValue *
@@ -899,9 +902,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_KERNING = {
 };
 
 static GtkCssValue font_kerning_values[] = {
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, GTK_CSS_FONT_KERNING_AUTO, "auto" },
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, GTK_CSS_FONT_KERNING_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, GTK_CSS_FONT_KERNING_NONE, "none" }
+  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, FALSE, GTK_CSS_FONT_KERNING_AUTO, "auto" },
+  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, FALSE, GTK_CSS_FONT_KERNING_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_KERNING, 1, TRUE, FALSE, GTK_CSS_FONT_KERNING_NONE, "none" }
 };
 
 GtkCssValue *
@@ -956,9 +959,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_POSITION = {
 };
 
 static GtkCssValue font_variant_position_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, GTK_CSS_FONT_VARIANT_POSITION_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, GTK_CSS_FONT_VARIANT_POSITION_SUB, "sub" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, GTK_CSS_FONT_VARIANT_POSITION_SUPER, "super" }
+  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_POSITION_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_POSITION_SUB, "sub" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_POSITION_SUPER, "super" }
 };
 
 GtkCssValue *
@@ -1013,13 +1016,13 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_CAPS = {
 };
 
 static GtkCssValue font_variant_caps_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_SMALL_CAPS, "small-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_ALL_SMALL_CAPS, "all-small-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_PETITE_CAPS, "petite-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_ALL_PETITE_CAPS, "all-petite-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_UNICASE, "unicase" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, GTK_CSS_FONT_VARIANT_CAPS_TITLING_CAPS, "titling-caps" }
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_SMALL_CAPS, "small-caps" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_ALL_SMALL_CAPS, "all-small-caps" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_PETITE_CAPS, "petite-caps" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_ALL_PETITE_CAPS, "all-petite-caps" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_UNICASE, "unicase" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_CAPS_TITLING_CAPS, "titling-caps" }
 };
 
 GtkCssValue *
@@ -1074,8 +1077,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE = {
 };
 
 static GtkCssValue font_variant_alternate_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, TRUE, GTK_CSS_FONT_VARIANT_ALTERNATE_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, TRUE, GTK_CSS_FONT_VARIANT_ALTERNATE_HISTORICAL_FORMS, "historical-forms" }
+  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_ALTERNATE_NORMAL, "normal" },
+  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, TRUE, FALSE, GTK_CSS_FONT_VARIANT_ALTERNATE_HISTORICAL_FORMS, "historical-forms" }
 };
 
 GtkCssValue *
@@ -1583,10 +1586,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_TEXT_TRANSFORM = {
 };
 
 static GtkCssValue text_transform_values[] = {
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, GTK_CSS_TEXT_TRANSFORM_NONE, "none" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, GTK_CSS_TEXT_TRANSFORM_LOWERCASE, "lowercase" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, GTK_CSS_TEXT_TRANSFORM_UPPERCASE, "uppercase" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, GTK_CSS_TEXT_TRANSFORM_CAPITALIZE, "capitalize" },
+  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, FALSE, GTK_CSS_TEXT_TRANSFORM_NONE, "none" },
+  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, FALSE, GTK_CSS_TEXT_TRANSFORM_LOWERCASE, "lowercase" },
+  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, FALSE, GTK_CSS_TEXT_TRANSFORM_UPPERCASE, "uppercase" },
+  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, TRUE, FALSE, GTK_CSS_TEXT_TRANSFORM_CAPITALIZE, "capitalize" },
 };
 
 GtkCssValue *

gtk/gtkcssfiltervalue.c

@@ -307,55 +307,56 @@ gtk_css_value_filter_free (GtkCssValue *value)
 
 /* returns TRUE if dest == src */
 static gboolean
-gtk_css_filter_compute (GtkCssFilter     *dest,
-                        GtkCssFilter     *src,
-                        guint             property_id,
-                        GtkStyleProvider *provider,
-                        GtkCssStyle      *style,
-                        GtkCssStyle      *parent_style)
+gtk_css_filter_compute (GtkCssFilter      *dest,
+                        GtkCssFilter      *src,
+                        guint              property_id,
+                        GtkStyleProvider  *provider,
+                        GtkCssStyle       *style,
+                        GtkCssStyle       *parent_style,
+                        GtkCssVariableSet *variables)
 {
   dest->type = src->type;
 
   switch (src->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      dest->brightness.value = _gtk_css_value_compute (src->brightness.value, property_id, provider, style, parent_style);
+      dest->brightness.value = _gtk_css_value_compute (src->brightness.value, property_id, provider, style, parent_style, variables);
       return dest->brightness.value == src->brightness.value;
 
     case GTK_CSS_FILTER_CONTRAST:
-      dest->contrast.value = _gtk_css_value_compute (src->contrast.value, property_id, provider, style, parent_style);
+      dest->contrast.value = _gtk_css_value_compute (src->contrast.value, property_id, provider, style, parent_style, variables);
       return dest->contrast.value == src->contrast.value;
 
     case GTK_CSS_FILTER_GRAYSCALE:
-      dest->grayscale.value = _gtk_css_value_compute (src->grayscale.value, property_id, provider, style, parent_style);
+      dest->grayscale.value = _gtk_css_value_compute (src->grayscale.value, property_id, provider, style, parent_style, variables);
       return dest->grayscale.value == src->grayscale.value;
 
     case GTK_CSS_FILTER_HUE_ROTATE:
-      dest->hue_rotate.value = _gtk_css_value_compute (src->hue_rotate.value, property_id, provider, style, parent_style);
+      dest->hue_rotate.value = _gtk_css_value_compute (src->hue_rotate.value, property_id, provider, style, parent_style, variables);
       return dest->hue_rotate.value == src->hue_rotate.value;
 
     case GTK_CSS_FILTER_INVERT:
-      dest->invert.value = _gtk_css_value_compute (src->invert.value, property_id, provider, style, parent_style);
+      dest->invert.value = _gtk_css_value_compute (src->invert.value, property_id, provider, style, parent_style, variables);
       return dest->invert.value == src->invert.value;
 
     case GTK_CSS_FILTER_OPACITY:
-      dest->opacity.value = _gtk_css_value_compute (src->opacity.value, property_id, provider, style, parent_style);
+      dest->opacity.value = _gtk_css_value_compute (src->opacity.value, property_id, provider, style, parent_style, variables);
       return dest->opacity.value == src->opacity.value;
 
     case GTK_CSS_FILTER_SATURATE:
-      dest->saturate.value = _gtk_css_value_compute (src->saturate.value, property_id, provider, style, parent_style);
+      dest->saturate.value = _gtk_css_value_compute (src->saturate.value, property_id, provider, style, parent_style, variables);
       return dest->saturate.value == src->saturate.value;
 
     case GTK_CSS_FILTER_SEPIA:
-      dest->sepia.value = _gtk_css_value_compute (src->sepia.value, property_id, provider, style, parent_style);
+      dest->sepia.value = _gtk_css_value_compute (src->sepia.value, property_id, provider, style, parent_style, variables);
       return dest->sepia.value == src->sepia.value;
 
     case GTK_CSS_FILTER_BLUR:
-      dest->blur.value = _gtk_css_value_compute (src->blur.value, property_id, provider, style, parent_style);
+      dest->blur.value = _gtk_css_value_compute (src->blur.value, property_id, provider, style, parent_style, variables);
       return dest->blur.value == src->blur.value;
 
     case GTK_CSS_FILTER_DROP_SHADOW:
-      dest->drop_shadow.value = _gtk_css_value_compute (src->drop_shadow.value, property_id, provider, style, parent_style);
+      dest->drop_shadow.value = _gtk_css_value_compute (src->drop_shadow.value, property_id, provider, style, parent_style, variables);
       return dest->drop_shadow.value == src->drop_shadow.value;
 
     case GTK_CSS_FILTER_NONE:
@@ -366,11 +367,12 @@ gtk_css_filter_compute (GtkCssFilter     *dest,
 }
 
 static GtkCssValue *
-gtk_css_value_filter_compute (GtkCssValue      *value,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_filter_compute (GtkCssValue       *value,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssValue *result;
   gboolean changes;
@@ -390,7 +392,8 @@ gtk_css_value_filter_compute (GtkCssValue      *value,
                                           property_id,
                                           provider,
                                           style,
-                                          parent_style);
+                                          parent_style,
+                                          variables);
     }
 
   if (!changes)
@@ -723,7 +726,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_FILTER = {
   gtk_css_value_filter_print
 };
 
-static GtkCssValue filter_none_singleton = { &GTK_CSS_VALUE_FILTER, 1, TRUE, 0, {  { GTK_CSS_FILTER_NONE } } };
+static GtkCssValue filter_none_singleton = { &GTK_CSS_VALUE_FILTER, 1, TRUE, FALSE, 0, {  { GTK_CSS_FILTER_NONE } } };
 
 static GtkCssValue *
 gtk_css_filter_value_alloc (guint n_filters)

gtk/gtkcssfontfeaturesvalue.c

@@ -53,11 +53,12 @@ gtk_css_value_font_features_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_font_features_compute (GtkCssValue      *specified,
-                                     guint             property_id,
-                                     GtkStyleProvider *provider,
-                                     GtkCssStyle      *style,
-                                     GtkCssStyle      *parent_style)
+gtk_css_value_font_features_compute (GtkCssValue       *specified,
+                                     guint              property_id,
+                                     GtkStyleProvider  *provider,
+                                     GtkCssStyle       *style,
+                                     GtkCssStyle       *parent_style,
+                                     GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (specified);
 }

gtk/gtkcssfontvariationsvalue.c

@@ -52,11 +52,12 @@ gtk_css_value_font_variations_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_font_variations_compute (GtkCssValue      *specified,
-                                       guint             property_id,
-                                       GtkStyleProvider *provider,
-                                       GtkCssStyle      *style,
-                                       GtkCssStyle      *parent_style)
+gtk_css_value_font_variations_compute (GtkCssValue       *specified,
+                                       guint              property_id,
+                                       GtkStyleProvider  *provider,
+                                       GtkCssStyle       *style,
+                                       GtkCssStyle       *parent_style,
+                                       GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (specified);
 }

gtk/gtkcssimage.c

@@ -65,11 +65,12 @@ gtk_css_image_real_get_aspect_ratio (GtkCssImage *image)
 }
 
 static GtkCssImage *
-gtk_css_image_real_compute (GtkCssImage      *image,
-                            guint             property_id,
-                            GtkStyleProvider *provider,
-                            GtkCssStyle      *style,
-                            GtkCssStyle      *parent_style)
+gtk_css_image_real_compute (GtkCssImage       *image,
+                            guint              property_id,
+                            GtkStyleProvider  *provider,
+                            GtkCssStyle       *style,
+                            GtkCssStyle       *parent_style,
+                            GtkCssVariableSet *variables)
 {
   return g_object_ref (image);
 }
@@ -173,11 +174,12 @@ _gtk_css_image_get_aspect_ratio (GtkCssImage *image)
 }
 
 GtkCssImage *
-_gtk_css_image_compute (GtkCssImage      *image,
-                        guint             property_id,
-                        GtkStyleProvider *provider,
-                        GtkCssStyle      *style,
-                        GtkCssStyle      *parent_style)
+_gtk_css_image_compute (GtkCssImage       *image,
+                        guint              property_id,
+                        GtkStyleProvider  *provider,
+                        GtkCssStyle       *style,
+                        GtkCssStyle       *parent_style,
+                        GtkCssVariableSet *variables)
 {
   GtkCssImageClass *klass;
 
@@ -187,7 +189,7 @@ _gtk_css_image_compute (GtkCssImage      *image,
 
   klass = GTK_CSS_IMAGE_GET_CLASS (image);
 
-  return klass->compute (image, property_id, provider, style, parent_style);
+  return klass->compute (image, property_id, provider, style, parent_style, variables);
 }
 
 GtkCssImage *

gtk/gtkcssimageconic.c

@@ -313,11 +313,12 @@ gtk_css_image_conic_print (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_conic_compute (GtkCssImage      *image,
-                             guint             property_id,
-                             GtkStyleProvider *provider,
-                             GtkCssStyle      *style,
-                             GtkCssStyle      *parent_style)
+gtk_css_image_conic_compute (GtkCssImage       *image,
+                             guint              property_id,
+                             GtkStyleProvider  *provider,
+                             GtkCssStyle       *style,
+                             GtkCssStyle       *parent_style,
+                             GtkCssVariableSet *variables)
 {
   GtkCssImageConic *self = GTK_CSS_IMAGE_CONIC (image);
   GtkCssImageConic *copy;
@@ -325,8 +326,8 @@ gtk_css_image_conic_compute (GtkCssImage      *image,
 
   copy = g_object_new (GTK_TYPE_CSS_IMAGE_CONIC, NULL);
 
-  copy->center = _gtk_css_value_compute (self->center, property_id, provider, style, parent_style);
-  copy->rotation = _gtk_css_value_compute (self->rotation, property_id, provider, style, parent_style);
+  copy->center = _gtk_css_value_compute (self->center, property_id, provider, style, parent_style, variables);
+  copy->rotation = _gtk_css_value_compute (self->rotation, property_id, provider, style, parent_style, variables);
 
   copy->n_stops = self->n_stops;
   copy->color_stops = g_malloc (sizeof (GtkCssImageConicColorStop) * copy->n_stops);
@@ -335,11 +336,11 @@ gtk_css_image_conic_compute (GtkCssImage      *image,
       const GtkCssImageConicColorStop *stop = &self->color_stops[i];
       GtkCssImageConicColorStop *scopy = &copy->color_stops[i];
 
-      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style, variables);
 
       if (stop->offset)
         {
-          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style, variables);
         }
       else
         {

gtk/gtkcssimagecrossfade.c

@@ -399,11 +399,12 @@ gtk_css_image_cross_fade_print (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_cross_fade_compute (GtkCssImage      *image,
-                                  guint             property_id,
-                                  GtkStyleProvider *provider,
-                                  GtkCssStyle      *style,
-                                  GtkCssStyle      *parent_style)
+gtk_css_image_cross_fade_compute (GtkCssImage       *image,
+                                  guint              property_id,
+                                  GtkStyleProvider  *provider,
+                                  GtkCssStyle       *style,
+                                  GtkCssStyle       *parent_style,
+                                  GtkCssVariableSet *variables)
 {
   GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
   GtkCssImageCrossFade *result;
@@ -418,7 +419,7 @@ gtk_css_image_cross_fade_compute (GtkCssImage      *image,
       gtk_css_image_cross_fade_add (result,
                                     entry->has_progress,
                                     entry->progress,
-                                    _gtk_css_image_compute (entry->image, property_id, provider, style, parent_style));
+                                    _gtk_css_image_compute (entry->image, property_id, provider, style, parent_style, variables));
     }
 
   return GTK_CSS_IMAGE (result);

gtk/gtkcssimagefallback.c

@@ -133,11 +133,12 @@ gtk_css_image_fallback_dispose (GObject *object)
 
 
 static GtkCssImage *
-gtk_css_image_fallback_compute (GtkCssImage      *image,
-                                guint             property_id,
-                                GtkStyleProvider *provider,
-                                GtkCssStyle      *style,
-                                GtkCssStyle      *parent_style)
+gtk_css_image_fallback_compute (GtkCssImage       *image,
+                                guint              property_id,
+                                GtkStyleProvider  *provider,
+                                GtkCssStyle       *style,
+                                GtkCssStyle       *parent_style,
+                                GtkCssVariableSet *variables)
 {
   GtkCssImageFallback *fallback = GTK_CSS_IMAGE_FALLBACK (image);
   GtkCssImageFallback *copy;
@@ -152,7 +153,8 @@ gtk_css_image_fallback_compute (GtkCssImage      *image,
                                                  property_id,
                                                  provider,
                                                  style,
-                                                 parent_style);
+                                                 parent_style,
+                                                 variables);
 
       /* image($color) that didn't change */
       if (computed_color && !fallback->images &&
@@ -168,7 +170,8 @@ gtk_css_image_fallback_compute (GtkCssImage      *image,
                                                     property_id,
                                                     provider,
                                                     style,
-                                                    parent_style);
+                                                    parent_style,
+                                                    variables);
 
           if (gtk_css_image_is_invalid (copy->images[i]))
             continue;

gtk/gtkcssimageicontheme.c

@@ -138,11 +138,12 @@ gtk_css_image_icon_theme_print (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_icon_theme_compute (GtkCssImage      *image,
-                                  guint             property_id,
-                                  GtkStyleProvider *provider,
-                                  GtkCssStyle      *style,
-                                  GtkCssStyle      *parent_style)
+gtk_css_image_icon_theme_compute (GtkCssImage       *image,
+                                  guint              property_id,
+                                  GtkStyleProvider  *provider,
+                                  GtkCssStyle       *style,
+                                  GtkCssStyle       *parent_style,
+                                  GtkCssVariableSet *variables)
 {
   GtkCssImageIconTheme *icon_theme = GTK_CSS_IMAGE_ICON_THEME (image);
   GtkCssImageIconTheme *copy;
@@ -156,7 +157,7 @@ gtk_css_image_icon_theme_compute (GtkCssImage      *image,
   copy->icon_theme = gtk_icon_theme_get_for_display (display);
   copy->serial = gtk_icon_theme_get_serial (copy->icon_theme);
   copy->scale = gtk_style_provider_get_scale (provider);
-  gtk_icon_theme_lookup_symbolic_colors (style, copy->colors);
+  gtk_css_style_lookup_symbolic_colors (style, copy->colors);
 
   return GTK_CSS_IMAGE (copy);
 }

gtk/gtkcssimagelinear.c

@@ -488,11 +488,12 @@ gtk_css_image_linear_print (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_linear_compute (GtkCssImage      *image,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_image_linear_compute (GtkCssImage       *image,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
   GtkCssImageLinear *copy;
@@ -503,7 +504,7 @@ gtk_css_image_linear_compute (GtkCssImage      *image,
   copy->side = linear->side;
 
   if (linear->angle)
-    copy->angle = _gtk_css_value_compute (linear->angle, property_id, provider, style, parent_style);
+    copy->angle = _gtk_css_value_compute (linear->angle, property_id, provider, style, parent_style, variables);
 
   copy->n_stops = linear->n_stops;
   copy->color_stops = g_malloc (sizeof (GtkCssImageLinearColorStop) * copy->n_stops);
@@ -512,11 +513,11 @@ gtk_css_image_linear_compute (GtkCssImage      *image,
       const GtkCssImageLinearColorStop *stop = &linear->color_stops[i];
       GtkCssImageLinearColorStop *scopy = &copy->color_stops[i];
 
-      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style, variables);
 
       if (stop->offset)
         {
-          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style, variables);
         }
       else
         {

gtk/gtkcssimagepaintable.c

@@ -96,11 +96,12 @@ gtk_css_image_paintable_get_static_image (GtkCssImage *image)
 }
 
 static GtkCssImage *
-gtk_css_image_paintable_compute (GtkCssImage      *image,
-                                 guint             property_id,
-                                 GtkStyleProvider *provider,
-                                 GtkCssStyle      *style,
-                                 GtkCssStyle      *parent_style)
+gtk_css_image_paintable_compute (GtkCssImage       *image,
+                                 guint              property_id,
+                                 GtkStyleProvider  *provider,
+                                 GtkCssStyle       *style,
+                                 GtkCssStyle       *parent_style,
+                                 GtkCssVariableSet *variables)
 {
   return gtk_css_image_paintable_get_static_image (image);
 }

gtk/gtkcssimageprivate.h

@@ -26,6 +26,7 @@
 #include "gtk/css/gtkcsstokenizerprivate.h"
 #include "gtk/css/gtkcssparserprivate.h"
 #include "gtk/gtkcsstypesprivate.h"
+#include "gtk/gtkcssvariablesetprivate.h"
 #include "gtk/gtksnapshot.h"
 #include "gtk/gtkstyleprovider.h"
 
@@ -62,7 +63,8 @@ struct _GtkCssImageClass
                                                     guint                       property_id,
                                                     GtkStyleProvider           *provider,
                                                     GtkCssStyle                *style,
-                                                    GtkCssStyle                *parent_style);
+                                                    GtkCssStyle                *parent_style,
+                                                    GtkCssVariableSet          *variables);
   /* compare two images for equality */
   gboolean     (* equal)                           (GtkCssImage                *image1,
                                                     GtkCssImage                *image2);
@@ -106,7 +108,8 @@ GtkCssImage *  _gtk_css_image_compute              (GtkCssImage                *
                                                     guint                       property_id,
                                                     GtkStyleProvider           *provider,
                                                     GtkCssStyle                *style,
-                                                    GtkCssStyle                *parent_style);
+                                                    GtkCssStyle                *parent_style,
+                                                    GtkCssVariableSet          *variables);
 gboolean       _gtk_css_image_equal                (GtkCssImage                *image1,
                                                     GtkCssImage                *image2) G_GNUC_PURE;
 GtkCssImage *  _gtk_css_image_transition           (GtkCssImage                *start,

gtk/gtkcssimageradial.c

@@ -489,11 +489,12 @@ gtk_css_image_radial_print (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_radial_compute (GtkCssImage      *image,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_image_radial_compute (GtkCssImage       *image,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssImageRadial *radial = GTK_CSS_IMAGE_RADIAL (image);
   GtkCssImageRadial *copy;
@@ -504,13 +505,13 @@ gtk_css_image_radial_compute (GtkCssImage      *image,
   copy->circle = radial->circle;
   copy->size = radial->size;
 
-  copy->position = _gtk_css_value_compute (radial->position, property_id, provider, style, parent_style);
+  copy->position = _gtk_css_value_compute (radial->position, property_id, provider, style, parent_style, variables);
 
   if (radial->sizes[0])
-    copy->sizes[0] = _gtk_css_value_compute (radial->sizes[0], property_id, provider, style, parent_style);
+    copy->sizes[0] = _gtk_css_value_compute (radial->sizes[0], property_id, provider, style, parent_style, variables);
 
   if (radial->sizes[1])
-    copy->sizes[1] = _gtk_css_value_compute (radial->sizes[1], property_id, provider, style, parent_style);
+    copy->sizes[1] = _gtk_css_value_compute (radial->sizes[1], property_id, provider, style, parent_style, variables);
 
   copy->n_stops = radial->n_stops;
   copy->color_stops = g_malloc (sizeof (GtkCssImageRadialColorStop) * copy->n_stops);
@@ -519,11 +520,11 @@ gtk_css_image_radial_compute (GtkCssImage      *image,
       const GtkCssImageRadialColorStop *stop = &radial->color_stops[i];
       GtkCssImageRadialColorStop *scopy = &copy->color_stops[i];
 
-      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style, variables);
 
       if (stop->offset)
         {
-          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style, variables);
         }
       else
         {

gtk/gtkcssimagerecolor.c

@@ -97,6 +97,7 @@ gtk_css_image_recolor_load_texture (GtkCssImageRecolor  *recolor,
                                     GError             **error)
 {
   char *uri;
+  gboolean only_fg;
 
   if (recolor->texture)
     return;
@@ -110,7 +111,7 @@ gtk_css_image_recolor_load_texture (GtkCssImageRecolor  *recolor,
       if (g_str_has_suffix (uri, ".symbolic.png"))
         recolor->texture = gtk_load_symbolic_texture_from_resource (resource_path);
       else
-        recolor->texture = gdk_texture_new_from_resource_symbolic (resource_path, 0, 0, 1.0, NULL);
+        recolor->texture = gdk_texture_new_from_resource_symbolic (resource_path, 0, 0, 1.0, &only_fg, NULL);
 
       g_free (resource_path);
     }
@@ -119,7 +120,7 @@ gtk_css_image_recolor_load_texture (GtkCssImageRecolor  *recolor,
       if (g_str_has_suffix (uri, ".symbolic.png"))
         recolor->texture = gtk_load_symbolic_texture_from_file (recolor->file);
       else
-        recolor->texture = gdk_texture_new_from_file_symbolic (recolor->file, 0, 0, 1.0, NULL);
+        recolor->texture = gdk_texture_new_from_file_symbolic (recolor->file, 0, 0, 1.0, &only_fg, NULL);
     }
 
   g_free (uri);
@@ -200,11 +201,12 @@ gtk_css_image_recolor_snapshot (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_recolor_compute (GtkCssImage      *image,
-                               guint             property_id,
-                               GtkStyleProvider *provider,
-                               GtkCssStyle      *style,
-                               GtkCssStyle      *parent_style)
+gtk_css_image_recolor_compute (GtkCssImage       *image,
+                               guint              property_id,
+                               GtkStyleProvider  *provider,
+                               GtkCssStyle       *style,
+                               GtkCssStyle       *parent_style,
+                               GtkCssVariableSet *variables)
 {
   GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (image);
   GtkCssValue *palette;
@@ -215,7 +217,7 @@ gtk_css_image_recolor_compute (GtkCssImage      *image,
   scale = gtk_style_provider_get_scale (provider);
 
   if (recolor->palette)
-    palette = _gtk_css_value_compute (recolor->palette, property_id, provider, style, parent_style);
+    palette = _gtk_css_value_compute (recolor->palette, property_id, provider, style, parent_style, variables);
   else
     palette = _gtk_css_value_ref (style->core->icon_palette);
 

gtk/gtkcssimagescaled.c

@@ -97,11 +97,12 @@ gtk_css_image_scaled_dispose (GObject *object)
 
 
 static GtkCssImage *
-gtk_css_image_scaled_compute (GtkCssImage      *image,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_image_scaled_compute (GtkCssImage       *image,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   GtkCssImageScaled *scaled = GTK_CSS_IMAGE_SCALED (image);
   int scale;
@@ -137,7 +138,8 @@ gtk_css_image_scaled_compute (GtkCssImage      *image,
                                            property_id,
                                            provider,
                                            style,
-                                           parent_style);
+                                           parent_style,
+                                           variables);
   res->scales[0] = scaled->scales[best];
 
   return GTK_CSS_IMAGE (res);

gtk/gtkcssimageurl.c

@@ -112,11 +112,12 @@ gtk_css_image_url_snapshot (GtkCssImage *image,
 }
 
 static GtkCssImage *
-gtk_css_image_url_compute (GtkCssImage      *image,
-                           guint             property_id,
-                           GtkStyleProvider *provider,
-                           GtkCssStyle      *style,
-                           GtkCssStyle      *parent_style)
+gtk_css_image_url_compute (GtkCssImage       *image,
+                           guint              property_id,
+                           GtkStyleProvider  *provider,
+                           GtkCssStyle       *style,
+                           GtkCssStyle       *parent_style,
+                           GtkCssVariableSet *variables)
 {
   GtkCssImageUrl *url = GTK_CSS_IMAGE_URL (image);
   GtkCssImage *copy;

gtk/gtkcssimagevalue.c

@@ -34,11 +34,12 @@ gtk_css_value_image_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_image_compute (GtkCssValue      *value,
-                             guint             property_id,
-                             GtkStyleProvider *provider,
-                             GtkCssStyle      *style,
-                             GtkCssStyle      *parent_style)
+gtk_css_value_image_compute (GtkCssValue       *value,
+                             guint              property_id,
+                             GtkStyleProvider  *provider,
+                             GtkCssStyle       *style,
+                             GtkCssStyle       *parent_style,
+                             GtkCssVariableSet *variables)
 {
   GtkCssImage *image, *computed;
   
@@ -47,7 +48,7 @@ gtk_css_value_image_compute (GtkCssValue      *value,
   if (image == NULL)
     return _gtk_css_value_ref (value);
 
-  computed = _gtk_css_image_compute (image, property_id, provider, style, parent_style);
+  computed = _gtk_css_image_compute (image, property_id, provider, style, parent_style, variables);
 
   if (computed == image)
     {
@@ -136,7 +137,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_IMAGE = {
 GtkCssValue *
 _gtk_css_image_value_new (GtkCssImage *image)
 {
-  static GtkCssValue image_none_singleton = { &GTK_CSS_VALUE_IMAGE, 1, TRUE, NULL };
+  static GtkCssValue image_none_singleton = { &GTK_CSS_VALUE_IMAGE, 1, TRUE, FALSE, NULL };
   GtkCssValue *value;
 
   if (image == NULL)

gtk/gtkcssinheritvalue.c

@@ -34,11 +34,12 @@ gtk_css_value_inherit_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_inherit_compute (GtkCssValue      *value,
-                               guint             property_id,
-                               GtkStyleProvider *provider,
-                               GtkCssStyle      *style,
-                               GtkCssStyle      *parent_style)
+gtk_css_value_inherit_compute (GtkCssValue       *value,
+                               guint              property_id,
+                               GtkStyleProvider  *provider,
+                               GtkCssStyle       *style,
+                               GtkCssStyle       *parent_style,
+                               GtkCssVariableSet *variables)
 {
   if (parent_style)
     {
@@ -50,7 +51,8 @@ gtk_css_value_inherit_compute (GtkCssValue      *value,
                                      property_id,
                                      provider,
                                      style,
-                                     parent_style);
+                                     parent_style,
+                                     variables);
     }
 }
 

gtk/gtkcssinitialvalue.c

@@ -38,11 +38,12 @@ gtk_css_value_initial_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_initial_compute (GtkCssValue      *value,
-                               guint             property_id,
-                               GtkStyleProvider *provider,
-                               GtkCssStyle      *style,
-                               GtkCssStyle      *parent_style)
+gtk_css_value_initial_compute (GtkCssValue       *value,
+                               guint              property_id,
+                               GtkStyleProvider  *provider,
+                               GtkCssStyle       *style,
+                               GtkCssStyle       *parent_style,
+                               GtkCssVariableSet *variables)
 {
   GtkSettings *settings;
 
@@ -75,7 +76,8 @@ gtk_css_value_initial_compute (GtkCssValue      *value,
                                  property_id,
                                  provider,
                                  style,
-                                 parent_style);
+                                 parent_style,
+                                 variables);
 }
 
 static gboolean
@@ -135,5 +137,6 @@ _gtk_css_initial_value_new_compute (guint             property_id,
                                         property_id,
                                         provider,
                                         style,
-                                        parent_style);
+                                        parent_style,
+                                        NULL);
 }

gtk/gtkcsskeyframes.c

@@ -21,6 +21,8 @@
 
 #include "gtkcssstyleprivate.h"
 #include "gtkcssarrayvalueprivate.h"
+#include "gtkcsscustompropertypoolprivate.h"
+#include "gtkcssreferencevalueprivate.h"
 #include "gtkcssshorthandpropertyprivate.h"
 #include "gtkcssstylepropertyprivate.h"
 #include "gtkstylepropertyprivate.h"
@@ -31,12 +33,15 @@
 #include <string.h>
 
 struct _GtkCssKeyframes {
-  int ref_count;                /* ref count */
-  int n_keyframes;              /* number of keyframes (at least 2 for 0% and 100% */
-  double *keyframe_progress;    /* ordered array of n_keyframes of [0..1] */
-  int n_properties;             /* number of properties used by keyframes */
-  guint *property_ids;          /* ordered array of n_properties property ids */
-  GtkCssValue **values;         /* 2D array: n_keyframes * n_properties of (value or NULL) for all the keyframes */
+  int ref_count;                 /* ref count */
+  int n_keyframes;               /* number of keyframes (at least 2 for 0% and 100% */
+  double *keyframe_progress;     /* ordered array of n_keyframes of [0..1] */
+  int n_properties;              /* number of properties used by keyframes */
+  guint *property_ids;           /* ordered array of n_properties property ids */
+  GtkCssValue **values;          /* 2D array: n_keyframes * n_properties of (value or NULL) for all the keyframes */
+  GtkCssVariableSet **variables; /* array of variable sets for each keyframe */
+  int *variable_ids;             /* ordered array of variable ids */
+  int n_variables;               /* number of variable used by keyframes */
 };
 
 #define KEYFRAMES_VALUE(keyframes, k, p) ((keyframes)->values[(k) * (keyframes)->n_properties + (p)])
@@ -72,8 +77,13 @@ _gtk_css_keyframes_unref (GtkCssKeyframes *keyframes)
           _gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
           KEYFRAMES_VALUE (keyframes, k, p) = NULL;
         }
+
+      if (keyframes->variables && keyframes->variables[k])
+        gtk_css_variable_set_unref (keyframes->variables[k]);
     }
   g_free (keyframes->values);
+  g_free (keyframes->variables);
+  g_free (keyframes->variable_ids);
 
   g_free (keyframes);
 }
@@ -120,6 +130,9 @@ gtk_css_keyframes_add_keyframe (GtkCssKeyframes *keyframes,
       memset (&KEYFRAMES_VALUE (keyframes, k, 0), 0, size);
     }
 
+  if (keyframes->variables)
+    keyframes->variables = g_realloc (keyframes->variables, sizeof (GtkCssVariableSet *) * keyframes->n_keyframes);
+
   return k;
 }
 
@@ -173,6 +186,26 @@ gtk_css_keyframes_lookup_property (GtkCssKeyframes *keyframes,
   return p;
 }
 
+static void
+gtk_css_keyframes_register_variable (GtkCssKeyframes *keyframes,
+                                     int              variable_id)
+{
+  guint p;
+
+  for (p = 0; p < keyframes->n_variables; p++)
+    {
+      if (keyframes->variable_ids[p] == variable_id)
+        return;
+      else if (keyframes->variable_ids[p] > variable_id)
+        break;
+    }
+
+  keyframes->n_variables++;
+  keyframes->variable_ids = g_realloc (keyframes->variable_ids, sizeof (int) * keyframes->n_variables);
+  memmove (keyframes->variable_ids + p + 1, keyframes->variable_ids + p, sizeof (int) * (keyframes->n_variables - p - 1));
+  keyframes->variable_ids[p] = variable_id;
+}
+
 static GtkCssKeyframes *
 gtk_css_keyframes_alloc (void)
 {
@@ -235,6 +268,47 @@ gtk_css_keyframes_parse_declaration (GtkCssKeyframes *keyframes,
       return FALSE;
     }
 
+  /* This is a custom property */
+  if (name[0] == '-' && name[1] == '-')
+    {
+      GtkCssVariableValue *var_value;
+      GtkCssCustomPropertyPool *pool;
+      int id;
+
+      if (!gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_COLON))
+        {
+          gtk_css_parser_error_syntax (parser, "Expected a ':'");
+          g_free (name);
+          return FALSE;
+        }
+
+      var_value = gtk_css_parser_parse_value_into_token_stream (parser);
+      if (var_value == NULL)
+        {
+          g_free (name);
+          return FALSE;
+        }
+
+      if (!keyframes->variables)
+        keyframes->variables = g_new0 (GtkCssVariableSet *, keyframes->n_keyframes);
+
+      if (!keyframes->variables[k])
+        keyframes->variables[k] = gtk_css_variable_set_new ();
+
+      pool = gtk_css_custom_property_pool_get ();
+      id = gtk_css_custom_property_pool_add (pool, name);
+      gtk_css_keyframes_register_variable (keyframes, id);
+
+      gtk_css_variable_value_taint (var_value);
+
+      gtk_css_variable_set_add (keyframes->variables[k], id, var_value);
+
+      gtk_css_custom_property_pool_unref (pool, id);
+
+      g_free (name);
+      return TRUE;
+    }
+
   property = _gtk_style_property_lookup (name);
   if (property == NULL)
     {
@@ -251,9 +325,53 @@ gtk_css_keyframes_parse_declaration (GtkCssKeyframes *keyframes,
       return FALSE;
     }
 
-  value = _gtk_style_property_parse_value (property, parser);
-  if (value == NULL)
-    return FALSE;
+  if (gtk_css_parser_has_references (parser))
+    {
+      GtkCssVariableValue *var_value;
+
+      var_value = gtk_css_parser_parse_value_into_token_stream (parser);
+      if (var_value == NULL)
+        return FALSE;
+
+      if (GTK_IS_CSS_SHORTHAND_PROPERTY (property))
+        {
+          GtkCssShorthandProperty *shorthand = GTK_CSS_SHORTHAND_PROPERTY (property);
+          guint i, n;
+          GtkCssValue **values;
+
+          n = _gtk_css_shorthand_property_get_n_subproperties (shorthand);
+
+          values = g_new (GtkCssValue *, n);
+
+          for (i = 0; i < n; i++)
+            {
+              GtkCssValue *child =
+                _gtk_css_reference_value_new (property,
+                                              var_value,
+                                              gtk_css_parser_get_file (parser));
+              _gtk_css_reference_value_set_subproperty (child, i);
+
+              values[i] = _gtk_css_array_value_get_nth (child, i);
+            }
+
+          value = _gtk_css_array_value_new_from_array (values, n);
+          g_free (values);
+        }
+      else
+        {
+          value = _gtk_css_reference_value_new (property,
+                                                var_value,
+                                                gtk_css_parser_get_file (parser));
+        }
+
+      gtk_css_variable_value_unref (var_value);
+    }
+  else
+    {
+      value = _gtk_style_property_parse_value (property, parser);
+      if (value == NULL)
+        return FALSE;
+    }
 
   if (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
     {
@@ -314,6 +432,9 @@ gtk_css_keyframes_parse_block (GtkCssKeyframes *keyframes,
       gtk_css_parser_end_block (parser);
     }
 
+  if (keyframes->variables && keyframes->variables[k])
+    gtk_css_variable_set_resolve_cycles (keyframes->variables[k]);
+
   gtk_css_parser_end_block (parser);
 
   return TRUE;
@@ -378,12 +499,27 @@ compare_property_by_name (gconstpointer a,
                     _gtk_css_style_property_lookup_by_id (keyframes->property_ids[*(const guint *) b]))));
 }
 
+static int
+compare_custom_property_ids (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+  GtkCssCustomPropertyPool *pool = user_data;
+  int id1 = GPOINTER_TO_INT (*((const int *) a));
+  int id2 = GPOINTER_TO_INT (*((const int *) b));
+  const char *name1, *name2;
+
+  name1 = gtk_css_custom_property_pool_get_name (pool, id1);
+  name2 = gtk_css_custom_property_pool_get_name (pool, id2);
+
+  return strcmp (name1, name2);
+}
+
 void
 _gtk_css_keyframes_print (GtkCssKeyframes *keyframes,
                           GString         *string)
 {
+  GtkCssCustomPropertyPool *pool = gtk_css_custom_property_pool_get ();
   guint k, p;
-  guint *sorted;
+  guint *sorted, *sorted_variable_ids = NULL;
 
   g_return_if_fail (keyframes != NULL);
   g_return_if_fail (string != NULL);
@@ -393,6 +529,18 @@ _gtk_css_keyframes_print (GtkCssKeyframes *keyframes,
     sorted[p] = p;
   g_qsort_with_data (sorted, keyframes->n_properties, sizeof (guint), compare_property_by_name, keyframes);
 
+  if (keyframes->variable_ids)
+    {
+      sorted_variable_ids = g_memdup2 (keyframes->variable_ids,
+                                       sizeof (int) * keyframes->n_variables);
+
+      g_qsort_with_data (sorted_variable_ids,
+                         keyframes->n_variables,
+                         sizeof (int),
+                         compare_custom_property_ids,
+                         pool);
+    }
+
   for (k = 0; k < keyframes->n_keyframes; k++)
     {
       /* useful for 0% and 100% which might be empty */
@@ -422,11 +570,43 @@ _gtk_css_keyframes_print (GtkCssKeyframes *keyframes,
           g_string_append (string, ";\n");
         }
 
+      if (keyframes->variables && keyframes->variables[k])
+        {
+          for (p = 0; p < keyframes->n_variables; p++)
+            {
+              int variable_id = sorted_variable_ids[p];
+              GtkCssVariableValue *value =
+                gtk_css_variable_set_lookup (keyframes->variables[k], variable_id, NULL);
+              const char *name;
+
+              if (value == NULL)
+                continue;
+
+              if (!opened)
+                {
+                  if (keyframes->keyframe_progress[k] == 0.0)
+                    g_string_append (string, "  from {\n");
+                  else if (keyframes->keyframe_progress[k] == 1.0)
+                    g_string_append (string, "  to {\n");
+                  else
+                    g_string_append_printf (string, "  %g%% {\n", keyframes->keyframe_progress[k] * 100);
+                  opened = TRUE;
+                }
+
+              name = gtk_css_custom_property_pool_get_name (pool, variable_id);
+
+              g_string_append_printf (string, "    %s: ", name);
+              gtk_css_variable_value_print (value, string);
+              g_string_append (string, ";\n");
+            }
+        }
+
       if (opened)
         g_string_append (string, "  }\n");
     }
 
   g_free (sorted);
+  g_free (sorted_variable_ids);
 }
 
 GtkCssKeyframes *
@@ -461,10 +641,27 @@ _gtk_css_keyframes_compute (GtkCssKeyframes  *keyframes,
                                                                       resolved->property_ids[p],
                                                                       provider,
                                                                       style,
-                                                                      parent_style);
+                                                                      parent_style,
+                                                                      keyframes->variables ? keyframes->variables[k] : NULL);
         }
     }
 
+  if (keyframes->variables)
+    {
+      resolved->variables = g_new0 (GtkCssVariableSet *, resolved->n_keyframes);
+
+      for (k = 0; k < resolved->n_keyframes; k++)
+        {
+          if (keyframes->variables[k])
+            resolved->variables[k] = gtk_css_variable_set_ref (keyframes->variables[k]);
+        }
+    }
+  else
+    resolved->variables = NULL;
+
+  resolved->variable_ids = g_memdup2 (keyframes->variable_ids, keyframes->n_variables * sizeof (int));
+  resolved->n_variables = keyframes->n_variables;
+
   return resolved;
 }
 
@@ -540,3 +737,83 @@ _gtk_css_keyframes_get_value (GtkCssKeyframes *keyframes,
   return result;
 }
 
+guint
+_gtk_css_keyframes_get_n_variables (GtkCssKeyframes *keyframes)
+{
+  g_return_val_if_fail (keyframes != NULL, 0);
+
+  return keyframes->n_variables;
+}
+
+int
+_gtk_css_keyframes_get_variable_id (GtkCssKeyframes *keyframes,
+                                    guint            id)
+{
+  g_return_val_if_fail (keyframes != NULL, 0);
+  g_return_val_if_fail (id < keyframes->n_variables, 0);
+
+  return keyframes->variable_ids[id];
+}
+
+GtkCssVariableValue *
+_gtk_css_keyframes_get_variable (GtkCssKeyframes     *keyframes,
+                                 guint                id,
+                                 double               progress,
+                                 GtkCssVariableValue *default_value)
+{
+  GtkCssVariableValue *start_value, *end_value, *result;
+  double start_progress, end_progress;
+  int variable_id;
+  guint k;
+
+  g_return_val_if_fail (keyframes != NULL, 0);
+  g_return_val_if_fail (id < keyframes->n_variables, 0);
+
+  start_value = default_value;
+  start_progress = 0.0;
+  end_value = default_value;
+  end_progress = 1.0;
+
+  variable_id = keyframes->variable_ids[id];
+
+  for (k = 0; k < keyframes->n_keyframes; k++)
+    {
+      GtkCssVariableValue *value;
+
+      if (keyframes->variables[k] == NULL)
+        continue;
+
+      value = gtk_css_variable_set_lookup (keyframes->variables[k], variable_id, NULL);
+
+      if (value == NULL)
+        continue;
+
+      if (keyframes->keyframe_progress[k] == progress)
+        {
+          return gtk_css_variable_value_ref (value);
+        }
+      else if (keyframes->keyframe_progress[k] < progress)
+        {
+          start_value = value;
+          start_progress = keyframes->keyframe_progress[k];
+        }
+      else
+        {
+          end_value = value;
+          end_progress = keyframes->keyframe_progress[k];
+          break;
+        }
+    }
+
+  progress = (progress - start_progress) / (end_progress - start_progress);
+
+  result = gtk_css_variable_value_transition (start_value,
+                                              end_value,
+                                              progress);
+
+  /* XXX: Dear spec, what's the correct thing to do here? */
+  if (result == NULL)
+    return start_value ? gtk_css_variable_value_ref (start_value) : NULL;
+
+  return result;
+}

gtk/gtkcsskeyframesprivate.h

@@ -50,5 +50,13 @@ GtkCssValue *       _gtk_css_keyframes_get_value              (GtkCssKeyframes
                                                                double                  progress,
                                                                GtkCssValue            *default_value);
 
+guint               _gtk_css_keyframes_get_n_variables        (GtkCssKeyframes        *keyframes);
+int                 _gtk_css_keyframes_get_variable_id        (GtkCssKeyframes        *keyframes,
+                                                               guint                   id);
+GtkCssVariableValue *_gtk_css_keyframes_get_variable          (GtkCssKeyframes        *keyframes,
+                                                               guint                   id,
+                                                               double                  progress,
+                                                               GtkCssVariableValue    *default_value);
+
 G_END_DECLS
 

gtk/gtkcsslineheightvalue.c

@@ -39,15 +39,16 @@ gtk_css_value_line_height_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_line_height_compute (GtkCssValue      *value,
-                                   guint             property_id,
-                                   GtkStyleProvider *provider,
-                                   GtkCssStyle      *style,
-                                   GtkCssStyle      *parent_style)
+gtk_css_value_line_height_compute (GtkCssValue       *value,
+                                   guint              property_id,
+                                   GtkStyleProvider  *provider,
+                                   GtkCssStyle       *style,
+                                   GtkCssStyle       *parent_style,
+                                   GtkCssVariableSet *variables)
 {
   GtkCssValue *height;
 
-  height = _gtk_css_value_compute (value->height, property_id, provider, style, parent_style);
+  height = _gtk_css_value_compute (value->height, property_id, provider, style, parent_style, variables);
 
   if (gtk_css_number_value_get_dimension (height) == GTK_CSS_DIMENSION_PERCENTAGE)
     {

gtk/gtkcsslookup.c

@@ -19,6 +19,7 @@
 
 #include "gtkcsslookupprivate.h"
 
+#include "gtkcsscustompropertypoolprivate.h"
 #include "gtkcssstylepropertyprivate.h"
 #include "gtkcsstypesprivate.h"
 #include "gtkprivatetypebuiltins.h"
@@ -36,6 +37,9 @@ void
 _gtk_css_lookup_destroy (GtkCssLookup *lookup)
 {
   _gtk_bitmask_free (lookup->set_values);
+
+  if (lookup->custom_values)
+    g_hash_table_unref (lookup->custom_values);
 }
 
 gboolean
@@ -74,3 +78,17 @@ _gtk_css_lookup_set (GtkCssLookup  *lookup,
   lookup->values[id].section = section;
   lookup->set_values = _gtk_bitmask_set (lookup->set_values, id, TRUE);
 }
+
+void
+_gtk_css_lookup_set_custom (GtkCssLookup        *lookup,
+                            int                  id,
+                            GtkCssVariableValue *value)
+{
+  gtk_internal_return_if_fail (lookup != NULL);
+
+  if (!lookup->custom_values)
+    lookup->custom_values = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+  if (!g_hash_table_contains (lookup->custom_values, GINT_TO_POINTER (id)))
+    g_hash_table_replace (lookup->custom_values, GINT_TO_POINTER (id), value);
+}

gtk/gtkcsslookupprivate.h

@@ -23,6 +23,8 @@
 #include "gtk/gtkcssstaticstyleprivate.h"
 
 #include "gtk/css/gtkcsssection.h"
+#include "gtk/css/gtkcsstokenizerprivate.h"
+#include "gtk/css/gtkcssvariablevalueprivate.h"
 
 
 G_BEGIN_DECLS
@@ -37,6 +39,7 @@ typedef struct {
 struct _GtkCssLookup {
   GtkBitmask *set_values;
   GtkCssLookupValue  values[GTK_CSS_PROPERTY_N_PROPERTIES];
+  GHashTable *custom_values;
 };
 
 void                    _gtk_css_lookup_init                    (GtkCssLookup               *lookup);
@@ -47,6 +50,9 @@ void                    _gtk_css_lookup_set                     (GtkCssLookup
                                                                  guint                       id,
                                                                  GtkCssSection              *section,
                                                                  GtkCssValue                *value);
+void                    _gtk_css_lookup_set_custom              (GtkCssLookup               *lookup,
+                                                                 int                         id,
+                                                                 GtkCssVariableValue        *value);
 
 static inline const GtkBitmask *
 _gtk_css_lookup_get_set_values (const GtkCssLookup *lookup)

gtk/gtkcssnode.c

@@ -445,9 +445,12 @@ gtk_css_node_real_update_style (GtkCssNode                   *cssnode,
     }
   else if (static_style != style && (change & GTK_CSS_CHANGE_TIMESTAMP))
     {
+      GtkCssNode *parent = gtk_css_node_get_parent (cssnode);
       new_style = gtk_css_animated_style_new_advance (GTK_CSS_ANIMATED_STYLE (style),
                                                       static_style,
-                                                      timestamp);
+                                                      parent ? gtk_css_node_get_style (parent) : NULL,
+                                                      timestamp,
+                                                      gtk_css_node_get_style_provider (cssnode));
     }
   else
     {

gtk/gtkcssnumbervalue.c

@@ -108,11 +108,12 @@ get_base_font_size_px (guint             property_id,
 }
 
 static GtkCssValue *
-gtk_css_value_number_compute (GtkCssValue      *number,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_number_compute (GtkCssValue       *number,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   double value;
 
@@ -130,7 +131,8 @@ gtk_css_value_number_compute (GtkCssValue      *number,
         {
           GtkCssValue *computed = _gtk_css_value_compute (number->calc.terms[i],
                                                           property_id, provider, style,
-                                                          parent_style);
+                                                          parent_style,
+                                                          variables);
           changed |= computed != number->calc.terms[i];
           new_values[i] = computed;
         }
@@ -366,38 +368,38 @@ gtk_css_dimension_value_new (double     value,
                              GtkCssUnit unit)
 {
   static GtkCssValue number_singletons[] = {
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 0 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 1 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 96 }} }, /* DPI default */
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 0 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 1 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_NUMBER, 96 }} }, /* DPI default */
   };
   static GtkCssValue px_singletons[] = {
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 0 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 1 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 2 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 3 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 4 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 5 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 6 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 7 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 8 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 16 }} }, /* Icon size default */
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 32 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_PX, 64 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 0 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 1 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 2 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 3 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 4 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 5 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 6 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 7 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 8 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 16 }} }, /* Icon size default */
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 32 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PX, 64 }} },
   };
   static GtkCssValue percent_singletons[] = {
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE,  TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 0 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 50 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 100 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE,  FALSE, TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 0 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, FALSE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 50 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, FALSE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_PERCENT, 100 }} },
   };
   static GtkCssValue second_singletons[] = {
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_S, 0 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_S, 1 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_S, 0 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_S, 1 }} },
   };
   static GtkCssValue deg_singletons[] = {
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 0 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 90 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 180 }} },
-    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 270 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 0 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 90 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 180 }} },
+    { &GTK_CSS_VALUE_NUMBER, 1, TRUE, FALSE, TYPE_DIMENSION, {{ GTK_CSS_DEG, 270 }} },
   };
   GtkCssValue *result;
 

gtk/gtkcsspalettevalue.c

@@ -103,11 +103,12 @@ gtk_css_value_palette_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_palette_compute (GtkCssValue      *specified,
-                               guint             property_id,
-                               GtkStyleProvider *provider,
-                               GtkCssStyle      *style,
-                               GtkCssStyle      *parent_style)
+gtk_css_value_palette_compute (GtkCssValue       *specified,
+                               guint              property_id,
+                               GtkStyleProvider  *provider,
+                               GtkCssStyle       *style,
+                               GtkCssStyle       *parent_style,
+                               GtkCssVariableSet *variables)
 {
   GtkCssValue *computed_color;
   GtkCssValue *result;
@@ -120,7 +121,7 @@ gtk_css_value_palette_compute (GtkCssValue      *specified,
     {
       GtkCssValue *value = specified->color_values[i];
 
-      computed_color = _gtk_css_value_compute (value, property_id, provider, style, parent_style);
+      computed_color = _gtk_css_value_compute (value, property_id, provider, style, parent_style, variables);
       result->color_names[i] = g_strdup (specified->color_names[i]);
       result->color_values[i] = computed_color;
 

gtk/gtkcsspositionvalue.c

@@ -36,16 +36,17 @@ gtk_css_value_position_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_position_compute (GtkCssValue      *position,
-                                guint             property_id,
-                                GtkStyleProvider *provider,
-                                GtkCssStyle      *style,
-                                GtkCssStyle      *parent_style)
+gtk_css_value_position_compute (GtkCssValue       *position,
+                                guint              property_id,
+                                GtkStyleProvider  *provider,
+                                GtkCssStyle       *style,
+                                GtkCssStyle       *parent_style,
+                                GtkCssVariableSet *variables)
 {
   GtkCssValue *x, *y;
 
-  x = _gtk_css_value_compute (position->x, property_id, provider, style, parent_style);
-  y = _gtk_css_value_compute (position->y, property_id, provider, style, parent_style);
+  x = _gtk_css_value_compute (position->x, property_id, provider, style, parent_style, variables);
+  y = _gtk_css_value_compute (position->y, property_id, provider, style, parent_style, variables);
   if (x == position->x && y == position->y)
     {
       _gtk_css_value_unref (x);

gtk/gtkcssprovider.c

@@ -22,10 +22,13 @@
 #include <gtk/css/gtkcss.h>
 #include "gtk/css/gtkcsstokenizerprivate.h"
 #include "gtk/css/gtkcssparserprivate.h"
+#include "gtk/css/gtkcssvariablevalueprivate.h"
 #include "gtkbitmaskprivate.h"
 #include "gtkcssarrayvalueprivate.h"
 #include "gtkcsscolorvalueprivate.h"
+#include "gtkcsscustompropertypoolprivate.h"
 #include "gtkcsskeyframesprivate.h"
+#include "gtkcssreferencevalueprivate.h"
 #include "gtkcssselectorprivate.h"
 #include "gtkcssshorthandpropertyprivate.h"
 #include "gtksettingsprivate.h"
@@ -113,6 +116,7 @@ struct GtkCssRuleset
   PropertyValue *styles;
   guint n_styles;
   guint owns_styles : 1;
+  GHashTable *custom_properties;
 };
 
 struct _GtkCssScanner
@@ -270,6 +274,8 @@ gtk_css_ruleset_clear (GtkCssRuleset *ruleset)
 	    gtk_css_section_unref (ruleset->styles[i].section);
         }
       g_free (ruleset->styles);
+      if (ruleset->custom_properties)
+        g_hash_table_unref (ruleset->custom_properties);
     }
   if (ruleset->selector)
     _gtk_css_selector_free (ruleset->selector);
@@ -285,7 +291,7 @@ gtk_css_ruleset_add (GtkCssRuleset       *ruleset,
 {
   guint i;
 
-  g_return_if_fail (ruleset->owns_styles || ruleset->n_styles == 0);
+  g_return_if_fail (ruleset->owns_styles || (ruleset->n_styles == 0 && ruleset->custom_properties == NULL));
 
   ruleset->owns_styles = TRUE;
 
@@ -315,6 +321,39 @@ gtk_css_ruleset_add (GtkCssRuleset       *ruleset,
     ruleset->styles[i].section = NULL;
 }
 
+static void
+unref_custom_property_name (gpointer pointer)
+{
+  GtkCssCustomPropertyPool *pool = gtk_css_custom_property_pool_get ();
+
+  gtk_css_custom_property_pool_unref (pool, GPOINTER_TO_INT (pointer));
+}
+
+static void
+gtk_css_ruleset_add_custom (GtkCssRuleset       *ruleset,
+                            const char          *name,
+                            GtkCssVariableValue *value)
+{
+  GtkCssCustomPropertyPool *pool;
+  int id;
+
+  g_return_if_fail (ruleset->owns_styles || (ruleset->n_styles == 0 && ruleset->custom_properties == NULL));
+
+  ruleset->owns_styles = TRUE;
+
+  if (ruleset->custom_properties == NULL)
+    {
+      ruleset->custom_properties = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+                                                          unref_custom_property_name,
+                                                          (GDestroyNotify) gtk_css_variable_value_unref);
+    }
+
+  pool = gtk_css_custom_property_pool_get ();
+  id = gtk_css_custom_property_pool_add (pool, name);
+
+  g_hash_table_replace (ruleset->custom_properties, GINT_TO_POINTER (id), value);
+}
+
 static void
 gtk_css_scanner_destroy (GtkCssScanner *scanner)
 {
@@ -490,7 +529,7 @@ gtk_css_style_provider_lookup (GtkStyleProvider             *provider,
         {
           ruleset = gtk_css_selector_matches_get (&tree_rules, i);
 
-          if (ruleset->styles == NULL)
+          if (ruleset->styles == NULL && ruleset->custom_properties == NULL)
             continue;
 
           for (j = 0; j < ruleset->n_styles; j++)
@@ -506,6 +545,18 @@ gtk_css_style_provider_lookup (GtkStyleProvider             *provider,
                                    ruleset->styles[j].section,
                                    ruleset->styles[j].value);
             }
+
+          if (ruleset->custom_properties)
+            {
+              GHashTableIter iter;
+              gpointer id;
+              GtkCssVariableValue *value;
+
+              g_hash_table_iter_init (&iter, ruleset->custom_properties);
+
+              while (g_hash_table_iter_next (&iter, &id, (gpointer) &value))
+                _gtk_css_lookup_set_custom (lookup, GPOINTER_TO_INT (id), value);
+            }
         }
     }
   gtk_css_selector_matches_clear (&tree_rules);
@@ -572,7 +623,7 @@ css_provider_commit (GtkCssProvider  *css_provider,
   GtkCssProviderPrivate *priv = gtk_css_provider_get_instance_private (css_provider);
   guint i;
 
-  if (ruleset->styles == NULL)
+  if (ruleset->styles == NULL && ruleset->custom_properties == NULL)
     {
       for (i = 0; i < gtk_css_selectors_get_size (selectors); i++)
         _gtk_css_selector_free (gtk_css_selectors_get (selectors, i));
@@ -814,6 +865,42 @@ parse_declaration (GtkCssScanner *scanner,
   if (name == NULL)
     goto out;
 
+  /* This is a custom property */
+  if (name[0] == '-' && name[1] == '-')
+    {
+      GtkCssVariableValue *value;
+      GtkCssSection *section;
+
+      if (!gtk_css_parser_try_token (scanner->parser, GTK_CSS_TOKEN_COLON))
+        {
+          gtk_css_parser_error_syntax (scanner->parser, "Expected ':'");
+          goto out;
+        }
+
+      value = gtk_css_parser_parse_value_into_token_stream (scanner->parser);
+      if (value == NULL)
+        goto out;
+
+      if (gtk_keep_css_sections)
+        {
+          section = gtk_css_section_new (gtk_css_parser_get_file (scanner->parser),
+                                         gtk_css_parser_get_block_location (scanner->parser),
+                                         gtk_css_parser_get_end_location (scanner->parser));
+        }
+      else
+        section = NULL;
+
+      if (section != NULL)
+        {
+          gtk_css_variable_value_set_section (value, section);
+          gtk_css_section_unref (section);
+        }
+
+      gtk_css_ruleset_add_custom (ruleset, name, value);
+
+      goto out;
+    }
+
   property = _gtk_style_property_lookup (name);
 
   if (property)
@@ -827,15 +914,60 @@ parse_declaration (GtkCssScanner *scanner,
           goto out;
         }
 
-      value = _gtk_style_property_parse_value (property, scanner->parser);
-
-      if (value == NULL)
-        goto out;
-
-      if (!gtk_css_parser_has_token (scanner->parser, GTK_CSS_TOKEN_EOF))
+      if (gtk_css_parser_has_references (scanner->parser))
         {
-          gtk_css_parser_error_syntax (scanner->parser, "Junk at end of value for %s", property->name);
-          goto out;
+          GtkCssVariableValue *var_value;
+
+          var_value = gtk_css_parser_parse_value_into_token_stream (scanner->parser);
+          if (var_value == NULL)
+            goto out;
+
+          if (GTK_IS_CSS_SHORTHAND_PROPERTY (property))
+            {
+              GtkCssShorthandProperty *shorthand = GTK_CSS_SHORTHAND_PROPERTY (property);
+              guint i, n;
+              GtkCssValue **values;
+
+              n = _gtk_css_shorthand_property_get_n_subproperties (shorthand);
+
+              values = g_new (GtkCssValue *, n);
+
+              for (i = 0; i < n; i++)
+                {
+                  GtkCssValue *child =
+                    _gtk_css_reference_value_new (property,
+                                                  var_value,
+                                                  gtk_css_parser_get_file (scanner->parser));
+                  _gtk_css_reference_value_set_subproperty (child, i);
+
+                  values[i] = _gtk_css_array_value_get_nth (child, i);
+                }
+
+              value = _gtk_css_array_value_new_from_array (values, n);
+              g_free (values);
+            }
+          else
+            {
+              value = _gtk_css_reference_value_new (property,
+                                                    var_value,
+                                                    gtk_css_parser_get_file (scanner->parser));
+            }
+
+          gtk_css_variable_value_unref (var_value);
+        }
+      else
+        {
+          value = _gtk_style_property_parse_value (property, scanner->parser);
+
+          if (value == NULL)
+            goto out;
+
+          if (!gtk_css_parser_has_token (scanner->parser, GTK_CSS_TOKEN_EOF))
+            {
+              gtk_css_parser_error_syntax (scanner->parser, "Junk at end of value for %s", property->name);
+              gtk_css_value_unref (value);
+              goto out;
+            }
         }
 
       if (gtk_keep_css_sections)
@@ -1112,7 +1244,7 @@ gtk_css_provider_load_from_data (GtkCssProvider  *css_provider,
   if (length < 0)
     length = strlen (data);
 
-  bytes = g_bytes_new_static (data, length);
+  bytes = g_bytes_new (data, length);
 
   gtk_css_provider_load_from_bytes (css_provider, bytes);
 
@@ -1139,7 +1271,7 @@ gtk_css_provider_load_from_string (GtkCssProvider *css_provider,
   g_return_if_fail (GTK_IS_CSS_PROVIDER (css_provider));
   g_return_if_fail (string != NULL);
 
-  bytes = g_bytes_new_static (string, strlen (string));
+  bytes = g_bytes_new (string, strlen (string));
 
   gtk_css_provider_load_from_bytes (css_provider, bytes);
 
@@ -1473,6 +1605,20 @@ compare_properties (gconstpointer a, gconstpointer b, gpointer style)
                  _gtk_style_property_get_name (GTK_STYLE_PROPERTY (styles[*ub].property)));
 }
 
+static int
+compare_custom_properties (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+  GtkCssCustomPropertyPool *pool = user_data;
+  int id1 = GPOINTER_TO_INT (*((const int *) a));
+  int id2 = GPOINTER_TO_INT (*((const int *) b));
+  const char *name1, *name2;
+
+  name1 = gtk_css_custom_property_pool_get_name (pool, id1);
+  name2 = gtk_css_custom_property_pool_get_name (pool, id2);
+
+  return strcmp (name1, name2);
+}
+
 static void
 gtk_css_ruleset_print (const GtkCssRuleset *ruleset,
                        GString             *str)
@@ -1506,6 +1652,31 @@ gtk_css_ruleset_print (const GtkCssRuleset *ruleset,
       g_free (sorted);
     }
 
+  if (ruleset->custom_properties)
+    {
+      GtkCssCustomPropertyPool *pool = gtk_css_custom_property_pool_get ();
+      GPtrArray *keys;
+
+      keys = g_hash_table_get_keys_as_ptr_array (ruleset->custom_properties);
+      g_ptr_array_sort_with_data (keys, compare_custom_properties, pool);
+
+      for (i = 0; i < keys->len; i++)
+        {
+          int id = GPOINTER_TO_INT (g_ptr_array_index (keys, i));
+          const char *name = gtk_css_custom_property_pool_get_name (pool, id);
+          GtkCssVariableValue *value = g_hash_table_lookup (ruleset->custom_properties,
+                                                            GINT_TO_POINTER (id));
+
+          g_string_append (str, "  ");
+          g_string_append (str, name);
+          g_string_append (str, ": ");
+          gtk_css_variable_value_print (value, str);
+          g_string_append (str, ";\n");
+        }
+
+      g_ptr_array_unref (keys);
+    }
+
   g_string_append (str, "}\n");
 }
 

gtk/gtkcssreferencevalue.c

@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gtkcssreferencevalueprivate.h"
+
+#include "gtkcssarrayvalueprivate.h"
+#include "gtkcsscustompropertypoolprivate.h"
+#include "gtkcssshorthandpropertyprivate.h"
+#include "gtkcssstyleprivate.h"
+#include "gtkcssunsetvalueprivate.h"
+#include "gtkcssvalueprivate.h"
+#include "gtkstyleproviderprivate.h"
+#include "gdk/gdkprofilerprivate.h"
+
+#define GDK_ARRAY_NAME gtk_css_refs
+#define GDK_ARRAY_TYPE_NAME GtkCssRefs
+#define GDK_ARRAY_ELEMENT_TYPE gpointer
+#define GDK_ARAY_PREALLOC 32
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+#define MAX_TOKEN_LENGTH 65536
+
+typedef enum {
+  RESOLVE_SUCCESS,
+  RESOLVE_INVALID,
+  RESOLVE_ANIMATION_TAINTED,
+} ResolveResult;
+
+struct _GtkCssValue {
+  GTK_CSS_VALUE_BASE
+
+  GtkStyleProperty *property;
+  GtkCssVariableValue *value;
+  GFile *file;
+  guint subproperty;
+};
+
+static void
+gtk_css_value_reference_free (GtkCssValue *value)
+{
+  gtk_css_variable_value_unref (value->value);
+  if (value->file)
+    g_object_unref (value->file);
+}
+
+static ResolveResult
+resolve_references_do (GtkCssVariableValue *value,
+                       guint                property_id,
+                       GtkCssVariableSet   *style_variables,
+                       GtkCssVariableSet   *keyframes_variables,
+                       gboolean             root,
+                       GtkCssRefs          *refs,
+                       gsize               *out_length,
+                       gsize               *out_n_refs)
+{
+  GtkCssCustomPropertyPool *pool = gtk_css_custom_property_pool_get ();
+  gsize i;
+  gsize length = value->length;
+  gsize n_refs = 0;
+  ResolveResult ret = RESOLVE_SUCCESS;
+
+  if (value->is_animation_tainted)
+    {
+      GtkCssStyleProperty *prop = _gtk_css_style_property_lookup_by_id (property_id);
+
+      if (!_gtk_css_style_property_is_animated (prop))
+        {
+          /* Animation-tainted variables make other variables that reference
+           * them animation-tainted too, so unlike regular invalid variables it
+           * propagates to the root. For example, if --test is animation-tainted,
+           * --test2: var(--test, fallback1); prop: var(--test2, fallback2); will\
+           * resolve to fallback2 and _not_ to fallback1. So we'll propagate it
+           * up until the root, and treat it same as invalid there instead. */
+          ret = RESOLVE_ANIMATION_TAINTED;
+          goto error;
+        }
+    }
+
+  if (value->is_invalid)
+    {
+      ret = RESOLVE_INVALID;
+      goto error;
+    }
+
+  if (!root)
+    {
+      n_refs += 1;
+      gtk_css_refs_append (refs, value);
+    }
+
+  for (i = 0; i < value->n_references; i++)
+    {
+      GtkCssVariableValueReference *ref = &value->references[i];
+      int id = gtk_css_custom_property_pool_lookup (pool, ref->name);
+      GtkCssVariableValue *var_value = NULL;
+      gsize var_length, var_refs;
+      GtkCssVariableSet *source = style_variables;
+      ResolveResult result = RESOLVE_INVALID;
+
+      if (keyframes_variables)
+        var_value = gtk_css_variable_set_lookup (keyframes_variables, id, NULL);
+
+      if (!var_value && style_variables)
+        var_value = gtk_css_variable_set_lookup (style_variables, id, &source);
+
+      if (var_value)
+        {
+          result = resolve_references_do (var_value, property_id, source,
+                                          keyframes_variables, FALSE,
+                                          refs, &var_length, &var_refs);
+
+          if (root && result == RESOLVE_ANIMATION_TAINTED)
+            result = RESOLVE_INVALID;
+        }
+
+      if (result == RESOLVE_INVALID)
+        {
+          if (ref->fallback)
+            {
+              result = resolve_references_do (ref->fallback, property_id,
+                                              style_variables, keyframes_variables,
+                                              FALSE, refs, &var_length, &var_refs);
+
+              if (root && result == RESOLVE_ANIMATION_TAINTED)
+                result = RESOLVE_INVALID;
+            }
+
+          if (result != RESOLVE_SUCCESS)
+            {
+              ret = result;
+              goto error;
+            }
+        }
+      else if (result == RESOLVE_ANIMATION_TAINTED)
+        {
+          ret = RESOLVE_ANIMATION_TAINTED;
+          goto error;
+        }
+
+      length += var_length - ref->length;
+      n_refs += var_refs;
+
+      if (length > MAX_TOKEN_LENGTH)
+        {
+          ret = RESOLVE_INVALID;
+          goto error;
+        }
+    }
+
+  if (out_length)
+    *out_length = length;
+
+  if (out_n_refs)
+    *out_n_refs = n_refs;
+
+  return ret;
+
+error:
+  /* Remove the references we added as if nothing happened */
+  gtk_css_refs_splice (refs, gtk_css_refs_get_size (refs) - n_refs, n_refs, TRUE, NULL, 0);
+
+  if (out_length)
+    *out_length = 0;
+
+  if (out_n_refs)
+    *out_n_refs = 0;
+
+  return ret;
+}
+
+static void
+resolve_references (GtkCssVariableValue *input,
+                    guint                property_id,
+                    GtkCssStyle         *style,
+                    GtkCssVariableSet   *keyframes_variables,
+                    GtkCssRefs          *refs)
+{
+  if (resolve_references_do (input, property_id, style->variables,
+                             keyframes_variables, TRUE, refs,
+                             NULL, NULL) != RESOLVE_SUCCESS)
+    gtk_css_refs_clear (refs);
+}
+
+static void
+parser_error (GtkCssParser         *parser,
+              const GtkCssLocation *start,
+              const GtkCssLocation *end,
+              const GError         *error,
+              gpointer              user_data)
+{
+  GtkStyleProvider *provider = user_data;
+  GtkCssSection *section;
+
+  section = gtk_css_section_new (gtk_css_parser_get_file (parser),
+                                 start,
+                                 end);
+
+  gtk_style_provider_emit_error (provider, section, (GError *) error);
+
+  gtk_css_section_unref (section);
+}
+
+static GtkCssValue *
+gtk_css_value_reference_compute (GtkCssValue       *value,
+                                 guint              property_id,
+                                 GtkStyleProvider  *provider,
+                                 GtkCssStyle       *style,
+                                 GtkCssStyle       *parent_style,
+                                 GtkCssVariableSet *variables)
+{
+  GtkCssValue *result = NULL, *computed;
+  GtkCssRefs refs;
+  gint64 start;
+
+  start = GDK_PROFILER_CURRENT_TIME;
+
+  gtk_css_refs_init (&refs);
+
+  resolve_references (value->value, property_id, style, variables, &refs);
+
+  gdk_profiler_end_mark (start, "resolve refs", "");
+
+  if (gtk_css_refs_get_size (&refs) > 0)
+    {
+      start = GDK_PROFILER_CURRENT_TIME;
+
+      GtkCssParser *value_parser =
+        gtk_css_parser_new_for_token_stream (value->value,
+                                             value->file,
+                                             (GtkCssVariableValue **) refs.start,
+                                             gtk_css_refs_get_size (&refs),
+                                             parser_error, provider, NULL);
+
+      result = _gtk_style_property_parse_value (value->property, value_parser);
+      gtk_css_parser_unref (value_parser);
+
+      gdk_profiler_end_mark (start, "reparse", "");
+    }
+
+  gtk_css_refs_clear (&refs);
+
+  if (result == NULL)
+    result = _gtk_css_unset_value_new ();
+
+  if (GTK_IS_CSS_SHORTHAND_PROPERTY (value->property))
+    {
+      GtkCssValue *sub = gtk_css_value_ref (_gtk_css_array_value_get_nth (result, value->subproperty));
+      gtk_css_value_unref (result);
+      result = sub;
+    }
+
+  computed = _gtk_css_value_compute (result,
+                                     property_id,
+                                     provider,
+                                     style,
+                                     parent_style,
+                                     variables);
+
+  gtk_css_value_unref (result);
+
+  return computed;
+}
+
+static gboolean
+gtk_css_value_reference_equal (const GtkCssValue *value1,
+                               const GtkCssValue *value2)
+{
+  return FALSE;
+}
+
+static GtkCssValue *
+gtk_css_value_reference_transition (GtkCssValue *start,
+                                    GtkCssValue *end,
+                                    guint        property_id,
+                                    double       progress)
+{
+  return NULL;
+}
+
+static void
+gtk_css_value_reference_print (const GtkCssValue *value,
+                               GString           *string)
+{
+  gtk_css_variable_value_print (value->value, string);
+}
+
+static const GtkCssValueClass GTK_CSS_VALUE_REFERENCE = {
+  "GtkCssReferenceValue",
+  gtk_css_value_reference_free,
+  gtk_css_value_reference_compute,
+  gtk_css_value_reference_equal,
+  gtk_css_value_reference_transition,
+  NULL,
+  NULL,
+  gtk_css_value_reference_print
+};
+
+GtkCssValue *
+_gtk_css_reference_value_new (GtkStyleProperty    *property,
+                              GtkCssVariableValue *value,
+                              GFile               *file)
+{
+  GtkCssValue *result;
+
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_REFERENCE);
+  result->property = property;
+  result->value = gtk_css_variable_value_ref (value);
+  result->contains_variables = TRUE;
+
+  if (file)
+    result->file = g_object_ref (file);
+  else
+    result->file = NULL;
+
+  return result;
+}
+
+void
+_gtk_css_reference_value_set_subproperty (GtkCssValue *value,
+                                          guint        property)
+{
+  g_assert (GTK_IS_CSS_SHORTHAND_PROPERTY (value->property));
+
+  value->subproperty = property;
+}
+

gtk/gtkcssreferencevalueprivate.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 GNOME Foundation Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alice Mikhaylenko <alicem@gnome.org>
+ */
+
+#pragma once
+
+#include <gtk/css/gtkcss.h>
+#include "gtkcssvalueprivate.h"
+#include "gtkstylepropertyprivate.h"
+#include "css/gtkcssvariablevalueprivate.h"
+
+G_BEGIN_DECLS
+
+GtkCssValue *_gtk_css_reference_value_new             (GtkStyleProperty    *property,
+                                                       GtkCssVariableValue *value,
+                                                       GFile               *file);
+void         _gtk_css_reference_value_set_subproperty (GtkCssValue         *value,
+                                                       guint                property);
+
+G_END_DECLS

gtk/gtkcssrepeatvalue.c

@@ -34,11 +34,12 @@ gtk_css_value_repeat_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_repeat_compute (GtkCssValue      *value,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_repeat_compute (GtkCssValue       *value,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (value);
 }
@@ -140,28 +141,28 @@ static struct {
   GtkCssValue values[4];
 } background_repeat_values[4] = {
   { "no-repeat",
-  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_SPACE     }
+  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_NO_REPEAT },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_REPEAT    },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_ROUND     },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_SPACE     }
   } },
   { "repeat",
-  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_SPACE     }
+  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_NO_REPEAT },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_REPEAT    },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_ROUND     },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_SPACE     }
   } }, 
   { "round",
-  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_SPACE     }
+  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_REPEAT    },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_ROUND     },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_SPACE     }
   } }, 
   { "space",
-  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_SPACE     }
+  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_REPEAT    },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_ROUND     },
+    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_SPACE     }
   } }
 };
 
@@ -234,28 +235,28 @@ static struct {
   GtkCssValue values[4];
 } border_repeat_values[4] = {
   { "stretch",
-  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_SPACE   }
+  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_STRETCH },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_REPEAT  },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_ROUND   },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_SPACE   }
   } },
   { "repeat",
-  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_SPACE   }
+  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_STRETCH },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_REPEAT  },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_ROUND   },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_SPACE   }
   } }, 
   { "round",
-  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_SPACE   }
+  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_STRETCH },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_REPEAT  },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_ROUND   },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_SPACE   }
   } }, 
   { "space",
-  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_SPACE   }
+  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_STRETCH },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_REPEAT  },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_ROUND   },
+    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, TRUE, FALSE, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_SPACE   }
   } }
 };
 

gtk/gtkcssshadowvalue.c

@@ -113,11 +113,12 @@ gtk_css_value_shadow_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_shadow_compute (GtkCssValue      *value,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_shadow_compute (GtkCssValue       *value,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   guint i;
   ShadowValue *shadows;
@@ -128,11 +129,11 @@ gtk_css_value_shadow_compute (GtkCssValue      *value,
     {
       const ShadowValue *shadow = &value->shadows[i];
 
-      shadows[i].hoffset = _gtk_css_value_compute (shadow->hoffset, property_id, provider, style, parent_style);
-      shadows[i].voffset = _gtk_css_value_compute (shadow->voffset, property_id, provider, style, parent_style);
-      shadows[i].radius = _gtk_css_value_compute (shadow->radius, property_id, provider, style, parent_style);
-      shadows[i].spread = _gtk_css_value_compute (shadow->spread, property_id, provider, style, parent_style),
-      shadows[i].color = _gtk_css_value_compute (shadow->color, property_id, provider, style, parent_style);
+      shadows[i].hoffset = _gtk_css_value_compute (shadow->hoffset, property_id, provider, style, parent_style, variables);
+      shadows[i].voffset = _gtk_css_value_compute (shadow->voffset, property_id, provider, style, parent_style, variables);
+      shadows[i].radius = _gtk_css_value_compute (shadow->radius, property_id, provider, style, parent_style, variables);
+      shadows[i].spread = _gtk_css_value_compute (shadow->spread, property_id, provider, style, parent_style, variables),
+      shadows[i].color = _gtk_css_value_compute (shadow->color, property_id, provider, style, parent_style, variables);
       shadows[i].inset = shadow->inset;
     }
 

gtk/gtkcssstaticstyle.c

@@ -31,6 +31,7 @@
 #include "gtkcssstringvalueprivate.h"
 #include "gtkcssstylepropertyprivate.h"
 #include "gtkcsstransitionprivate.h"
+#include "gtkcssvaluesprivate.h"
 #include "gtkprivate.h"
 #include "gtksettings.h"
 #include "gtkstyleanimationprivate.h"
@@ -45,130 +46,6 @@ static void gtk_css_static_style_compute_value (GtkCssStaticStyle *style,
                                                 GtkCssValue       *specified,
                                                 GtkCssSection     *section);
 
-static const int core_props[] = {
-  GTK_CSS_PROPERTY_COLOR,
-  GTK_CSS_PROPERTY_DPI,
-  GTK_CSS_PROPERTY_FONT_SIZE,
-  GTK_CSS_PROPERTY_ICON_PALETTE
-};
-
-static const int background_props[] = {
-  GTK_CSS_PROPERTY_BACKGROUND_COLOR,
-  GTK_CSS_PROPERTY_BOX_SHADOW,
-  GTK_CSS_PROPERTY_BACKGROUND_CLIP,
-  GTK_CSS_PROPERTY_BACKGROUND_ORIGIN,
-  GTK_CSS_PROPERTY_BACKGROUND_SIZE,
-  GTK_CSS_PROPERTY_BACKGROUND_POSITION,
-  GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
-  GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
-  GTK_CSS_PROPERTY_BACKGROUND_BLEND_MODE
-};
-
-static const int border_props[] = {
-  GTK_CSS_PROPERTY_BORDER_TOP_STYLE,
-  GTK_CSS_PROPERTY_BORDER_TOP_WIDTH,
-  GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
-  GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH,
-  GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE,
-  GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
-  GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
-  GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH,
-  GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
-  GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
-  GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
-  GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
-  GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
-  GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
-  GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
-  GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
-  GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE,
-  GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT,
-  GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE,
-  GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH
-};
-
-static const int icon_props[] = {
-  GTK_CSS_PROPERTY_ICON_SIZE,
-  GTK_CSS_PROPERTY_ICON_SHADOW,
-  GTK_CSS_PROPERTY_ICON_STYLE,
-};
-
-static const int outline_props[] = {
-  GTK_CSS_PROPERTY_OUTLINE_STYLE,
-  GTK_CSS_PROPERTY_OUTLINE_WIDTH,
-  GTK_CSS_PROPERTY_OUTLINE_OFFSET,
-  GTK_CSS_PROPERTY_OUTLINE_COLOR,
-};
-
-static const int font_props[] = {
-  GTK_CSS_PROPERTY_FONT_FAMILY,
-  GTK_CSS_PROPERTY_FONT_STYLE,
-  GTK_CSS_PROPERTY_FONT_WEIGHT,
-  GTK_CSS_PROPERTY_FONT_STRETCH,
-  GTK_CSS_PROPERTY_LETTER_SPACING,
-  GTK_CSS_PROPERTY_TEXT_SHADOW,
-  GTK_CSS_PROPERTY_CARET_COLOR,
-  GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR,
-  GTK_CSS_PROPERTY_FONT_FEATURE_SETTINGS,
-  GTK_CSS_PROPERTY_FONT_VARIATION_SETTINGS,
-  GTK_CSS_PROPERTY_LINE_HEIGHT,
-};
-static const int font_variant_props[] = {
-  GTK_CSS_PROPERTY_TEXT_DECORATION_LINE,
-  GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR,
-  GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE,
-  GTK_CSS_PROPERTY_TEXT_TRANSFORM,
-  GTK_CSS_PROPERTY_FONT_KERNING,
-  GTK_CSS_PROPERTY_FONT_VARIANT_LIGATURES,
-  GTK_CSS_PROPERTY_FONT_VARIANT_POSITION,
-  GTK_CSS_PROPERTY_FONT_VARIANT_CAPS,
-  GTK_CSS_PROPERTY_FONT_VARIANT_NUMERIC,
-  GTK_CSS_PROPERTY_FONT_VARIANT_ALTERNATES,
-  GTK_CSS_PROPERTY_FONT_VARIANT_EAST_ASIAN,
-};
-
-static const int animation_props[] = {
-  GTK_CSS_PROPERTY_ANIMATION_NAME,
-  GTK_CSS_PROPERTY_ANIMATION_DURATION,
-  GTK_CSS_PROPERTY_ANIMATION_TIMING_FUNCTION,
-  GTK_CSS_PROPERTY_ANIMATION_ITERATION_COUNT,
-  GTK_CSS_PROPERTY_ANIMATION_DIRECTION,
-  GTK_CSS_PROPERTY_ANIMATION_PLAY_STATE,
-  GTK_CSS_PROPERTY_ANIMATION_DELAY,
-  GTK_CSS_PROPERTY_ANIMATION_FILL_MODE,
-};
-
-static const int transition_props[] = {
-  GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
-  GTK_CSS_PROPERTY_TRANSITION_DURATION,
-  GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
-  GTK_CSS_PROPERTY_TRANSITION_DELAY,
-};
-
-static const int size_props[] = {
-  GTK_CSS_PROPERTY_MARGIN_TOP,
-  GTK_CSS_PROPERTY_MARGIN_LEFT,
-  GTK_CSS_PROPERTY_MARGIN_BOTTOM,
-  GTK_CSS_PROPERTY_MARGIN_RIGHT,
-  GTK_CSS_PROPERTY_PADDING_TOP,
-  GTK_CSS_PROPERTY_PADDING_LEFT,
-  GTK_CSS_PROPERTY_PADDING_BOTTOM,
-  GTK_CSS_PROPERTY_PADDING_RIGHT,
-  GTK_CSS_PROPERTY_BORDER_SPACING,
-  GTK_CSS_PROPERTY_MIN_WIDTH,
-  GTK_CSS_PROPERTY_MIN_HEIGHT,
-};
-
-static const int other_props[] = {
-  GTK_CSS_PROPERTY_ICON_SOURCE,
-  GTK_CSS_PROPERTY_ICON_TRANSFORM,
-  GTK_CSS_PROPERTY_ICON_FILTER,
-  GTK_CSS_PROPERTY_TRANSFORM,
-  GTK_CSS_PROPERTY_TRANSFORM_ORIGIN,
-  GTK_CSS_PROPERTY_OPACITY,
-  GTK_CSS_PROPERTY_FILTER,
-};
-
 #define GET_VALUES(v) (GtkCssValue **)((guint8*)(v) + sizeof (GtkCssValues))
 
 #define DEFINE_VALUES(ENUM, TYPE, NAME) \
@@ -322,6 +199,12 @@ gtk_css_static_style_dispose (GObject *object)
       style->sections = NULL;
     }
 
+  if (style->original_values)
+    {
+      g_ptr_array_unref (style->original_values);
+      style->original_values = NULL;
+    }
+
   G_OBJECT_CLASS (gtk_css_static_style_parent_class)->dispose (object);
 }
 
@@ -331,6 +214,19 @@ gtk_css_static_style_get_static_style (GtkCssStyle *style)
   return (GtkCssStaticStyle *)style;
 }
 
+static GtkCssValue *
+gtk_css_static_style_get_original_value (GtkCssStyle *style,
+                                         guint        id)
+{
+  GtkCssStaticStyle *sstyle = GTK_CSS_STATIC_STYLE (style);
+
+  if (sstyle->original_values == NULL ||
+      id >= sstyle->original_values->len)
+    return NULL;
+
+  return g_ptr_array_index (sstyle->original_values, id);
+}
+
 static void
 gtk_css_static_style_class_init (GtkCssStaticStyleClass *klass)
 {
@@ -341,6 +237,7 @@ gtk_css_static_style_class_init (GtkCssStaticStyleClass *klass)
 
   style_class->get_section = gtk_css_static_style_get_section;
   style_class->get_static_style = gtk_css_static_style_get_static_style;
+  style_class->get_original_value = gtk_css_static_style_get_original_value;
 
   gtk_css_core_values_init ();
   gtk_css_background_values_init ();
@@ -369,6 +266,13 @@ maybe_unref_section (gpointer section)
     gtk_css_section_unref (section);
 }
 
+static void
+maybe_unref_value (gpointer value)
+{
+  if (value)
+    _gtk_css_value_unref (value);
+}
+
 static inline void
 gtk_css_take_value (GtkCssValue **variable,
                     GtkCssValue  *value)
@@ -382,6 +286,7 @@ static void
 gtk_css_static_style_set_value (GtkCssStaticStyle *sstyle,
                                 guint              id,
                                 GtkCssValue       *value,
+                                GtkCssValue       *original_value,
                                 GtkCssSection     *section)
 {
   GtkCssStyle *style = (GtkCssStyle *)sstyle;
@@ -684,6 +589,22 @@ gtk_css_static_style_set_value (GtkCssStaticStyle *sstyle,
         g_ptr_array_set_size (sstyle->sections, id + 1);
       g_ptr_array_index (sstyle->sections, id) = gtk_css_section_ref (section);
     }
+
+  if (sstyle->original_values && sstyle->original_values->len > id &&
+      g_ptr_array_index (sstyle->original_values, id))
+    {
+      _gtk_css_value_unref (g_ptr_array_index (sstyle->original_values, id));
+      g_ptr_array_index (sstyle->original_values, id) = NULL;
+    }
+
+  if (original_value)
+    {
+      if (sstyle->original_values == NULL)
+        sstyle->original_values = g_ptr_array_new_with_free_func (maybe_unref_value);
+      if (sstyle->original_values->len <= id)
+        g_ptr_array_set_size (sstyle->original_values, id + 1);
+      g_ptr_array_index (sstyle->original_values, id) = _gtk_css_value_ref (original_value);
+    }
 }
 
 static GtkCssStyle *default_style;
@@ -912,6 +833,32 @@ gtk_css_lookup_resolve (GtkCssLookup      *lookup,
   gtk_internal_return_if_fail (GTK_IS_CSS_STATIC_STYLE (style));
   gtk_internal_return_if_fail (parent_style == NULL || GTK_IS_CSS_STYLE (parent_style));
 
+  if (lookup->custom_values)
+    {
+      GHashTableIter iter;
+      gpointer id;
+      GtkCssVariableValue *value;
+
+      style->variables = gtk_css_variable_set_new ();
+
+      g_hash_table_iter_init (&iter, lookup->custom_values);
+
+      while (g_hash_table_iter_next (&iter, &id, (gpointer) &value))
+        gtk_css_variable_set_add (style->variables, GPOINTER_TO_INT (id), value);
+
+      gtk_css_variable_set_resolve_cycles (style->variables);
+
+      if (parent_style)
+        {
+          gtk_css_variable_set_set_parent (style->variables,
+                                           parent_style->variables);
+        }
+    }
+  else if (parent_style && parent_style->variables)
+    {
+      style->variables = gtk_css_variable_set_ref (parent_style->variables);
+    }
+
   if (_gtk_bitmask_is_empty (_gtk_css_lookup_get_set_values (lookup)))
     {
       style->background = (GtkCssBackgroundValues *)gtk_css_values_ref (gtk_css_background_initial_values);
@@ -1047,7 +994,7 @@ gtk_css_static_style_compute_value (GtkCssStaticStyle *style,
                                     GtkCssValue       *specified,
                                     GtkCssSection     *section)
 {
-  GtkCssValue *value;
+  GtkCssValue *value, *original_value;
   GtkBorderStyle border_style;
 
   gtk_internal_return_if_fail (id < GTK_CSS_PROPERTY_N_PROPERTIES);
@@ -1068,7 +1015,7 @@ gtk_css_static_style_compute_value (GtkCssStaticStyle *style,
         border_style = _gtk_css_border_style_value_get (gtk_css_style_get_value ((GtkCssStyle *)style, id - 1));
         if (border_style == GTK_BORDER_STYLE_NONE || border_style == GTK_BORDER_STYLE_HIDDEN)
           {
-            gtk_css_static_style_set_value (style, id, gtk_css_dimension_value_new (0, GTK_CSS_NUMBER), section);
+            gtk_css_static_style_set_value (style, id, gtk_css_dimension_value_new (0, GTK_CSS_NUMBER), NULL, section);
             return;
           }
         break;
@@ -1085,19 +1032,34 @@ gtk_css_static_style_compute_value (GtkCssStaticStyle *style,
    */
   if (specified)
     {
-      value = _gtk_css_value_compute (specified, id, provider, (GtkCssStyle *)style, parent_style);
+      value = _gtk_css_value_compute (specified, id, provider, (GtkCssStyle *)style, parent_style, NULL);
+
+      if (gtk_css_value_contains_variables (specified))
+        original_value = specified;
+      else
+        original_value = NULL;
     }
   else if (parent_style && _gtk_css_style_property_is_inherit (_gtk_css_style_property_lookup_by_id (id)))
     {
+      GtkCssValue *parent_original_value;
+
       /* Just take the style from the parent */
       value = _gtk_css_value_ref (gtk_css_style_get_value (parent_style, id));
+
+      parent_original_value = gtk_css_style_get_original_value (parent_style, id);
+
+      if (parent_original_value)
+        original_value = parent_original_value;
+      else
+        original_value = NULL;
     }
   else
     {
       value = _gtk_css_initial_value_new_compute (id, provider, (GtkCssStyle *)style, parent_style);
+      original_value = NULL;
     }
 
-  gtk_css_static_style_set_value (style, id, value, section);
+  gtk_css_static_style_set_value (style, id, value, original_value, section);
 }
 
 GtkCssChange
@@ -1107,3 +1069,15 @@ gtk_css_static_style_get_change (GtkCssStaticStyle *style)
 
   return style->change;
 }
+
+void
+gtk_css_custom_values_compute_changes_and_affects (GtkCssStyle    *style1,
+                                                   GtkCssStyle    *style2,
+                                                   GtkBitmask    **changes,
+                                                   GtkCssAffects  *affects)
+{
+  if (gtk_css_variable_set_equal (style1->variables, style2->variables))
+    return;
+
+  *changes = _gtk_bitmask_set (*changes, GTK_CSS_PROPERTY_CUSTOM, TRUE);
+}

gtk/gtkcssstaticstyleprivate.h

@@ -40,6 +40,7 @@ struct _GtkCssStaticStyle
   GtkCssStyle parent;
 
   GPtrArray             *sections;             /* sections the values are defined in */
+  GPtrArray             *original_values;
 
   GtkCssChange           change;               /* change as returned by value lookup */
 };

gtk/gtkcssstringvalue.c

@@ -35,11 +35,12 @@ gtk_css_value_string_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_string_compute (GtkCssValue      *value,
-                              guint             property_id,
-                              GtkStyleProvider *provider,
-                              GtkCssStyle      *style,
-                              GtkCssStyle      *parent_style)
+gtk_css_value_string_compute (GtkCssValue       *value,
+                              guint              property_id,
+                              GtkStyleProvider  *provider,
+                              GtkCssStyle       *style,
+                              GtkCssStyle       *parent_style,
+                              GtkCssVariableSet *variables)
 {
   return _gtk_css_value_ref (value);
 }
@@ -226,3 +227,4 @@ _gtk_css_ident_value_get (const GtkCssValue *value)
   return value->string;
 }
 
+

gtk/gtkcssstyle.c

@@ -24,11 +24,13 @@
 
 #include "gtkcssanimationprivate.h"
 #include "gtkcssarrayvalueprivate.h"
+#include "gtkcsscustompropertypoolprivate.h"
 #include "gtkcssenumvalueprivate.h"
 #include "gtkcssinheritvalueprivate.h"
 #include "gtkcssinitialvalueprivate.h"
 #include "gtkcssnumbervalueprivate.h"
 #include "gtkcsscolorvalueprivate.h"
+#include "gtkcsspalettevalueprivate.h"
 #include "gtkcssshorthandpropertyprivate.h"
 #include "gtkcssstringvalueprivate.h"
 #include "gtkcssfontvariationsvalueprivate.h"
@@ -73,6 +75,9 @@ gtk_css_style_finalize (GObject *object)
   gtk_css_values_unref ((GtkCssValues *)style->size);
   gtk_css_values_unref ((GtkCssValues *)style->other);
 
+  if (style->variables)
+    gtk_css_variable_set_unref (style->variables);
+
   G_OBJECT_CLASS (gtk_css_style_parent_class)->finalize (object);
 }
 
@@ -311,6 +316,15 @@ gtk_css_style_get_static_style (GtkCssStyle *style)
   return GTK_CSS_STYLE_GET_CLASS (style)->get_static_style (style);
 }
 
+GtkCssValue *
+gtk_css_style_get_original_value (GtkCssStyle *style,
+                                  guint        id)
+{
+  gtk_internal_return_val_if_fail (GTK_IS_CSS_STYLE (style), NULL);
+
+  return GTK_CSS_STYLE_GET_CLASS (style)->get_original_value (style, id);
+}
+
 /*
  * gtk_css_style_print:
  * @style: a `GtkCssStyle`
@@ -368,6 +382,43 @@ gtk_css_style_print (GtkCssStyle *style,
       retval = TRUE;
     }
 
+    if (style->variables)
+      {
+        GtkCssCustomPropertyPool *pool = gtk_css_custom_property_pool_get ();
+        GArray *ids = gtk_css_variable_set_list_ids (style->variables);
+
+        for (i = 0; i < ids->len; i++)
+          {
+            int id = g_array_index (ids, int, i);
+            const char *name = gtk_css_custom_property_pool_get_name (pool, id);
+            GtkCssVariableSet *source;
+            GtkCssVariableValue *value = gtk_css_variable_set_lookup (style->variables, id, &source);
+
+            if (!value)
+              continue;
+
+            if (source != style->variables && skip_initial)
+              continue;
+
+            g_string_append_printf (string, "%*s%s: ", indent, "", name);
+            gtk_css_variable_value_print (value, string);
+            g_string_append_c (string, ';');
+
+            if (value->section)
+              {
+                g_string_append (string, " /* ");
+                gtk_css_section_print (value->section, string);
+                g_string_append (string, " */");
+              }
+
+            g_string_append_c (string, '\n');
+          }
+
+        retval = TRUE;
+
+        g_array_unref (ids);
+      }
+
   return retval;
 }
 
@@ -750,6 +801,33 @@ gtk_css_style_get_pango_font (GtkCssStyle *style)
   return description;
 }
 
+void
+gtk_css_style_lookup_symbolic_colors (GtkCssStyle *style,
+                                      GdkRGBA      color_out[4])
+{
+  GtkCssValue *palette, *color;
+  const char *names[4] = {
+    [GTK_SYMBOLIC_COLOR_ERROR] = "error",
+    [GTK_SYMBOLIC_COLOR_WARNING] = "warning",
+    [GTK_SYMBOLIC_COLOR_SUCCESS] = "success"
+  };
+
+  color = style->core->color;
+  palette = style->core->icon_palette;
+  color_out[GTK_SYMBOLIC_COLOR_FOREGROUND] = *gtk_css_color_value_get_rgba (color);
+
+  for (gsize i = 1; i < 4; i++)
+    {
+      const GdkRGBA *lookup;
+
+      lookup = gtk_css_palette_value_get_color (palette, names[i]);
+      if (lookup)
+        color_out[i] = *lookup;
+      else
+        color_out[i] = color_out[GTK_SYMBOLIC_COLOR_FOREGROUND];
+    }
+}
+
 /* Refcounted value structs */
 
 static const int values_size[] = {
@@ -837,3 +915,22 @@ gtk_css_values_new (GtkCssValuesType type)
 
   return values;
 }
+
+GtkCssVariableValue *
+gtk_css_style_get_custom_property (GtkCssStyle *style,
+                                   int          id)
+{
+  if (style->variables)
+    return gtk_css_variable_set_lookup (style->variables, id, NULL);
+
+  return NULL;
+}
+
+GArray *
+gtk_css_style_list_custom_properties (GtkCssStyle *style)
+{
+  if (style->variables)
+    return gtk_css_variable_set_list_ids (style->variables);
+
+  return NULL;
+}

gtk/gtkcssstylechange.c

@@ -102,6 +102,12 @@ compute_change (GtkCssStyleChange *change)
                                                       change->new_style,
                                                       &change->changes,
                                                       &change->affects);
+
+  if (change->old_style->variables != change->new_style->variables)
+    gtk_css_custom_values_compute_changes_and_affects (change->old_style,
+                                                       change->new_style,
+                                                       &change->changes,
+                                                       &change->affects);
 }
 
 void

gtk/gtkcssstyleprivate.h

@@ -24,6 +24,8 @@
 
 #include "gtk/gtkbitmaskprivate.h"
 #include "gtk/gtkcssvalueprivate.h"
+#include "gtk/gtkcssvariablesetprivate.h"
+#include "gtk/css/gtkcssvariablevalueprivate.h"
 
 G_BEGIN_DECLS
 
@@ -232,6 +234,10 @@ struct _GtkCssStyle
   GtkCssTransitionValues  *transition;
   GtkCssSizeValues        *size;
   GtkCssOtherValues       *other;
+  GtkCssVariableSet       *variables;
+
+  GtkCssValue             *variable_values;
+  int                      n_variable_values;
 };
 
 struct _GtkCssStyleClass
@@ -246,6 +252,9 @@ struct _GtkCssStyleClass
   gboolean              (* is_static)                           (GtkCssStyle            *style);
 
   GtkCssStaticStyle *   (* get_static_style)                    (GtkCssStyle            *style);
+
+  GtkCssValue *         (* get_original_value)                  (GtkCssStyle            *style,
+                                                                 guint                   id);
 };
 
 GType                   gtk_css_style_get_type                  (void) G_GNUC_CONST;
@@ -257,6 +266,9 @@ GtkCssSection *         gtk_css_style_get_section               (GtkCssStyle
 gboolean                gtk_css_style_is_static                 (GtkCssStyle            *style) G_GNUC_PURE;
 GtkCssStaticStyle *     gtk_css_style_get_static_style          (GtkCssStyle            *style);
 
+GtkCssValue *           gtk_css_style_get_original_value        (GtkCssStyle            *style,
+                                                                 guint                   id) G_GNUC_PURE;
+
 char *                  gtk_css_style_to_string                 (GtkCssStyle            *style);
 gboolean                gtk_css_style_print                     (GtkCssStyle            *style,
                                                                  GString                *string,
@@ -268,6 +280,13 @@ char *                  gtk_css_style_compute_font_features     (GtkCssStyle
 PangoAttrList *         gtk_css_style_get_pango_attributes      (GtkCssStyle            *style);
 PangoFontDescription *  gtk_css_style_get_pango_font            (GtkCssStyle            *style);
 
+void                    gtk_css_style_lookup_symbolic_colors    (GtkCssStyle            *style,
+                                                                 GdkRGBA                 color_out[4]);
+
+GtkCssVariableValue *   gtk_css_style_get_custom_property       (GtkCssStyle            *style,
+                                                                 int                     id);
+GArray *                gtk_css_style_list_custom_properties    (GtkCssStyle            *style);
+
 GtkCssValues *gtk_css_values_new   (GtkCssValuesType  type);
 GtkCssValues *gtk_css_values_ref   (GtkCssValues     *values);
 void          gtk_css_values_unref (GtkCssValues     *values);
@@ -317,6 +336,10 @@ void gtk_css_other_values_compute_changes_and_affects (GtkCssStyle *style1,
                                                       GtkCssStyle *style2,
                                                       GtkBitmask    **changes,
                                                       GtkCssAffects *affects);
+void gtk_css_custom_values_compute_changes_and_affects (GtkCssStyle *style1,
+                                                      GtkCssStyle *style2,
+                                                      GtkBitmask    **changes,
+                                                      GtkCssAffects *affects);
 
 G_END_DECLS
 

gtk/gtkcsstransformvalue.c

@@ -273,12 +273,13 @@ gtk_css_value_transform_free (GtkCssValue *value)
 
 /* returns TRUE if dest == src */
 static gboolean
-gtk_css_transform_compute (GtkCssTransform  *dest,
-                           GtkCssTransform  *src,
-                           guint             property_id,
-                           GtkStyleProvider *provider,
-                           GtkCssStyle      *style,
-                           GtkCssStyle      *parent_style)
+gtk_css_transform_compute (GtkCssTransform   *dest,
+                           GtkCssTransform   *src,
+                           guint              property_id,
+                           GtkStyleProvider  *provider,
+                           GtkCssStyle       *style,
+                           GtkCssStyle       *parent_style,
+                           GtkCssVariableSet *variables)
 {
   dest->type = src->type;
 
@@ -288,41 +289,41 @@ gtk_css_transform_compute (GtkCssTransform  *dest,
       memcpy (dest, src, sizeof (GtkCssTransform));
       return TRUE;
     case GTK_CSS_TRANSFORM_TRANSLATE:
-      dest->translate.x = _gtk_css_value_compute (src->translate.x, property_id, provider, style, parent_style);
-      dest->translate.y = _gtk_css_value_compute (src->translate.y, property_id, provider, style, parent_style);
-      dest->translate.z = _gtk_css_value_compute (src->translate.z, property_id, provider, style, parent_style);
+      dest->translate.x = _gtk_css_value_compute (src->translate.x, property_id, provider, style, parent_style, variables);
+      dest->translate.y = _gtk_css_value_compute (src->translate.y, property_id, provider, style, parent_style, variables);
+      dest->translate.z = _gtk_css_value_compute (src->translate.z, property_id, provider, style, parent_style, variables);
       return dest->translate.x == src->translate.x
           && dest->translate.y == src->translate.y
           && dest->translate.z == src->translate.z;
     case GTK_CSS_TRANSFORM_ROTATE:
-      dest->rotate.x = _gtk_css_value_compute (src->rotate.x, property_id, provider, style, parent_style);
-      dest->rotate.y = _gtk_css_value_compute (src->rotate.y, property_id, provider, style, parent_style);
-      dest->rotate.z = _gtk_css_value_compute (src->rotate.z, property_id, provider, style, parent_style);
-      dest->rotate.angle = _gtk_css_value_compute (src->rotate.angle, property_id, provider, style, parent_style);
+      dest->rotate.x = _gtk_css_value_compute (src->rotate.x, property_id, provider, style, parent_style, variables);
+      dest->rotate.y = _gtk_css_value_compute (src->rotate.y, property_id, provider, style, parent_style, variables);
+      dest->rotate.z = _gtk_css_value_compute (src->rotate.z, property_id, provider, style, parent_style, variables);
+      dest->rotate.angle = _gtk_css_value_compute (src->rotate.angle, property_id, provider, style, parent_style, variables);
       return dest->rotate.x == src->rotate.x
           && dest->rotate.y == src->rotate.y
           && dest->rotate.z == src->rotate.z
           && dest->rotate.angle == src->rotate.angle;
     case GTK_CSS_TRANSFORM_SCALE:
-      dest->scale.x = _gtk_css_value_compute (src->scale.x, property_id, provider, style, parent_style);
-      dest->scale.y = _gtk_css_value_compute (src->scale.y, property_id, provider, style, parent_style);
-      dest->scale.z = _gtk_css_value_compute (src->scale.z, property_id, provider, style, parent_style);
+      dest->scale.x = _gtk_css_value_compute (src->scale.x, property_id, provider, style, parent_style, variables);
+      dest->scale.y = _gtk_css_value_compute (src->scale.y, property_id, provider, style, parent_style, variables);
+      dest->scale.z = _gtk_css_value_compute (src->scale.z, property_id, provider, style, parent_style, variables);
       return dest->scale.x == src->scale.x
           && dest->scale.y == src->scale.y
           && dest->scale.z == src->scale.z;
     case GTK_CSS_TRANSFORM_SKEW:
-      dest->skew.x = _gtk_css_value_compute (src->skew.x, property_id, provider, style, parent_style);
-      dest->skew.y = _gtk_css_value_compute (src->skew.y, property_id, provider, style, parent_style);
+      dest->skew.x = _gtk_css_value_compute (src->skew.x, property_id, provider, style, parent_style, variables);
+      dest->skew.y = _gtk_css_value_compute (src->skew.y, property_id, provider, style, parent_style, variables);
       return dest->skew.x == src->skew.x
           && dest->skew.y == src->skew.y;
     case GTK_CSS_TRANSFORM_SKEW_X:
-      dest->skew_x.skew = _gtk_css_value_compute (src->skew_x.skew, property_id, provider, style, parent_style);
+      dest->skew_x.skew = _gtk_css_value_compute (src->skew_x.skew, property_id, provider, style, parent_style, variables);
       return dest->skew_x.skew == src->skew_x.skew;
     case GTK_CSS_TRANSFORM_SKEW_Y:
-      dest->skew_y.skew = _gtk_css_value_compute (src->skew_y.skew, property_id, provider, style, parent_style);
+      dest->skew_y.skew = _gtk_css_value_compute (src->skew_y.skew, property_id, provider, style, parent_style, variables);
       return dest->skew_y.skew == src->skew_y.skew;
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
-      dest->perspective.depth = _gtk_css_value_compute (src->perspective.depth, property_id, provider, style, parent_style);
+      dest->perspective.depth = _gtk_css_value_compute (src->perspective.depth, property_id, provider, style, parent_style, variables);
       return dest->perspective.depth == src->perspective.depth;
     case GTK_CSS_TRANSFORM_NONE:
     default:
@@ -332,11 +333,12 @@ gtk_css_transform_compute (GtkCssTransform  *dest,
 }
 
 static GtkCssValue *
-gtk_css_value_transform_compute (GtkCssValue      *value,
-                                 guint             property_id,
-                                 GtkStyleProvider *provider,
-                                 GtkCssStyle      *style,
-                                 GtkCssStyle      *parent_style)
+gtk_css_value_transform_compute (GtkCssValue       *value,
+                                 guint              property_id,
+                                 GtkStyleProvider  *provider,
+                                 GtkCssStyle       *style,
+                                 GtkCssStyle       *parent_style,
+                                 GtkCssVariableSet *variables)
 {
   GtkCssValue *result;
   gboolean changes;
@@ -356,7 +358,8 @@ gtk_css_value_transform_compute (GtkCssValue      *value,
                                              property_id,
                                              provider,
                                              style,
-                                             parent_style);
+                                             parent_style,
+                                             variables);
     }
 
   if (!changes)
@@ -801,7 +804,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_TRANSFORM = {
   gtk_css_value_transform_print
 };
 
-static GtkCssValue transform_none_singleton = { &GTK_CSS_VALUE_TRANSFORM, 1, TRUE, 0, {  { GTK_CSS_TRANSFORM_NONE } } };
+static GtkCssValue transform_none_singleton = { &GTK_CSS_VALUE_TRANSFORM, 1, TRUE, FALSE, 0, {  { GTK_CSS_TRANSFORM_NONE } } };
 
 static GtkCssValue *
 gtk_css_transform_value_alloc (guint n_transforms)

gtk/gtkcsstypesprivate.h

@@ -277,7 +277,8 @@ enum { /*< skip >*/
   GTK_CSS_PROPERTY_FONT_VARIATION_SETTINGS,
   GTK_CSS_PROPERTY_LINE_HEIGHT,
   /* add more */
-  GTK_CSS_PROPERTY_N_PROPERTIES
+  GTK_CSS_PROPERTY_N_PROPERTIES,
+  GTK_CSS_PROPERTY_CUSTOM,
 };
 
 typedef enum /*< skip >*/ {

gtk/gtkcssunsetvalue.c

@@ -35,11 +35,12 @@ gtk_css_value_unset_free (GtkCssValue *value)
 }
 
 static GtkCssValue *
-gtk_css_value_unset_compute (GtkCssValue      *value,
-                             guint             property_id,
-                             GtkStyleProvider *provider,
-                             GtkCssStyle      *style,
-                             GtkCssStyle      *parent_style)
+gtk_css_value_unset_compute (GtkCssValue       *value,
+                             guint              property_id,
+                             GtkStyleProvider  *provider,
+                             GtkCssStyle       *style,
+                             GtkCssStyle       *parent_style,
+                             GtkCssVariableSet *variables)
 {
   GtkCssStyleProperty *property;
   GtkCssValue *unset_value;
@@ -55,7 +56,8 @@ gtk_css_value_unset_compute (GtkCssValue      *value,
                                  property_id,
                                  provider,
                                  style,
-                                 parent_style);
+                                 parent_style,
+                                 variables);
 }
 
 static gboolean

gtk/gtkcssvalue.c

@@ -199,6 +199,7 @@ gtk_css_value_unref (GtkCssValue *value)
  * @provider: Style provider for looking up extra information
  * @style: Style to compute for
  * @parent_style: parent style to use for inherited values
+ * @variables: an additional set of variables to use along with @style
  *
  * Converts the specified @value into the computed value for the CSS
  * property given by @property_id using the information in @context.
@@ -208,11 +209,12 @@ gtk_css_value_unref (GtkCssValue *value)
  * Returns: the computed value
  **/
 GtkCssValue *
-_gtk_css_value_compute (GtkCssValue      *value,
-                        guint             property_id,
-                        GtkStyleProvider *provider,
-                        GtkCssStyle      *style,
-                        GtkCssStyle      *parent_style)
+_gtk_css_value_compute (GtkCssValue       *value,
+                        guint              property_id,
+                        GtkStyleProvider  *provider,
+                        GtkCssStyle       *style,
+                        GtkCssStyle       *parent_style,
+                        GtkCssVariableSet *variables)
 {
   if (gtk_css_value_is_computed (value))
     return _gtk_css_value_ref (value);
@@ -221,7 +223,7 @@ _gtk_css_value_compute (GtkCssValue      *value,
   get_accounting_data (value->class->type_name)->computed++;
 #endif
 
-  return value->class->compute (value, property_id, provider, style, parent_style);
+  return value->class->compute (value, property_id, provider, style, parent_style, variables);
 }
 
 gboolean
@@ -367,3 +369,9 @@ gtk_css_value_is_computed (const GtkCssValue *value)
 {
   return value->is_computed;
 }
+
+gboolean
+gtk_css_value_contains_variables (const GtkCssValue *value)
+{
+  return value->contains_variables;
+}

gtk/gtkcssvalueprivate.h

@@ -22,6 +22,7 @@
 #include <glib-object.h>
 
 #include "gtkcsstypesprivate.h"
+#include "gtkcssvariablesetprivate.h"
 #include "gtkstyleprovider.h"
 
 G_BEGIN_DECLS
@@ -37,7 +38,8 @@ typedef struct _GtkCssValueClass      GtkCssValueClass;
 #define GTK_CSS_VALUE_BASE \
   const GtkCssValueClass *class; \
   int ref_count; \
-  guint is_computed: 1;
+  guint is_computed: 1; \
+  guint contains_variables: 1;
 
 struct _GtkCssValueClass {
   const char *type_name;
@@ -47,7 +49,8 @@ struct _GtkCssValueClass {
                                                        guint                       property_id,
                                                        GtkStyleProvider           *provider,
                                                        GtkCssStyle                *style,
-                                                       GtkCssStyle                *parent_style);
+                                                       GtkCssStyle                *parent_style,
+                                                       GtkCssVariableSet          *variables);
   gboolean      (* equal)                             (const GtkCssValue          *value1,
                                                        const GtkCssValue          *value2);
   GtkCssValue * (* transition)                        (GtkCssValue                *start,
@@ -76,7 +79,8 @@ GtkCssValue *_gtk_css_value_compute                   (GtkCssValue
                                                        guint                       property_id,
                                                        GtkStyleProvider           *provider,
                                                        GtkCssStyle                *style,
-                                                       GtkCssStyle                *parent_style) G_GNUC_PURE;
+                                                       GtkCssStyle                *parent_style,
+                                                       GtkCssVariableSet          *variables) G_GNUC_PURE;
 gboolean     _gtk_css_value_equal                     (const GtkCssValue          *value1,
                                                        const GtkCssValue          *value2) G_GNUC_PURE;
 gboolean     _gtk_css_value_equal0                    (const GtkCssValue          *value1,
@@ -93,6 +97,7 @@ char *       _gtk_css_value_to_string                 (const GtkCssValue
 void         _gtk_css_value_print                     (const GtkCssValue          *value,
                                                        GString                    *string);
 gboolean     gtk_css_value_is_computed                (const GtkCssValue          *value) G_GNUC_PURE;
+gboolean     gtk_css_value_contains_variables         (const GtkCssValue          *value) G_GNUC_PURE;
 
 G_END_DECLS
 

gtk/gtkcssvaluesprivate.h

@@ -0,0 +1,151 @@
+/*
+ * Copyright © 2012 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+static const int core_props[] = {
+  GTK_CSS_PROPERTY_COLOR,
+  GTK_CSS_PROPERTY_DPI,
+  GTK_CSS_PROPERTY_FONT_SIZE,
+  GTK_CSS_PROPERTY_ICON_PALETTE
+};
+
+static const int background_props[] = {
+  GTK_CSS_PROPERTY_BACKGROUND_COLOR,
+  GTK_CSS_PROPERTY_BOX_SHADOW,
+  GTK_CSS_PROPERTY_BACKGROUND_CLIP,
+  GTK_CSS_PROPERTY_BACKGROUND_ORIGIN,
+  GTK_CSS_PROPERTY_BACKGROUND_SIZE,
+  GTK_CSS_PROPERTY_BACKGROUND_POSITION,
+  GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
+  GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
+  GTK_CSS_PROPERTY_BACKGROUND_BLEND_MODE
+};
+
+static const int border_props[] = {
+  GTK_CSS_PROPERTY_BORDER_TOP_STYLE,
+  GTK_CSS_PROPERTY_BORDER_TOP_WIDTH,
+  GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
+  GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH,
+  GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE,
+  GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
+  GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
+  GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH,
+  GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
+  GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
+  GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
+  GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
+  GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
+  GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
+  GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
+  GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
+  GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE,
+  GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT,
+  GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE,
+  GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH
+};
+
+static const int icon_props[] = {
+  GTK_CSS_PROPERTY_ICON_SIZE,
+  GTK_CSS_PROPERTY_ICON_SHADOW,
+  GTK_CSS_PROPERTY_ICON_STYLE,
+};
+
+static const int outline_props[] = {
+  GTK_CSS_PROPERTY_OUTLINE_STYLE,
+  GTK_CSS_PROPERTY_OUTLINE_WIDTH,
+  GTK_CSS_PROPERTY_OUTLINE_OFFSET,
+  GTK_CSS_PROPERTY_OUTLINE_COLOR,
+};
+
+static const int font_props[] = {
+  GTK_CSS_PROPERTY_FONT_FAMILY,
+  GTK_CSS_PROPERTY_FONT_STYLE,
+  GTK_CSS_PROPERTY_FONT_WEIGHT,
+  GTK_CSS_PROPERTY_FONT_STRETCH,
+  GTK_CSS_PROPERTY_LETTER_SPACING,
+  GTK_CSS_PROPERTY_TEXT_SHADOW,
+  GTK_CSS_PROPERTY_CARET_COLOR,
+  GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR,
+  GTK_CSS_PROPERTY_FONT_FEATURE_SETTINGS,
+  GTK_CSS_PROPERTY_FONT_VARIATION_SETTINGS,
+  GTK_CSS_PROPERTY_LINE_HEIGHT,
+};
+
+static const int font_variant_props[] = {
+  GTK_CSS_PROPERTY_TEXT_DECORATION_LINE,
+  GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR,
+  GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE,
+  GTK_CSS_PROPERTY_TEXT_TRANSFORM,
+  GTK_CSS_PROPERTY_FONT_KERNING,
+  GTK_CSS_PROPERTY_FONT_VARIANT_LIGATURES,
+  GTK_CSS_PROPERTY_FONT_VARIANT_POSITION,
+  GTK_CSS_PROPERTY_FONT_VARIANT_CAPS,
+  GTK_CSS_PROPERTY_FONT_VARIANT_NUMERIC,
+  GTK_CSS_PROPERTY_FONT_VARIANT_ALTERNATES,
+  GTK_CSS_PROPERTY_FONT_VARIANT_EAST_ASIAN,
+};
+
+static const int animation_props[] = {
+  GTK_CSS_PROPERTY_ANIMATION_NAME,
+  GTK_CSS_PROPERTY_ANIMATION_DURATION,
+  GTK_CSS_PROPERTY_ANIMATION_TIMING_FUNCTION,
+  GTK_CSS_PROPERTY_ANIMATION_ITERATION_COUNT,
+  GTK_CSS_PROPERTY_ANIMATION_DIRECTION,
+  GTK_CSS_PROPERTY_ANIMATION_PLAY_STATE,
+  GTK_CSS_PROPERTY_ANIMATION_DELAY,
+  GTK_CSS_PROPERTY_ANIMATION_FILL_MODE,
+};
+
+static const int transition_props[] = {
+  GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
+  GTK_CSS_PROPERTY_TRANSITION_DURATION,
+  GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
+  GTK_CSS_PROPERTY_TRANSITION_DELAY,
+};
+
+static const int size_props[] = {
+  GTK_CSS_PROPERTY_MARGIN_TOP,
+  GTK_CSS_PROPERTY_MARGIN_LEFT,
+  GTK_CSS_PROPERTY_MARGIN_BOTTOM,
+  GTK_CSS_PROPERTY_MARGIN_RIGHT,
+  GTK_CSS_PROPERTY_PADDING_TOP,
+  GTK_CSS_PROPERTY_PADDING_LEFT,
+  GTK_CSS_PROPERTY_PADDING_BOTTOM,
+  GTK_CSS_PROPERTY_PADDING_RIGHT,
+  GTK_CSS_PROPERTY_BORDER_SPACING,
+  GTK_CSS_PROPERTY_MIN_WIDTH,
+  GTK_CSS_PROPERTY_MIN_HEIGHT,
+};
+
+static const int other_props[] = {
+  GTK_CSS_PROPERTY_ICON_SOURCE,
+  GTK_CSS_PROPERTY_ICON_TRANSFORM,
+  GTK_CSS_PROPERTY_ICON_FILTER,
+  GTK_CSS_PROPERTY_TRANSFORM,
+  GTK_CSS_PROPERTY_TRANSFORM_ORIGIN,
+  GTK_CSS_PROPERTY_OPACITY,
+  GTK_CSS_PROPERTY_FILTER,
+};
+
+G_END_DECLS