theme: Reduce the height of titlebars

The height of our titlebars is geared towards headerbars that can
host controls. For a traditional title-only titlebar, a smaller
footprint is sufficient and frees up some valuable vertical space

docs/reference/gtk/css-properties.md

@@ -21,7 +21,7 @@ Percentage
 : %, calc()
 
 Angle
-: deg, rad, grad, turn, calc()
+: deg, grad, turn, calc()
 
 Time
 : s, ms, calc()

gdk/gdkvulkancontext.c

@@ -607,8 +607,7 @@ physical_device_check_features (VkPhysicalDevice device)
     features |= GDK_VULKAN_FEATURE_YCBCR;
 
   if (physical_device_supports_extension (device, VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME) &&
-      physical_device_supports_extension (device, VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME) &&
-      physical_device_supports_extension (device, VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME))
+      physical_device_supports_extension (device, VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME))
     features |= GDK_VULKAN_FEATURE_DMABUF;
 
   if (physical_device_supports_extension (device, VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME))
@@ -1518,7 +1517,6 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
 
                   g_ptr_array_add (device_extensions, (gpointer) VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
                   g_ptr_array_add (device_extensions, (gpointer) VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
-                  g_ptr_array_add (device_extensions, (gpointer) VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME);
 
                   g_ptr_array_add (device_extensions, (gpointer) VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME);
                   g_ptr_array_add (device_extensions, (gpointer) VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);

gtk/css/gtkcssparser.c

@@ -812,26 +812,6 @@ gtk_css_parser_warn_syntax (GtkCssParser *self,
   va_end (args);
 }
 
-void
-gtk_css_parser_warn_deprecated (GtkCssParser *self,
-                                 const char   *format,
-                                 ...)
-{
-  va_list args;
-  GError *error;
-
-  va_start (args, format);
-  error = g_error_new_valist (GTK_CSS_PARSER_WARNING,
-                              GTK_CSS_PARSER_WARNING_DEPRECATED,
-                              format, args);
-  gtk_css_parser_emit_error (self,
-                             gtk_css_parser_get_start_location (self),
-                             gtk_css_parser_get_end_location (self),
-                             error);
-  g_error_free (error);
-  va_end (args);
-}
-
 gboolean
 gtk_css_parser_consume_function (GtkCssParser *self,
                                  guint         min_args,
@@ -1320,9 +1300,6 @@ gtk_css_parser_has_references (GtkCssParser *self)
   gboolean ret = FALSE;
   int inner_blocks = 0, i;
 
-  /* We don't want gtk_css_parser_ensure_token to expand references on us here */
-  g_assert (self->n_refs == 0);
-
   gtk_css_tokenizer_save (tokenizer);
 
   do {
@@ -1338,7 +1315,7 @@ gtk_css_parser_has_references (GtkCssParser *self)
           if (gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_PARENS) ||
               gtk_css_token_is (token, GTK_CSS_TOKEN_CLOSE_SQUARE))
             {
-              goto done;
+              goto error;
             }
         }
 
@@ -1361,7 +1338,7 @@ gtk_css_parser_has_references (GtkCssParser *self)
           inner_blocks++;
           gtk_css_parser_start_block (self);
 
-          if (is_var)
+          if (!ret && is_var)
             {
               token = gtk_css_parser_get_token (self);
 
@@ -1369,18 +1346,18 @@ gtk_css_parser_has_references (GtkCssParser *self)
                 {
                   const char *var_name = gtk_css_token_get_string (token);
 
-                  if (strlen (var_name) < 3 || var_name[0] != '-' || var_name[1] != '-')
-                    goto done;
+                  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 done;
+                    {
+                      goto error;
+                    }
 
                   ret = TRUE;
-                  /* We got our answer. Now get it out as fast as possible! */
-                  goto done;
                 }
             }
         }
@@ -1388,7 +1365,18 @@ gtk_css_parser_has_references (GtkCssParser *self)
   while (!gtk_css_parser_has_token (self, GTK_CSS_TOKEN_SEMICOLON) &&
          !gtk_css_parser_has_token (self, GTK_CSS_TOKEN_CLOSE_CURLY));
 
-done:
+  if (inner_blocks > 0)
+    goto error;
+
+  g_assert (tokenizer == get_tokenizer (self));
+
+  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);
 
@@ -1398,7 +1386,7 @@ done:
   self->location = *gtk_css_tokenizer_get_location (tokenizer);
   gtk_css_tokenizer_read_token (tokenizer, &self->token, NULL);
 
-  return ret;
+  return FALSE;
 }
 
 static void
@@ -1494,9 +1482,9 @@ gtk_css_parser_parse_value_into_token_stream (GtkCssParser *self)
                   GtkCssVariableValueReference ref;
                   char *var_name = g_strdup (gtk_css_token_get_string (token));
 
-                  if (strlen (var_name) < 3 || var_name[0] != '-' || var_name[1] != '-')
+                  if (var_name[0] != '-' || var_name[1] != '-')
                     {
-                      gtk_css_parser_error_syntax (self, "Invalid variable name: %s", var_name);
+                      gtk_css_parser_error_value (self, "Invalid variable name: %s", var_name);
                       g_free (var_name);
                       goto error;
                     }
@@ -1539,20 +1527,6 @@ gtk_css_parser_parse_value_into_token_stream (GtkCssParser *self)
 
                   gtk_css_parser_references_append (&refs, &ref);
                 }
-              else
-                {
-                  if (gtk_css_token_is (token, GTK_CSS_TOKEN_EOF))
-                    {
-                      gtk_css_parser_error_syntax (self, "Missing variable name");
-                    }
-                  else
-                    {
-                      char *s = gtk_css_token_to_string (token);
-                      gtk_css_parser_error_syntax (self, "Expected a variable name, not %s", s);
-                      g_free (s);
-                    }
-                  goto error;
-                }
             }
         }
     }

gtk/css/gtkcssparserprivate.h

@@ -120,9 +120,6 @@ void                    gtk_css_parser_warn                     (GtkCssParser
 void                    gtk_css_parser_warn_syntax              (GtkCssParser                   *self,
                                                                  const char                     *format,
                                                                  ...) G_GNUC_PRINTF(2, 3);
-void                    gtk_css_parser_warn_deprecated          (GtkCssParser                   *self,
-                                                                 const char                     *format,
-                                                                 ...) G_GNUC_PRINTF(2, 3);
 
 
 gboolean                gtk_css_parser_has_token                (GtkCssParser                   *self,

gtk/deprecated/gtkcellrendererspinner.c

@@ -253,7 +253,7 @@ gtk_cell_renderer_spinner_update_size (GtkCellRendererSpinner *cell,
   node = gtk_style_context_get_node (context);
   gtk_icon_size_set_style_classes (node, priv->icon_size);
   style = gtk_css_node_get_style (node);
-  priv->size = gtk_css_number_value_get (style->icon->icon_size, 100);
+  priv->size = _gtk_css_number_value_get (style->icon->icon_size, 100);
 
   gtk_style_context_restore (context);
 }

gtk/deprecated/gtkcellrenderertoggle.c

@@ -370,7 +370,7 @@ static int
 calc_indicator_size (GtkStyleContext *context)
 {
   GtkCssStyle *style = gtk_style_context_lookup_style (context);
-  return gtk_css_number_value_get (style->icon->icon_size, 100);
+  return _gtk_css_number_value_get (style->icon->icon_size, 100);
 }
 
 static void

gtk/deprecated/gtkstylecontext.c

@@ -778,15 +778,15 @@ gtk_style_context_resolve_color (GtkStyleContext    *context,
   g_return_val_if_fail (color != NULL, FALSE);
   g_return_val_if_fail (result != NULL, FALSE);
 
-  val = gtk_css_color_value_resolve (color,
-                                     GTK_STYLE_PROVIDER (priv->cascade),
-                                     _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR));
-
+  val = _gtk_css_color_value_resolve (color,
+                                      GTK_STYLE_PROVIDER (priv->cascade),
+                                      _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR),
+                                      NULL);
   if (val == NULL)
     return FALSE;
 
   *result = *gtk_css_color_value_get_rgba (val);
-  gtk_css_value_unref (val);
+  _gtk_css_value_unref (val);
   return TRUE;
 }
 
@@ -860,10 +860,10 @@ gtk_style_context_get_border (GtkStyleContext *context,
 
   style = gtk_style_context_lookup_style (context);
 
-  border->top = round (gtk_css_number_value_get (style->border->border_top_width, 100));
-  border->right = round (gtk_css_number_value_get (style->border->border_right_width, 100));
-  border->bottom = round (gtk_css_number_value_get (style->border->border_bottom_width, 100));
-  border->left = round (gtk_css_number_value_get (style->border->border_left_width, 100));
+  border->top = round (_gtk_css_number_value_get (style->border->border_top_width, 100));
+  border->right = round (_gtk_css_number_value_get (style->border->border_right_width, 100));
+  border->bottom = round (_gtk_css_number_value_get (style->border->border_bottom_width, 100));
+  border->left = round (_gtk_css_number_value_get (style->border->border_left_width, 100));
 }
 
 /**
@@ -886,10 +886,10 @@ gtk_style_context_get_padding (GtkStyleContext *context,
 
   style = gtk_style_context_lookup_style (context);
 
-  padding->top = round (gtk_css_number_value_get (style->size->padding_top, 100));
-  padding->right = round (gtk_css_number_value_get (style->size->padding_right, 100));
-  padding->bottom = round (gtk_css_number_value_get (style->size->padding_bottom, 100));
-  padding->left = round (gtk_css_number_value_get (style->size->padding_left, 100));
+  padding->top = round (_gtk_css_number_value_get (style->size->padding_top, 100));
+  padding->right = round (_gtk_css_number_value_get (style->size->padding_right, 100));
+  padding->bottom = round (_gtk_css_number_value_get (style->size->padding_bottom, 100));
+  padding->left = round (_gtk_css_number_value_get (style->size->padding_left, 100));
 }
 
 /**
@@ -912,10 +912,10 @@ gtk_style_context_get_margin (GtkStyleContext *context,
 
   style = gtk_style_context_lookup_style (context);
 
-  margin->top = round (gtk_css_number_value_get (style->size->margin_top, 100));
-  margin->right = round (gtk_css_number_value_get (style->size->margin_right, 100));
-  margin->bottom = round (gtk_css_number_value_get (style->size->margin_bottom, 100));
-  margin->left = round (gtk_css_number_value_get (style->size->margin_left, 100));
+  margin->top = round (_gtk_css_number_value_get (style->size->margin_top, 100));
+  margin->right = round (_gtk_css_number_value_get (style->size->margin_right, 100));
+  margin->bottom = round (_gtk_css_number_value_get (style->size->margin_bottom, 100));
+  margin->left = round (_gtk_css_number_value_get (style->size->margin_left, 100));
 }
 
 void
@@ -928,10 +928,10 @@ _gtk_style_context_get_cursor_color (GtkStyleContext *context,
   style = gtk_style_context_lookup_style (context);
 
   if (primary_color)
-    *primary_color = *gtk_css_color_value_get_rgba (style->used->caret_color);
+    *primary_color = *gtk_css_color_value_get_rgba (style->font->caret_color ? style->font->caret_color : style->core->color);
 
   if (secondary_color)
-    *secondary_color = *gtk_css_color_value_get_rgba (style->used->secondary_caret_color);
+    *secondary_color = *gtk_css_color_value_get_rgba (style->font->secondary_caret_color ? style->font->secondary_caret_color : style->core->color);
 }
 
 /**

gtk/deprecated/gtktreeview.c

@@ -2691,8 +2691,8 @@ gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
   gtk_style_context_add_class (context, "expander");
 
   style = gtk_style_context_lookup_style (context);
-  min_width = gtk_css_number_value_get (style->size->min_width, 100);
-  min_height = gtk_css_number_value_get (style->size->min_height, 100);
+  min_width = _gtk_css_number_value_get (style->size->min_width, 100);
+  min_height = _gtk_css_number_value_get (style->size->min_height, 100);
 
   gtk_style_context_restore (context);
 
@@ -5521,7 +5521,7 @@ get_separator_height (GtkTreeView *tree_view)
   gtk_style_context_add_class (context, "separator");
 
   style = gtk_style_context_lookup_style (context);
-  d = gtk_css_number_value_get (style->size->min_height, 100);
+  d = _gtk_css_number_value_get (style->size->min_height, 100);
 
   if (d < 1)
     min_size = ceil (d);

gtk/gskpango.c

@@ -356,7 +356,7 @@ gsk_pango_renderer_prepare_run (PangoRenderer  *renderer,
 
       node = gtk_text_view_get_selection_node ((GtkTextView *)crenderer->widget);
       style = gtk_css_node_get_style (node);
-      fg_rgba = gtk_css_color_value_get_rgba (style->used->color);
+      fg_rgba = gtk_css_color_value_get_rgba (style->core->color);
     }
   else if (crenderer->state == GSK_PANGO_RENDERER_CURSOR && gtk_widget_has_focus (crenderer->widget))
     {
@@ -365,7 +365,7 @@ gsk_pango_renderer_prepare_run (PangoRenderer  *renderer,
 
       node = gtk_widget_get_css_node (crenderer->widget);
       style = gtk_css_node_get_style (node);
-      fg_rgba = gtk_css_color_value_get_rgba (style->used->background_color);
+      fg_rgba = gtk_css_color_value_get_rgba (style->background->background_color);
     }
   else
     fg_rgba = appearance->fg_rgba;

gtk/gtkaboutdialog.c

@@ -1696,12 +1696,12 @@ follow_if_link (GtkAboutDialog *about,
 
       if (uri && !g_ptr_array_find_with_equal_func (about->visited_links, uri, (GCompareFunc)strcmp, NULL))
         {
-          const GdkRGBA *visited_link_color;
+          GdkRGBA visited_link_color;
           GtkCssStyle *style;
 
           style = gtk_css_node_get_style (about->visited_link_node);
-          visited_link_color = gtk_css_color_value_get_rgba (style->used->color);
-          g_object_set (G_OBJECT (tag), "foreground-rgba", visited_link_color, NULL);
+          visited_link_color = *gtk_css_color_value_get_rgba (style->core->color);
+          g_object_set (G_OBJECT (tag), "foreground-rgba", &visited_link_color, NULL);
 
           g_ptr_array_add (about->visited_links, g_strdup (uri));
         }
@@ -1836,18 +1836,17 @@ text_buffer_new (GtkAboutDialog  *about,
   char **p;
   char *q0, *q1, *q2, *r1, *r2;
   GtkTextBuffer *buffer;
-  const GdkRGBA *color;
-  const GdkRGBA *link_color;
-  const GdkRGBA *visited_link_color;
+  GdkRGBA color;
+  GdkRGBA link_color;
+  GdkRGBA visited_link_color;
   GtkTextIter start_iter, end_iter;
   GtkTextTag *tag;
   GtkCssStyle *style;
 
   style = gtk_css_node_get_style (about->link_node);
-  link_color = gtk_css_color_value_get_rgba (style->used->color);
-
+  link_color = *gtk_css_color_value_get_rgba (style->core->color);
   style = gtk_css_node_get_style (about->visited_link_node);
-  visited_link_color = gtk_css_color_value_get_rgba (style->used->color);
+  visited_link_color = *gtk_css_color_value_get_rgba (style->core->color);
 
   buffer = gtk_text_buffer_new (NULL);
 
@@ -1908,7 +1907,7 @@ text_buffer_new (GtkAboutDialog  *about,
                 color = link_color;
 
               tag = gtk_text_buffer_create_tag (buffer, NULL,
-                                                "foreground-rgba", color,
+                                                "foreground-rgba", &color,
                                                 "underline", PANGO_UNDERLINE_SINGLE,
                                                 NULL);
               if (strcmp (link_type, "email") == 0)

gtk/gtkapplication-quartz.c

@@ -76,19 +76,13 @@ G_DEFINE_TYPE (GtkApplicationImplQuartz, gtk_application_impl_quartz, GTK_TYPE_A
 
 -(NSApplicationTerminateReply) applicationShouldTerminate:(NSApplication *)sender
 {
-  const gchar *quit_action_name = "quit";
-  GActionGroup *action_group = G_ACTION_GROUP (quartz->impl.application);
-
-  if (quartz->quit_inhibit != 0)
-    return NSTerminateCancel;
-
-  if (g_action_group_has_action (action_group, quit_action_name))
-    {
-      g_action_group_activate_action (action_group, quit_action_name, NULL);
-      return NSTerminateCancel;
-    }
-
-  return NSTerminateNow;
+  /* We have no way to give our message other than to pop up a dialog
+   * ourselves, which we should not do since the OS will already show
+   * one when we return NSTerminateNow.
+   *
+   * Just let the OS show the generic message...
+   */
+  return quartz->quit_inhibit == 0 ? NSTerminateNow : NSTerminateCancel;
 }
 
 -(void)application:(NSApplication *)theApplication openFiles:(NSArray *)filenames

gtk/gtkbuiltinicon.c

@@ -84,7 +84,7 @@ gtk_builtin_icon_measure (GtkWidget      *widget,
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
 
-  *minimum = *natural = gtk_css_number_value_get (style->icon->icon_size, 100);
+  *minimum = *natural = _gtk_css_number_value_get (style->icon->icon_size, 100);
 }
 
 static void

gtk/gtkcolumnview.c

@@ -2212,7 +2212,7 @@ gtk_column_view_scroll_to (GtkColumnView       *self,
                            GtkScrollInfo       *scroll)
 {
   g_return_if_fail (GTK_IS_COLUMN_VIEW (self));
-  g_return_if_fail (pos < gtk_list_base_get_n_items (GTK_LIST_BASE (self->listview)));
+  g_return_if_fail (pos < gtk_list_base_get_n_items (GTK_LIST_BASE (self)));
   g_return_if_fail (column == NULL || GTK_IS_COLUMN_VIEW_COLUMN (column));
   if (column)
     {

gtk/gtkcssanimatedstyle.c

@@ -42,37 +42,10 @@
 
 G_DEFINE_TYPE (GtkCssAnimatedStyle, gtk_css_animated_style, GTK_TYPE_CSS_STYLE)
 
-static inline gboolean
-property_has_color (guint id)
-{
-  switch (id)
-    {
-    case GTK_CSS_PROPERTY_COLOR:
-    case GTK_CSS_PROPERTY_ICON_PALETTE:
-    case GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR:
-    case GTK_CSS_PROPERTY_TEXT_SHADOW:
-    case GTK_CSS_PROPERTY_BOX_SHADOW:
-    case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
-    case GTK_CSS_PROPERTY_OUTLINE_COLOR:
-    case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
-    case GTK_CSS_PROPERTY_ICON_SOURCE:
-    case GTK_CSS_PROPERTY_ICON_SHADOW:
-    case GTK_CSS_PROPERTY_CARET_COLOR:
-    case GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR:
-      return TRUE;
-    default:
-       return FALSE;
-    }
-}
-
 #define DEFINE_VALUES(ENUM, TYPE, NAME) \
 static inline void \
-gtk_css_ ## NAME ## _values_recompute (GtkCssAnimatedStyle   *animated, \
-                                       GtkCssComputeContext  *context, \
-                                       GtkCssAnimationChange  change) \
+gtk_css_ ## NAME ## _values_recompute (GtkCssAnimatedStyle  *animated, \
+                                       GtkCssComputeContext *context) \
 { \
   GtkCssStyle *style = (GtkCssStyle *)animated; \
   GtkCssValue **values = (GtkCssValue **)((guint8*)(animated->style->NAME) + sizeof (GtkCssValues)); \
@@ -82,7 +55,6 @@ gtk_css_ ## NAME ## _values_recompute (GtkCssAnimatedStyle   *animated, \
     { \
       guint id = NAME ## _props[i]; \
       GtkCssValue *original, *computed; \
-      gboolean needs_recompute = FALSE; \
 \
       if (values[i] == NULL) \
         continue; \
@@ -91,27 +63,13 @@ gtk_css_ ## NAME ## _values_recompute (GtkCssAnimatedStyle   *animated, \
       if (original == NULL) \
         continue; \
 \
-      if ((change & GTK_CSS_ANIMATION_CHANGE_VARIABLES) && \
-           gtk_css_value_contains_variables (original)) \
-        needs_recompute = TRUE; \
-\
-      if ((change & GTK_CSS_ANIMATION_CHANGE_COLOR) && \
-          property_has_color (id)) \
-        needs_recompute = TRUE; \
-\
-      if (!needs_recompute) \
-        continue; \
-\
-      computed = gtk_css_value_compute (original, \
-                                        id, \
-                                        context); \
+      computed = _gtk_css_value_compute (original, \
+                                         id, \
+                                         context); \
       if (computed == NULL) \
         continue; \
 \
       gtk_css_animated_style_set_animated_value (animated, id, computed); \
-\
-      if (id == GTK_CSS_PROPERTY_COLOR) \
-        change |= GTK_CSS_ANIMATION_CHANGE_COLOR; \
     } \
 }
 
@@ -645,20 +603,16 @@ gtk_css_animated_style_get_intrinsic_value (GtkCssAnimatedStyle *style,
   return gtk_css_style_get_value (style->style, id);
 }
 
-gboolean
+void
 gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
                                                   int                  id,
                                                   GtkCssVariableValue *value)
 {
   GtkCssStyle *style = (GtkCssStyle *)animated;
-  GtkCssVariableValue *old_value;
+  GtkCssComputeContext context = { NULL, };
 
-  gtk_internal_return_val_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style), FALSE);
-  gtk_internal_return_val_if_fail (value != NULL, FALSE);
-
-  old_value = gtk_css_style_get_custom_property (style, id);
-  if (gtk_css_variable_value_equal (old_value, value))
-    return FALSE;
+  gtk_internal_return_if_fail (GTK_IS_CSS_ANIMATED_STYLE (style));
+  gtk_internal_return_if_fail (value != NULL);
 
   if (style->variables == NULL)
     {
@@ -675,38 +629,22 @@ gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
 
   gtk_css_variable_set_add (style->variables, id, value);
 
-  return TRUE;
-}
+  context.provider = animated->provider;
+  context.style = animated->style;
+  context.parent_style = animated->parent_style;
+  context.provider = animated->provider;
 
-void
-gtk_css_animated_style_recompute (GtkCssAnimatedStyle   *style,
-                                  GtkCssAnimationChange  change)
-{
-  GtkCssComputeContext context = { NULL, };
-  GtkCssValue *shorthands[GTK_CSS_SHORTHAND_PROPERTY_N_PROPERTIES] = { NULL, };
-
-  context.provider = style->provider;
-  context.style = style->style;
-  context.parent_style = style->parent_style;
-  context.shorthands = shorthands;
-
-  gtk_css_core_values_recompute (style, &context, change);
-  gtk_css_background_values_recompute (style, &context, change);
-  gtk_css_border_values_recompute (style, &context, change);
-  gtk_css_icon_values_recompute (style, &context, change);
-  gtk_css_outline_values_recompute (style, &context, change);
-  gtk_css_font_values_recompute (style, &context, change);
-  gtk_css_font_variant_values_recompute (style, &context, change);
-  gtk_css_animation_values_recompute (style, &context, change);
-  gtk_css_transition_values_recompute (style, &context, change);
-  gtk_css_size_values_recompute (style, &context, change);
-  gtk_css_other_values_recompute (style, &context, change);
-
-  for (unsigned int i = 0; i < GTK_CSS_SHORTHAND_PROPERTY_N_PROPERTIES; i++)
-    {
-      if (shorthands[i])
-        gtk_css_value_unref (shorthands[i]);
-    }
+  gtk_css_core_values_recompute (animated, &context);
+  gtk_css_background_values_recompute (animated, &context);
+  gtk_css_border_values_recompute (animated, &context);
+  gtk_css_icon_values_recompute (animated, &context);
+  gtk_css_outline_values_recompute (animated, &context);
+  gtk_css_font_values_recompute (animated, &context);
+  gtk_css_font_variant_values_recompute (animated, &context);
+  gtk_css_animation_values_recompute (animated, &context);
+  gtk_css_transition_values_recompute (animated, &context);
+  gtk_css_size_values_recompute (animated, &context);
+  gtk_css_other_values_recompute (animated, &context);
 }
 
 GtkCssVariableValue *
@@ -855,8 +793,8 @@ gtk_css_animated_style_create_css_transitions (GPtrArray   *animations,
 
   if (_gtk_css_array_value_get_n_values (durations) == 1 &&
       _gtk_css_array_value_get_n_values (delays) == 1 &&
-      gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, 0), 100) +
-      gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, 0), 100) == 0)
+      _gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, 0), 100) +
+      _gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, 0), 100) == 0)
     return animations;
 
   transition_infos_set (transitions, base_style->transition->transition_property);
@@ -871,8 +809,8 @@ gtk_css_animated_style_create_css_transitions (GPtrArray   *animations,
       if (!transitions[i].pending)
         continue;
 
-      duration = gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, transitions[i].index), 100);
-      delay = gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, transitions[i].index), 100);
+      duration = _gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, transitions[i].index), 100);
+      delay = _gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, transitions[i].index), 100);
       if (duration + delay == 0.0)
         continue;
 
@@ -881,7 +819,7 @@ gtk_css_animated_style_create_css_transitions (GPtrArray   *animations,
           start = gtk_css_animated_style_get_intrinsic_value ((GtkCssAnimatedStyle *)source, i);
           end = gtk_css_style_get_value (base_style, i);
 
-          if (gtk_css_value_equal (start, end))
+          if (_gtk_css_value_equal (start, end))
             {
               animation = gtk_css_animated_style_find_transition ((GtkCssAnimatedStyle *)source, i);
               if (animation)
@@ -897,8 +835,8 @@ gtk_css_animated_style_create_css_transitions (GPtrArray   *animations,
             }
         }
 
-      if (gtk_css_value_equal (gtk_css_style_get_value (source, i),
-                               gtk_css_style_get_value (base_style, i)))
+      if (_gtk_css_value_equal (gtk_css_style_get_value (source, i),
+                                gtk_css_style_get_value (base_style, i)))
         continue;
 
       animation = _gtk_css_transition_new (i,
@@ -1004,13 +942,13 @@ gtk_css_animated_style_create_css_animations (GPtrArray        *animations,
           animation = _gtk_css_animation_new (name,
                                               keyframes,
                                               timestamp,
-                                              gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, i), 100) * G_USEC_PER_SEC,
-                                              gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, i), 100) * G_USEC_PER_SEC,
+                                              _gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, i), 100) * G_USEC_PER_SEC,
+                                              _gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, i), 100) * G_USEC_PER_SEC,
                                               _gtk_css_array_value_get_nth (timing_functions, i),
                                               _gtk_css_direction_value_get (_gtk_css_array_value_get_nth (directions, i)),
                                               _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_number_value_get (_gtk_css_array_value_get_nth (iteration_counts, i), 100));
         }
 
       if (!animations)
@@ -1047,7 +985,6 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
   GtkCssAnimatedStyle *result;
   GtkCssStyle *style;
   GPtrArray *animations = NULL;
-  GtkCssComputeContext context = { 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);
@@ -1093,12 +1030,6 @@ gtk_css_animated_style_new (GtkCssStyle      *base_style,
 
   gtk_css_animated_style_apply_animations (result);
 
-  context.provider = provider;
-  context.style = base_style;
-  context.parent_style = parent_style;
-
-  gtk_css_style_resolve_used_values ((GtkCssStyle *) result, &context);
-
   return GTK_CSS_STYLE (result);
 }
 
@@ -1113,7 +1044,6 @@ gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
   GtkCssStyle *style;
   GPtrArray *animations;
   guint i;
-  GtkCssComputeContext context = { NULL, };
 
   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);
@@ -1173,12 +1103,6 @@ gtk_css_animated_style_new_advance (GtkCssAnimatedStyle *source,
 
   gtk_css_animated_style_apply_animations (result);
 
-  context.provider = provider;
-  context.style = base_style;
-  context.parent_style = parent_style;
-
-  gtk_css_style_resolve_used_values ((GtkCssStyle *) result, &context);
-
   return GTK_CSS_STYLE (result);
 }
 

gtk/gtkcssanimatedstyleprivate.h

@@ -70,17 +70,9 @@ void                    gtk_css_animated_style_set_animated_value(GtkCssAnimated
 GtkCssValue *           gtk_css_animated_style_get_intrinsic_value (GtkCssAnimatedStyle *style,
                                                                  guint                   id);
 
-gboolean                gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
+void                    gtk_css_animated_style_set_animated_custom_value (GtkCssAnimatedStyle *animated,
                                                                  int                     id,
                                                                  GtkCssVariableValue    *value);
-
-typedef enum {
-  GTK_CSS_ANIMATION_CHANGE_VARIABLES = 1 << 0,
-  GTK_CSS_ANIMATION_CHANGE_COLOR     = 1 << 1,
-} GtkCssAnimationChange;
-
-void                    gtk_css_animated_style_recompute        (GtkCssAnimatedStyle    *style,
-                                                                 GtkCssAnimationChange   change);
 GtkCssVariableValue *   gtk_css_animated_style_get_intrinsic_custom_value (GtkCssAnimatedStyle *style,
                                                                  int                     id);
 

gtk/gtkcssanimation.c

@@ -95,7 +95,6 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
   GtkCssKeyframes *resolved_keyframes;
   double progress;
   guint i;
-  GtkCssAnimationChange change = 0;
 
   if (!gtk_css_animation_is_executing (animation))
     return;
@@ -126,8 +125,7 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
       if (!value)
         continue;
 
-      if (gtk_css_animated_style_set_animated_custom_value (style, variable_id, value))
-        change |= GTK_CSS_ANIMATION_CHANGE_VARIABLES;
+      gtk_css_animated_style_set_animated_custom_value (style, variable_id, value);
 
       gtk_css_variable_value_unref (value);
     }
@@ -136,7 +134,7 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
     {
       GtkCssValue *value;
       guint property_id;
-
+      
       property_id = _gtk_css_keyframes_get_property_id (resolved_keyframes, i);
 
       value = _gtk_css_keyframes_get_value (resolved_keyframes,
@@ -144,14 +142,8 @@ gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
                                             progress,
                                             gtk_css_animated_style_get_intrinsic_value (style, property_id));
       gtk_css_animated_style_set_animated_value (style, property_id, value);
-
-      if (property_id == GTK_CSS_PROPERTY_COLOR)
-        change |= GTK_CSS_ANIMATION_CHANGE_COLOR;
     }
 
-  if (change != 0)
-    gtk_css_animated_style_recompute (style, change);
-
   _gtk_css_keyframes_unref (resolved_keyframes);
 }
 
@@ -179,7 +171,7 @@ gtk_css_animation_free (GtkStyleAnimation *animation)
 
   g_free (self->name);
   _gtk_css_keyframes_unref (self->keyframes);
-  gtk_css_value_unref (self->ease);
+  _gtk_css_value_unref (self->ease);
 
   g_free (self);
 }
@@ -219,7 +211,7 @@ _gtk_css_animation_new (const char      *name,
 
   animation->name = g_strdup (name);
   animation->keyframes = _gtk_css_keyframes_ref (keyframes);
-  animation->ease = gtk_css_value_ref (ease);
+  animation->ease = _gtk_css_value_ref (ease);
   animation->direction = direction;
   animation->play_state = play_state;
   animation->fill_mode = fill_mode;
@@ -250,7 +242,7 @@ _gtk_css_animation_advance_with_play_state (GtkCssAnimation *source,
 
   animation->name = g_strdup (source->name);
   animation->keyframes = _gtk_css_keyframes_ref (source->keyframes);
-  animation->ease = gtk_css_value_ref (source->ease);
+  animation->ease = _gtk_css_value_ref (source->ease);
   animation->direction = source->direction;
   animation->play_state = play_state;
   animation->fill_mode = source->fill_mode;

gtk/gtkcssarrayvalue.c

@@ -35,7 +35,7 @@ gtk_css_value_array_free (GtkCssValue *value)
   guint i;
 
   for (i = 0; i < value->n_values; i++)
-    gtk_css_value_unref (value->values[i]);
+    _gtk_css_value_unref (value->values[i]);
 
   g_free (value);
 }
@@ -52,24 +52,24 @@ 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, context);
+      i_value =  _gtk_css_value_compute (value->values[i], property_id, context);
 
       if (result == NULL &&
 	  i_value != value->values[i])
 	{
 	  result = _gtk_css_array_value_new_from_array (value->values, value->n_values);
 	  for (j = 0; j < i; j++)
-	    gtk_css_value_ref (result->values[j]);
+	    _gtk_css_value_ref (result->values[j]);
 	}
 
       if (result != NULL)
 	result->values[i] = i_value;
       else
-	gtk_css_value_unref (i_value);
+	_gtk_css_value_unref (i_value);
     }
 
   if (result == NULL)
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   return result;
 }
@@ -85,8 +85,8 @@ gtk_css_value_array_equal (const GtkCssValue *value1,
 
   for (i = 0; i < value1->n_values; i++)
     {
-      if (!gtk_css_value_equal (value1->values[i],
-                                value2->values[i]))
+      if (!_gtk_css_value_equal (value1->values[i],
+                                 value2->values[i]))
         return FALSE;
     }
 
@@ -125,14 +125,14 @@ gtk_css_value_array_transition_repeat (GtkCssValue *start,
 
   for (i = 0; i < n; i++)
     {
-      transitions[i] = gtk_css_value_transition (start->values[i % start->n_values],
-                                                 end->values[i % end->n_values],
-                                                 property_id,
-                                                 progress);
+      transitions[i] = _gtk_css_value_transition (start->values[i % start->n_values],
+                                                  end->values[i % end->n_values],
+                                                  property_id,
+                                                  progress);
       if (transitions[i] == NULL)
         {
           while (i--)
-            gtk_css_value_unref (transitions[i]);
+            _gtk_css_value_unref (transitions[i]);
           return NULL;
         }
     }
@@ -166,14 +166,14 @@ gtk_css_value_array_transition_extend (GtkCssValue *start,
 
   for (i = 0; i < MIN (start->n_values, end->n_values); i++)
     {
-      transitions[i] = gtk_css_value_transition (start->values[i],
-                                                 end->values[i],
-                                                 property_id,
-                                                 progress);
+      transitions[i] = _gtk_css_value_transition (start->values[i],
+                                                  end->values[i],
+                                                  property_id,
+                                                  progress);
       if (transitions[i] == NULL)
         {
           while (i--)
-            gtk_css_value_unref (transitions[i]);
+            _gtk_css_value_unref (transitions[i]);
           return NULL;
         }
     }
@@ -186,28 +186,28 @@ gtk_css_value_array_transition_extend (GtkCssValue *start,
 
       for (; i < start->n_values; i++)
         {
-          transitions[i] = gtk_css_value_transition (start->values[i],
-                                                     default_value,
-                                                     property_id,
-                                                     progress);
+          transitions[i] = _gtk_css_value_transition (start->values[i],
+                                                      default_value,
+                                                      property_id,
+                                                      progress);
           if (transitions[i] == NULL)
             {
               while (i--)
-                gtk_css_value_unref (transitions[i]);
+                _gtk_css_value_unref (transitions[i]);
               return NULL;
             }
         }
 
       for (; i < end->n_values; i++)
         {
-          transitions[i] = gtk_css_value_transition (default_value,
-                                                     end->values[i],
-                                                     property_id,
-                                                     progress);
+          transitions[i] = _gtk_css_value_transition (default_value,
+                                                      end->values[i],
+                                                      property_id,
+                                                      progress);
           if (transitions[i] == NULL)
             {
               while (i--)
-                gtk_css_value_unref (transitions[i]);
+                _gtk_css_value_unref (transitions[i]);
               return NULL;
             }
         }
@@ -325,17 +325,17 @@ gtk_css_value_array_get_dynamic_value (GtkCssValue *value,
 	{
 	  result = _gtk_css_array_value_new_from_array (value->values, value->n_values);
 	  for (j = 0; j < i; j++)
-	    gtk_css_value_ref (result->values[j]);
+	    _gtk_css_value_ref (result->values[j]);
 	}
 
       if (result != NULL)
 	result->values[i] = i_value;
       else
-	gtk_css_value_unref (i_value);
+	_gtk_css_value_unref (i_value);
     }
 
   if (result == NULL)
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   return result;
 }
@@ -356,7 +356,7 @@ gtk_css_value_array_print (const GtkCssValue *value,
     {
       if (i > 0)
         g_string_append (string, ", ");
-      gtk_css_value_print (value->values[i], string);
+      _gtk_css_value_print (value->values[i], string);
     }
 }
 
@@ -392,12 +392,11 @@ _gtk_css_array_value_new_from_array (GtkCssValue **values,
   if (n_values == 1)
     return values[0];
 
-  result = gtk_css_value_alloc (&GTK_CSS_VALUE_ARRAY, sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (n_values - 1));
+  result = _gtk_css_value_alloc (&GTK_CSS_VALUE_ARRAY, sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (n_values - 1));
   result->n_values = n_values;
   memcpy (&result->values[0], values, sizeof (GtkCssValue *) * n_values);
 
   result->is_computed = TRUE;
-  result->contains_variables = FALSE;
   for (i = 0; i < n_values; i ++)
     {
       if (!gtk_css_value_is_computed (values[i]))
@@ -428,7 +427,7 @@ _gtk_css_array_value_parse (GtkCssParser *parser,
     if (value == NULL)
       {
         for (i = 0; i < n_values; i ++)
-          gtk_css_value_unref (values[i]);
+          _gtk_css_value_unref (values[i]);
 
         return NULL;
       }

gtk/gtkcssbgsizevalue.c

@@ -33,9 +33,9 @@ static void
 gtk_css_value_bg_size_free (GtkCssValue *value)
 {
   if (value->x)
-    gtk_css_value_unref (value->x);
+    _gtk_css_value_unref (value->x);
   if (value->y)
-    gtk_css_value_unref (value->y);
+    _gtk_css_value_unref (value->y);
 
   g_free (value);
 }
@@ -48,24 +48,24 @@ gtk_css_value_bg_size_compute (GtkCssValue          *value,
   GtkCssValue *x, *y;
 
   if (value->x == NULL && value->y == NULL)
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   x = y = NULL;
 
   if (value->x)
-    x = gtk_css_value_compute (value->x, property_id, context);
+    x = _gtk_css_value_compute (value->x, property_id, context);
 
   if (value->y)
-    y = gtk_css_value_compute (value->y, property_id, context);
+    y = _gtk_css_value_compute (value->y, property_id, context);
 
   if (x == value->x && y == value->y)
     {
       if (x)
-        gtk_css_value_unref (x);
+        _gtk_css_value_unref (x);
       if (y)
-        gtk_css_value_unref (y);
+        _gtk_css_value_unref (y);
 
-      return gtk_css_value_ref (value);
+      return _gtk_css_value_ref (value);
     }
 
   return _gtk_css_bg_size_value_new (value->x ? x : NULL,
@@ -80,10 +80,10 @@ gtk_css_value_bg_size_equal (const GtkCssValue *value1,
          value1->contain == value2->contain &&
          (value1->x == value2->x ||
           (value1->x != NULL && value2->x != NULL &&
-           gtk_css_value_equal (value1->x, value2->x))) &&
+           _gtk_css_value_equal (value1->x, value2->x))) &&
          (value1->y == value2->y ||
           (value1->y != NULL && value2->y != NULL &&
-           gtk_css_value_equal (value1->y, value2->y)));
+           _gtk_css_value_equal (value1->y, value2->y)));
 }
 
 static GtkCssValue *
@@ -95,9 +95,9 @@ gtk_css_value_bg_size_transition (GtkCssValue *start,
   GtkCssValue *x, *y;
 
   if (start->cover)
-    return end->cover ? gtk_css_value_ref (end) : NULL;
+    return end->cover ? _gtk_css_value_ref (end) : NULL;
   if (start->contain)
-    return end->contain ? gtk_css_value_ref (end) : NULL;
+    return end->contain ? _gtk_css_value_ref (end) : NULL;
 
   if ((start->x != NULL) ^ (end->x != NULL) ||
       (start->y != NULL) ^ (end->y != NULL))
@@ -105,7 +105,7 @@ gtk_css_value_bg_size_transition (GtkCssValue *start,
 
   if (start->x)
     {
-      x = gtk_css_value_transition (start->x, end->x, property_id, progress);
+      x = _gtk_css_value_transition (start->x, end->x, property_id, progress);
       if (x == NULL)
         return NULL;
     }
@@ -114,10 +114,10 @@ gtk_css_value_bg_size_transition (GtkCssValue *start,
 
   if (start->y)
     {
-      y = gtk_css_value_transition (start->y, end->y, property_id, progress);
+      y = _gtk_css_value_transition (start->y, end->y, property_id, progress);
       if (y == NULL)
         {
-          gtk_css_value_unref (x);
+          _gtk_css_value_unref (x);
           return NULL;
         }
     }
@@ -140,12 +140,12 @@ gtk_css_value_bg_size_print (const GtkCssValue *value,
       if (value->x == NULL)
         g_string_append (string, "auto");
       else
-        gtk_css_value_print (value->x, string);
+        _gtk_css_value_print (value->x, string);
 
       if (value->y)
         {
           g_string_append_c (string, ' ');
-          gtk_css_value_print (value->y, string);
+          _gtk_css_value_print (value->y, string);
         }
     }
 }
@@ -161,9 +161,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, 1, 0, 0, FALSE, FALSE, NULL, NULL };
-static GtkCssValue cover_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, 1, 0, 0, TRUE, FALSE, NULL, NULL };
-static GtkCssValue contain_singleton = { &GTK_CSS_VALUE_BG_SIZE, 1, 1, 0, 0, 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,
@@ -172,9 +172,9 @@ _gtk_css_bg_size_value_new (GtkCssValue *x,
   GtkCssValue *result;
 
   if (x == NULL && y == NULL)
-    return gtk_css_value_ref (&auto_singleton);
+    return _gtk_css_value_ref (&auto_singleton);
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_BG_SIZE);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_BG_SIZE);
   result->x = x;
   result->y = y;
   result->is_computed = (!x || gtk_css_value_is_computed (x)) &&
@@ -189,18 +189,18 @@ _gtk_css_bg_size_value_parse (GtkCssParser *parser)
   GtkCssValue *x, *y;
 
   if (gtk_css_parser_try_ident (parser, "cover"))
-    return gtk_css_value_ref (&cover_singleton);
+    return _gtk_css_value_ref (&cover_singleton);
   else if (gtk_css_parser_try_ident (parser, "contain"))
-    return gtk_css_value_ref (&contain_singleton);
+    return _gtk_css_value_ref (&contain_singleton);
 
   if (gtk_css_parser_try_ident (parser, "auto"))
     x = NULL;
   else
     {
-      x = gtk_css_number_value_parse (parser,
-                                      GTK_CSS_POSITIVE_ONLY
-                                      | GTK_CSS_PARSE_PERCENT
-                                      | GTK_CSS_PARSE_LENGTH);
+      x = _gtk_css_number_value_parse (parser,
+                                       GTK_CSS_POSITIVE_ONLY
+                                       | GTK_CSS_PARSE_PERCENT
+                                       | GTK_CSS_PARSE_LENGTH);
       if (x == NULL)
         return NULL;
     }
@@ -211,13 +211,13 @@ _gtk_css_bg_size_value_parse (GtkCssParser *parser)
     y = NULL;
   else
     {
-      y = gtk_css_number_value_parse (parser,
-                                      GTK_CSS_POSITIVE_ONLY
-                                      | GTK_CSS_PARSE_PERCENT
-                                      | GTK_CSS_PARSE_LENGTH);
+      y = _gtk_css_number_value_parse (parser,
+                                       GTK_CSS_POSITIVE_ONLY
+                                       | GTK_CSS_PARSE_PERCENT
+                                       | GTK_CSS_PARSE_LENGTH);
       if (y == NULL)
         {
-          gtk_css_value_unref (x);
+          _gtk_css_value_unref (x);
           return NULL;
         }
     }
@@ -280,8 +280,8 @@ _gtk_css_bg_size_value_compute_size (const GtkCssValue *value,
       double x, y;
 
       /* note: 0 does the right thing later for 'auto' */
-      x = value->x ? gtk_css_number_value_get (value->x, area_width) : 0;
-      y = value->y ? gtk_css_number_value_get (value->y, area_height) : 0;
+      x = value->x ? _gtk_css_number_value_get (value->x, area_width) : 0;
+      y = value->y ? _gtk_css_number_value_get (value->y, area_height) : 0;
 
       if ((x <= 0 && value->x) ||
           (y <= 0 && value->y))

gtk/gtkcssbordervalue.c

@@ -35,7 +35,7 @@ gtk_css_value_border_free (GtkCssValue *value)
   for (i = 0; i < 4; i++)
     {
       if (value->values[i])
-        gtk_css_value_unref (value->values[i]);
+        _gtk_css_value_unref (value->values[i]);
     }
 
   g_free (value);
@@ -55,7 +55,7 @@ gtk_css_value_border_compute (GtkCssValue          *value,
     {
       if (value->values[i])
         {
-          values[i] = gtk_css_value_compute (value->values[i], property_id, context);
+          values[i] = _gtk_css_value_compute (value->values[i], property_id, context);
           changed |= (values[i] != value->values[i]);
         }
       else
@@ -69,9 +69,9 @@ gtk_css_value_border_compute (GtkCssValue          *value,
       for (i = 0; i < 4; i++)
         {
           if (values[i] != NULL)
-            gtk_css_value_unref (values[i]);
+            _gtk_css_value_unref (values[i]);
         }
-      return gtk_css_value_ref (value);
+      return _gtk_css_value_ref (value);
     }
 
   computed = _gtk_css_border_value_new (values[0], values[1], values[2], values[3]);
@@ -91,7 +91,7 @@ gtk_css_value_border_equal (const GtkCssValue *value1,
 
   for (i = 0; i < 4; i++)
     {
-      if (!gtk_css_value_equal0 (value1->values[i], value2->values[i]))
+      if (!_gtk_css_value_equal0 (value1->values[i], value2->values[i]))
         return FALSE;
     }
 
@@ -113,11 +113,11 @@ gtk_css_value_border_print (const GtkCssValue *value,
 {
   guint i, n;
 
-  if (!gtk_css_value_equal0 (value->values[GTK_CSS_RIGHT], value->values[GTK_CSS_LEFT]))
+  if (!_gtk_css_value_equal0 (value->values[GTK_CSS_RIGHT], value->values[GTK_CSS_LEFT]))
     n = 4;
-  else if (!gtk_css_value_equal0 (value->values[GTK_CSS_TOP], value->values[GTK_CSS_BOTTOM]))
+  else if (!_gtk_css_value_equal0 (value->values[GTK_CSS_TOP], value->values[GTK_CSS_BOTTOM]))
     n = 3;
-  else if (!gtk_css_value_equal0 (value->values[GTK_CSS_TOP], value->values[GTK_CSS_RIGHT]))
+  else if (!_gtk_css_value_equal0 (value->values[GTK_CSS_TOP], value->values[GTK_CSS_RIGHT]))
     n = 2;
   else
     n = 1;
@@ -130,7 +130,7 @@ gtk_css_value_border_print (const GtkCssValue *value,
       if (value->values[i] == NULL)
         g_string_append (string, "auto");
       else
-        gtk_css_value_print (value->values[i], string);
+        _gtk_css_value_print (value->values[i], string);
     }
 
   if (value->fill)
@@ -156,7 +156,7 @@ _gtk_css_border_value_new (GtkCssValue *top,
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_BORDER);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_BORDER);
   result->values[GTK_CSS_TOP] = top;
   result->values[GTK_CSS_RIGHT] = right;
   result->values[GTK_CSS_BOTTOM] = bottom;
@@ -191,10 +191,10 @@ _gtk_css_border_value_parse (GtkCssParser           *parser,
       if (!gtk_css_number_value_can_parse (parser))
         break;
 
-      result->values[i] = gtk_css_number_value_parse (parser, flags);
+      result->values[i] = _gtk_css_number_value_parse (parser, flags);
       if (result->values[i] == NULL)
         {
-          gtk_css_value_unref (result);
+          _gtk_css_value_unref (result);
           return NULL;
         }
     }
@@ -202,7 +202,7 @@ _gtk_css_border_value_parse (GtkCssParser           *parser,
   if (i == 0)
     {
       gtk_css_parser_error_syntax (parser, "Expected a number");
-      gtk_css_value_unref (result);
+      _gtk_css_value_unref (result);
       return NULL;
     }
 
@@ -212,7 +212,7 @@ _gtk_css_border_value_parse (GtkCssParser           *parser,
   for (; i < 4; i++)
     {
       if (result->values[(i - 1) >> 1])
-        result->values[i] = gtk_css_value_ref (result->values[(i - 1) >> 1]);
+        result->values[i] = _gtk_css_value_ref (result->values[(i - 1) >> 1]);
     }
 
   result->is_computed = TRUE;

gtk/gtkcssboxesimplprivate.h

@@ -84,17 +84,17 @@ gtk_css_boxes_rect_grow (GskRoundedRect *dest,
       if (gtk_css_dimension_value_is_zero (right))
         dest->bounds.size.width = src->bounds.size.width;
       else
-        dest->bounds.size.width = src->bounds.size.width + gtk_css_number_value_get (right, 100);
+        dest->bounds.size.width = src->bounds.size.width + _gtk_css_number_value_get (right, 100);
     }
   else
     {
-      const double left_value = gtk_css_number_value_get (left, 100);
+      const double left_value = _gtk_css_number_value_get (left, 100);
 
       dest->bounds.origin.x = src->bounds.origin.x - left_value;
       if (gtk_css_dimension_value_is_zero (right))
         dest->bounds.size.width = src->bounds.size.width + left_value;
       else
-        dest->bounds.size.width = src->bounds.size.width + left_value + gtk_css_number_value_get (right, 100);
+        dest->bounds.size.width = src->bounds.size.width + left_value + _gtk_css_number_value_get (right, 100);
 
     }
 
@@ -105,17 +105,17 @@ gtk_css_boxes_rect_grow (GskRoundedRect *dest,
       if (gtk_css_dimension_value_is_zero (bottom))
         dest->bounds.size.height = src->bounds.size.height;
       else
-        dest->bounds.size.height = src->bounds.size.height + gtk_css_number_value_get (bottom, 100);
+        dest->bounds.size.height = src->bounds.size.height + _gtk_css_number_value_get (bottom, 100);
     }
   else
     {
-      const double top_value = gtk_css_number_value_get (top, 100);
+      const double top_value = _gtk_css_number_value_get (top, 100);
 
       dest->bounds.origin.y = src->bounds.origin.y - top_value;
       if (gtk_css_dimension_value_is_zero (bottom))
         dest->bounds.size.height = src->bounds.size.height + top_value;
       else
-        dest->bounds.size.height = src->bounds.size.height + top_value + gtk_css_number_value_get (bottom, 100);
+        dest->bounds.size.height = src->bounds.size.height + top_value + _gtk_css_number_value_get (bottom, 100);
     }
 }
 
@@ -127,10 +127,10 @@ gtk_css_boxes_rect_shrink (GskRoundedRect *dest,
                            GtkCssValue    *bottom_value,
                            GtkCssValue    *left_value)
 {
-  double top = gtk_css_number_value_get (top_value, 100);
-  double right = gtk_css_number_value_get (right_value, 100);
-  double bottom = gtk_css_number_value_get (bottom_value, 100);
-  double left = gtk_css_number_value_get (left_value, 100);
+  double top = _gtk_css_number_value_get (top_value, 100);
+  double right = _gtk_css_number_value_get (right_value, 100);
+  double bottom = _gtk_css_number_value_get (bottom_value, 100);
+  double left = _gtk_css_number_value_get (left_value, 100);
 
   /* FIXME: Do we need underflow checks here? */
   dest->bounds.origin.x = src->bounds.origin.x + left;
@@ -255,8 +255,8 @@ gtk_css_boxes_compute_outline_rect (GtkCssBoxes *boxes)
   dest = &boxes->box[GTK_CSS_AREA_OUTLINE_BOX].bounds;
   src = &boxes->box[GTK_CSS_AREA_BORDER_BOX].bounds;
 
-  d = gtk_css_number_value_get (boxes->style->outline->outline_offset, 100) +
-      gtk_css_number_value_get (boxes->style->outline->outline_width, 100);
+  d = _gtk_css_number_value_get (boxes->style->outline->outline_offset, 100) +
+      _gtk_css_number_value_get (boxes->style->outline->outline_width, 100);
 
   dest->origin.x = src->origin.x - d;
   dest->origin.y = src->origin.y - d;
@@ -483,8 +483,8 @@ gtk_css_boxes_compute_outline_box (GtkCssBoxes *boxes)
   src = &boxes->box[GTK_CSS_AREA_BORDER_BOX];
   dest = &boxes->box[GTK_CSS_AREA_OUTLINE_BOX];
 
-  d = gtk_css_number_value_get (boxes->style->outline->outline_offset, 100) +
-      gtk_css_number_value_get (boxes->style->outline->outline_width, 100);
+  d = _gtk_css_number_value_get (boxes->style->outline->outline_offset, 100) +
+      _gtk_css_number_value_get (boxes->style->outline->outline_width, 100);
 
   /* Grow border rect into outline rect */
   dest->bounds.origin.x = src->bounds.origin.x - d;

gtk/gtkcsscalcvalue.c

@@ -60,7 +60,7 @@ gtk_css_calc_value_parse_value (GtkCssParser           *parser,
       return result;
     }
 
-  return gtk_css_number_value_parse (parser, flags);
+  return _gtk_css_number_value_parse (parser, flags);
 }
 
 static gboolean
@@ -96,11 +96,11 @@ gtk_css_calc_value_parse_product (GtkCssParser           *parser,
           if (value == NULL)
             goto fail;
           if (is_number (value))
-            temp = gtk_css_number_value_multiply (result, gtk_css_number_value_get (value, 100));
+            temp = gtk_css_number_value_multiply (result, _gtk_css_number_value_get (value, 100));
           else
-            temp = gtk_css_number_value_multiply (value, gtk_css_number_value_get (result, 100));
-          gtk_css_value_unref (value);
-          gtk_css_value_unref (result);
+            temp = gtk_css_number_value_multiply (value, _gtk_css_number_value_get (result, 100));
+          _gtk_css_value_unref (value);
+          _gtk_css_value_unref (result);
           result = temp;
         }
       else if (gtk_css_parser_try_delim (parser, '/'))
@@ -108,9 +108,9 @@ gtk_css_calc_value_parse_product (GtkCssParser           *parser,
           value = gtk_css_calc_value_parse_product (parser, GTK_CSS_PARSE_NUMBER);
           if (value == NULL)
             goto fail;
-          temp = gtk_css_number_value_multiply (result, 1.0 / gtk_css_number_value_get (value, 100));
-          gtk_css_value_unref (value);
-          gtk_css_value_unref (result);
+          temp = gtk_css_number_value_multiply (result, 1.0 / _gtk_css_number_value_get (value, 100));
+          _gtk_css_value_unref (value);
+          _gtk_css_value_unref (result);
           result = temp;
         }
       else
@@ -132,7 +132,7 @@ gtk_css_calc_value_parse_product (GtkCssParser           *parser,
   return result;
 
 fail:
-  gtk_css_value_unref (result);
+  _gtk_css_value_unref (result);
   return NULL;
 }
 
@@ -162,7 +162,7 @@ gtk_css_calc_value_parse_sum (GtkCssParser           *parser,
           if (temp == NULL)
             goto fail;
           next = gtk_css_number_value_multiply (temp, -1);
-          gtk_css_value_unref (temp);
+          _gtk_css_value_unref (temp);
         }
       else
         {
@@ -178,15 +178,15 @@ gtk_css_calc_value_parse_sum (GtkCssParser           *parser,
         }
 
       temp = gtk_css_number_value_add (result, next);
-      gtk_css_value_unref (result);
-      gtk_css_value_unref (next);
+      _gtk_css_value_unref (result);
+      _gtk_css_value_unref (next);
       result = temp;
     }
 
   return result;
 
 fail:
-  gtk_css_value_unref (result);
+  _gtk_css_value_unref (result);
   return NULL;
 }
 
@@ -232,307 +232,3 @@ gtk_css_calc_value_parse (GtkCssParser           *parser,
   return data.value;
 }
 
-typedef struct
-{
-  GtkCssNumberParseFlags flags;
-  GPtrArray *values;
-} ParseArgnData;
-
-static guint
-gtk_css_argn_value_parse_arg (GtkCssParser *parser,
-                              guint         arg,
-                              gpointer      data_)
-{
-  ParseArgnData *data = data_;
-  GtkCssValue *value;
-
-  value = gtk_css_calc_value_parse_sum (parser, data->flags);
-  if (value == NULL)
-    return 0;
-
-  g_ptr_array_add (data->values, value);
-
-  return 1;
-}
-
-typedef struct
-{
-  GtkCssNumberParseFlags flags;
-  GtkCssValue *values[3];
-} ParseClampData;
-
-static guint
-gtk_css_clamp_value_parse_arg (GtkCssParser *parser,
-                               guint         arg,
-                               gpointer      data_)
-{
-  ParseClampData *data = data_;
-
-  if ((arg == 0 || arg == 2))
-    {
-      if (gtk_css_parser_try_ident (parser, "none"))
-        {
-          data->values[arg] = NULL;
-          return 1;
-        }
-    }
-
-  data->values[arg] = gtk_css_calc_value_parse_sum (parser, data->flags);
-  if (data->values[arg] == NULL)
-    return 0;
-
-  return 1;
-}
-
-GtkCssValue *
-gtk_css_clamp_value_parse (GtkCssParser           *parser,
-                           GtkCssNumberParseFlags  flags,
-                           guint                   type)
-{
-  ParseClampData data;
-  GtkCssValue *result = NULL;
-
-  if (!gtk_css_parser_has_function (parser, "clamp"))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected 'clamp('");
-      return NULL;
-    }
-
-  /* This can only be handled at compute time, we allow '-' after all */
-  data.flags = flags & ~GTK_CSS_POSITIVE_ONLY;
-  data.values[0] = NULL;
-  data.values[1] = NULL;
-  data.values[2] = NULL;
-
-  if (gtk_css_parser_consume_function (parser, 3, 3, gtk_css_clamp_value_parse_arg, &data))
-    {
-      GtkCssDimension dim = gtk_css_number_value_get_dimension (data.values[1]);
-      if ((data.values[0] && gtk_css_number_value_get_dimension (data.values[0]) != dim) ||
-          (data.values[2] && gtk_css_number_value_get_dimension (data.values[2]) != dim))
-        gtk_css_parser_error_syntax (parser, "Inconsistent types in 'clamp('");
-      else
-        result = gtk_css_math_value_new (type, 0, data.values, 3);
-    }
-
-  if (result == NULL)
-    {
-      g_clear_pointer (&data.values[0], gtk_css_value_unref);
-      g_clear_pointer (&data.values[1], gtk_css_value_unref);
-      g_clear_pointer (&data.values[2], gtk_css_value_unref);
-    }
-
-  return result;
-}
-
-typedef struct {
-  GtkCssNumberParseFlags flags;
-  guint mode;
-  gboolean has_mode;
-  GtkCssValue *values[2];
-} ParseRoundData;
-
-static guint
-gtk_css_round_value_parse_arg (GtkCssParser *parser,
-                               guint         arg,
-                               gpointer      data_)
-{
-  ParseRoundData *data = data_;
-
-  if (arg == 0)
-    {
-      const char *modes[] = { "nearest", "up", "down", "to-zero" };
-
-      for (guint i = 0; i < G_N_ELEMENTS (modes); i++)
-        {
-          if (gtk_css_parser_try_ident (parser, modes[i]))
-            {
-              data->mode = i;
-              data->has_mode = TRUE;
-              return 1;
-            }
-        }
-
-      data->values[0] = gtk_css_calc_value_parse_sum (parser, data->flags);
-      if (data->values[0] == NULL)
-        return 0;
-    }
-  else if (arg == 1)
-    {
-      GtkCssValue *value = gtk_css_calc_value_parse_sum (parser, data->flags);
-
-      if (value == NULL)
-        return 0;
-
-      if (data->has_mode)
-        data->values[0] = value;
-      else
-        data->values[1] = value;
-    }
-  else
-    {
-      if (!data->has_mode)
-        {
-          gtk_css_parser_error_syntax (parser, "Too many argument for 'round'");
-          return 0;
-        }
-
-      data->values[1] = gtk_css_calc_value_parse_sum (parser, data->flags);
-
-      if (data->values[1] == NULL)
-        return 0;
-    }
-
-  return 1;
-}
-
-GtkCssValue *
-gtk_css_round_value_parse (GtkCssParser           *parser,
-                           GtkCssNumberParseFlags  flags,
-                           guint                   type)
-{
-  ParseRoundData data;
-  GtkCssValue *result = NULL;
-
-  if (!gtk_css_parser_has_function (parser, "round"))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected 'round('");
-      return NULL;
-    }
-
-  data.flags = flags & ~GTK_CSS_POSITIVE_ONLY;
-  data.mode = ROUND_NEAREST;
-  data.has_mode = FALSE;
-  data.values[0] = NULL;
-  data.values[1] = NULL;
-
-  if (gtk_css_parser_consume_function (parser, 1, 3, gtk_css_round_value_parse_arg, &data) &&
-      data.values[0] != NULL)
-    {
-      if (data.values[1] != NULL &&
-          gtk_css_number_value_get_dimension (data.values[0]) !=
-          gtk_css_number_value_get_dimension (data.values[1]))
-        gtk_css_parser_error_syntax (parser, "Inconsistent types in 'round('");
-      else if (data.values[1] == NULL &&
-               gtk_css_number_value_get_dimension (data.values[0]) != GTK_CSS_DIMENSION_NUMBER)
-        gtk_css_parser_error_syntax (parser, "Can't omit second argument to 'round(' here");
-      else
-        result = gtk_css_math_value_new (type, data.mode, data.values, data.values[1] != NULL ? 2 : 1);
-    }
-
-  if (result == NULL)
-    {
-      g_clear_pointer (&data.values[0], gtk_css_value_unref);
-      g_clear_pointer (&data.values[1], gtk_css_value_unref);
-    }
-
-  return result;
-}
-
-typedef struct {
-  GtkCssNumberParseFlags flags;
-  GtkCssValue *values[2];
-} ParseArg2Data;
-
-static guint
-gtk_css_arg2_value_parse_arg (GtkCssParser *parser,
-                              guint         arg,
-                              gpointer      data_)
-{
-  ParseArg2Data *data = data_;
-
-  data->values[arg] = gtk_css_calc_value_parse_sum (parser, data->flags);
-  if (data->values[arg] == NULL)
-    return 0;
-
-  return 1;
-}
-
-GtkCssValue *
-gtk_css_arg2_value_parse (GtkCssParser           *parser,
-                          GtkCssNumberParseFlags  flags,
-                          guint                   min_args,
-                          guint                   max_args,
-                          const char             *function,
-                          guint                   type)
-{
-  ParseArg2Data data;
-  GtkCssValue *result = NULL;
-
-  g_assert (1 <= min_args && min_args <= max_args && max_args <= 2);
-
-  if (!gtk_css_parser_has_function (parser, function))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected '%s('", function);
-      return NULL;
-    }
-
-  data.flags = flags & ~GTK_CSS_POSITIVE_ONLY;
-  data.values[0] = NULL;
-  data.values[1] = NULL;
-
-  if (gtk_css_parser_consume_function (parser, min_args, max_args, gtk_css_arg2_value_parse_arg, &data))
-    {
-      if (data.values[1] != NULL &&
-          gtk_css_number_value_get_dimension (data.values[0]) !=
-          gtk_css_number_value_get_dimension (data.values[1]))
-        gtk_css_parser_error_syntax (parser, "Inconsistent types in '%s('", function);
-      else
-        result = gtk_css_math_value_new (type, 0, data.values, data.values[1] != NULL ? 2 : 1);
-    }
-
-  if (result == NULL)
-    {
-      g_clear_pointer (&data.values[0], gtk_css_value_unref);
-      g_clear_pointer (&data.values[1], gtk_css_value_unref);
-    }
-
-  return result;
-}
-
-GtkCssValue *
-gtk_css_argn_value_parse (GtkCssParser           *parser,
-                          GtkCssNumberParseFlags  flags,
-                          const char             *function,
-                          guint                   type)
-{
-  ParseArgnData data;
-  GtkCssValue *result = NULL;
-
-  if (!gtk_css_parser_has_function (parser, function))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected '%s('", function);
-      return NULL;
-    }
-
-  /* This can only be handled at compute time, we allow '-' after all */
-  data.flags = flags & ~GTK_CSS_POSITIVE_ONLY;
-  data.values = g_ptr_array_new ();
-
-  if (gtk_css_parser_consume_function (parser, 1, G_MAXUINT, gtk_css_argn_value_parse_arg, &data))
-    {
-      GtkCssValue *val = (GtkCssValue *) g_ptr_array_index (data.values, 0);
-      GtkCssDimension dim = gtk_css_number_value_get_dimension (val);
-      guint i;
-      for (i = 1; i < data.values->len; i++)
-        {
-          val = (GtkCssValue *) g_ptr_array_index (data.values, i);
-          if (gtk_css_number_value_get_dimension (val) != dim)
-            break;
-        }
-      if (i < data.values->len)
-        gtk_css_parser_error_syntax (parser, "Inconsistent types in '%s('", function);
-      else
-        result = gtk_css_math_value_new (type, 0, (GtkCssValue **)data.values->pdata, data.values->len);
-    }
-
-  if (result == NULL)
-    {
-      for (guint i = 0; i < data.values->len; i++)
-        gtk_css_value_unref ((GtkCssValue *)g_ptr_array_index (data.values, i));
-    }
-
-  g_ptr_array_unref (data.values);
-
-  return result;
-}
-

gtk/gtkcsscalcvalueprivate.h

@@ -23,21 +23,6 @@ G_BEGIN_DECLS
 
 GtkCssValue *   gtk_css_calc_value_parse            (GtkCssParser           *parser,
                                                      GtkCssNumberParseFlags  flags);
-GtkCssValue *   gtk_css_clamp_value_parse           (GtkCssParser           *parser,
-                                                     GtkCssNumberParseFlags  flags,
-                                                     guint                   type);
-GtkCssValue *   gtk_css_round_value_parse           (GtkCssParser           *parser,
-                                                     GtkCssNumberParseFlags  flags,
-                                                     guint                   type);
-GtkCssValue *   gtk_css_arg2_value_parse            (GtkCssParser           *parser,
-                                                     GtkCssNumberParseFlags  flags,
-                                                     guint                   min_args,
-                                                     guint                   max_args,
-                                                     const char             *function,
-                                                     guint                   type);
-GtkCssValue *   gtk_css_argn_value_parse            (GtkCssParser           *parser,
-                                                     GtkCssNumberParseFlags  flags,
-                                                     const char             *function,
-                                                     guint                   type);
 
 G_END_DECLS
+

gtk/gtkcsscolorvalueprivate.h

@@ -27,23 +27,24 @@ G_BEGIN_DECLS
 
 GtkCssValue *   gtk_css_color_value_new_transparent     (void) G_GNUC_PURE;
 GtkCssValue *   gtk_css_color_value_new_white           (void) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_literal         (const GdkRGBA  *color) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_name            (const char     *name) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_shade           (GtkCssValue    *color,
+GtkCssValue *   _gtk_css_color_value_new_literal        (const GdkRGBA  *color) G_GNUC_PURE;
+GtkCssValue *   _gtk_css_color_value_new_name           (const char     *name) G_GNUC_PURE;
+GtkCssValue *   _gtk_css_color_value_new_shade          (GtkCssValue    *color,
                                                          double          factor) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_alpha           (GtkCssValue    *color,
+GtkCssValue *   _gtk_css_color_value_new_alpha          (GtkCssValue    *color,
                                                          double          factor) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_mix             (GtkCssValue    *color1,
+GtkCssValue *   _gtk_css_color_value_new_mix            (GtkCssValue    *color1,
                                                          GtkCssValue    *color2,
                                                          double          factor) G_GNUC_PURE;
-GtkCssValue *   gtk_css_color_value_new_current_color   (void) G_GNUC_PURE;
+GtkCssValue *   _gtk_css_color_value_new_current_color  (void) G_GNUC_PURE;
 
 gboolean        gtk_css_color_value_can_parse           (GtkCssParser   *parser);
-GtkCssValue *   gtk_css_color_value_parse               (GtkCssParser   *parser);
+GtkCssValue *   _gtk_css_color_value_parse              (GtkCssParser   *parser);
 
-GtkCssValue *   gtk_css_color_value_resolve             (GtkCssValue      *color,
+GtkCssValue *   _gtk_css_color_value_resolve            (GtkCssValue      *color,
                                                          GtkStyleProvider *provider,
-                                                         GtkCssValue      *current);
+                                                         GtkCssValue      *current,
+                                                         GSList           *cycle_list);
 const GdkRGBA * gtk_css_color_value_get_rgba            (const GtkCssValue *color) G_GNUC_CONST;
 
 

gtk/gtkcsscornervalue.c

@@ -30,8 +30,8 @@ struct _GtkCssValue {
 static void
 gtk_css_value_corner_free (GtkCssValue *value)
 {
-  gtk_css_value_unref (value->x);
-  gtk_css_value_unref (value->y);
+  _gtk_css_value_unref (value->x);
+  _gtk_css_value_unref (value->y);
 
   g_free (value);
 }
@@ -43,13 +43,13 @@ gtk_css_value_corner_compute (GtkCssValue          *corner,
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_value_compute (corner->x, property_id, context);
-  y = gtk_css_value_compute (corner->y, property_id, context);
+  x = _gtk_css_value_compute (corner->x, property_id, context);
+  y = _gtk_css_value_compute (corner->y, property_id, context);
   if (x == corner->x && y == corner->y)
     {
-      gtk_css_value_unref (x);
-      gtk_css_value_unref (y);
-      return gtk_css_value_ref (corner);
+      _gtk_css_value_unref (x);
+      _gtk_css_value_unref (y);
+      return _gtk_css_value_ref (corner);
     }
 
   return _gtk_css_corner_value_new (x, y);
@@ -59,8 +59,8 @@ static gboolean
 gtk_css_value_corner_equal (const GtkCssValue *corner1,
                             const GtkCssValue *corner2)
 {
-  return gtk_css_value_equal (corner1->x, corner2->x)
-      && gtk_css_value_equal (corner1->y, corner2->y);
+  return _gtk_css_value_equal (corner1->x, corner2->x)
+      && _gtk_css_value_equal (corner1->y, corner2->y);
 }
 
 static GtkCssValue *
@@ -71,13 +71,13 @@ gtk_css_value_corner_transition (GtkCssValue *start,
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_value_transition (start->x, end->x, property_id, progress);
+  x = _gtk_css_value_transition (start->x, end->x, property_id, progress);
   if (x == NULL)
     return NULL;
-  y = gtk_css_value_transition (start->y, end->y, property_id, progress);
+  y = _gtk_css_value_transition (start->y, end->y, property_id, progress);
   if (y == NULL)
     {
-      gtk_css_value_unref (x);
+      _gtk_css_value_unref (x);
       return NULL;
     }
 
@@ -88,11 +88,11 @@ static void
 gtk_css_value_corner_print (const GtkCssValue *corner,
                             GString           *string)
 {
-  gtk_css_value_print (corner->x, string);
-  if (!gtk_css_value_equal (corner->x, corner->y))
+  _gtk_css_value_print (corner->x, string);
+  if (!_gtk_css_value_equal (corner->x, corner->y))
     {
       g_string_append_c (string, ' ');
-      gtk_css_value_print (corner->y, string);
+      _gtk_css_value_print (corner->y, string);
     }
 }
 
@@ -108,14 +108,14 @@ static const GtkCssValueClass GTK_CSS_VALUE_CORNER = {
 };
 
 static GtkCssValue corner_singletons[] = {
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, NULL, NULL },
-  { &GTK_CSS_VALUE_CORNER, 1, 1, 0, 0, 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
@@ -158,7 +158,7 @@ _gtk_css_corner_value_new (GtkCssValue *x,
         }
     }
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_CORNER);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_CORNER);
   result->x = x;
   result->y = y;
 
@@ -170,24 +170,24 @@ _gtk_css_corner_value_parse (GtkCssParser *parser)
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_number_value_parse (parser,
-                                  GTK_CSS_POSITIVE_ONLY
-                                  | GTK_CSS_PARSE_PERCENT
-                                  | GTK_CSS_PARSE_LENGTH);
+  x = _gtk_css_number_value_parse (parser,
+                                   GTK_CSS_POSITIVE_ONLY
+                                   | GTK_CSS_PARSE_PERCENT
+                                   | GTK_CSS_PARSE_LENGTH);
   if (x == NULL)
     return NULL;
 
   if (!gtk_css_number_value_can_parse (parser))
-    y = gtk_css_value_ref (x);
+    y = _gtk_css_value_ref (x);
   else
     {
-      y = gtk_css_number_value_parse (parser,
-                                      GTK_CSS_POSITIVE_ONLY
-                                      | GTK_CSS_PARSE_PERCENT
-                                      | GTK_CSS_PARSE_LENGTH);
+      y = _gtk_css_number_value_parse (parser,
+                                       GTK_CSS_POSITIVE_ONLY
+                                       | GTK_CSS_PARSE_PERCENT
+                                       | GTK_CSS_PARSE_LENGTH);
       if (y == NULL)
         {
-          gtk_css_value_unref (x);
+          _gtk_css_value_unref (x);
           return NULL;
         }
     }
@@ -202,7 +202,7 @@ _gtk_css_corner_value_get_x (const GtkCssValue *corner,
   g_return_val_if_fail (corner != NULL, 0.0);
   g_return_val_if_fail (corner->class == &GTK_CSS_VALUE_CORNER, 0.0);
 
-  return gtk_css_number_value_get (corner->x, one_hundred_percent);
+  return _gtk_css_number_value_get (corner->x, one_hundred_percent);
 }
 
 double
@@ -212,7 +212,7 @@ _gtk_css_corner_value_get_y (const GtkCssValue *corner,
   g_return_val_if_fail (corner != NULL, 0.0);
   g_return_val_if_fail (corner->class == &GTK_CSS_VALUE_CORNER, 0.0);
 
-  return gtk_css_number_value_get (corner->y, one_hundred_percent);
+  return _gtk_css_number_value_get (corner->y, one_hundred_percent);
 }
 
 gboolean

gtk/gtkcsseasevalue.c

@@ -54,7 +54,7 @@ gtk_css_value_ease_compute (GtkCssValue          *value,
                             guint                 property_id,
                             GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (value);
+  return _gtk_css_value_ref (value);
 }
 
 static gboolean
@@ -156,7 +156,7 @@ _gtk_css_ease_value_new_cubic_bezier (double x1,
   g_return_val_if_fail (x2 >= 0.0, NULL);
   g_return_val_if_fail (x2 <= 1.0, NULL);
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
 
   value->type = GTK_CSS_EASE_CUBIC_BEZIER;
   value->u.cubic.x1 = x1;
@@ -176,7 +176,7 @@ _gtk_css_ease_value_new_steps (guint n_steps,
 
   g_return_val_if_fail (n_steps > 0, NULL);
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
 
   value->type = GTK_CSS_EASE_STEPS;
   value->u.steps.steps = n_steps;

gtk/gtkcssenumvalue.c

@@ -45,7 +45,7 @@ gtk_css_value_enum_compute (GtkCssValue          *value,
                             guint                 property_id,
                             GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (value);
+  return _gtk_css_value_ref (value);
 }
 
 static gboolean
@@ -85,16 +85,16 @@ static const GtkCssValueClass GTK_CSS_VALUE_BORDER_STYLE = {
 };
 
 static GtkCssValue border_style_values[] = {
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_NONE, "none" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_SOLID, "solid" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_INSET, "inset" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_OUTSET, "outset" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_HIDDEN, "hidden" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_DOTTED, "dotted" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_DASHED, "dashed" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_DOUBLE, "double" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, GTK_BORDER_STYLE_GROOVE, "groove" },
-  { &GTK_CSS_VALUE_BORDER_STYLE, 1, 1, 0, 0, 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 *
@@ -102,7 +102,7 @@ _gtk_css_border_style_value_new (GtkBorderStyle border_style)
 {
   g_return_val_if_fail (border_style < G_N_ELEMENTS (border_style_values), NULL);
 
-  return gtk_css_value_ref (&border_style_values[border_style]);
+  return _gtk_css_value_ref (&border_style_values[border_style]);
 }
 
 GtkCssValue *
@@ -115,7 +115,7 @@ _gtk_css_border_style_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (border_style_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, border_style_values[i].name))
-        return gtk_css_value_ref (&border_style_values[i]);
+        return _gtk_css_value_ref (&border_style_values[i]);
     }
 
   return NULL;
@@ -143,22 +143,22 @@ static const GtkCssValueClass GTK_CSS_VALUE_BLEND_MODE = {
 };
 
 static GtkCssValue blend_mode_values[] = {
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_DEFAULT, "normal" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_MULTIPLY, "multiply" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_SCREEN, "screen" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_OVERLAY, "overlay" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_DARKEN, "darken" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_LIGHTEN, "lighten" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_COLOR_DODGE, "color-dodge" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_COLOR_BURN, "color-burn" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_HARD_LIGHT, "hard-light" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_SOFT_LIGHT, "soft-light" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_DIFFERENCE, "difference" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_EXCLUSION, "exclusion" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_COLOR, "color" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_HUE, "hue" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, GSK_BLEND_MODE_SATURATION, "saturation" },
-  { &GTK_CSS_VALUE_BLEND_MODE, 1, 1, 0, 0, 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 *
@@ -166,7 +166,7 @@ _gtk_css_blend_mode_value_new (GskBlendMode blend_mode)
 {
   g_return_val_if_fail (blend_mode < G_N_ELEMENTS (blend_mode_values), NULL);
 
-  return gtk_css_value_ref (&blend_mode_values[blend_mode]);
+  return _gtk_css_value_ref (&blend_mode_values[blend_mode]);
 }
 
 GtkCssValue *
@@ -179,7 +179,7 @@ _gtk_css_blend_mode_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (blend_mode_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, blend_mode_values[i].name))
-        return gtk_css_value_ref (&blend_mode_values[i]);
+        return _gtk_css_value_ref (&blend_mode_values[i]);
     }
 
   return NULL;
@@ -198,7 +198,7 @@ _gtk_css_blend_mode_value_get (const GtkCssValue *value)
 static double
 get_dpi (GtkCssStyle *style)
 {
-  return gtk_css_number_value_get (style->core->dpi, 96);
+  return _gtk_css_number_value_get (style->core->dpi, 96);
 }
 
 /* XXX: Kinda bad to have that machinery here, nobody expects vital font
@@ -265,7 +265,7 @@ gtk_css_value_font_size_compute (GtkCssValue          *value,
       break;
     case GTK_CSS_FONT_SIZE_SMALLER:
       if (parent_style)
-        font_size = gtk_css_number_value_get (parent_style->core->font_size, 100);
+        font_size = _gtk_css_number_value_get (parent_style->core->font_size, 100);
       else
         font_size = gtk_css_font_size_get_default_px (provider, style);
       /* This is what WebKit does... */
@@ -273,7 +273,7 @@ gtk_css_value_font_size_compute (GtkCssValue          *value,
       break;
     case GTK_CSS_FONT_SIZE_LARGER:
       if (parent_style)
-        font_size = gtk_css_number_value_get (parent_style->core->font_size, 100);
+        font_size = _gtk_css_number_value_get (parent_style->core->font_size, 100);
       else
         font_size = gtk_css_font_size_get_default_px (provider, style);
       /* This is what WebKit does... */
@@ -281,7 +281,7 @@ gtk_css_value_font_size_compute (GtkCssValue          *value,
       break;
   }
 
-  return gtk_css_number_value_new (font_size, GTK_CSS_PX);
+  return _gtk_css_number_value_new (font_size, GTK_CSS_PX);
 }
 
 static const GtkCssValueClass GTK_CSS_VALUE_FONT_SIZE = {
@@ -296,15 +296,15 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_SIZE = {
 };
 
 static GtkCssValue font_size_values[] = {
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_SMALLER, "smaller" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_LARGER, "larger" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_XX_SMALL, "xx-small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_X_SMALL, "x-small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_SMALL, "small" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_MEDIUM, "medium" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_LARGE, "large" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, GTK_CSS_FONT_SIZE_X_LARGE, "x-large" },
-  { &GTK_CSS_VALUE_FONT_SIZE, 1, 0, 0, 0, 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 *
@@ -312,7 +312,7 @@ _gtk_css_font_size_value_new (GtkCssFontSize font_size)
 {
   g_return_val_if_fail (font_size < G_N_ELEMENTS (font_size_values), NULL);
 
-  return gtk_css_value_ref (&font_size_values[font_size]);
+  return _gtk_css_value_ref (&font_size_values[font_size]);
 }
 
 GtkCssValue *
@@ -325,7 +325,7 @@ _gtk_css_font_size_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_size_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_size_values[i].name))
-        return gtk_css_value_ref (&font_size_values[i]);
+        return _gtk_css_value_ref (&font_size_values[i]);
     }
 
   return NULL;
@@ -353,9 +353,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_STYLE = {
 };
 
 static GtkCssValue font_style_values[] = {
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, 1, 0, 0, PANGO_STYLE_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, 1, 0, 0, PANGO_STYLE_OBLIQUE, "oblique" },
-  { &GTK_CSS_VALUE_FONT_STYLE, 1, 1, 0, 0, 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 *
@@ -363,7 +363,7 @@ _gtk_css_font_style_value_new (PangoStyle font_style)
 {
   g_return_val_if_fail (font_style < G_N_ELEMENTS (font_style_values), NULL);
 
-  return gtk_css_value_ref (&font_style_values[font_style]);
+  return _gtk_css_value_ref (&font_style_values[font_style]);
 }
 
 GtkCssValue *
@@ -376,7 +376,7 @@ _gtk_css_font_style_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_style_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_style_values[i].name))
-        return gtk_css_value_ref (&font_style_values[i]);
+        return _gtk_css_value_ref (&font_style_values[i]);
     }
 
   return NULL;
@@ -404,10 +404,10 @@ gtk_css_value_font_weight_compute (GtkCssValue          *value,
   int parent_value;
 
   if (value->value >= 0)
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   if (context->parent_style)
-    parent_value = gtk_css_number_value_get (context->parent_style->font->font_weight, 100);
+    parent_value = _gtk_css_number_value_get (context->parent_style->font->font_weight, 100);
   else
     parent_value = 400;
 
@@ -435,7 +435,7 @@ gtk_css_value_font_weight_compute (GtkCssValue          *value,
       new_weight = PANGO_WEIGHT_NORMAL;
     }
 
-  return gtk_css_number_value_new (new_weight, GTK_CSS_NUMBER);
+  return _gtk_css_number_value_new (new_weight, GTK_CSS_NUMBER);
 }
 
 static const GtkCssValueClass GTK_CSS_VALUE_FONT_WEIGHT = {
@@ -450,8 +450,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_WEIGHT = {
 };
 
 static GtkCssValue font_weight_values[] = {
-  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, 0, 0, 0, BOLDER, "bolder" },
-  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, 0, 0, 0, LIGHTER, "lighter" },
+  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, FALSE, BOLDER, "bolder" },
+  { &GTK_CSS_VALUE_FONT_WEIGHT, 1, FALSE, FALSE, LIGHTER, "lighter" },
 };
 
 GtkCssValue *
@@ -464,13 +464,13 @@ gtk_css_font_weight_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_weight_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_weight_values[i].name))
-        return gtk_css_value_ref (&font_weight_values[i]);
+        return _gtk_css_value_ref (&font_weight_values[i]);
     }
 
   if (gtk_css_parser_try_ident (parser, "normal"))
-    return gtk_css_number_value_new (PANGO_WEIGHT_NORMAL, GTK_CSS_NUMBER);
+    return _gtk_css_number_value_new (PANGO_WEIGHT_NORMAL, GTK_CSS_NUMBER);
   if (gtk_css_parser_try_ident (parser, "bold"))
-    return gtk_css_number_value_new (PANGO_WEIGHT_BOLD, GTK_CSS_NUMBER);
+    return _gtk_css_number_value_new (PANGO_WEIGHT_BOLD, GTK_CSS_NUMBER);
 
   return NULL;
 }
@@ -500,15 +500,15 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_STRETCH = {
 };
 
 static GtkCssValue font_stretch_values[] = {
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_ULTRA_CONDENSED, "ultra-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_EXTRA_CONDENSED, "extra-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_CONDENSED, "condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_SEMI_CONDENSED, "semi-condensed" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_SEMI_EXPANDED, "semi-expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_EXPANDED, "expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, PANGO_STRETCH_EXTRA_EXPANDED, "extra-expanded" },
-  { &GTK_CSS_VALUE_FONT_STRETCH, 1, 1, 0, 0, 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 *
@@ -516,7 +516,7 @@ _gtk_css_font_stretch_value_new (PangoStretch font_stretch)
 {
   g_return_val_if_fail (font_stretch < G_N_ELEMENTS (font_stretch_values), NULL);
 
-  return gtk_css_value_ref (&font_stretch_values[font_stretch]);
+  return _gtk_css_value_ref (&font_stretch_values[font_stretch]);
 }
 
 GtkCssValue *
@@ -529,7 +529,7 @@ _gtk_css_font_stretch_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_stretch_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_stretch_values[i].name))
-        return gtk_css_value_ref (&font_stretch_values[i]);
+        return _gtk_css_value_ref (&font_stretch_values[i]);
     }
 
   return NULL;
@@ -557,9 +557,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_TEXT_DECORATION_STYLE = {
 };
 
 static GtkCssValue text_decoration_style_values[] = {
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, 1, 0, 0, GTK_CSS_TEXT_DECORATION_STYLE_SOLID, "solid" },
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, 1, 0, 0, GTK_CSS_TEXT_DECORATION_STYLE_DOUBLE, "double" },
-  { &GTK_CSS_VALUE_TEXT_DECORATION_STYLE, 1, 1, 0, 0, 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 *
@@ -567,7 +567,7 @@ _gtk_css_text_decoration_style_value_new (GtkTextDecorationStyle style)
 {
   g_return_val_if_fail (style < G_N_ELEMENTS (text_decoration_style_values), NULL);
 
-  return gtk_css_value_ref (&text_decoration_style_values[style]);
+  return _gtk_css_value_ref (&text_decoration_style_values[style]);
 }
 
 GtkCssValue *
@@ -580,7 +580,7 @@ _gtk_css_text_decoration_style_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (text_decoration_style_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, text_decoration_style_values[i].name))
-        return gtk_css_value_ref (&text_decoration_style_values[i]);
+        return _gtk_css_value_ref (&text_decoration_style_values[i]);
     }
 
   return NULL;
@@ -608,9 +608,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_AREA = {
 };
 
 static GtkCssValue area_values[] = {
-  { &GTK_CSS_VALUE_AREA, 1, 1, 0, 0, GTK_CSS_AREA_BORDER_BOX, "border-box" },
-  { &GTK_CSS_VALUE_AREA, 1, 1, 0, 0, GTK_CSS_AREA_PADDING_BOX, "padding-box" },
-  { &GTK_CSS_VALUE_AREA, 1, 1, 0, 0, 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 *
@@ -621,7 +621,7 @@ _gtk_css_area_value_new (GtkCssArea area)
   for (i = 0; i < G_N_ELEMENTS (area_values); i++)
     {
       if (area_values[i].value == area)
-        return gtk_css_value_ref (&area_values[i]);
+        return _gtk_css_value_ref (&area_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -637,7 +637,7 @@ _gtk_css_area_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (area_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, area_values[i].name))
-        return gtk_css_value_ref (&area_values[i]);
+        return _gtk_css_value_ref (&area_values[i]);
     }
 
   return NULL;
@@ -665,10 +665,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_DIRECTION = {
 };
 
 static GtkCssValue direction_values[] = {
-  { &GTK_CSS_VALUE_DIRECTION, 1, 1, 0, 0, GTK_CSS_DIRECTION_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, 1, 0, 0, GTK_CSS_DIRECTION_REVERSE, "reverse" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, 1, 0, 0, GTK_CSS_DIRECTION_ALTERNATE, "alternate" },
-  { &GTK_CSS_VALUE_DIRECTION, 1, 1, 0, 0, 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 *
@@ -679,7 +679,7 @@ _gtk_css_direction_value_new (GtkCssDirection direction)
   for (i = 0; i < G_N_ELEMENTS (direction_values); i++)
     {
       if (direction_values[i].value == direction)
-        return gtk_css_value_ref (&direction_values[i]);
+        return _gtk_css_value_ref (&direction_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -698,7 +698,7 @@ _gtk_css_direction_value_try_parse (GtkCssParser *parser)
   for (i = G_N_ELEMENTS (direction_values) - 1; i >= 0; i--)
     {
       if (gtk_css_parser_try_ident (parser, direction_values[i].name))
-        return gtk_css_value_ref (&direction_values[i]);
+        return _gtk_css_value_ref (&direction_values[i]);
     }
 
   return NULL;
@@ -726,8 +726,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_PLAY_STATE = {
 };
 
 static GtkCssValue play_state_values[] = {
-  { &GTK_CSS_VALUE_PLAY_STATE, 1, 1, 0, 0, GTK_CSS_PLAY_STATE_RUNNING, "running" },
-  { &GTK_CSS_VALUE_PLAY_STATE, 1, 1, 0, 0, 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 *
@@ -738,7 +738,7 @@ _gtk_css_play_state_value_new (GtkCssPlayState play_state)
   for (i = 0; i < G_N_ELEMENTS (play_state_values); i++)
     {
       if (play_state_values[i].value == play_state)
-        return gtk_css_value_ref (&play_state_values[i]);
+        return _gtk_css_value_ref (&play_state_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -754,7 +754,7 @@ _gtk_css_play_state_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (play_state_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, play_state_values[i].name))
-        return gtk_css_value_ref (&play_state_values[i]);
+        return _gtk_css_value_ref (&play_state_values[i]);
     }
 
   return NULL;
@@ -782,10 +782,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_FILL_MODE = {
 };
 
 static GtkCssValue fill_mode_values[] = {
-  { &GTK_CSS_VALUE_FILL_MODE, 1, 1, 0, 0, GTK_CSS_FILL_NONE, "none" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, 1, 0, 0, GTK_CSS_FILL_FORWARDS, "forwards" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, 1, 0, 0, GTK_CSS_FILL_BACKWARDS, "backwards" },
-  { &GTK_CSS_VALUE_FILL_MODE, 1, 1, 0, 0, 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 *
@@ -796,7 +796,7 @@ _gtk_css_fill_mode_value_new (GtkCssFillMode fill_mode)
   for (i = 0; i < G_N_ELEMENTS (fill_mode_values); i++)
     {
       if (fill_mode_values[i].value == fill_mode)
-        return gtk_css_value_ref (&fill_mode_values[i]);
+        return _gtk_css_value_ref (&fill_mode_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -812,7 +812,7 @@ _gtk_css_fill_mode_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (fill_mode_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, fill_mode_values[i].name))
-        return gtk_css_value_ref (&fill_mode_values[i]);
+        return _gtk_css_value_ref (&fill_mode_values[i]);
     }
 
   return NULL;
@@ -840,9 +840,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_ICON_STYLE = {
 };
 
 static GtkCssValue icon_style_values[] = {
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, 1, 0, 0, GTK_CSS_ICON_STYLE_REQUESTED, "requested" },
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, 1, 0, 0, GTK_CSS_ICON_STYLE_REGULAR, "regular" },
-  { &GTK_CSS_VALUE_ICON_STYLE, 1, 1, 0, 0, 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 *
@@ -853,7 +853,7 @@ _gtk_css_icon_style_value_new (GtkCssIconStyle icon_style)
   for (i = 0; i < G_N_ELEMENTS (icon_style_values); i++)
     {
       if (icon_style_values[i].value == icon_style)
-        return gtk_css_value_ref (&icon_style_values[i]);
+        return _gtk_css_value_ref (&icon_style_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -869,7 +869,7 @@ _gtk_css_icon_style_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (icon_style_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, icon_style_values[i].name))
-        return gtk_css_value_ref (&icon_style_values[i]);
+        return _gtk_css_value_ref (&icon_style_values[i]);
     }
 
   return NULL;
@@ -897,9 +897,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_KERNING = {
 };
 
 static GtkCssValue font_kerning_values[] = {
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, 1, 0, 0, GTK_CSS_FONT_KERNING_AUTO, "auto" },
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, 1, 0, 0, GTK_CSS_FONT_KERNING_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_KERNING, 1, 1, 0, 0, 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 *
@@ -910,7 +910,7 @@ _gtk_css_font_kerning_value_new (GtkCssFontKerning kerning)
   for (i = 0; i < G_N_ELEMENTS (font_kerning_values); i++)
     {
       if (font_kerning_values[i].value == kerning)
-        return gtk_css_value_ref (&font_kerning_values[i]);
+        return _gtk_css_value_ref (&font_kerning_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -926,7 +926,7 @@ _gtk_css_font_kerning_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_kerning_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_kerning_values[i].name))
-        return gtk_css_value_ref (&font_kerning_values[i]);
+        return _gtk_css_value_ref (&font_kerning_values[i]);
     }
 
   return NULL;
@@ -954,9 +954,9 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_POSITION = {
 };
 
 static GtkCssValue font_variant_position_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_POSITION_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_POSITION_SUB, "sub" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_POSITION, 1, 1, 0, 0, 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 *
@@ -967,7 +967,7 @@ _gtk_css_font_variant_position_value_new (GtkCssFontVariantPosition position)
   for (i = 0; i < G_N_ELEMENTS (font_variant_position_values); i++)
     {
       if (font_variant_position_values[i].value == position)
-        return gtk_css_value_ref (&font_variant_position_values[i]);
+        return _gtk_css_value_ref (&font_variant_position_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -983,7 +983,7 @@ _gtk_css_font_variant_position_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_variant_position_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_variant_position_values[i].name))
-        return gtk_css_value_ref (&font_variant_position_values[i]);
+        return _gtk_css_value_ref (&font_variant_position_values[i]);
     }
 
   return NULL;
@@ -1011,13 +1011,13 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_CAPS = {
 };
 
 static GtkCssValue font_variant_caps_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_SMALL_CAPS, "small-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_ALL_SMALL_CAPS, "all-small-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_PETITE_CAPS, "petite-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_ALL_PETITE_CAPS, "all-petite-caps" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_CAPS_UNICASE, "unicase" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_CAPS, 1, 1, 0, 0, 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 *
@@ -1028,7 +1028,7 @@ _gtk_css_font_variant_caps_value_new (GtkCssFontVariantCaps caps)
   for (i = 0; i < G_N_ELEMENTS (font_variant_caps_values); i++)
     {
       if (font_variant_caps_values[i].value == caps)
-        return gtk_css_value_ref (&font_variant_caps_values[i]);
+        return _gtk_css_value_ref (&font_variant_caps_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -1044,7 +1044,7 @@ _gtk_css_font_variant_caps_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_variant_caps_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_variant_caps_values[i].name))
-        return gtk_css_value_ref (&font_variant_caps_values[i]);
+        return _gtk_css_value_ref (&font_variant_caps_values[i]);
     }
 
   return NULL;
@@ -1072,8 +1072,8 @@ static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE = {
 };
 
 static GtkCssValue font_variant_alternate_values[] = {
-  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, 1, 0, 0, GTK_CSS_FONT_VARIANT_ALTERNATE_NORMAL, "normal" },
-  { &GTK_CSS_VALUE_FONT_VARIANT_ALTERNATE, 1, 1, 0, 0, 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 *
@@ -1084,7 +1084,7 @@ _gtk_css_font_variant_alternate_value_new (GtkCssFontVariantAlternate alternate)
   for (i = 0; i < G_N_ELEMENTS (font_variant_alternate_values); i++)
     {
       if (font_variant_alternate_values[i].value == alternate)
-        return gtk_css_value_ref (&font_variant_alternate_values[i]);
+        return _gtk_css_value_ref (&font_variant_alternate_values[i]);
     }
 
   g_return_val_if_reached (NULL);
@@ -1100,7 +1100,7 @@ _gtk_css_font_variant_alternate_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (font_variant_alternate_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, font_variant_alternate_values[i].name))
-        return gtk_css_value_ref (&font_variant_alternate_values[i]);
+        return _gtk_css_value_ref (&font_variant_alternate_values[i]);
     }
 
   return NULL;
@@ -1197,7 +1197,7 @@ _gtk_css_text_decoration_line_value_new (GtkTextDecorationLine line)
   if (!text_decoration_line_is_valid (line))
     return NULL;
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_TEXT_DECORATION_LINE);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_TEXT_DECORATION_LINE);
   value->value = line;
   value->name = NULL;
   value->is_computed = TRUE;
@@ -1306,7 +1306,7 @@ _gtk_css_font_variant_ligature_value_new (GtkCssFontVariantLigature ligatures)
   if (!ligature_value_is_valid (ligatures))
     return NULL;
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_LIGATURE);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_LIGATURE);
   value->value = ligatures;
   value->name = NULL;
   value->is_computed = TRUE;
@@ -1410,7 +1410,7 @@ _gtk_css_font_variant_numeric_value_new (GtkCssFontVariantNumeric numeric)
   if (!numeric_value_is_valid (numeric))
     return NULL;
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_NUMERIC);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_NUMERIC);
   value->value = numeric;
   value->name = NULL;
   value->is_computed = TRUE;
@@ -1521,7 +1521,7 @@ _gtk_css_font_variant_east_asian_value_new (GtkCssFontVariantEastAsian east_asia
   if (!east_asian_value_is_valid (east_asian))
     return NULL;
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_EAST_ASIAN);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIANT_EAST_ASIAN);
   value->value = east_asian;
   value->name = NULL;
   value->is_computed = TRUE;
@@ -1581,10 +1581,10 @@ static const GtkCssValueClass GTK_CSS_VALUE_TEXT_TRANSFORM = {
 };
 
 static GtkCssValue text_transform_values[] = {
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, 1, 0, 0, GTK_CSS_TEXT_TRANSFORM_NONE, "none" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, 1, 0, 0, GTK_CSS_TEXT_TRANSFORM_LOWERCASE, "lowercase" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, 1, 0, 0, GTK_CSS_TEXT_TRANSFORM_UPPERCASE, "uppercase" },
-  { &GTK_CSS_VALUE_TEXT_TRANSFORM, 1, 1, 0, 0, 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 *
@@ -1592,7 +1592,7 @@ _gtk_css_text_transform_value_new (GtkTextTransform transform)
 {
   g_return_val_if_fail (transform < G_N_ELEMENTS (text_transform_values), NULL);
 
-  return gtk_css_value_ref (&text_transform_values[transform]);
+  return _gtk_css_value_ref (&text_transform_values[transform]);
 }
 
 GtkCssValue *
@@ -1605,7 +1605,7 @@ _gtk_css_text_transform_value_try_parse (GtkCssParser *parser)
   for (i = 0; i < G_N_ELEMENTS (text_transform_values); i++)
     {
       if (gtk_css_parser_try_ident (parser, text_transform_values[i].name))
-        return gtk_css_value_ref (&text_transform_values[i]);
+        return _gtk_css_value_ref (&text_transform_values[i]);
     }
 
   return NULL;

gtk/gtkcssfiltervalue.c

@@ -65,34 +65,34 @@ gtk_css_filter_clear (GtkCssFilter *filter)
   switch (filter->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      gtk_css_value_unref (filter->brightness.value);
+      _gtk_css_value_unref (filter->brightness.value);
       break;
     case GTK_CSS_FILTER_CONTRAST:
-      gtk_css_value_unref (filter->contrast.value);
+      _gtk_css_value_unref (filter->contrast.value);
       break;
     case GTK_CSS_FILTER_GRAYSCALE:
-      gtk_css_value_unref (filter->grayscale.value);
+      _gtk_css_value_unref (filter->grayscale.value);
       break;
     case GTK_CSS_FILTER_HUE_ROTATE:
-      gtk_css_value_unref (filter->hue_rotate.value);
+      _gtk_css_value_unref (filter->hue_rotate.value);
       break;
     case GTK_CSS_FILTER_INVERT:
-      gtk_css_value_unref (filter->invert.value);
+      _gtk_css_value_unref (filter->invert.value);
       break;
     case GTK_CSS_FILTER_OPACITY:
-      gtk_css_value_unref (filter->opacity.value);
+      _gtk_css_value_unref (filter->opacity.value);
       break;
     case GTK_CSS_FILTER_SATURATE:
-      gtk_css_value_unref (filter->saturate.value);
+      _gtk_css_value_unref (filter->saturate.value);
       break;
     case GTK_CSS_FILTER_SEPIA:
-      gtk_css_value_unref (filter->sepia.value);
+      _gtk_css_value_unref (filter->sepia.value);
       break;
     case GTK_CSS_FILTER_BLUR:
-      gtk_css_value_unref (filter->blur.value);
+      _gtk_css_value_unref (filter->blur.value);
       break;
     case GTK_CSS_FILTER_DROP_SHADOW:
-      gtk_css_value_unref (filter->drop_shadow.value);
+      _gtk_css_value_unref (filter->drop_shadow.value);
       break;
     case GTK_CSS_FILTER_NONE:
     default:
@@ -108,31 +108,31 @@ gtk_css_filter_init_identity (GtkCssFilter       *filter,
   switch (other->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      filter->brightness.value = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      filter->brightness.value = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_CONTRAST:
-      filter->contrast.value = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      filter->contrast.value = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_GRAYSCALE:
-      filter->grayscale.value = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+      filter->grayscale.value = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_HUE_ROTATE:
-      filter->hue_rotate.value = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      filter->hue_rotate.value = _gtk_css_number_value_new (0, GTK_CSS_DEG);
       break;
     case GTK_CSS_FILTER_INVERT:
-      filter->invert.value = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+      filter->invert.value = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_OPACITY:
-      filter->opacity.value = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      filter->opacity.value = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_SATURATE:
-      filter->saturate.value = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      filter->saturate.value = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_SEPIA:
-      filter->sepia.value = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+      filter->sepia.value = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_FILTER_BLUR:
-      filter->blur.value = gtk_css_number_value_new (0, GTK_CSS_PX);
+      filter->blur.value = _gtk_css_number_value_new (0, GTK_CSS_PX);
       break;
     case GTK_CSS_FILTER_DROP_SHADOW:
       filter->drop_shadow.value = gtk_css_shadow_value_new_filter (other->drop_shadow.value);
@@ -160,19 +160,19 @@ gtk_css_filter_get_matrix (const GtkCssFilter *filter,
   switch (filter->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      value = gtk_css_number_value_get (filter->brightness.value, 1.0);
+      value = _gtk_css_number_value_get (filter->brightness.value, 1.0);
       graphene_matrix_init_scale (matrix, value, value, value);
       graphene_vec4_init (offset, 0.0, 0.0, 0.0, 0.0);
       break;
 
     case GTK_CSS_FILTER_CONTRAST:
-      value = gtk_css_number_value_get (filter->contrast.value, 1.0);
+      value = _gtk_css_number_value_get (filter->contrast.value, 1.0);
       graphene_matrix_init_scale (matrix, value, value, value);
       graphene_vec4_init (offset, 0.5 - 0.5 * value, 0.5 - 0.5 * value, 0.5 - 0.5 * value, 0.0);
       break;
 
     case GTK_CSS_FILTER_GRAYSCALE:
-      value = gtk_css_number_value_get (filter->grayscale.value, 1.0);
+      value = _gtk_css_number_value_get (filter->grayscale.value, 1.0);
       graphene_matrix_init_from_float (matrix, (float[16]) {
                                            1.0 - (1.0 - R) * value, R * value, R * value, 0.0,
                                            G * value, 1.0 - (1.0 - G) * value, G * value, 0.0,
@@ -185,7 +185,7 @@ gtk_css_filter_get_matrix (const GtkCssFilter *filter,
     case GTK_CSS_FILTER_HUE_ROTATE:
       {
         double c, s;
-        value = gtk_css_number_value_get (filter->grayscale.value, 1.0) * G_PI / 180.0;
+        value = _gtk_css_number_value_get (filter->grayscale.value, 1.0) * G_PI / 180.0;
         c = cos (value);
         s = sin (value);
         graphene_matrix_init_from_float (matrix, (float[16]) {
@@ -208,13 +208,13 @@ gtk_css_filter_get_matrix (const GtkCssFilter *filter,
       break;
 
     case GTK_CSS_FILTER_INVERT:
-      value = gtk_css_number_value_get (filter->invert.value, 1.0);
+      value = _gtk_css_number_value_get (filter->invert.value, 1.0);
       graphene_matrix_init_scale (matrix, 1.0 - 2 * value, 1.0 - 2 * value, 1.0 - 2 * value);
       graphene_vec4_init (offset, value, value, value, 0.0);
       break;
 
     case GTK_CSS_FILTER_OPACITY:
-      value = gtk_css_number_value_get (filter->opacity.value, 1.0);
+      value = _gtk_css_number_value_get (filter->opacity.value, 1.0);
       graphene_matrix_init_from_float (matrix, (float[16]) {
                                            1.0, 0.0, 0.0, 0.0,
                                            0.0, 1.0, 0.0, 0.0,
@@ -225,7 +225,7 @@ gtk_css_filter_get_matrix (const GtkCssFilter *filter,
       break;
 
     case GTK_CSS_FILTER_SATURATE:
-      value = gtk_css_number_value_get (filter->saturate.value, 1.0);
+      value = _gtk_css_number_value_get (filter->saturate.value, 1.0);
       graphene_matrix_init_from_float (matrix, (float[16]) {
                                            R + (1.0 - R) * value, R - R * value, R - R * value, 0.0,
                                            G - G * value, G + (1.0 - G) * value, G - G * value, 0.0,
@@ -236,7 +236,7 @@ gtk_css_filter_get_matrix (const GtkCssFilter *filter,
       break;
 
     case GTK_CSS_FILTER_SEPIA:
-      value = gtk_css_number_value_get (filter->sepia.value, 1.0);
+      value = _gtk_css_number_value_get (filter->sepia.value, 1.0);
       graphene_matrix_init_from_float (matrix, (float[16]) {
                                            1.0 - 0.607 * value, 0.349 * value, 0.272 * value, 0.0,
                                            0.769 * value, 1.0 - 0.314 * value, 0.534 * value, 0.0,
@@ -317,43 +317,43 @@ gtk_css_filter_compute (GtkCssFilter         *dest,
   switch (src->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      dest->brightness.value = gtk_css_value_compute (src->brightness.value, property_id, context);
+      dest->brightness.value = _gtk_css_value_compute (src->brightness.value, property_id, context);
       return dest->brightness.value == src->brightness.value;
 
     case GTK_CSS_FILTER_CONTRAST:
-      dest->contrast.value = gtk_css_value_compute (src->contrast.value, property_id, context);
+      dest->contrast.value = _gtk_css_value_compute (src->contrast.value, property_id, context);
       return dest->contrast.value == src->contrast.value;
 
     case GTK_CSS_FILTER_GRAYSCALE:
-      dest->grayscale.value = gtk_css_value_compute (src->grayscale.value, property_id, context);
+      dest->grayscale.value = _gtk_css_value_compute (src->grayscale.value, property_id, context);
       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, context);
+      dest->hue_rotate.value = _gtk_css_value_compute (src->hue_rotate.value, property_id, context);
       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, context);
+      dest->invert.value = _gtk_css_value_compute (src->invert.value, property_id, context);
       return dest->invert.value == src->invert.value;
 
     case GTK_CSS_FILTER_OPACITY:
-      dest->opacity.value = gtk_css_value_compute (src->opacity.value, property_id, context);
+      dest->opacity.value = _gtk_css_value_compute (src->opacity.value, property_id, context);
       return dest->opacity.value == src->opacity.value;
 
     case GTK_CSS_FILTER_SATURATE:
-      dest->saturate.value = gtk_css_value_compute (src->saturate.value, property_id, context);
+      dest->saturate.value = _gtk_css_value_compute (src->saturate.value, property_id, context);
       return dest->saturate.value == src->saturate.value;
 
     case GTK_CSS_FILTER_SEPIA:
-      dest->sepia.value = gtk_css_value_compute (src->sepia.value, property_id, context);
+      dest->sepia.value = _gtk_css_value_compute (src->sepia.value, property_id, context);
       return dest->sepia.value == src->sepia.value;
 
     case GTK_CSS_FILTER_BLUR:
-      dest->blur.value = gtk_css_value_compute (src->blur.value, property_id, context);
+      dest->blur.value = _gtk_css_value_compute (src->blur.value, property_id, context);
       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, context);
+      dest->drop_shadow.value = _gtk_css_value_compute (src->drop_shadow.value, property_id, context);
       return dest->drop_shadow.value == src->drop_shadow.value;
 
     case GTK_CSS_FILTER_NONE:
@@ -374,7 +374,7 @@ gtk_css_value_filter_compute (GtkCssValue          *value,
 
   /* Special case the 99% case of "none" */
   if (gtk_css_filter_value_is_none (value))
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   changes = FALSE;
   result = gtk_css_filter_value_alloc (value->n_filters);
@@ -389,8 +389,8 @@ gtk_css_value_filter_compute (GtkCssValue          *value,
 
   if (!changes)
     {
-      gtk_css_value_unref (result);
-      result = gtk_css_value_ref (value);
+      _gtk_css_value_unref (result);
+      result = _gtk_css_value_ref (value);
     }
 
   return result;
@@ -406,34 +406,34 @@ gtk_css_filter_equal (const GtkCssFilter *filter1,
   switch (filter1->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      return gtk_css_value_equal (filter1->brightness.value, filter2->brightness.value);
+      return _gtk_css_value_equal (filter1->brightness.value, filter2->brightness.value);
 
     case GTK_CSS_FILTER_CONTRAST:
-      return gtk_css_value_equal (filter1->contrast.value, filter2->contrast.value);
+      return _gtk_css_value_equal (filter1->contrast.value, filter2->contrast.value);
 
     case GTK_CSS_FILTER_GRAYSCALE:
-      return gtk_css_value_equal (filter1->grayscale.value, filter2->grayscale.value);
+      return _gtk_css_value_equal (filter1->grayscale.value, filter2->grayscale.value);
 
     case GTK_CSS_FILTER_HUE_ROTATE:
-      return gtk_css_value_equal (filter1->hue_rotate.value, filter2->hue_rotate.value);
+      return _gtk_css_value_equal (filter1->hue_rotate.value, filter2->hue_rotate.value);
 
     case GTK_CSS_FILTER_INVERT:
-      return gtk_css_value_equal (filter1->invert.value, filter2->invert.value);
+      return _gtk_css_value_equal (filter1->invert.value, filter2->invert.value);
 
     case GTK_CSS_FILTER_OPACITY:
-      return gtk_css_value_equal (filter1->opacity.value, filter2->opacity.value);
+      return _gtk_css_value_equal (filter1->opacity.value, filter2->opacity.value);
 
     case GTK_CSS_FILTER_SATURATE:
-      return gtk_css_value_equal (filter1->saturate.value, filter2->saturate.value);
+      return _gtk_css_value_equal (filter1->saturate.value, filter2->saturate.value);
 
     case GTK_CSS_FILTER_SEPIA:
-      return gtk_css_value_equal (filter1->sepia.value, filter2->sepia.value);
+      return _gtk_css_value_equal (filter1->sepia.value, filter2->sepia.value);
 
     case GTK_CSS_FILTER_BLUR:
-      return gtk_css_value_equal (filter1->blur.value, filter2->blur.value);
+      return _gtk_css_value_equal (filter1->blur.value, filter2->blur.value);
 
     case GTK_CSS_FILTER_DROP_SHADOW:
-      return gtk_css_value_equal (filter1->drop_shadow.value, filter2->drop_shadow.value);
+      return _gtk_css_value_equal (filter1->drop_shadow.value, filter2->drop_shadow.value);
 
     case GTK_CSS_FILTER_NONE:
     default:
@@ -488,43 +488,43 @@ gtk_css_filter_transition (GtkCssFilter       *result,
   switch (start->type)
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
-      result->brightness.value = gtk_css_value_transition (start->brightness.value, end->brightness.value, property_id, progress);
+      result->brightness.value = _gtk_css_value_transition (start->brightness.value, end->brightness.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_CONTRAST:
-      result->contrast.value = gtk_css_value_transition (start->contrast.value, end->contrast.value, property_id, progress);
+      result->contrast.value = _gtk_css_value_transition (start->contrast.value, end->contrast.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_GRAYSCALE:
-      result->grayscale.value = gtk_css_value_transition (start->grayscale.value, end->grayscale.value, property_id, progress);
+      result->grayscale.value = _gtk_css_value_transition (start->grayscale.value, end->grayscale.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_HUE_ROTATE:
-      result->hue_rotate.value = gtk_css_value_transition (start->hue_rotate.value, end->hue_rotate.value, property_id, progress);
+      result->hue_rotate.value = _gtk_css_value_transition (start->hue_rotate.value, end->hue_rotate.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_INVERT:
-      result->invert.value = gtk_css_value_transition (start->invert.value, end->invert.value, property_id, progress);
+      result->invert.value = _gtk_css_value_transition (start->invert.value, end->invert.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_OPACITY:
-      result->opacity.value = gtk_css_value_transition (start->opacity.value, end->opacity.value, property_id, progress);
+      result->opacity.value = _gtk_css_value_transition (start->opacity.value, end->opacity.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_SATURATE:
-      result->saturate.value = gtk_css_value_transition (start->saturate.value, end->saturate.value, property_id, progress);
+      result->saturate.value = _gtk_css_value_transition (start->saturate.value, end->saturate.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_SEPIA:
-      result->sepia.value = gtk_css_value_transition (start->sepia.value, end->sepia.value, property_id, progress);
+      result->sepia.value = _gtk_css_value_transition (start->sepia.value, end->sepia.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_BLUR:
-      result->blur.value = gtk_css_value_transition (start->blur.value, end->blur.value, property_id, progress);
+      result->blur.value = _gtk_css_value_transition (start->blur.value, end->blur.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_DROP_SHADOW:
-      result->drop_shadow.value = gtk_css_value_transition (start->drop_shadow.value, end->drop_shadow.value, property_id, progress);
+      result->drop_shadow.value = _gtk_css_value_transition (start->drop_shadow.value, end->drop_shadow.value, property_id, progress);
       break;
 
     case GTK_CSS_FILTER_NONE:
@@ -546,7 +546,7 @@ gtk_css_value_filter_transition (GtkCssValue *start,
   if (gtk_css_filter_value_is_none (start))
     {
       if (gtk_css_filter_value_is_none (end))
-        return gtk_css_value_ref (start);
+        return _gtk_css_value_ref (start);
 
       n = 0;
     }
@@ -620,61 +620,61 @@ gtk_css_filter_print (const GtkCssFilter *filter,
     {
     case GTK_CSS_FILTER_BRIGHTNESS:
       g_string_append (string, "brightness(");
-      gtk_css_value_print (filter->brightness.value, string);
+      _gtk_css_value_print (filter->brightness.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_CONTRAST:
       g_string_append (string, "contrast(");
-      gtk_css_value_print (filter->contrast.value, string);
+      _gtk_css_value_print (filter->contrast.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_GRAYSCALE:
       g_string_append (string, "grayscale(");
-      gtk_css_value_print (filter->grayscale.value, string);
+      _gtk_css_value_print (filter->grayscale.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_HUE_ROTATE:
       g_string_append (string, "hue-rotate(");
-      gtk_css_value_print (filter->hue_rotate.value, string);
+      _gtk_css_value_print (filter->hue_rotate.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_INVERT:
       g_string_append (string, "invert(");
-      gtk_css_value_print (filter->invert.value, string);
+      _gtk_css_value_print (filter->invert.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_OPACITY:
       g_string_append (string, "opacity(");
-      gtk_css_value_print (filter->opacity.value, string);
+      _gtk_css_value_print (filter->opacity.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_SATURATE:
       g_string_append (string, "saturate(");
-      gtk_css_value_print (filter->saturate.value, string);
+      _gtk_css_value_print (filter->saturate.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_SEPIA:
       g_string_append (string, "sepia(");
-      gtk_css_value_print (filter->sepia.value, string);
+      _gtk_css_value_print (filter->sepia.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_BLUR:
       g_string_append (string, "blur(");
-      gtk_css_value_print (filter->blur.value, string);
+      _gtk_css_value_print (filter->blur.value, string);
       g_string_append (string, ")");
       break;
 
     case GTK_CSS_FILTER_DROP_SHADOW:
       g_string_append (string, "drop-shadow(");
-      gtk_css_value_print (filter->drop_shadow.value, string);
+      _gtk_css_value_print (filter->drop_shadow.value, string);
       g_string_append (string, ")");
       break;
 
@@ -717,7 +717,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_FILTER = {
   gtk_css_value_filter_print
 };
 
-static GtkCssValue filter_none_singleton = { &GTK_CSS_VALUE_FILTER, 1, 1, 0, 0, 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)
@@ -726,7 +726,7 @@ gtk_css_filter_value_alloc (guint n_filters)
 
   g_return_val_if_fail (n_filters > 0, NULL);
 
-  result = gtk_css_value_alloc (&GTK_CSS_VALUE_FILTER, sizeof (GtkCssValue) + sizeof (GtkCssFilter) * (n_filters - 1));
+  result = _gtk_css_value_alloc (&GTK_CSS_VALUE_FILTER, sizeof (GtkCssValue) + sizeof (GtkCssFilter) * (n_filters - 1));
   result->n_filters = n_filters;
 
   return result;
@@ -735,7 +735,7 @@ gtk_css_filter_value_alloc (guint n_filters)
 GtkCssValue *
 gtk_css_filter_value_new_none (void)
 {
-  return gtk_css_value_ref (&filter_none_singleton);
+  return _gtk_css_value_ref (&filter_none_singleton);
 }
 
 static gboolean
@@ -751,7 +751,7 @@ gtk_css_filter_parse_number (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_PARSE_PERCENT | GTK_CSS_POSITIVE_ONLY);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_PARSE_PERCENT | GTK_CSS_POSITIVE_ONLY);
   if (values[n] == NULL)
     return 0;
 
@@ -765,7 +765,7 @@ gtk_css_filter_parse_length (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
   if (values[n] == NULL)
     return 0;
 
@@ -779,7 +779,7 @@ gtk_css_filter_parse_angle (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
   if (values[n] == NULL)
     return 0;
 
@@ -957,7 +957,7 @@ gtk_css_filter_value_push_snapshot (const GtkCssValue *filter,
         {
           if (filter->filters[j].type == GTK_CSS_FILTER_BLUR)
             {
-              double std_dev = gtk_css_number_value_get (filter->filters[j].blur.value, 100.0);
+              double std_dev = _gtk_css_number_value_get (filter->filters[j].blur.value, 100.0);
               gtk_snapshot_push_blur (snapshot, 2 * std_dev);
             }
           else if (filter->filters[j].type == GTK_CSS_FILTER_DROP_SHADOW)

gtk/gtkcssfontfeaturesvalue.c

@@ -57,7 +57,7 @@ gtk_css_value_font_features_compute (GtkCssValue          *specified,
                                      guint                 property_id,
                                      GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (specified);
+  return _gtk_css_value_ref (specified);
 }
 
 static gboolean
@@ -168,7 +168,7 @@ gtk_css_font_features_value_new_empty (void)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_FEATURES);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_FEATURES);
   result->features = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
   result->is_computed = TRUE;
 
@@ -181,7 +181,7 @@ gtk_css_font_features_value_new_default (void)
   if (default_font_features == NULL)
     default_font_features = gtk_css_font_features_value_new_empty ();
 
-  return gtk_css_value_ref (default_font_features);
+  return _gtk_css_value_ref (default_font_features);
 }
 
 static gboolean
@@ -215,7 +215,7 @@ gtk_css_font_features_value_parse (GtkCssParser *parser)
     name = gtk_css_parser_consume_string (parser);
     if (name == NULL)
       {
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
@@ -223,7 +223,7 @@ gtk_css_font_features_value_parse (GtkCssParser *parser)
       {
         gtk_css_parser_error_value (parser, "Not a valid OpenType tag.");
         g_free (name);
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
@@ -236,7 +236,7 @@ gtk_css_font_features_value_parse (GtkCssParser *parser)
         if (!gtk_css_parser_consume_integer (parser, &num))
           {
             g_free (name);
-            gtk_css_value_unref (result);
+            _gtk_css_value_unref (result);
             return NULL;
           }
       }

gtk/gtkcssfontvariationsvalue.c

@@ -56,7 +56,7 @@ gtk_css_value_font_variations_compute (GtkCssValue          *specified,
                                        guint                 property_id,
                                        GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (specified);
+  return _gtk_css_value_ref (specified);
 }
 
 static gboolean
@@ -76,7 +76,7 @@ gtk_css_value_font_variations_equal (const GtkCssValue *value1,
       if (coord2 == NULL)
         return FALSE;
 
-      if (!gtk_css_value_equal (coord1, coord2))
+      if (!_gtk_css_value_equal (coord1, coord2))
         return FALSE;
     }
 
@@ -106,9 +106,9 @@ gtk_css_value_font_variations_transition (GtkCssValue *start,
     {
       end_coord = g_hash_table_lookup (end->axes, name);
       if (end_coord == NULL)
-        transition = gtk_css_value_ref (start_coord);
+        transition = _gtk_css_value_ref (start_coord);
       else
-        transition = gtk_css_value_transition (start_coord, end_coord, property_id, progress);
+        transition = _gtk_css_value_transition (start_coord, end_coord, property_id, progress);
 
       gtk_css_font_variations_value_add_axis (result, name, transition);
     }
@@ -120,7 +120,7 @@ gtk_css_value_font_variations_transition (GtkCssValue *start,
       if (start_coord != NULL)
         continue;
 
-      gtk_css_font_variations_value_add_axis (result, name, gtk_css_value_ref (end_coord));
+      gtk_css_font_variations_value_add_axis (result, name, _gtk_css_value_ref (end_coord));
     }
 
   return result;
@@ -149,7 +149,7 @@ gtk_css_value_font_variations_print (const GtkCssValue *value,
       else
         g_string_append (string, ", ");
       g_string_append_printf (string, "\"%s\" ", name);
-      gtk_css_value_print (coord, string);
+      _gtk_css_value_print (coord, string);
     }
 }
 
@@ -169,10 +169,10 @@ gtk_css_font_variations_value_new_empty (void)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIATIONS);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_FONT_VARIATIONS);
   result->axes = g_hash_table_new_full (g_str_hash, g_str_equal,
                                         g_free,
-                                        (GDestroyNotify) gtk_css_value_unref);
+                                        (GDestroyNotify) _gtk_css_value_unref);
   result->is_computed = TRUE;
 
   return result;
@@ -184,7 +184,7 @@ gtk_css_font_variations_value_new_default (void)
   if (default_font_variations == NULL)
     default_font_variations = gtk_css_font_variations_value_new_empty ();
 
-  return gtk_css_value_ref (default_font_variations);
+  return _gtk_css_value_ref (default_font_variations);
 }
 
 static gboolean
@@ -217,7 +217,7 @@ gtk_css_font_variations_value_parse (GtkCssParser *parser)
     name = gtk_css_parser_consume_string (parser);
     if (name == NULL)
       {
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
@@ -225,15 +225,15 @@ gtk_css_font_variations_value_parse (GtkCssParser *parser)
       {
         gtk_css_parser_error_value (parser, "Not a valid OpenType tag.");
         g_free (name);
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
-    coord = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+    coord = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
     if (coord == NULL)
       {
         g_free (name);
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
@@ -268,7 +268,7 @@ gtk_css_font_variations_value_get_variations (GtkCssValue *value)
       else
         g_string_append (string, ",");
       g_string_append_printf (string, "%s=%g", name,
-                              gtk_css_number_value_get (coord, 100));
+                              _gtk_css_number_value_get (coord, 100));
     }
 
   return g_string_free (string, FALSE);

gtk/gtkcssimage.c

@@ -120,19 +120,6 @@ gtk_css_image_real_is_computed (GtkCssImage *image)
   return FALSE;
 }
 
-static gboolean
-gtk_css_image_real_contains_current_color (GtkCssImage *image)
-{
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_real_resolve (GtkCssImage *image,
-                            GtkCssValue *current_color)
-{
-  return g_object_ref (image);
-}
-
 static void
 _gtk_css_image_class_init (GtkCssImageClass *klass)
 {
@@ -146,8 +133,6 @@ _gtk_css_image_class_init (GtkCssImageClass *klass)
   klass->is_dynamic = gtk_css_image_real_is_dynamic;
   klass->get_dynamic_image = gtk_css_image_real_get_dynamic_image;
   klass->is_computed = gtk_css_image_real_is_computed;
-  klass->contains_current_color = gtk_css_image_real_contains_current_color;
-  klass->resolve = gtk_css_image_real_resolve;
 }
 
 static void
@@ -254,11 +239,11 @@ _gtk_css_image_equal (GtkCssImage *image1,
   return klass->equal (image1, image2);
 }
 
-static void
-gtk_css_image_draw (GtkCssImage *image,
-                    cairo_t     *cr,
-                    double       width,
-                    double       height)
+void
+_gtk_css_image_draw (GtkCssImage        *image,
+                     cairo_t            *cr,
+                     double              width,
+                     double              height)
 {
   GtkSnapshot *snapshot;
   GskRenderNode *node;
@@ -512,7 +497,7 @@ _gtk_css_image_get_surface (GtkCssImage     *image,
                                          surface_height);
 
   cr = cairo_create (result);
-  gtk_css_image_draw (image, cr, surface_width, surface_height);
+  _gtk_css_image_draw (image, cr, surface_width, surface_height);
   cairo_destroy (cr);
 
   return result;
@@ -603,20 +588,3 @@ gtk_css_image_is_computed (GtkCssImage *image)
 
   return klass->is_computed (image);
 }
-
-gboolean
-gtk_css_image_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageClass *klass = GTK_CSS_IMAGE_GET_CLASS (image);
-
-  return klass->contains_current_color (image);
-}
-
-GtkCssImage *
-gtk_css_image_resolve (GtkCssImage *image,
-                       GtkCssValue *current_color)
-{
-  GtkCssImageClass *klass = GTK_CSS_IMAGE_GET_CLASS (image);
-
-  return klass->resolve (image, current_color);
-}

gtk/gtkcssimageconic.c

@@ -61,7 +61,7 @@ gtk_css_image_conic_snapshot (GtkCssImage        *image,
         }
       else
         {
-          pos = gtk_css_number_value_get (stop->offset, 360) / 360;
+          pos = _gtk_css_number_value_get (stop->offset, 360) / 360;
           pos = CLAMP (pos, 0.0, 1.0);
         }
 
@@ -86,7 +86,7 @@ gtk_css_image_conic_snapshot (GtkCssImage        *image,
           &GRAPHENE_RECT_INIT (0, 0, width, height),
           &GRAPHENE_POINT_INIT (_gtk_css_position_value_get_x (self->center, width),
                                 _gtk_css_position_value_get_y (self->center, height)),
-          gtk_css_number_value_get (self->rotation, 360),
+          _gtk_css_number_value_get (self->rotation, 360),
           stops,
           self->n_stops);
 }
@@ -98,13 +98,13 @@ parse_angles (GtkCssParser *parser,
 {
   GtkCssValue **angles = option_data;
   
-  angles[0] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE | GTK_CSS_PARSE_PERCENT);
+  angles[0] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE | GTK_CSS_PARSE_PERCENT);
   if (angles[0] == NULL)
     return FALSE;
 
   if (gtk_css_number_value_can_parse (parser))
     {
-      angles[1] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE | GTK_CSS_PARSE_PERCENT);
+      angles[1] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE | GTK_CSS_PARSE_PERCENT);
       if (angles[1] == NULL)
         return FALSE;
     }
@@ -119,7 +119,7 @@ parse_color (GtkCssParser *parser,
 {
   GtkCssValue **color = option_data;
   
-  *color = gtk_css_color_value_parse (parser);
+  *color = _gtk_css_color_value_parse (parser);
   if (*color == NULL)
     return FALSE;
 
@@ -176,14 +176,14 @@ gtk_css_image_conic_parse_first_arg (GtkCssImageConic *self,
 
   if (gtk_css_parser_try_ident (parser, "from"))
     {
-      self->rotation = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
+      self->rotation = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
       if (self->rotation == NULL)
         return 0;
       nothing_parsed = FALSE;
     }
   else
     {
-      self->rotation = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      self->rotation = _gtk_css_number_value_new (0, GTK_CSS_DEG);
     }
 
   if (gtk_css_parser_try_ident (parser, "at"))
@@ -195,8 +195,8 @@ gtk_css_image_conic_parse_first_arg (GtkCssImageConic *self,
     }
   else
     {
-      self->center = _gtk_css_position_value_new (gtk_css_number_value_new (50, GTK_CSS_PERCENT),
-                                                  gtk_css_number_value_new (50, GTK_CSS_PERCENT));
+      self->center = _gtk_css_position_value_new (_gtk_css_number_value_new (50, GTK_CSS_PERCENT),
+                                                   _gtk_css_number_value_new (50, GTK_CSS_PERCENT));
     }
 
   if (!nothing_parsed)
@@ -269,25 +269,25 @@ gtk_css_image_conic_print (GtkCssImage *image,
 
   if (self->center)
     {
-      GtkCssValue *compare = _gtk_css_position_value_new (gtk_css_number_value_new (50, GTK_CSS_PERCENT),
-                                                          gtk_css_number_value_new (50, GTK_CSS_PERCENT));
+      GtkCssValue *compare = _gtk_css_position_value_new (_gtk_css_number_value_new (50, GTK_CSS_PERCENT),
+                                                          _gtk_css_number_value_new (50, GTK_CSS_PERCENT));
 
-      if (!gtk_css_value_equal (self->center, compare))
+      if (!_gtk_css_value_equal (self->center, compare))
         {
           g_string_append (string, "from ");
-          gtk_css_value_print (self->center, string);
+          _gtk_css_value_print (self->center, string);
           written = TRUE;
         }
 
       gtk_css_value_unref (compare);
     }
 
-  if (self->rotation && gtk_css_number_value_get (self->rotation, 360) != 0)
+  if (self->rotation && _gtk_css_number_value_get (self->rotation, 360) != 0)
     {
       if (written)
         g_string_append_c (string, ' ');
       g_string_append (string, "at ");
-      gtk_css_value_print (self->rotation, string);
+      _gtk_css_value_print (self->rotation, string);
     }
 
   if (written)
@@ -300,12 +300,12 @@ gtk_css_image_conic_print (GtkCssImage *image,
       if (i > 0)
         g_string_append (string, ", ");
 
-      gtk_css_value_print (stop->color, string);
+      _gtk_css_value_print (stop->color, string);
 
       if (stop->offset)
         {
           g_string_append (string, " ");
-          gtk_css_value_print (stop->offset, string);
+          _gtk_css_value_print (stop->offset, string);
         }
     }
 
@@ -323,21 +323,21 @@ 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, context);
-  copy->rotation = gtk_css_value_compute (self->rotation, property_id, context);
+  copy->center = _gtk_css_value_compute (self->center, property_id, context);
+  copy->rotation = _gtk_css_value_compute (self->rotation, property_id, context);
 
   copy->n_stops = self->n_stops;
-  copy->color_stops = g_new (GtkCssImageConicColorStop, self->n_stops);
+  copy->color_stops = g_malloc (sizeof (GtkCssImageConicColorStop) * copy->n_stops);
   for (i = 0; i < self->n_stops; i++)
     {
       const GtkCssImageConicColorStop *stop = &self->color_stops[i];
       GtkCssImageConicColorStop *scopy = &copy->color_stops[i];
 
-      scopy->color = gtk_css_value_compute (stop->color, property_id, context);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, context);
 
       if (stop->offset)
         {
-          scopy->offset = gtk_css_value_compute (stop->offset, property_id, context);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, context);
         }
       else
         {
@@ -372,11 +372,11 @@ gtk_css_image_conic_transition (GtkCssImage *start_image,
 
   result = g_object_new (GTK_TYPE_CSS_IMAGE_CONIC, NULL);
 
-  result->center = gtk_css_value_transition (start->center, end->center, property_id, progress);
+  result->center = _gtk_css_value_transition (start->center, end->center, property_id, progress);
   if (result->center == NULL)
     goto fail;
 
-  result->rotation = gtk_css_value_transition (start->rotation, end->rotation, property_id, progress);
+  result->rotation = _gtk_css_value_transition (start->rotation, end->rotation, property_id, progress);
   if (result->rotation == NULL)
     goto fail;
 
@@ -397,22 +397,22 @@ gtk_css_image_conic_transition (GtkCssImage *start_image,
         }
       else
         {
-          stop->offset = gtk_css_value_transition (start_stop->offset,
-                                                   end_stop->offset,
-                                                   property_id,
-                                                   progress);
+          stop->offset = _gtk_css_value_transition (start_stop->offset,
+                                                    end_stop->offset,
+                                                    property_id,
+                                                    progress);
           if (stop->offset == NULL)
             goto fail;
         }
 
-      stop->color = gtk_css_value_transition (start_stop->color,
-                                              end_stop->color,
-                                              property_id,
-                                              progress);
+      stop->color = _gtk_css_value_transition (start_stop->color,
+                                               end_stop->color,
+                                               property_id,
+                                               progress);
       if (stop->color == NULL)
         {
           if (stop->offset)
-            gtk_css_value_unref (stop->offset);
+            _gtk_css_value_unref (stop->offset);
           goto fail;
         }
 
@@ -434,8 +434,8 @@ gtk_css_image_conic_equal (GtkCssImage *image1,
   GtkCssImageConic *conic2 = (GtkCssImageConic *) image2;
   guint i;
 
-  if (!gtk_css_value_equal (conic1->center, conic2->center) ||
-      !gtk_css_value_equal (conic1->rotation, conic2->rotation))
+  if (!_gtk_css_value_equal (conic1->center, conic2->center) ||
+      !_gtk_css_value_equal (conic1->rotation, conic2->rotation))
     return FALSE;
 
   for (i = 0; i < conic1->n_stops; i++)
@@ -443,8 +443,8 @@ gtk_css_image_conic_equal (GtkCssImage *image1,
       const GtkCssImageConicColorStop *stop1 = &conic1->color_stops[i];
       const GtkCssImageConicColorStop *stop2 = &conic2->color_stops[i];
 
-      if (!gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
-          !gtk_css_value_equal (stop1->color, stop2->color))
+      if (!_gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
+          !_gtk_css_value_equal (stop1->color, stop2->color))
         return FALSE;
     }
 
@@ -461,9 +461,9 @@ gtk_css_image_conic_dispose (GObject *object)
     {
       GtkCssImageConicColorStop *stop = &self->color_stops[i];
 
-      gtk_css_value_unref (stop->color);
+      _gtk_css_value_unref (stop->color);
       if (stop->offset)
-        gtk_css_value_unref (stop->offset);
+        _gtk_css_value_unref (stop->offset);
     }
   g_free (self->color_stops);
 
@@ -503,53 +503,6 @@ gtk_css_image_conic_is_computed (GtkCssImage *image)
   return computed;
 }
 
-static gboolean
-gtk_css_image_conic_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageConic *self = GTK_CSS_IMAGE_CONIC (image);
-
-  for (guint i = 0; i < self->n_stops; i ++)
-    {
-      const GtkCssImageConicColorStop *stop = &self->color_stops[i];
-
-      if (gtk_css_value_contains_current_color (stop->color))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_conic_resolve (GtkCssImage *image,
-                             GtkCssValue *current_color)
-{
-  GtkCssImageConic *self = GTK_CSS_IMAGE_CONIC (image);
-  GtkCssImageConic *resolved;
-
-  if (!gtk_css_image_conic_contains_current_color (image))
-    return g_object_ref (image);
-
-  resolved = g_object_new (GTK_TYPE_CSS_IMAGE_CONIC, NULL);
-
-  resolved->center = gtk_css_value_ref (self->center);
-  resolved->rotation = gtk_css_value_ref (self->rotation);
-
-  resolved->n_stops = self->n_stops;
-  resolved->color_stops = g_new (GtkCssImageConicColorStop, self->n_stops);
-
-  for (guint i = 0; i < self->n_stops; i++)
-    {
-      if (self->color_stops[i].offset)
-        resolved->color_stops[i].offset = gtk_css_value_ref (self->color_stops[i].offset);
-      else
-        resolved->color_stops[i].offset = NULL;
-
-      resolved->color_stops[i].color = gtk_css_color_value_resolve (self->color_stops[i].color, NULL, current_color);
-    }
-
-  return GTK_CSS_IMAGE (resolved);
-}
-
 static void
 gtk_css_image_conic_class_init (GtkCssImageConicClass *klass)
 {
@@ -563,8 +516,6 @@ gtk_css_image_conic_class_init (GtkCssImageConicClass *klass)
   image_class->equal = gtk_css_image_conic_equal;
   image_class->transition = gtk_css_image_conic_transition;
   image_class->is_computed = gtk_css_image_conic_is_computed;
-  image_class->contains_current_color = gtk_css_image_conic_contains_current_color;
-  image_class->resolve = gtk_css_image_conic_resolve;
 
   object_class->dispose = gtk_css_image_conic_dispose;
 }

gtk/gtkcssimagecrossfade.c

@@ -289,11 +289,11 @@ parse_progress (GtkCssParser *parser,
   double *progress = option_data;
   GtkCssValue *number;
   
-  number = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_PERCENT | GTK_CSS_POSITIVE_ONLY);
+  number = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_PERCENT | GTK_CSS_POSITIVE_ONLY);
   if (number == NULL)
     return FALSE;
-  *progress = gtk_css_number_value_get (number, 1);
-  gtk_css_value_unref (number);
+  *progress = _gtk_css_number_value_get (number, 1);
+  _gtk_css_value_unref (number);
 
   if (*progress > 1.0)
     {
@@ -323,7 +323,7 @@ parse_image (GtkCssParser *parser,
     {
       GtkCssValue *color;
 
-      color = gtk_css_color_value_parse (parser);
+      color = _gtk_css_color_value_parse (parser);
       if (color == NULL)
         return FALSE;
 

gtk/gtkcssimagefallback.c

@@ -72,10 +72,7 @@ gtk_css_image_fallback_snapshot (GtkCssImage *image,
     {
       if (fallback->color)
         {
-          const GdkRGBA *color;
-
-          color = gtk_css_color_value_get_rgba (fallback->color);
-
+          const GdkRGBA *color = gtk_css_color_value_get_rgba (fallback->color);
           if (!gdk_rgba_is_clear (color))
             gtk_snapshot_append_color (snapshot, color,
                                        &GRAPHENE_RECT_INIT (0, 0, width, height));
@@ -108,7 +105,7 @@ gtk_css_image_fallback_print (GtkCssImage *image,
     {
       if (fallback->n_images > 0)
         g_string_append (string, ",");
-      gtk_css_value_print (fallback->color, string);
+      _gtk_css_value_print (fallback->color, string);
     }
 
   g_string_append (string, ")");
@@ -127,7 +124,7 @@ gtk_css_image_fallback_dispose (GObject *object)
 
   if (fallback->color)
     {
-      gtk_css_value_unref (fallback->color);
+      _gtk_css_value_unref (fallback->color);
       fallback->color = NULL;
     }
 
@@ -149,9 +146,9 @@ gtk_css_image_fallback_compute (GtkCssImage          *image,
       GtkCssValue *computed_color = NULL;
 
       if (fallback->color)
-        computed_color = gtk_css_value_compute (fallback->color,
-                                                property_id,
-                                                context);
+        computed_color = _gtk_css_value_compute (fallback->color,
+                                                 property_id,
+                                                 context);
 
       /* image($color) that didn't change */
       if (computed_color && !fallback->images &&
@@ -214,7 +211,7 @@ gtk_css_image_fallback_parse_arg (GtkCssParser *parser,
     }
   else
     {
-      data->color = gtk_css_color_value_parse (parser);
+      data->color = _gtk_css_color_value_parse (parser);
       if (data->color == NULL)
         return 0;
 
@@ -237,7 +234,7 @@ gtk_css_image_fallback_parse (GtkCssImage  *image,
 
   if (!gtk_css_parser_consume_function (parser, 1, G_MAXUINT, gtk_css_image_fallback_parse_arg, &data))
     {
-      g_clear_pointer (&data.color, gtk_css_value_unref);
+      g_clear_pointer (&data.color, _gtk_css_value_unref);
       if (data.images)
         g_ptr_array_free (data.images, TRUE);
       return FALSE;
@@ -270,7 +267,7 @@ gtk_css_image_fallback_equal (GtkCssImage *image1,
       if (fallback2->used >= 0)
         return FALSE;
 
-      return gtk_css_value_equal (fallback1->color, fallback2->color);
+      return _gtk_css_value_equal (fallback1->color, fallback2->color);
     }
 
   if (fallback2->used < 0)
@@ -304,69 +301,6 @@ gtk_css_image_fallback_is_computed (GtkCssImage *image)
   return TRUE;
 }
 
-static gboolean
-gtk_css_image_fallback_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageFallback *fallback = GTK_CSS_IMAGE_FALLBACK (image);
-
-  if (fallback->used < 0)
-    {
-      guint i;
-
-      if (fallback->color && !fallback->images)
-        return gtk_css_value_contains_current_color (fallback->color);
-
-      for (i = 0; i < fallback->n_images; i++)
-        {
-          if (gtk_css_image_contains_current_color (fallback->images[i]))
-            return TRUE;
-        }
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_fallback_resolve (GtkCssImage *image,
-                                GtkCssValue *current_color)
-{
-  GtkCssImageFallback *fallback = GTK_CSS_IMAGE_FALLBACK (image);
-  GtkCssImageFallback *resolved;
-  int i;
-
-  if (fallback->used < 0)
-    {
-      GtkCssValue *resolved_color = NULL;
-
-      if (fallback->color)
-        resolved_color = gtk_css_color_value_resolve (fallback->color, NULL, current_color);
-
-      /* image($color) that didn't change */
-      if (resolved_color && !fallback->images && resolved_color == fallback->color)
-        return g_object_ref (image);
-
-      resolved = g_object_new (_gtk_css_image_fallback_get_type (), NULL);
-      resolved->n_images = fallback->n_images;
-      resolved->images = g_new (GtkCssImage *, fallback->n_images);
-      for (i = 0; i < fallback->n_images; i++)
-        {
-          resolved->images[i] = g_object_ref (fallback->images[i]);
-
-          if (gtk_css_image_is_invalid (resolved->images[i]))
-            continue;
-
-          if (resolved->used < 0)
-            resolved->used = i;
-        }
-
-      resolved->color = resolved_color;
-
-      return GTK_CSS_IMAGE (resolved);
-    }
-  else
-    return GTK_CSS_IMAGE (g_object_ref (image));
-}
-
 static void
 _gtk_css_image_fallback_class_init (GtkCssImageFallbackClass *klass)
 {
@@ -382,8 +316,6 @@ _gtk_css_image_fallback_class_init (GtkCssImageFallbackClass *klass)
   image_class->print = gtk_css_image_fallback_print;
   image_class->equal = gtk_css_image_fallback_equal;
   image_class->is_computed = gtk_css_image_fallback_is_computed;
-  image_class->contains_current_color = gtk_css_image_fallback_contains_current_color;
-  image_class->resolve = gtk_css_image_fallback_resolve;
 
   object_class->dispose = gtk_css_image_fallback_dispose;
 }

gtk/gtkcssimageicontheme.c

@@ -29,8 +29,6 @@
 #include "gtkstyleproviderprivate.h"
 #include "gtksymbolicpaintable.h"
 #include "gtkiconthemeprivate.h"
-#include "gtkcsscolorvalueprivate.h"
-#include "gtkcsspalettevalueprivate.h"
 
 G_DEFINE_TYPE (GtkCssImageIconTheme, _gtk_css_image_icon_theme, GTK_TYPE_CSS_IMAGE)
 
@@ -52,7 +50,6 @@ gtk_css_image_icon_theme_snapshot (GtkCssImage *image,
   double icon_width, icon_height;
   int size;
   double x, y;
-  GdkRGBA colors[4];
 
   size = floor (MIN (width, height));
   if (size <= 0)
@@ -92,15 +89,11 @@ gtk_css_image_icon_theme_snapshot (GtkCssImage *image,
       gtk_snapshot_save (snapshot);
       gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (x, y));
     }
-
-  for (guint i = 0; i < 4; i++)
-    colors[i] = *gtk_css_color_value_get_rgba (icon_theme->colors[i]);
-
   gtk_symbolic_paintable_snapshot_symbolic (GTK_SYMBOLIC_PAINTABLE (icon),
                                             snapshot,
                                             icon_width,
                                             icon_height,
-                                            colors,
+                                            icon_theme->colors,
                                             G_N_ELEMENTS (icon_theme->colors));
   if (x != 0 || y != 0)
     gtk_snapshot_restore (snapshot);
@@ -153,7 +146,6 @@ gtk_css_image_icon_theme_compute (GtkCssImage          *image,
   GtkCssImageIconTheme *copy;
   GtkSettings *settings;
   GdkDisplay *display;
-  const char *names[4] = { NULL, "success", "warning", "error" };
 
   copy = g_object_new (GTK_TYPE_CSS_IMAGE_ICON_THEME, NULL);
   copy->name = g_strdup (icon_theme->name);
@@ -162,18 +154,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 (context->provider);
-
-  for (guint i = 0; i < 4; i++)
-    {
-      GtkCssValue *color = NULL;
-
-      if (names[i])
-        color = gtk_css_palette_value_get_color (context->style->core->icon_palette, names[i]);
-      if (color)
-        copy->colors[i] = gtk_css_value_ref (color);
-      else
-        copy->colors[i] = gtk_css_value_ref (context->style->core->color);
-    }
+  gtk_css_style_lookup_symbolic_colors (context->style, copy->colors);
 
   return GTK_CSS_IMAGE (copy);
 }
@@ -199,51 +180,10 @@ gtk_css_image_icon_theme_dispose (GObject *object)
   icon_theme->name = NULL;
 
   g_clear_object (&icon_theme->cached_icon);
-  g_clear_pointer (&icon_theme->colors[0], gtk_css_value_unref);
-  g_clear_pointer (&icon_theme->colors[1], gtk_css_value_unref);
-  g_clear_pointer (&icon_theme->colors[2], gtk_css_value_unref);
-  g_clear_pointer (&icon_theme->colors[3], gtk_css_value_unref);
 
   G_OBJECT_CLASS (_gtk_css_image_icon_theme_parent_class)->dispose (object);
 }
 
-static gboolean
-gtk_css_image_icon_theme_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageIconTheme *icon_theme = GTK_CSS_IMAGE_ICON_THEME (image);
-
-  for (guint i = 0; i < 4; i++)
-    {
-      if (!icon_theme->colors[i] ||
-          gtk_css_value_contains_current_color (icon_theme->colors[i]))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_icon_theme_resolve (GtkCssImage *image,
-                                  GtkCssValue *current)
-{
-  GtkCssImageIconTheme *icon_theme = GTK_CSS_IMAGE_ICON_THEME (image);
-  GtkCssImageIconTheme *copy;
-
-  if (!gtk_css_image_icon_theme_contains_current_color (image))
-    return g_object_ref (image);
-
-  copy = g_object_new (GTK_TYPE_CSS_IMAGE_ICON_THEME, NULL);
-  copy->name = g_strdup (icon_theme->name);
-  copy->icon_theme = icon_theme->icon_theme;
-  copy->serial = icon_theme->serial;
-  copy->scale = icon_theme->scale;
-
-  for (guint i = 0; i < 4; i++)
-    copy->colors[i] = gtk_css_color_value_resolve (icon_theme->colors[i], NULL, current);
-
-  return GTK_CSS_IMAGE (copy);
-}
-
 static void
 _gtk_css_image_icon_theme_class_init (GtkCssImageIconThemeClass *klass)
 {
@@ -256,8 +196,7 @@ _gtk_css_image_icon_theme_class_init (GtkCssImageIconThemeClass *klass)
   image_class->print = gtk_css_image_icon_theme_print;
   image_class->compute = gtk_css_image_icon_theme_compute;
   image_class->equal = gtk_css_image_icon_theme_equal;
-  image_class->contains_current_color = gtk_css_image_icon_theme_contains_current_color;
-  image_class->resolve = gtk_css_image_icon_theme_resolve;
+
   object_class->dispose = gtk_css_image_icon_theme_dispose;
 }
 

gtk/gtkcssimageiconthemeprivate.h

@@ -39,7 +39,7 @@ struct _GtkCssImageIconTheme
   GtkCssImage parent;
 
   GtkIconTheme *icon_theme;
-  GtkCssValue *colors[4];
+  GdkRGBA colors[4];
   int serial;
   int scale;
   char *name;

gtk/gtkcssimagelinear.c

@@ -46,7 +46,7 @@ gtk_css_image_linear_get_repeating_start_end (GtkCssImageLinear *linear,
   if (stop->offset == NULL)
     *start = 0;
   else
-    *start = gtk_css_number_value_get (stop->offset, length) / length;
+    *start = _gtk_css_number_value_get (stop->offset, length) / length;
 
   *end = *start;
 
@@ -57,7 +57,7 @@ gtk_css_image_linear_get_repeating_start_end (GtkCssImageLinear *linear,
       if (stop->offset == NULL)
         continue;
 
-      pos = gtk_css_number_value_get (stop->offset, length) / length;
+      pos = _gtk_css_number_value_get (stop->offset, length) / length;
 
       *end = MAX (pos, *end);
     }
@@ -134,10 +134,10 @@ gtk_css_image_linear_compute_start_point (double angle_in_degrees,
 }
 
 static void
-gtk_css_image_linear_snapshot (GtkCssImage *image,
-                               GtkSnapshot *snapshot,
-                               double       width,
-                               double       height)
+gtk_css_image_linear_snapshot (GtkCssImage        *image,
+                               GtkSnapshot        *snapshot,
+                               double              width,
+                               double              height)
 {
   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
   GskColorStop *stops;
@@ -174,7 +174,7 @@ gtk_css_image_linear_snapshot (GtkCssImage *image,
     }
   else
     {
-      angle = gtk_css_number_value_get (linear->angle, 100);
+      angle = _gtk_css_number_value_get (linear->angle, 100);
     }
 
   gtk_css_image_linear_compute_start_point (angle,
@@ -188,16 +188,12 @@ gtk_css_image_linear_snapshot (GtkCssImage *image,
 
       if (start == end)
         {
-          /* Repeating gradients with all color stops sharing the same offset
-           * get the color of the last color stop
-           */
+          /* repeating gradients with all color stops sharing the same offset
+           * get the color of the last color stop */
           const GtkCssImageLinearColorStop *stop = &linear->color_stops[linear->n_stops - 1];
-          const GdkRGBA *color;
-
-          color = gtk_css_color_value_get_rgba (stop->color);
 
           gtk_snapshot_append_color (snapshot,
-                                     color,
+                                     gtk_css_color_value_get_rgba (stop->color),
                                      &GRAPHENE_RECT_INIT (0, 0, width, height));
           return;
         }
@@ -228,7 +224,7 @@ gtk_css_image_linear_snapshot (GtkCssImage *image,
         }
       else
         {
-          pos = gtk_css_number_value_get (stop->offset, length) / length;
+          pos = _gtk_css_number_value_get (stop->offset, length) / length;
           pos = CLAMP (pos, 0.0, 1.0);
         }
 
@@ -240,9 +236,8 @@ gtk_css_image_linear_snapshot (GtkCssImage *image,
 
           offset += step;
 
-          stops[last].color = *gtk_css_color_value_get_rgba (stop->color);
-
           stops[last].offset = (offset - start) / (end - start);
+          stops[last].color = *gtk_css_color_value_get_rgba (stop->color);
         }
 
       offset = pos;
@@ -278,18 +273,18 @@ gtk_css_image_linear_parse_color_stop (GtkCssImageLinear *self,
 {
   GtkCssImageLinearColorStop stop;
 
-  stop.color = gtk_css_color_value_parse (parser);
+  stop.color = _gtk_css_color_value_parse (parser);
   if (stop.color == NULL)
     return 0;
 
   if (gtk_css_number_value_can_parse (parser))
     {
-      stop.offset = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_PARSE_PERCENT
-                                                | GTK_CSS_PARSE_LENGTH);
+      stop.offset = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_PARSE_PERCENT
+                                                 | GTK_CSS_PARSE_LENGTH);
       if (stop.offset == NULL)
         {
-          gtk_css_value_unref (stop.color);
+          _gtk_css_value_unref (stop.color);
           return 0;
         }
     }
@@ -364,7 +359,7 @@ gtk_css_image_linear_parse_first_arg (GtkCssImageLinear *linear,
     }
   else if (gtk_css_number_value_can_parse (parser))
     {
-      linear->angle = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
+      linear->angle = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
       if (linear->angle == NULL)
         return 0;
 
@@ -469,7 +464,7 @@ gtk_css_image_linear_print (GtkCssImage *image,
     }
   else
     {
-      gtk_css_value_print (linear->angle, string);
+      _gtk_css_value_print (linear->angle, string);
       g_string_append (string, ", ");
     }
 
@@ -480,12 +475,12 @@ gtk_css_image_linear_print (GtkCssImage *image,
       if (i > 0)
         g_string_append (string, ", ");
 
-      gtk_css_value_print (stop->color, string);
+      _gtk_css_value_print (stop->color, string);
 
       if (stop->offset)
         {
           g_string_append (string, " ");
-          gtk_css_value_print (stop->offset, string);
+          _gtk_css_value_print (stop->offset, string);
         }
     }
 
@@ -506,7 +501,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, context);
+    copy->angle = _gtk_css_value_compute (linear->angle, property_id, context);
 
   copy->n_stops = linear->n_stops;
   copy->color_stops = g_malloc (sizeof (GtkCssImageLinearColorStop) * copy->n_stops);
@@ -515,11 +510,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, context);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, context);
 
       if (stop->offset)
         {
-          scopy->offset = gtk_css_value_compute (stop->offset, property_id, context);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, context);
         }
       else
         {
@@ -561,7 +556,7 @@ gtk_css_image_linear_transition (GtkCssImage *start_image,
 
   result->side = start->side;
   if (result->side == 0)
-    result->angle = gtk_css_value_transition (start->angle, end->angle, property_id, progress);
+    result->angle = _gtk_css_value_transition (start->angle, end->angle, property_id, progress);
   if (result->angle == NULL)
     goto fail;
 
@@ -583,22 +578,22 @@ gtk_css_image_linear_transition (GtkCssImage *start_image,
         }
       else
         {
-          stop->offset = gtk_css_value_transition (start_stop->offset,
-                                                   end_stop->offset,
-                                                   property_id,
-                                                   progress);
+          stop->offset = _gtk_css_value_transition (start_stop->offset,
+                                                    end_stop->offset,
+                                                    property_id,
+                                                    progress);
           if (stop->offset == NULL)
             goto fail;
         }
 
-      stop->color = gtk_css_value_transition (start_stop->color,
-                                              end_stop->color,
-                                              property_id,
-                                              progress);
+      stop->color = _gtk_css_value_transition (start_stop->color,
+                                               end_stop->color,
+                                               property_id,
+                                               progress);
       if (stop->color == NULL)
         {
           if (stop->offset)
-            gtk_css_value_unref (stop->offset);
+            _gtk_css_value_unref (stop->offset);
           goto fail;
         }
 
@@ -622,7 +617,7 @@ gtk_css_image_linear_equal (GtkCssImage *image1,
 
   if (linear1->repeating != linear2->repeating ||
       linear1->side != linear2->side ||
-      (linear1->side == 0 && !gtk_css_value_equal (linear1->angle, linear2->angle)) ||
+      (linear1->side == 0 && !_gtk_css_value_equal (linear1->angle, linear2->angle)) ||
       linear1->n_stops != linear2->n_stops)
     return FALSE;
 
@@ -631,8 +626,8 @@ gtk_css_image_linear_equal (GtkCssImage *image1,
       const GtkCssImageLinearColorStop *stop1 = &linear1->color_stops[i];
       const GtkCssImageLinearColorStop *stop2 = &linear2->color_stops[i];
 
-      if (!gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
-          !gtk_css_value_equal (stop1->color, stop2->color))
+      if (!_gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
+          !_gtk_css_value_equal (stop1->color, stop2->color))
         return FALSE;
     }
 
@@ -649,16 +644,16 @@ gtk_css_image_linear_dispose (GObject *object)
     {
       GtkCssImageLinearColorStop *stop = &linear->color_stops[i];
 
-      gtk_css_value_unref (stop->color);
+      _gtk_css_value_unref (stop->color);
       if (stop->offset)
-        gtk_css_value_unref (stop->offset);
+        _gtk_css_value_unref (stop->offset);
     }
   g_free (linear->color_stops);
 
   linear->side = 0;
   if (linear->angle)
     {
-      gtk_css_value_unref (linear->angle);
+      _gtk_css_value_unref (linear->angle);
       linear->angle = NULL;
     }
 
@@ -694,56 +689,6 @@ gtk_css_image_linear_is_computed (GtkCssImage *image)
   return computed;
 }
 
-static gboolean
-gtk_css_image_linear_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
-
-  for (guint i = 0; i < linear->n_stops; i ++)
-    {
-      const GtkCssImageLinearColorStop *stop = &linear->color_stops[i];
-
-      if (gtk_css_value_contains_current_color (stop->color))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_linear_resolve (GtkCssImage *image,
-                              GtkCssValue *current_color)
-{
-  GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
-  GtkCssImageLinear *copy;
-  guint i;
-
-  copy = g_object_new (GTK_TYPE_CSS_IMAGE_LINEAR, NULL);
-  copy->repeating = linear->repeating;
-  copy->side = linear->side;
-
-  if (linear->angle)
-    copy->angle = gtk_css_value_ref (linear->angle);
-
-  copy->n_stops = linear->n_stops;
-  copy->color_stops = g_new (GtkCssImageLinearColorStop, copy->n_stops);
-
-  for (i = 0; i < linear->n_stops; i++)
-    {
-      const GtkCssImageLinearColorStop *stop = &linear->color_stops[i];
-      GtkCssImageLinearColorStop *scopy = &copy->color_stops[i];
-
-      scopy->color = gtk_css_color_value_resolve (stop->color, NULL, current_color);
-
-      if (stop->offset)
-        scopy->offset = gtk_css_value_ref (stop->offset);
-      else
-        scopy->offset = NULL;
-    }
-
-  return GTK_CSS_IMAGE (copy);
-}
-
 static void
 _gtk_css_image_linear_class_init (GtkCssImageLinearClass *klass)
 {
@@ -757,8 +702,6 @@ _gtk_css_image_linear_class_init (GtkCssImageLinearClass *klass)
   image_class->equal = gtk_css_image_linear_equal;
   image_class->transition = gtk_css_image_linear_transition;
   image_class->is_computed = gtk_css_image_linear_is_computed;
-  image_class->contains_current_color = gtk_css_image_linear_contains_current_color;
-  image_class->resolve = gtk_css_image_linear_resolve;
 
   object_class->dispose = gtk_css_image_linear_dispose;
 }

gtk/gtkcssimageprivate.h

@@ -91,9 +91,6 @@ struct _GtkCssImageClass
   void         (* print)                           (GtkCssImage                *image,
                                                     GString                    *string);
   gboolean     (* is_computed)                     (GtkCssImage                *image);
-  gboolean     (* contains_current_color)          (GtkCssImage                *image);
-  GtkCssImage *( * resolve)                        (GtkCssImage                *image,
-                                                    GtkCssValue                *current_color);
 };
 
 GType          _gtk_css_image_get_type             (void) G_GNUC_CONST;
@@ -115,6 +112,10 @@ GtkCssImage *  _gtk_css_image_transition           (GtkCssImage                *
                                                     guint                       property_id,
                                                     double                      progress);
 
+void           _gtk_css_image_draw                 (GtkCssImage                *image,
+                                                    cairo_t                    *cr,
+                                                    double                      width,
+                                                    double                      height);
 void           gtk_css_image_snapshot              (GtkCssImage                *image,
                                                     GtkSnapshot                *snapshot,
                                                     double                      width,
@@ -141,10 +142,6 @@ cairo_surface_t *
                                                     int                         surface_height);
 gboolean       gtk_css_image_is_computed           (GtkCssImage                *image) G_GNUC_PURE;
 
-gboolean       gtk_css_image_contains_current_color (GtkCssImage *image) G_GNUC_PURE;
-
-GtkCssImage *  gtk_css_image_resolve                (GtkCssImage *image,
-                                                     GtkCssValue *current_color);
 
 G_END_DECLS
 

gtk/gtkcssimageradial.c

@@ -47,7 +47,7 @@ gtk_css_image_radial_get_start_end (GtkCssImageRadial *radial,
       if (stop->offset == NULL)
         *start = 0;
       else
-        *start = gtk_css_number_value_get (stop->offset, radius) / radius;
+        *start = _gtk_css_number_value_get (stop->offset, radius) / radius;
 
       *end = *start;
 
@@ -58,7 +58,7 @@ gtk_css_image_radial_get_start_end (GtkCssImageRadial *radial,
           if (stop->offset == NULL)
             continue;
 
-          pos = gtk_css_number_value_get (stop->offset, radius) / radius;
+          pos = _gtk_css_number_value_get (stop->offset, radius) / radius;
 
           *end = MAX (pos, *end);
         }
@@ -96,7 +96,7 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
       switch (radial->size)
         {
         case GTK_CSS_EXPLICIT_SIZE:
-          hradius = gtk_css_number_value_get (radial->sizes[0], width);
+          hradius = _gtk_css_number_value_get (radial->sizes[0], width);
           break;
         case GTK_CSS_CLOSEST_SIDE:
           hradius = MIN (MIN (x, width - x), MIN (y, height - y));
@@ -128,8 +128,8 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
       switch (radial->size)
         {
         case GTK_CSS_EXPLICIT_SIZE:
-          hradius = gtk_css_number_value_get (radial->sizes[0], width);
-          vradius = gtk_css_number_value_get (radial->sizes[1], height);
+          hradius = _gtk_css_number_value_get (radial->sizes[0], width);
+          vradius = _gtk_css_number_value_get (radial->sizes[1], height);
           break;
         case GTK_CSS_CLOSEST_SIDE:
           hradius = MIN (x, width - x);
@@ -176,7 +176,7 @@ gtk_css_image_radial_snapshot (GtkCssImage *image,
             continue;
         }
       else
-        pos = MIN (1.0, gtk_css_number_value_get (stop->offset, hradius) / hradius);
+        pos = MIN (1.0, _gtk_css_number_value_get (stop->offset, hradius) / hradius);
 
       pos = MAX (pos, offset);
       step = (pos - offset) / (i - last);
@@ -223,18 +223,18 @@ gtk_css_image_radial_parse_color_stop (GtkCssImageRadial *radial,
 {
   GtkCssImageRadialColorStop stop;
 
-  stop.color = gtk_css_color_value_parse (parser);
+  stop.color = _gtk_css_color_value_parse (parser);
   if (stop.color == NULL)
     return 0;
 
   if (gtk_css_number_value_can_parse (parser))
     {
-      stop.offset = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_PARSE_PERCENT
-                                                | GTK_CSS_PARSE_LENGTH);
+      stop.offset = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_PARSE_PERCENT
+                                                 | GTK_CSS_PARSE_LENGTH);
       if (stop.offset == NULL)
         {
-          gtk_css_value_unref (stop.color);
+          _gtk_css_value_unref (stop.color);
           return 0;
         }
     }
@@ -294,12 +294,12 @@ gtk_css_image_radial_parse_first_arg (GtkCssImageRadial *radial,
 
         if (!has_size && gtk_css_number_value_can_parse (parser))
           {
-            radial->sizes[0] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_PARSE_PERCENT);
+            radial->sizes[0] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_PARSE_PERCENT);
             if (radial->sizes[0] == NULL)
               return 0;
             if (gtk_css_number_value_can_parse (parser))
               {
-                radial->sizes[1] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_PARSE_PERCENT);
+                radial->sizes[1] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_PARSE_PERCENT);
                 if (radial->sizes[1] == NULL)
                   return 0;
               }
@@ -323,8 +323,8 @@ gtk_css_image_radial_parse_first_arg (GtkCssImageRadial *radial,
     }
   else
     {
-      radial->position = _gtk_css_position_value_new (gtk_css_number_value_new (50, GTK_CSS_PERCENT),
-                                                      gtk_css_number_value_new (50, GTK_CSS_PERCENT));
+      radial->position = _gtk_css_position_value_new (_gtk_css_number_value_new (50, GTK_CSS_PERCENT),
+                                                      _gtk_css_number_value_new (50, GTK_CSS_PERCENT));
     }
 
   if (!has_size)
@@ -358,7 +358,7 @@ gtk_css_image_radial_parse_first_arg (GtkCssImageRadial *radial,
   if (has_size && !radial->circle)
     {
       if (radial->sizes[0] && !radial->sizes[1])
-        radial->sizes[1] = gtk_css_value_ref (radial->sizes[0]);
+        radial->sizes[1] = _gtk_css_value_ref (radial->sizes[0]);
     }
 
   if (found_one)
@@ -456,16 +456,16 @@ gtk_css_image_radial_print (GtkCssImage *image,
   else
     {
       if (radial->sizes[0])
-        gtk_css_value_print (radial->sizes[0], string);
+        _gtk_css_value_print (radial->sizes[0], string);
       if (radial->sizes[1])
         {
           g_string_append (string, " ");
-          gtk_css_value_print (radial->sizes[1], string);
+          _gtk_css_value_print (radial->sizes[1], string);
         }
     }
 
   g_string_append (string, " at ");
-  gtk_css_value_print (radial->position, string);
+  _gtk_css_value_print (radial->position, string);
 
   g_string_append (string, ", ");
 
@@ -476,12 +476,12 @@ gtk_css_image_radial_print (GtkCssImage *image,
       if (i > 0)
         g_string_append (string, ", ");
 
-      gtk_css_value_print (stop->color, string);
+      _gtk_css_value_print (stop->color, string);
 
       if (stop->offset)
         {
           g_string_append (string, " ");
-          gtk_css_value_print (stop->offset, string);
+          _gtk_css_value_print (stop->offset, string);
         }
     }
 
@@ -502,13 +502,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, context);
+  copy->position = _gtk_css_value_compute (radial->position, property_id, context);
 
   if (radial->sizes[0])
-    copy->sizes[0] = gtk_css_value_compute (radial->sizes[0], property_id, context);
+    copy->sizes[0] = _gtk_css_value_compute (radial->sizes[0], property_id, context);
 
   if (radial->sizes[1])
-    copy->sizes[1] = gtk_css_value_compute (radial->sizes[1], property_id, context);
+    copy->sizes[1] = _gtk_css_value_compute (radial->sizes[1], property_id, context);
 
   copy->n_stops = radial->n_stops;
   copy->color_stops = g_malloc (sizeof (GtkCssImageRadialColorStop) * copy->n_stops);
@@ -517,11 +517,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, context);
+      scopy->color = _gtk_css_value_compute (stop->color, property_id, context);
 
       if (stop->offset)
         {
-          scopy->offset = gtk_css_value_compute (stop->offset, property_id, context);
+          scopy->offset = _gtk_css_value_compute (stop->offset, property_id, context);
         }
       else
         {
@@ -562,13 +562,13 @@ gtk_css_image_radial_transition (GtkCssImage *start_image,
   result->circle = start->circle;
   result->size = start->size;
 
-  result->position = gtk_css_value_transition (start->position, end->position, property_id, progress);
+  result->position = _gtk_css_value_transition (start->position, end->position, property_id, progress);
   if (result->position == NULL)
     goto fail;
 
   if (start->sizes[0] && end->sizes[0])
     {
-      result->sizes[0] = gtk_css_value_transition (start->sizes[0], end->sizes[0], property_id, progress);
+      result->sizes[0] = _gtk_css_value_transition (start->sizes[0], end->sizes[0], property_id, progress);
       if (result->sizes[0] == NULL)
         goto fail;
     }
@@ -577,7 +577,7 @@ gtk_css_image_radial_transition (GtkCssImage *start_image,
 
   if (start->sizes[1] && end->sizes[1])
     {
-      result->sizes[1] = gtk_css_value_transition (start->sizes[1], end->sizes[1], property_id, progress);
+      result->sizes[1] = _gtk_css_value_transition (start->sizes[1], end->sizes[1], property_id, progress);
       if (result->sizes[1] == NULL)
         goto fail;
     }
@@ -601,22 +601,22 @@ gtk_css_image_radial_transition (GtkCssImage *start_image,
         }
       else
         {
-          stop->offset = gtk_css_value_transition (start_stop->offset,
-                                                   end_stop->offset,
-                                                   property_id,
-                                                   progress);
+          stop->offset = _gtk_css_value_transition (start_stop->offset,
+                                                    end_stop->offset,
+                                                    property_id,
+                                                    progress);
           if (stop->offset == NULL)
             goto fail;
         }
 
-      stop->color = gtk_css_value_transition (start_stop->color,
-                                              end_stop->color,
-                                              property_id,
-                                              progress);
+      stop->color = _gtk_css_value_transition (start_stop->color,
+                                               end_stop->color,
+                                               property_id,
+                                               progress);
       if (stop->color == NULL)
         {
           if (stop->offset)
-            gtk_css_value_unref (stop->offset);
+            _gtk_css_value_unref (stop->offset);
           goto fail;
         }
 
@@ -640,11 +640,11 @@ gtk_css_image_radial_equal (GtkCssImage *image1,
 
   if (radial1->repeating != radial2->repeating ||
       radial1->size != radial2->size ||
-      !gtk_css_value_equal (radial1->position, radial2->position) ||
+      !_gtk_css_value_equal (radial1->position, radial2->position) ||
       ((radial1->sizes[0] == NULL) != (radial2->sizes[0] == NULL)) ||
-      (radial1->sizes[0] && radial2->sizes[0] && !gtk_css_value_equal (radial1->sizes[0], radial2->sizes[0])) ||
+      (radial1->sizes[0] && radial2->sizes[0] && !_gtk_css_value_equal (radial1->sizes[0], radial2->sizes[0])) ||
       ((radial1->sizes[1] == NULL) != (radial2->sizes[1] == NULL)) ||
-      (radial1->sizes[1] && radial2->sizes[1] && !gtk_css_value_equal (radial1->sizes[1], radial2->sizes[1])) ||
+      (radial1->sizes[1] && radial2->sizes[1] && !_gtk_css_value_equal (radial1->sizes[1], radial2->sizes[1])) ||
       radial1->n_stops != radial2->n_stops)
     return FALSE;
 
@@ -653,8 +653,8 @@ gtk_css_image_radial_equal (GtkCssImage *image1,
       const GtkCssImageRadialColorStop *stop1 = &radial1->color_stops[i];
       const GtkCssImageRadialColorStop *stop2 = &radial2->color_stops[i];
 
-      if (!gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
-          !gtk_css_value_equal (stop1->color, stop2->color))
+      if (!_gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
+          !_gtk_css_value_equal (stop1->color, stop2->color))
         return FALSE;
     }
 
@@ -671,22 +671,22 @@ gtk_css_image_radial_dispose (GObject *object)
     {
       GtkCssImageRadialColorStop *stop = &radial->color_stops[i];
 
-      gtk_css_value_unref (stop->color);
+      _gtk_css_value_unref (stop->color);
       if (stop->offset)
-        gtk_css_value_unref (stop->offset);
+        _gtk_css_value_unref (stop->offset);
     }
   g_free (radial->color_stops);
 
   if (radial->position)
     {
-      gtk_css_value_unref (radial->position);
+      _gtk_css_value_unref (radial->position);
       radial->position = NULL;
     }
 
   for (i = 0; i < 2; i++)
     if (radial->sizes[i])
       {
-        gtk_css_value_unref (radial->sizes[i]);
+        _gtk_css_value_unref (radial->sizes[i]);
         radial->sizes[i] = NULL;
       }
 
@@ -724,62 +724,6 @@ gtk_css_image_radial_is_computed (GtkCssImage *image)
 
   return computed;
 }
-
-static gboolean
-gtk_css_image_radial_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageRadial *radial = GTK_CSS_IMAGE_RADIAL (image);
-
-  for (guint i = 0; i < radial->n_stops; i ++)
-    {
-      const GtkCssImageRadialColorStop *stop = &radial->color_stops[i];
-
-      if (gtk_css_value_contains_current_color (stop->color))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_radial_resolve (GtkCssImage *image,
-                              GtkCssValue *current_color)
-{
-  GtkCssImageRadial *radial = GTK_CSS_IMAGE_RADIAL (image);
-  GtkCssImageRadial *copy;
-
-  copy = g_object_new (GTK_TYPE_CSS_IMAGE_RADIAL, NULL);
-  copy->repeating = radial->repeating;
-  copy->circle = radial->circle;
-  copy->size = radial->size;
-
-  copy->position = gtk_css_value_ref (radial->position);
-
-  if (radial->sizes[0])
-    copy->sizes[0] = gtk_css_value_ref (radial->sizes[0]);
-
-  if (radial->sizes[1])
-    copy->sizes[1] = gtk_css_value_ref (radial->sizes[1]);
-
-  copy->n_stops = radial->n_stops;
-  copy->color_stops = g_new (GtkCssImageRadialColorStop, copy->n_stops);
-
-  for (guint i = 0; i < radial->n_stops; i++)
-    {
-      const GtkCssImageRadialColorStop *stop = &radial->color_stops[i];
-      GtkCssImageRadialColorStop *scopy = &copy->color_stops[i];
-
-      scopy->color = gtk_css_color_value_resolve (stop->color, NULL, current_color);
-
-      if (stop->offset)
-        scopy->offset = gtk_css_value_ref (stop->offset);
-      else
-        scopy->offset = NULL;
-    }
-
-  return GTK_CSS_IMAGE (copy);
-}
-
 static void
 _gtk_css_image_radial_class_init (GtkCssImageRadialClass *klass)
 {
@@ -793,8 +737,6 @@ _gtk_css_image_radial_class_init (GtkCssImageRadialClass *klass)
   image_class->transition = gtk_css_image_radial_transition;
   image_class->equal = gtk_css_image_radial_equal;
   image_class->is_computed = gtk_css_image_radial_is_computed;
-  image_class->contains_current_color = gtk_css_image_radial_contains_current_color;
-  image_class->resolve = gtk_css_image_radial_resolve;
 
   object_class->dispose = gtk_css_image_radial_dispose;
 }

gtk/gtkcssimagerecolor.c

@@ -44,7 +44,7 @@ gtk_css_image_recolor_print (GtkCssImage *image,
   if (recolor->palette)
     {
       g_string_append (string, ",");
-      gtk_css_value_print (recolor->palette, string);
+      _gtk_css_value_print (recolor->palette, string);
     }
   g_string_append (string, ")");
 }
@@ -54,14 +54,44 @@ gtk_css_image_recolor_dispose (GObject *object)
 {
   GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (object);
 
-  g_clear_pointer (&recolor->palette, gtk_css_value_unref);
-  g_clear_pointer (&recolor->color, gtk_css_value_unref);
+  g_clear_pointer (&recolor->palette, _gtk_css_value_unref);
   g_clear_object (&recolor->file);
   g_clear_object (&recolor->texture);
 
   G_OBJECT_CLASS (_gtk_css_image_recolor_parent_class)->dispose (object);
 }
 
+static void
+lookup_symbolic_colors (GtkCssStyle *style,
+                        GtkCssValue *palette,
+                        GdkRGBA     *color_out,
+                        GdkRGBA     *success_out,
+                        GdkRGBA     *warning_out,
+                        GdkRGBA     *error_out)
+{
+  const GdkRGBA *lookup;
+
+  *color_out = *gtk_css_color_value_get_rgba (style->core->color);
+
+  lookup = gtk_css_palette_value_get_color (palette, "success");
+  if (lookup)
+    *success_out = *lookup;
+  else
+    *success_out = *color_out;
+
+  lookup = gtk_css_palette_value_get_color (palette, "warning");
+  if (lookup)
+    *warning_out = *lookup;
+  else
+    *warning_out = *color_out;
+
+  lookup = gtk_css_palette_value_get_color (palette, "error");
+  if (lookup)
+    *error_out = *lookup;
+  else
+    *error_out = *color_out;
+}
+
 static void
 gtk_css_image_recolor_load_texture (GtkCssImageRecolor  *recolor,
                                     GError             **error)
@@ -97,23 +127,22 @@ gtk_css_image_recolor_load_texture (GtkCssImageRecolor  *recolor,
 }
 
 static GtkCssImage *
-gtk_css_image_recolor_load (GtkCssImageRecolor    *recolor,
-                            GtkCssComputeContext  *context,
-                            GtkCssValue           *palette,
-                            int                    scale,
-                            GError               **gerror)
+gtk_css_image_recolor_load (GtkCssImageRecolor  *recolor,
+                            GtkCssStyle         *style,
+                            GtkCssValue         *palette,
+                            int                  scale,
+                            GError             **gerror)
 {
   GError *local_error = NULL;
   GtkCssImageRecolor *image;
 
   image = g_object_new (GTK_TYPE_CSS_IMAGE_RECOLOR, NULL);
 
-  image->file = g_object_ref (recolor->file);
-  image->palette = gtk_css_value_ref (palette);
-  image->color = gtk_css_value_ref (context->style->core->color);
-
+  lookup_symbolic_colors (style, palette, &image->color, &image->success, &image->warning, &image->error);
   gtk_css_image_recolor_load_texture (recolor, &local_error);
 
+  image->file = g_object_ref (recolor->file);
+
   if (recolor->texture)
     image->texture = g_object_ref (recolor->texture);
   else
@@ -143,34 +172,16 @@ gtk_css_image_recolor_snapshot (GtkCssImage *image,
                                 double       height)
 {
   GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (image);
-  const GdkRGBA *fg, *sc, *wc, *ec;
-  const GtkCssValue *color;
+  const GdkRGBA *fg = &recolor->color;
+  const GdkRGBA *sc = &recolor->success;
+  const GdkRGBA *wc = &recolor->warning;
+  const GdkRGBA *ec = &recolor->error;
   graphene_matrix_t matrix;
   graphene_vec4_t offset;
 
   if (recolor->texture == NULL)
     return;
 
-  fg = gtk_css_color_value_get_rgba (recolor->color);
-
-  color = gtk_css_palette_value_get_color (recolor->palette, "success");
-  if (color)
-    sc = gtk_css_color_value_get_rgba (color);
-  else
-    sc = fg;
-
-  color = gtk_css_palette_value_get_color (recolor->palette, "warning");
-  if (color)
-    wc = gtk_css_color_value_get_rgba (color);
-  else
-    wc = fg;
-
-  color = gtk_css_palette_value_get_color (recolor->palette, "error");
-  if (color)
-    ec = gtk_css_color_value_get_rgba (color);
-  else
-    ec = fg;
-
   graphene_matrix_init_from_float (&matrix,
           (float[16]) {
                        sc->red - fg->red, sc->green - fg->green, sc->blue - fg->blue, 0,
@@ -203,11 +214,11 @@ gtk_css_image_recolor_compute (GtkCssImage          *image,
   scale = gtk_style_provider_get_scale (context->provider);
 
   if (recolor->palette)
-    palette = gtk_css_value_compute (recolor->palette, property_id, context);
+    palette = _gtk_css_value_compute (recolor->palette, property_id, context);
   else
-    palette = gtk_css_value_ref (context->style->core->icon_palette);
+    palette = _gtk_css_value_ref (context->style->core->icon_palette);
 
-  img = gtk_css_image_recolor_load (recolor, context, palette, scale, &error);
+  img = gtk_css_image_recolor_load (recolor, context->style, palette, scale, &error);
 
   if (error)
     {
@@ -216,7 +227,7 @@ gtk_css_image_recolor_compute (GtkCssImage          *image,
       g_error_free (error);
     }
 
-  gtk_css_value_unref (palette);
+  _gtk_css_value_unref (palette);
 
   return img;
 }
@@ -256,7 +267,7 @@ gtk_css_image_recolor_parse_arg (GtkCssParser *parser,
 
 static gboolean
 gtk_css_image_recolor_parse (GtkCssImage  *image,
-                             GtkCssParser *parser)
+                                GtkCssParser *parser)
 {
   if (!gtk_css_parser_has_function (parser, "-gtk-recolor"))
     {
@@ -298,37 +309,8 @@ gtk_css_image_recolor_is_computed (GtkCssImage *image)
 {
   GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (image);
 
-  return recolor->texture && gtk_css_value_is_computed (recolor->palette);
-}
-
-static gboolean
-gtk_css_image_recolor_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (image);
-
-  if (!recolor->palette || !recolor->color)
-    return TRUE;
-
-  return gtk_css_value_contains_current_color (recolor->palette) ||
-         gtk_css_value_contains_current_color (recolor->color);
-}
-
-static GtkCssImage *
-gtk_css_image_recolor_resolve (GtkCssImage *image,
-                               GtkCssValue *current_color)
-{
-  GtkCssImageRecolor *recolor = GTK_CSS_IMAGE_RECOLOR (image);
-  GtkCssImageRecolor *img;
-
-  img = g_object_new (GTK_TYPE_CSS_IMAGE_RECOLOR, NULL);
-
-  img->palette = gtk_css_palette_value_resolve (recolor->palette, current_color);
-  img->color = gtk_css_color_value_resolve (recolor->color, NULL, current_color);
-  img->file = g_object_ref (recolor->file);
-  if (recolor->texture)
-    img->texture = g_object_ref (recolor->texture);
-
-  return GTK_CSS_IMAGE (img);
+  return recolor->texture &&
+         (!recolor->palette || gtk_css_value_is_computed (recolor->palette));
 }
 
 static void
@@ -344,8 +326,6 @@ _gtk_css_image_recolor_class_init (GtkCssImageRecolorClass *klass)
   image_class->parse = gtk_css_image_recolor_parse;
   image_class->print = gtk_css_image_recolor_print;
   image_class->is_computed = gtk_css_image_recolor_is_computed;
-  image_class->contains_current_color = gtk_css_image_recolor_contains_current_color;
-  image_class->resolve = gtk_css_image_recolor_resolve;
 
   object_class->dispose = gtk_css_image_recolor_dispose;
 }

gtk/gtkcssimagerecolorprivate.h

@@ -39,9 +39,12 @@ struct _GtkCssImageRecolor
   GtkCssImage parent;
 
   GFile *file;
-  GtkCssValue *color;
   GtkCssValue *palette;
   GdkTexture *texture;
+  GdkRGBA color;
+  GdkRGBA success;
+  GdkRGBA warning;
+  GdkRGBA error;
 };
 
 struct _GtkCssImageRecolorClass

gtk/gtkcssimagescaled.c

@@ -208,42 +208,6 @@ gtk_css_image_scaled_is_computed (GtkCssImage *image)
          gtk_css_image_is_computed (self->images[0]);
 }
 
-static gboolean
-gtk_css_image_scaled_contains_current_color (GtkCssImage *image)
-{
-  GtkCssImageScaled *self = GTK_CSS_IMAGE_SCALED (image);
-
-  for (guint i = 0; i < self->n_images; i++)
-    {
-      if (gtk_css_image_contains_current_color (self->images[i]))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
-static GtkCssImage *
-gtk_css_image_scaled_resolve (GtkCssImage *image,
-                              GtkCssValue *current_color)
-{
-  GtkCssImageScaled *self = GTK_CSS_IMAGE_SCALED (image);
-  GtkCssImageScaled *res;
-
-  res = g_object_new (GTK_TYPE_CSS_IMAGE_SCALED, NULL);
-
-  res->n_images = self->n_images;
-  res->images = g_new (GtkCssImage *, self->n_images);
-  res->scales = g_new (int, self->n_images);
-
-  for (guint i = 0; i < self->n_images; i++)
-    {
-      res->images[i] = gtk_css_image_resolve (self->images[i], current_color);
-      res->scales[i] = self->scales[i];
-    }
-
-  return GTK_CSS_IMAGE (res);
-}
-
 static void
 _gtk_css_image_scaled_class_init (GtkCssImageScaledClass *klass)
 {
@@ -258,8 +222,6 @@ _gtk_css_image_scaled_class_init (GtkCssImageScaledClass *klass)
   image_class->compute = gtk_css_image_scaled_compute;
   image_class->print = gtk_css_image_scaled_print;
   image_class->is_computed = gtk_css_image_scaled_is_computed;
-  image_class->contains_current_color = gtk_css_image_scaled_contains_current_color;
-  image_class->resolve = gtk_css_image_scaled_resolve;
 
   object_class->dispose = gtk_css_image_scaled_dispose;
 }

gtk/gtkcssimagevalue.c

@@ -43,14 +43,14 @@ gtk_css_value_image_compute (GtkCssValue          *value,
   image = _gtk_css_image_value_get_image (value);
 
   if (image == NULL)
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   computed = _gtk_css_image_compute (image, property_id, context);
 
   if (computed == image)
     {
       g_object_unref (computed);
-      return gtk_css_value_ref (value);
+      return _gtk_css_value_ref (value);
     }
 
   return _gtk_css_image_value_new (computed);
@@ -134,16 +134,15 @@ 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, 1, 0, 0, NULL };
+  static GtkCssValue image_none_singleton = { &GTK_CSS_VALUE_IMAGE, 1, TRUE, FALSE, NULL };
   GtkCssValue *value;
 
   if (image == NULL)
-    return gtk_css_value_ref (&image_none_singleton);
+    return _gtk_css_value_ref (&image_none_singleton);
 
-  value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_IMAGE);
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_IMAGE);
   value->image = image;
   value->is_computed = gtk_css_image_is_computed (image);
-  value->contains_current_color = gtk_css_image_contains_current_color (image);
 
   return value;
 }
@@ -156,12 +155,3 @@ _gtk_css_image_value_get_image (const GtkCssValue *value)
   return value->image;
 }
 
-GtkCssValue *
-gtk_css_image_value_resolve (GtkCssValue *value,
-                             GtkCssValue *current_color)
-{
-  if (!gtk_css_value_contains_current_color (value))
-    return gtk_css_value_ref (value);
-
-  return _gtk_css_image_value_new (gtk_css_image_resolve (_gtk_css_image_value_get_image (value), current_color));
-}

gtk/gtkcssimagevalueprivate.h

@@ -28,9 +28,6 @@ GtkCssValue *   _gtk_css_image_value_new           (GtkCssImage         *image);
 
 GtkCssImage *   _gtk_css_image_value_get_image     (const GtkCssValue   *image);
 
-GtkCssValue *    gtk_css_image_value_resolve       (GtkCssValue *value,
-                                                    GtkCssValue *current_color);
-
 
 G_END_DECLS
 

gtk/gtkcssinheritvalue.c

@@ -40,13 +40,13 @@ gtk_css_value_inherit_compute (GtkCssValue          *value,
 {
   if (context->parent_style)
     {
-      return gtk_css_value_ref (gtk_css_style_get_value (context->parent_style, property_id));
+      return _gtk_css_value_ref (gtk_css_style_get_value (context->parent_style, property_id));
     }
   else
     {
-      return gtk_css_value_compute (_gtk_css_initial_value_get (),
-                                    property_id,
-                                    context);
+      return _gtk_css_value_compute (_gtk_css_initial_value_get (),
+                                     property_id,
+                                     context);
     }
 }
 
@@ -89,7 +89,7 @@ static GtkCssValue inherit = { &GTK_CSS_VALUE_INHERIT, 1 };
 GtkCssValue *
 _gtk_css_inherit_value_new (void)
 {
-  return gtk_css_value_ref (&inherit);
+  return _gtk_css_value_ref (&inherit);
 }
 
 GtkCssValue *

gtk/gtkcssinitialvalue.c

@@ -55,7 +55,7 @@ gtk_css_value_initial_compute (GtkCssValue          *value,
           g_object_get (settings, "gtk-xft-dpi", &dpi_int, NULL);
 
           if (dpi_int > 0.0)
-            return gtk_css_number_value_new (dpi_int / 1024., GTK_CSS_NUMBER);
+            return _gtk_css_number_value_new (dpi_int / 1024., GTK_CSS_NUMBER);
         }
       break;
 
@@ -69,7 +69,7 @@ gtk_css_value_initial_compute (GtkCssValue          *value,
       break;
     }
 
-  return gtk_css_value_compute (_gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (property_id)),
+  return _gtk_css_value_compute (_gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (property_id)),
                                  property_id,
                                  context);
 }
@@ -113,7 +113,7 @@ static GtkCssValue initial = { &GTK_CSS_VALUE_INITIAL, 1 };
 GtkCssValue *
 _gtk_css_initial_value_new (void)
 {
-  return gtk_css_value_ref (&initial);
+  return _gtk_css_value_ref (&initial);
 }
 
 GtkCssValue *

gtk/gtkcsskeyframes.c

@@ -74,7 +74,7 @@ _gtk_css_keyframes_unref (GtkCssKeyframes *keyframes)
     {
       for (p = 0; p < keyframes->n_properties; p++)
         {
-          gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
+          _gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
           KEYFRAMES_VALUE (keyframes, k, p) = NULL;
         }
 
@@ -103,7 +103,7 @@ gtk_css_keyframes_add_keyframe (GtkCssKeyframes *keyframes,
               if (KEYFRAMES_VALUE (keyframes, k, p) == NULL)
                 continue;
 
-              gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
+              _gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
               KEYFRAMES_VALUE (keyframes, k, p) = NULL;
 
               /* XXX: GC properties that are now unset
@@ -244,9 +244,9 @@ keyframes_set_value (GtkCssKeyframes     *keyframes,
   p = gtk_css_keyframes_lookup_property (keyframes, _gtk_css_style_property_get_id (property));
   
   if (KEYFRAMES_VALUE (keyframes, k, p))
-    gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
+    _gtk_css_value_unref (KEYFRAMES_VALUE (keyframes, k, p));
 
-  KEYFRAMES_VALUE (keyframes, k, p) = gtk_css_value_ref (value);
+  KEYFRAMES_VALUE (keyframes, k, p) = _gtk_css_value_ref (value);
 
   return TRUE;
 }
@@ -376,7 +376,7 @@ gtk_css_keyframes_parse_declaration (GtkCssKeyframes *keyframes,
   if (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
     {
       gtk_css_parser_error_syntax (parser, "Junk at end of value");
-      gtk_css_value_unref (value);
+      _gtk_css_value_unref (value);
       return FALSE;
     }
 
@@ -407,7 +407,7 @@ gtk_css_keyframes_parse_declaration (GtkCssKeyframes *keyframes,
       g_assert_not_reached ();
     }
       
-  gtk_css_value_unref (value);
+  _gtk_css_value_unref (value);
 
   return TRUE;
 }
@@ -566,7 +566,7 @@ _gtk_css_keyframes_print (GtkCssKeyframes *keyframes,
                                                         GTK_STYLE_PROPERTY (
                                                           _gtk_css_style_property_lookup_by_id (
                                                             keyframes->property_ids[sorted[p]]))));
-          gtk_css_value_print (KEYFRAMES_VALUE (keyframes, k, sorted[p]), string);
+          _gtk_css_value_print (KEYFRAMES_VALUE (keyframes, k, sorted[p]), string);
           g_string_append (string, ";\n");
         }
 
@@ -644,9 +644,9 @@ _gtk_css_keyframes_compute (GtkCssKeyframes  *keyframes,
 
           context.variables = keyframes->variables ? keyframes->variables[k] : NULL;
 
-          KEYFRAMES_VALUE (resolved, k, p) =  gtk_css_value_compute (KEYFRAMES_VALUE (keyframes, k, p),
-                                                                     resolved->property_ids[p],
-                                                                     &context);
+          KEYFRAMES_VALUE (resolved, k, p) =  _gtk_css_value_compute (KEYFRAMES_VALUE (keyframes, k, p),
+                                                                      resolved->property_ids[p],
+                                                                      &context);
         }
     }
 
@@ -712,7 +712,7 @@ _gtk_css_keyframes_get_value (GtkCssKeyframes *keyframes,
 
       if (keyframes->keyframe_progress[k] == progress)
         {
-          return gtk_css_value_ref (KEYFRAMES_VALUE (keyframes, k, id));
+          return _gtk_css_value_ref (KEYFRAMES_VALUE (keyframes, k, id));
         }
       else if (keyframes->keyframe_progress[k] < progress)
         {
@@ -729,14 +729,14 @@ _gtk_css_keyframes_get_value (GtkCssKeyframes *keyframes,
 
   progress = (progress - start_progress) / (end_progress - start_progress);
 
-  result = gtk_css_value_transition (start_value,
-                                     end_value,
-                                     keyframes->property_ids[id],
-                                     progress);
+  result = _gtk_css_value_transition (start_value,
+                                      end_value,
+                                      keyframes->property_ids[id],
+                                      progress);
 
   /* XXX: Dear spec, what's the correct thing to do here? */
   if (result == NULL)
-    return gtk_css_value_ref (start_value);
+    return _gtk_css_value_ref (start_value);
 
   return result;
 }

gtk/gtkcsslineheightvalue.c

@@ -34,7 +34,7 @@ static GtkCssValue *gtk_css_value_line_height_new       (GtkCssValue *height);
 static void
 gtk_css_value_line_height_free (GtkCssValue *value)
 {
-  gtk_css_value_unref (value->height);
+  _gtk_css_value_unref (value->height);
   g_free (value);
 }
 
@@ -45,17 +45,17 @@ gtk_css_value_line_height_compute (GtkCssValue          *value,
 {
   GtkCssValue *height;
 
-  height = gtk_css_value_compute (value->height, property_id, context);
+  height = _gtk_css_value_compute (value->height, property_id, context);
 
   if (gtk_css_number_value_get_dimension (height) == GTK_CSS_DIMENSION_PERCENTAGE)
     {
       double factor;
       GtkCssValue *computed;
 
-      factor = gtk_css_number_value_get (height, 1);
+      factor = _gtk_css_number_value_get (height, 1);
       computed = gtk_css_number_value_multiply (context->style->core->font_size, factor);
 
-      gtk_css_value_unref (height);
+      _gtk_css_value_unref (height);
 
       return computed;
     }
@@ -72,7 +72,7 @@ gtk_css_value_line_height_equal (const GtkCssValue *value1,
   if (value1->height == NULL || value2->height == NULL)
     return FALSE;
 
-  return gtk_css_value_equal (value1->height, value2->height);
+  return _gtk_css_value_equal (value1->height, value2->height);
 }
 
 static GtkCssValue *
@@ -86,7 +86,7 @@ gtk_css_value_line_height_transition (GtkCssValue *start,
   if (start->height == NULL || end->height == NULL)
     return NULL;
 
-  height = gtk_css_value_transition (start->height, end->height, property_id, progress);
+  height = _gtk_css_value_transition (start->height, end->height, property_id, progress);
   if (height == NULL)
     return NULL;
 
@@ -100,7 +100,7 @@ gtk_css_value_line_height_print (const GtkCssValue *value,
   if (value->height == NULL)
     g_string_append (string, "normal");
   else
-    gtk_css_value_print (value->height, string);
+    _gtk_css_value_print (value->height, string);
 }
 
 static const GtkCssValueClass GTK_CSS_VALUE_LINE_HEIGHT = {
@@ -119,7 +119,7 @@ gtk_css_value_line_height_new_empty (void)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_LINE_HEIGHT);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_LINE_HEIGHT);
   result->height = NULL;
   result->is_computed = TRUE;
 
@@ -131,7 +131,7 @@ gtk_css_value_line_height_new (GtkCssValue *height)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_LINE_HEIGHT);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_LINE_HEIGHT);
   result->height = height;
 
   return result;
@@ -152,12 +152,12 @@ gtk_css_line_height_value_parse (GtkCssParser *parser)
   GtkCssValue *height;
 
   if (gtk_css_parser_try_ident (parser, "normal"))
-    return gtk_css_value_ref (gtk_css_line_height_value_get_default ());
+    return _gtk_css_value_ref (gtk_css_line_height_value_get_default ());
 
-  height = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER |
-                                               GTK_CSS_PARSE_PERCENT |
-                                               GTK_CSS_PARSE_LENGTH |
-                                               GTK_CSS_POSITIVE_ONLY);
+  height = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER |
+                                                GTK_CSS_PARSE_PERCENT |
+                                                GTK_CSS_PARSE_LENGTH |
+                                                GTK_CSS_POSITIVE_ONLY);
   if (!height)
     return NULL;
 
@@ -170,5 +170,5 @@ gtk_css_line_height_value_get (const GtkCssValue *value)
   if (value->class == &GTK_CSS_VALUE_LINE_HEIGHT)
     return 0.0;
 
-  return gtk_css_number_value_get (value, 1);
+  return _gtk_css_number_value_get (value, 1);
 }

gtk/gtkcssnumbervalueprivate.h

@@ -36,15 +36,13 @@ typedef enum /*< skip >*/ {
   GTK_CSS_PARSE_TIME = (1 << 5)
 } GtkCssNumberParseFlags;
 
-#define GTK_CSS_PARSE_DIMENSION (GTK_CSS_PARSE_LENGTH|GTK_CSS_PARSE_ANGLE|GTK_CSS_PARSE_TIME)
-
 GtkCssValue *   gtk_css_dimension_value_new         (double                  value,
                                                      GtkCssUnit              unit);
 
-GtkCssValue *   gtk_css_number_value_new            (double                  value,
+GtkCssValue *   _gtk_css_number_value_new           (double                  value,
                                                      GtkCssUnit              unit);
 gboolean        gtk_css_number_value_can_parse      (GtkCssParser           *parser);
-GtkCssValue *   gtk_css_number_value_parse          (GtkCssParser           *parser,
+GtkCssValue *   _gtk_css_number_value_parse         (GtkCssParser           *parser,
                                                      GtkCssNumberParseFlags  flags);
 
 GtkCssDimension gtk_css_number_value_get_dimension  (const GtkCssValue      *value) G_GNUC_PURE;
@@ -55,24 +53,10 @@ GtkCssValue *   gtk_css_number_value_add            (GtkCssValue            *val
                                                      GtkCssValue            *value2);
 GtkCssValue *   gtk_css_number_value_try_add        (GtkCssValue            *value1,
                                                      GtkCssValue            *value2);
-double          gtk_css_number_value_get            (const GtkCssValue      *number,
-                                                     double                  one_hundred_percent) G_GNUC_PURE;
-double          gtk_css_number_value_get_canonical  (GtkCssValue            *number,
+double          _gtk_css_number_value_get           (const GtkCssValue      *number,
                                                      double                  one_hundred_percent) G_GNUC_PURE;
 
 gboolean        gtk_css_dimension_value_is_zero     (const GtkCssValue      *value) G_GNUC_PURE;
 
-enum {
-  ROUND_NEAREST,
-  ROUND_UP,
-  ROUND_DOWN,
-  ROUND_TO_ZERO,
-};
-
-GtkCssValue *   gtk_css_math_value_new              (guint                    type,
-                                                     guint                    mode,
-                                                     GtkCssValue            **values,
-                                                     guint                    n_values);
-
 G_END_DECLS
 

gtk/gtkcsspalettevalue.c

@@ -94,7 +94,7 @@ gtk_css_value_palette_free (GtkCssValue *value)
   for (i = 0; i < value->n_colors; i ++)
     {
       g_free (value->color_names[i]);
-      gtk_css_value_unref (value->color_values[i]);
+      _gtk_css_value_unref (value->color_values[i]);
     }
 
   g_free (value->color_names);
@@ -118,7 +118,7 @@ gtk_css_value_palette_compute (GtkCssValue          *specified,
     {
       GtkCssValue *value = specified->color_values[i];
 
-      computed_color = gtk_css_value_compute (value, property_id, context);
+      computed_color = _gtk_css_value_compute (value, property_id, context);
       result->color_names[i] = g_strdup (specified->color_names[i]);
       result->color_values[i] = computed_color;
 
@@ -127,8 +127,8 @@ gtk_css_value_palette_compute (GtkCssValue          *specified,
 
   if (!changes)
     {
-      gtk_css_value_unref (result);
-      result = gtk_css_value_ref (specified);
+      _gtk_css_value_unref (result);
+      result = _gtk_css_value_ref (specified);
     }
 
   return result;
@@ -148,7 +148,7 @@ gtk_css_value_palette_equal (const GtkCssValue *value1,
       if (strcmp (value1->color_names[i], value2->color_names[i]) != 0)
         return FALSE;
 
-      if (!gtk_css_value_equal (value1->color_values[i], value2->color_values[i]))
+      if (!_gtk_css_value_equal (value1->color_values[i], value2->color_values[i]))
         return FALSE;
     }
 
@@ -184,9 +184,9 @@ gtk_css_value_palette_transition (GtkCssValue *start,
       end_color = gtk_css_palette_value_find_color (end, name);
 
       if (end_color == NULL)
-        transition = gtk_css_value_ref (start_color);
+        transition = _gtk_css_value_ref (start_color);
       else
-        transition = gtk_css_value_transition (start_color, end_color, property_id, progress);
+        transition = _gtk_css_value_transition (start_color, end_color, property_id, progress);
 
       g_ptr_array_add (new_names, g_strdup (name));
       g_ptr_array_add (new_values, transition);
@@ -202,7 +202,7 @@ gtk_css_value_palette_transition (GtkCssValue *start,
         continue;
 
       g_ptr_array_add (new_names, g_strdup (name));
-      g_ptr_array_add (new_values, gtk_css_value_ref (end_color));
+      g_ptr_array_add (new_values, _gtk_css_value_ref (end_color));
     }
 
   result->n_colors = new_names->len;
@@ -235,7 +235,7 @@ gtk_css_value_palette_print (const GtkCssValue *value,
 
       g_string_append (string, value->color_names[i]);
       g_string_append_c (string, ' ');
-      gtk_css_value_print (value->color_values[i], string);
+      _gtk_css_value_print (value->color_values[i], string);
     }
 }
 
@@ -255,7 +255,7 @@ gtk_css_palette_value_new_empty (void)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_PALETTE);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_PALETTE);
 
   return result;
 }
@@ -265,7 +265,7 @@ gtk_css_palette_value_new_sized (guint size)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_PALETTE);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_PALETTE);
   result->n_colors = size;
   result->color_names = g_malloc (sizeof (char *) * size);
   result->color_values = g_malloc (sizeof (GtkCssValue *) * size);
@@ -280,15 +280,15 @@ gtk_css_palette_value_new_default (void)
     {
       default_palette = gtk_css_palette_value_new_sized (3);
       gtk_css_palette_value_set_color (default_palette, 0, g_strdup ("error"),
-                                       gtk_css_color_value_new_name ("error_color"));
+                                       _gtk_css_color_value_new_name ("error_color"));
       gtk_css_palette_value_set_color (default_palette, 1, g_strdup ("success"),
-                                       gtk_css_color_value_new_name ("success_color"));
+                                       _gtk_css_color_value_new_name ("success_color"));
       gtk_css_palette_value_set_color (default_palette, 2, g_strdup ("warning"),
-                                       gtk_css_color_value_new_name ("warning_color"));
+                                       _gtk_css_color_value_new_name ("warning_color"));
       /* Above is already sorted */
     }
 
-  return gtk_css_value_ref (default_palette);
+  return _gtk_css_value_ref (default_palette);
 }
 
 GtkCssValue *
@@ -310,20 +310,19 @@ gtk_css_palette_value_parse (GtkCssParser *parser)
     ident = gtk_css_parser_consume_ident (parser);
     if (ident == NULL)
       {
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
-    color = gtk_css_color_value_parse (parser);
+    color = _gtk_css_color_value_parse (parser);
     if (color == NULL)
       {
         g_free (ident);
-        gtk_css_value_unref (result);
+        _gtk_css_value_unref (result);
         return NULL;
       }
 
     result->is_computed = result->is_computed && gtk_css_value_is_computed (color);
-    result->contains_current_color = result->contains_current_color || gtk_css_value_contains_current_color (color);
 
     g_ptr_array_add (names, ident);
     g_ptr_array_add (colors, color);
@@ -337,7 +336,7 @@ gtk_css_palette_value_parse (GtkCssParser *parser)
   return result;
 }
 
-GtkCssValue *
+const GdkRGBA *
 gtk_css_palette_value_get_color (GtkCssValue *value,
                                  const char  *name)
 {
@@ -348,27 +347,8 @@ gtk_css_palette_value_get_color (GtkCssValue *value,
   for (i = 0; i < value->n_colors; i ++)
     {
       if (strcmp (value->color_names[i], name) == 0)
-        return value->color_values[i];
+        return gtk_css_color_value_get_rgba (value->color_values[i]);
     }
 
   return NULL;
 }
-
-GtkCssValue *
-gtk_css_palette_value_resolve (GtkCssValue *value,
-                               GtkCssValue *current_color)
-{
-  GtkCssValue *result;
-
-  if (!gtk_css_value_contains_current_color (value))
-    return gtk_css_value_ref (value);
-
-  result = gtk_css_palette_value_new_sized (value->n_colors);
-  for (guint i = 0; i < value->n_colors; i++)
-    {
-      result->color_names[i] = g_strdup (value->color_names[i]);
-      result->color_values[i] = gtk_css_color_value_resolve (value->color_values[i], NULL, current_color);
-    }
-
-  return result;
-}

gtk/gtkcsspalettevalueprivate.h

@@ -30,11 +30,8 @@ GtkCssValue *   gtk_css_palette_value_new_default       (void);
 
 GtkCssValue *   gtk_css_palette_value_parse             (GtkCssParser        *parser);
 
-GtkCssValue *   gtk_css_palette_value_get_color         (GtkCssValue         *value,
+const GdkRGBA * gtk_css_palette_value_get_color         (GtkCssValue         *value,
                                                          const char          *color_name);
 
-GtkCssValue *   gtk_css_palette_value_resolve           (GtkCssValue         *value,
-                                                         GtkCssValue         *current_color);
-
 G_END_DECLS
 

gtk/gtkcsspositionvalue.c

@@ -30,8 +30,8 @@ struct _GtkCssValue {
 static void
 gtk_css_value_position_free (GtkCssValue *value)
 {
-  gtk_css_value_unref (value->x);
-  gtk_css_value_unref (value->y);
+  _gtk_css_value_unref (value->x);
+  _gtk_css_value_unref (value->y);
   g_free (value);
 }
 
@@ -42,13 +42,13 @@ gtk_css_value_position_compute (GtkCssValue          *position,
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_value_compute (position->x, property_id, context);
-  y = gtk_css_value_compute (position->y, property_id, context);
+  x = _gtk_css_value_compute (position->x, property_id, context);
+  y = _gtk_css_value_compute (position->y, property_id, context);
   if (x == position->x && y == position->y)
     {
-      gtk_css_value_unref (x);
-      gtk_css_value_unref (y);
-      return gtk_css_value_ref (position);
+      _gtk_css_value_unref (x);
+      _gtk_css_value_unref (y);
+      return _gtk_css_value_ref (position);
     }
 
   return _gtk_css_position_value_new (x, y);
@@ -58,8 +58,8 @@ static gboolean
 gtk_css_value_position_equal (const GtkCssValue *position1,
                               const GtkCssValue *position2)
 {
-  return gtk_css_value_equal (position1->x, position2->x)
-      && gtk_css_value_equal (position1->y, position2->y);
+  return _gtk_css_value_equal (position1->x, position2->x)
+      && _gtk_css_value_equal (position1->y, position2->y);
 }
 
 static GtkCssValue *
@@ -70,13 +70,13 @@ gtk_css_value_position_transition (GtkCssValue *start,
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_value_transition (start->x, end->x, property_id, progress);
+  x = _gtk_css_value_transition (start->x, end->x, property_id, progress);
   if (x == NULL)
     return NULL;
-  y = gtk_css_value_transition (start->y, end->y, property_id, progress);
+  y = _gtk_css_value_transition (start->y, end->y, property_id, progress);
   if (y == NULL)
     {
-      gtk_css_value_unref (x);
+      _gtk_css_value_unref (x);
       return NULL;
     }
 
@@ -92,15 +92,15 @@ gtk_css_value_position_print (const GtkCssValue *position,
     const char *y_name;
     GtkCssValue *number;
   } values[] = { 
-    { "left",   "top",    gtk_css_number_value_new (0, GTK_CSS_PERCENT) },
-    { "right",  "bottom", gtk_css_number_value_new (100, GTK_CSS_PERCENT) }
+    { "left",   "top",    _gtk_css_number_value_new (0, GTK_CSS_PERCENT) },
+    { "right",  "bottom", _gtk_css_number_value_new (100, GTK_CSS_PERCENT) }
   };
-  GtkCssValue *center = gtk_css_number_value_new (50, GTK_CSS_PERCENT);
+  GtkCssValue *center = _gtk_css_number_value_new (50, GTK_CSS_PERCENT);
   guint i;
 
-  if (gtk_css_value_equal (position->x, center))
+  if (_gtk_css_value_equal (position->x, center))
     {
-      if (gtk_css_value_equal (position->y, center))
+      if (_gtk_css_value_equal (position->y, center))
         {
           g_string_append (string, "center");
           goto done;
@@ -110,16 +110,16 @@ gtk_css_value_position_print (const GtkCssValue *position,
     {
       for (i = 0; i < G_N_ELEMENTS (values); i++)
         {
-          if (gtk_css_value_equal (position->x, values[i].number))
+          if (_gtk_css_value_equal (position->x, values[i].number))
             {
               g_string_append (string, values[i].x_name);
               break;
             }
         }
       if (i == G_N_ELEMENTS (values))
-        gtk_css_value_print (position->x, string);
+        _gtk_css_value_print (position->x, string);
 
-      if (gtk_css_value_equal (position->y, center))
+      if (_gtk_css_value_equal (position->y, center))
         goto done;
 
       g_string_append_c (string, ' ');
@@ -127,7 +127,7 @@ gtk_css_value_position_print (const GtkCssValue *position,
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      if (gtk_css_value_equal (position->y, values[i].number))
+      if (_gtk_css_value_equal (position->y, values[i].number))
         {
           g_string_append (string, values[i].y_name);
           goto done;
@@ -135,15 +135,15 @@ gtk_css_value_position_print (const GtkCssValue *position,
     }
   if (i == G_N_ELEMENTS (values))
     {
-      if (gtk_css_value_equal (position->x, center))
+      if (_gtk_css_value_equal (position->x, center))
         g_string_append (string, "center ");
-      gtk_css_value_print (position->y, string);
+      _gtk_css_value_print (position->y, string);
     }
 
 done:
   for (i = 0; i < G_N_ELEMENTS (values); i++)
-    gtk_css_value_unref (values[i].number);
-  gtk_css_value_unref (center);
+    _gtk_css_value_unref (values[i].number);
+  _gtk_css_value_unref (center);
 }
 
 static const GtkCssValueClass GTK_CSS_VALUE_POSITION = {
@@ -163,7 +163,7 @@ _gtk_css_position_value_new (GtkCssValue *x,
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_POSITION);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_POSITION);
   result->x = x;
   result->y = y;
   result->is_computed = gtk_css_value_is_computed (x) &&
@@ -196,9 +196,9 @@ position_value_parse (GtkCssParser *parser, gboolean try)
       if (gtk_css_parser_try_ident (parser, names[i].name))
         {
           if (names[i].horizontal)
-	    x = gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
+	    x = _gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
           else
-	    y = gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
+	    y = _gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
           swap = names[i].swap;
           break;
         }
@@ -207,9 +207,9 @@ position_value_parse (GtkCssParser *parser, gboolean try)
     {
       if (gtk_css_number_value_can_parse (parser))
         {
-          x = gtk_css_number_value_parse (parser,
-                                          GTK_CSS_PARSE_PERCENT
-                                          | GTK_CSS_PARSE_LENGTH);
+          x = _gtk_css_number_value_parse (parser,
+                                           GTK_CSS_PARSE_PERCENT
+                                           | GTK_CSS_PARSE_LENGTH);
 
           if (x == NULL)
             return NULL;
@@ -239,17 +239,17 @@ position_value_parse (GtkCssParser *parser, gboolean try)
               if (names[i].horizontal && !names[i].swap)
                 {
                   y = x;
-	          x = gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
+	          x = _gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
                 }
               else
                 {
-	          y = gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
+	          y = _gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
                 }
             }
           else
             {
               g_assert (names[i].horizontal || names[i].swap);
-	      x = gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
+	      x = _gtk_css_number_value_new (names[i].percentage, GTK_CSS_PERCENT);
             }
           break;
         }
@@ -263,24 +263,24 @@ position_value_parse (GtkCssParser *parser, gboolean try)
             {
               if (!try)
                 gtk_css_parser_error_syntax (parser, "Invalid combination of values");
-              gtk_css_value_unref (y);
+              _gtk_css_value_unref (y);
               return NULL;
             }
-          y = gtk_css_number_value_parse (parser,
-                                          GTK_CSS_PARSE_PERCENT
-                                          | GTK_CSS_PARSE_LENGTH);
+          y = _gtk_css_number_value_parse (parser,
+                                           GTK_CSS_PARSE_PERCENT
+                                           | GTK_CSS_PARSE_LENGTH);
           if (y == NULL)
             {
-              gtk_css_value_unref (x);
+              _gtk_css_value_unref (x);
 	      return NULL;
             }
         }
       else
         {
           if (y)
-            x = gtk_css_number_value_new (50, GTK_CSS_PERCENT);
+            x = _gtk_css_number_value_new (50, GTK_CSS_PERCENT);
           else
-            y = gtk_css_number_value_new (50, GTK_CSS_PERCENT);
+            y = _gtk_css_number_value_new (50, GTK_CSS_PERCENT);
         }
     }
 
@@ -304,22 +304,22 @@ gtk_css_position_value_parse_spacing (GtkCssParser *parser)
 {
   GtkCssValue *x, *y;
 
-  x = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
+  x = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
   if (x == NULL)
     return NULL;
 
   if (gtk_css_number_value_can_parse (parser))
     {
-      y = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
+      y = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH | GTK_CSS_POSITIVE_ONLY);
       if (y == NULL)
         {
-          gtk_css_value_unref (x);
+          _gtk_css_value_unref (x);
           return NULL;
         }
     }
   else
     {
-      y = gtk_css_value_ref (x);
+      y = _gtk_css_value_ref (x);
     }
 
   return _gtk_css_position_value_new (x, y);
@@ -332,7 +332,7 @@ _gtk_css_position_value_get_x (const GtkCssValue *position,
   g_return_val_if_fail (position != NULL, 0.0);
   g_return_val_if_fail (position->class == &GTK_CSS_VALUE_POSITION, 0.0);
 
-  return gtk_css_number_value_get (position->x, one_hundred_percent);
+  return _gtk_css_number_value_get (position->x, one_hundred_percent);
 }
 
 double
@@ -342,6 +342,6 @@ _gtk_css_position_value_get_y (const GtkCssValue *position,
   g_return_val_if_fail (position != NULL, 0.0);
   g_return_val_if_fail (position->class == &GTK_CSS_VALUE_POSITION, 0.0);
 
-  return gtk_css_number_value_get (position->y, one_hundred_percent);
+  return _gtk_css_number_value_get (position->y, one_hundred_percent);
 }
 

gtk/gtkcssprovider.c

@@ -184,12 +184,10 @@ gtk_css_provider_parsing_error (GtkCssProvider  *provider,
     {
       char *s = gtk_css_section_to_string (section);
 
-      if (GTK_DEBUG_CHECK (CSS) ||
-          !g_error_matches (error, GTK_CSS_PARSER_WARNING, GTK_CSS_PARSER_WARNING_DEPRECATED))
-        g_warning ("Theme parser %s: %s: %s",
-                   error->domain == GTK_CSS_PARSER_WARNING ? "warning" : "error",
-                   s,
-                   error->message);
+      g_warning ("Theme parser %s: %s: %s",
+                 error->domain == GTK_CSS_PARSER_WARNING ? "warning" : "error",
+                 s,
+                 error->message);
 
       g_free (s);
     }
@@ -271,7 +269,7 @@ gtk_css_ruleset_clear (GtkCssRuleset *ruleset)
 
       for (i = 0; i < ruleset->n_styles; i++)
         {
-          gtk_css_value_unref (ruleset->styles[i].value);
+          _gtk_css_value_unref (ruleset->styles[i].value);
 	  ruleset->styles[i].value = NULL;
 	  if (ruleset->styles[i].section)
 	    gtk_css_section_unref (ruleset->styles[i].section);
@@ -302,7 +300,7 @@ gtk_css_ruleset_add (GtkCssRuleset       *ruleset,
     {
       if (ruleset->styles[i].property == property)
         {
-          gtk_css_value_unref (ruleset->styles[i].value);
+          _gtk_css_value_unref (ruleset->styles[i].value);
 	  ruleset->styles[i].value = NULL;
 	  if (ruleset->styles[i].section)
 	    gtk_css_section_unref (ruleset->styles[i].section);
@@ -442,7 +440,7 @@ gtk_css_provider_init (GtkCssProvider *css_provider)
 
   priv->symbolic_colors = g_hash_table_new_full (g_str_hash, g_str_equal,
                                                  (GDestroyNotify) g_free,
-                                                 (GDestroyNotify) gtk_css_value_unref);
+                                                 (GDestroyNotify) _gtk_css_value_unref);
   priv->keyframes = g_hash_table_new_full (g_str_hash, g_str_equal,
                                            (GDestroyNotify) g_free,
                                            (GDestroyNotify) _gtk_css_keyframes_unref);
@@ -770,7 +768,7 @@ parse_color_definition (GtkCssScanner *scanner)
   if (name == NULL)
     return TRUE;
 
-  color = gtk_css_color_value_parse (scanner->parser);
+  color = _gtk_css_color_value_parse (scanner->parser);
   if (color == NULL)
     {
       g_free (name);
@@ -780,7 +778,7 @@ parse_color_definition (GtkCssScanner *scanner)
   if (!gtk_css_parser_has_token (scanner->parser, GTK_CSS_TOKEN_EOF))
     {
       g_free (name);
-      gtk_css_value_unref (color);
+      _gtk_css_value_unref (color);
       gtk_css_parser_error_syntax (scanner->parser,
                                    "Missing semicolon at end of color definition");
       return TRUE;
@@ -1032,10 +1030,10 @@ parse_declaration (GtkCssScanner *scanner,
               GtkCssStyleProperty *child = _gtk_css_shorthand_property_get_subproperty (shorthand, i);
               GtkCssValue *sub = _gtk_css_array_value_get_nth (value, i);
 
-              gtk_css_ruleset_add (ruleset, child, gtk_css_value_ref (sub), section);
+              gtk_css_ruleset_add (ruleset, child, _gtk_css_value_ref (sub), section);
             }
 
-            gtk_css_value_unref (value);
+            _gtk_css_value_unref (value);
         }
       else if (GTK_IS_CSS_STYLE_PROPERTY (property))
         {
@@ -1045,7 +1043,7 @@ parse_declaration (GtkCssScanner *scanner,
       else
         {
           g_assert_not_reached ();
-          gtk_css_value_unref (value);
+          _gtk_css_value_unref (value);
         }
 
       g_clear_pointer (&section, gtk_css_section_unref);
@@ -1691,7 +1689,7 @@ gtk_css_ruleset_print (const GtkCssRuleset *ruleset,
           g_string_append (str, "  ");
           g_string_append (str, _gtk_style_property_get_name (GTK_STYLE_PROPERTY (prop->property)));
           g_string_append (str, ": ");
-          gtk_css_value_print (prop->value, str);
+          _gtk_css_value_print (prop->value, str);
           g_string_append (str, ";\n");
         }
 
@@ -1744,7 +1742,7 @@ gtk_css_provider_print_colors (GHashTable *colors,
       g_string_append (str, "@define-color ");
       g_string_append (str, name);
       g_string_append (str, " ");
-      gtk_css_value_print (color, str);
+      _gtk_css_value_print (color, str);
       g_string_append (str, ";\n");
     }
 

gtk/gtkcssreferencevalue.c

@@ -317,7 +317,7 @@ pick_subproperty:
       result = sub;
     }
 
-  computed = gtk_css_value_compute (result, property_id, context);
+  computed = _gtk_css_value_compute (result, property_id, context);
   computed->is_computed = TRUE;
 
   gtk_css_value_unref (result);
@@ -366,7 +366,7 @@ _gtk_css_reference_value_new (GtkStyleProperty    *property,
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_REFERENCE);
+  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;

gtk/gtkcssrepeatvalue.c

@@ -38,7 +38,7 @@ gtk_css_value_repeat_compute (GtkCssValue          *value,
                               guint                 property_id,
                               GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (value);
+  return _gtk_css_value_ref (value);
 }
 
 static gboolean
@@ -138,28 +138,28 @@ static struct {
   GtkCssValue values[4];
 } background_repeat_values[4] = {
   { "no-repeat",
-  { { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_NO_REPEAT, GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,    GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,     GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_NO_REPEAT },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_REPEAT    },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,     GTK_CSS_REPEAT_STYLE_ROUND     },
-    { &GTK_CSS_VALUE_BACKGROUND_REPEAT, 1, 1, 0, 0, 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     }
   } }
 };
 
@@ -167,7 +167,7 @@ GtkCssValue *
 _gtk_css_background_repeat_value_new (GtkCssRepeatStyle x,
                                       GtkCssRepeatStyle y)
 {
-  return gtk_css_value_ref (&background_repeat_values[x].values[y]);
+  return _gtk_css_value_ref (&background_repeat_values[x].values[y]);
 }
 
 static gboolean
@@ -232,28 +232,28 @@ static struct {
   GtkCssValue values[4];
 } border_repeat_values[4] = {
   { "stretch",
-  { { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_STRETCH, GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_REPEAT,  GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_ROUND,   GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, 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, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_STRETCH },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_REPEAT  },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, GTK_CSS_REPEAT_STYLE_SPACE,   GTK_CSS_REPEAT_STYLE_ROUND   },
-    { &GTK_CSS_VALUE_BORDER_REPEAT, 1, 1, 0, 0, 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   }
   } }
 };
 
@@ -261,7 +261,7 @@ GtkCssValue *
 _gtk_css_border_repeat_value_new (GtkCssRepeatStyle x,
                                   GtkCssRepeatStyle y)
 {
-  return gtk_css_value_ref (&border_repeat_values[x].values[y]);
+  return _gtk_css_value_ref (&border_repeat_values[x].values[y]);
 }
 
 static gboolean

gtk/gtkcssshadowvalue.c

@@ -26,7 +26,6 @@
 #include "gtkcsscolorvalueprivate.h"
 #include "gtksnapshotprivate.h"
 #include "gtkpangoprivate.h"
-#include "gtkcssnodeprivate.h"
 
 #include "gsk/gskcairoblurprivate.h"
 #include "gsk/gskroundedrectprivate.h"
@@ -60,21 +59,21 @@ shadow_value_for_transition (ShadowValue *result,
                              gboolean     inset)
 {
   result->inset = inset;
-  result->hoffset = gtk_css_number_value_new (0, GTK_CSS_PX);
-  result->voffset = gtk_css_number_value_new (0, GTK_CSS_PX);
-  result->radius = gtk_css_number_value_new (0, GTK_CSS_PX);
-  result->spread = gtk_css_number_value_new (0, GTK_CSS_PX);
+  result->hoffset = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  result->voffset = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  result->radius = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  result->spread = _gtk_css_number_value_new (0, GTK_CSS_PX);
   result->color = gtk_css_color_value_new_transparent ();
 }
 
 static void
 shadow_value_unref (const ShadowValue *shadow)
 {
-  gtk_css_value_unref (shadow->hoffset);
-  gtk_css_value_unref (shadow->voffset);
-  gtk_css_value_unref (shadow->spread);
-  gtk_css_value_unref (shadow->radius);
-  gtk_css_value_unref (shadow->color);
+  _gtk_css_value_unref (shadow->hoffset);
+  _gtk_css_value_unref (shadow->voffset);
+  _gtk_css_value_unref (shadow->spread);
+  _gtk_css_value_unref (shadow->radius);
+  _gtk_css_value_unref (shadow->color);
 }
 
 static gboolean
@@ -89,11 +88,11 @@ shadow_value_transition (const ShadowValue *start,
     return FALSE;
 
   result->inset = start->inset;
-  result->hoffset = gtk_css_value_transition (start->hoffset, end->hoffset, property_id, progress);
-  result->voffset = gtk_css_value_transition (start->voffset, end->voffset, property_id, progress);
-  result->radius = gtk_css_value_transition (start->radius, end->radius, property_id, progress);
-  result->spread = gtk_css_value_transition (start->spread, end->spread, property_id, progress);
-  result->color = gtk_css_value_transition (start->color, end->color, property_id, progress);
+  result->hoffset = _gtk_css_value_transition (start->hoffset, end->hoffset, property_id, progress);
+  result->voffset = _gtk_css_value_transition (start->voffset, end->voffset, property_id, progress);
+  result->radius = _gtk_css_value_transition (start->radius, end->radius, property_id, progress);
+  result->spread = _gtk_css_value_transition (start->spread, end->spread, property_id, progress);
+  result->color = _gtk_css_value_transition (start->color, end->color, property_id, progress);
 
   return TRUE;
 }
@@ -127,11 +126,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, context);
-      shadows[i].voffset = gtk_css_value_compute (shadow->voffset, property_id, context);
-      shadows[i].radius = gtk_css_value_compute (shadow->radius, property_id, context);
-      shadows[i].spread = gtk_css_value_compute (shadow->spread, property_id, context),
-      shadows[i].color = gtk_css_value_compute (shadow->color, property_id, context);
+      shadows[i].hoffset = _gtk_css_value_compute (shadow->hoffset, property_id, context);
+      shadows[i].voffset = _gtk_css_value_compute (shadow->voffset, property_id, context);
+      shadows[i].radius = _gtk_css_value_compute (shadow->radius, property_id, context);
+      shadows[i].spread = _gtk_css_value_compute (shadow->spread, property_id, context),
+      shadows[i].color = _gtk_css_value_compute (shadow->color, property_id, context);
       shadows[i].inset = shadow->inset;
     }
 
@@ -153,11 +152,11 @@ gtk_css_value_shadow_equal (const GtkCssValue *value1,
       const ShadowValue *shadow2 = &value2->shadows[i];
 
       if (shadow1->inset != shadow2->inset ||
-          !gtk_css_value_equal (shadow1->hoffset, shadow2->hoffset) ||
-          !gtk_css_value_equal (shadow1->voffset, shadow2->voffset) ||
-          !gtk_css_value_equal (shadow1->radius, shadow2->radius) ||
-          !gtk_css_value_equal (shadow1->spread, shadow2->spread) ||
-          !gtk_css_value_equal (shadow1->color, shadow2->color))
+          !_gtk_css_value_equal (shadow1->hoffset, shadow2->hoffset) ||
+          !_gtk_css_value_equal (shadow1->voffset, shadow2->voffset) ||
+          !_gtk_css_value_equal (shadow1->radius, shadow2->radius) ||
+          !_gtk_css_value_equal (shadow1->spread, shadow2->spread) ||
+          !_gtk_css_value_equal (shadow1->color, shadow2->color))
         return FALSE;
     }
 
@@ -251,24 +250,24 @@ gtk_css_value_shadow_print (const GtkCssValue *value,
       if (i > 0)
         g_string_append (string, ", ");
 
-      gtk_css_value_print (shadow->hoffset, string);
+      _gtk_css_value_print (shadow->hoffset, string);
       g_string_append_c (string, ' ');
-      gtk_css_value_print (shadow->voffset, string);
+      _gtk_css_value_print (shadow->voffset, string);
       g_string_append_c (string, ' ');
-      if (gtk_css_number_value_get (shadow->radius, 100) != 0 ||
-          gtk_css_number_value_get (shadow->spread, 100) != 0)
+      if (_gtk_css_number_value_get (shadow->radius, 100) != 0 ||
+          _gtk_css_number_value_get (shadow->spread, 100) != 0)
         {
-          gtk_css_value_print (shadow->radius, string);
+          _gtk_css_value_print (shadow->radius, string);
           g_string_append_c (string, ' ');
         }
 
-      if (gtk_css_number_value_get (shadow->spread, 100) != 0)
+      if (_gtk_css_number_value_get (shadow->spread, 100) != 0)
         {
-          gtk_css_value_print (shadow->spread, string);
+          _gtk_css_value_print (shadow->spread, string);
           g_string_append_c (string, ' ');
         }
 
-      gtk_css_value_print (shadow->color, string);
+      _gtk_css_value_print (shadow->color, string);
 
       if (shadow->inset)
         g_string_append (string, " inset");
@@ -286,12 +285,12 @@ static const GtkCssValueClass GTK_CSS_VALUE_SHADOW = {
   gtk_css_value_shadow_print
 };
 
-static GtkCssValue shadow_none_singleton = { &GTK_CSS_VALUE_SHADOW, 1, 1, 0, 0, 0, 0 };
+static GtkCssValue shadow_none_singleton = { &GTK_CSS_VALUE_SHADOW, 1, TRUE, FALSE, 0 };
 
 GtkCssValue *
 gtk_css_shadow_value_new_none (void)
 {
-  return gtk_css_value_ref (&shadow_none_singleton);
+  return _gtk_css_value_ref (&shadow_none_singleton);
 }
 
 static GtkCssValue *
@@ -305,7 +304,7 @@ gtk_css_shadow_value_new (ShadowValue *shadows,
   if (n_shadows == 0)
     return gtk_css_shadow_value_new_none ();
 
-  retval = gtk_css_value_alloc (&GTK_CSS_VALUE_SHADOW, sizeof (GtkCssValue) + sizeof (ShadowValue) * (n_shadows - 1));
+  retval = _gtk_css_value_alloc (&GTK_CSS_VALUE_SHADOW, sizeof (GtkCssValue) + sizeof (ShadowValue) * (n_shadows - 1));
   retval->n_shadows = n_shadows;
   retval->is_filter = is_filter;
 
@@ -316,18 +315,15 @@ gtk_css_shadow_value_new (ShadowValue *shadows,
     {
       const ShadowValue *shadow = &retval->shadows[i];
 
-      if (retval->is_computed &&
-          (!gtk_css_value_is_computed (shadow->hoffset) ||
-           !gtk_css_value_is_computed (shadow->voffset) ||
-           !gtk_css_value_is_computed (shadow->spread) ||
-           !gtk_css_value_is_computed (shadow->radius) ||
-           !gtk_css_value_is_computed (shadow->color)))
+      if (!gtk_css_value_is_computed (shadow->hoffset) ||
+          !gtk_css_value_is_computed (shadow->voffset) ||
+          !gtk_css_value_is_computed (shadow->spread) ||
+          !gtk_css_value_is_computed (shadow->radius) ||
+          !gtk_css_value_is_computed (shadow->color))
         {
           retval->is_computed = FALSE;
+          break;
         }
-
-      if (gtk_css_value_contains_current_color (shadow->color))
-        retval->contains_current_color = TRUE;
     }
 
   return retval;
@@ -339,10 +335,10 @@ gtk_css_shadow_value_new_filter (const GtkCssValue *other)
   ShadowValue value;
 
   value.inset = FALSE;
-  value.hoffset = gtk_css_number_value_new (0, GTK_CSS_PX);
-  value.voffset = gtk_css_number_value_new (0, GTK_CSS_PX);
-  value.radius = gtk_css_number_value_new (0, GTK_CSS_PX);
-  value.spread = gtk_css_number_value_new (0, GTK_CSS_PX);
+  value.hoffset = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  value.voffset = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  value.radius = _gtk_css_number_value_new (0, GTK_CSS_PX);
+  value.spread = _gtk_css_number_value_new (0, GTK_CSS_PX);
   value.color = gtk_css_value_ref (other->shadows[0].color);
 
   return gtk_css_shadow_value_new (&value, 1, TRUE);
@@ -389,36 +385,36 @@ parse_lengths (GtkCssParser *parser,
 {
   GtkCssValue **values = option_data;
 
-  values[HOFFSET] = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_PARSE_LENGTH);
+  values[HOFFSET] = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_PARSE_LENGTH);
   if (values[HOFFSET] == NULL)
     return FALSE;
 
-  values[VOFFSET] = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_PARSE_LENGTH);
+  values[VOFFSET] = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_PARSE_LENGTH);
   if (values[VOFFSET] == NULL)
     return FALSE;
 
   if (gtk_css_number_value_can_parse (parser))
     {
-      values[RADIUS] = gtk_css_number_value_parse (parser,
-                                                   GTK_CSS_PARSE_LENGTH
-                                                   | GTK_CSS_POSITIVE_ONLY);
+      values[RADIUS] = _gtk_css_number_value_parse (parser,
+                                                    GTK_CSS_PARSE_LENGTH
+                                                    | GTK_CSS_POSITIVE_ONLY);
       if (values[RADIUS] == NULL)
         return FALSE;
     }
   else
-    values[RADIUS] = gtk_css_number_value_new (0.0, GTK_CSS_PX);
+    values[RADIUS] = _gtk_css_number_value_new (0.0, GTK_CSS_PX);
 
   if (box_shadow_mode && gtk_css_number_value_can_parse (parser))
     {
-      values[SPREAD] = gtk_css_number_value_parse (parser,
-                                                   GTK_CSS_PARSE_LENGTH);
+      values[SPREAD] = _gtk_css_number_value_parse (parser,
+                                                    GTK_CSS_PARSE_LENGTH);
       if (values[SPREAD] == NULL)
         return FALSE;
     }
   else
-    values[SPREAD] = gtk_css_number_value_new (0.0, GTK_CSS_PX);
+    values[SPREAD] = _gtk_css_number_value_new (0.0, GTK_CSS_PX);
 
   return TRUE;
 }
@@ -430,7 +426,7 @@ parse_color (GtkCssParser *parser,
 {
   GtkCssValue **color = option_data;
   
-  *color = gtk_css_color_value_parse (parser);
+  *color = _gtk_css_color_value_parse (parser);
   if (*color == NULL)
     return FALSE;
 
@@ -463,7 +459,7 @@ gtk_css_shadow_value_parse_one (GtkCssParser *parser,
     }
 
   if (color == NULL)
-    color = gtk_css_color_value_new_current_color ();
+    color = _gtk_css_color_value_new_current_color ();
 
   result->hoffset = values[HOFFSET];
   result->voffset = values[VOFFSET];
@@ -543,13 +539,13 @@ gtk_css_shadow_value_get_extents (const GtkCssValue *value,
       const ShadowValue *shadow = &value->shadows[i];
       double hoffset, voffset, spread, radius, clip_radius;
 
-      spread = gtk_css_number_value_get (shadow->spread, 0);
-      radius = gtk_css_number_value_get (shadow->radius, 0);
+      spread = _gtk_css_number_value_get (shadow->spread, 0);
+      radius = _gtk_css_number_value_get (shadow->radius, 0);
       if (!value->is_filter)
         radius = radius / 2.0;
       clip_radius = gsk_cairo_blur_compute_pixels (radius);
-      hoffset = gtk_css_number_value_get (shadow->hoffset, 0);
-      voffset = gtk_css_number_value_get (shadow->voffset, 0);
+      hoffset = _gtk_css_number_value_get (shadow->hoffset, 0);
+      voffset = _gtk_css_number_value_get (shadow->voffset, 0);
 
       border->top    = MAX (border->top, ceil (clip_radius + spread - voffset));
       border->right  = MAX (border->right, ceil (clip_radius + spread + hoffset));
@@ -582,10 +578,10 @@ gtk_css_shadow_value_snapshot_outset (const GtkCssValue    *value,
       if (gdk_rgba_is_clear (color))
         continue;
 
-      dx = gtk_css_number_value_get (shadow->hoffset, 0);
-      dy = gtk_css_number_value_get (shadow->voffset, 0);
-      spread = gtk_css_number_value_get (shadow->spread, 0);
-      radius = gtk_css_number_value_get (shadow->radius, 0);
+      dx = _gtk_css_number_value_get (shadow->hoffset, 0);
+      dy = _gtk_css_number_value_get (shadow->voffset, 0);
+      spread = _gtk_css_number_value_get (shadow->spread, 0);
+      radius = _gtk_css_number_value_get (shadow->radius, 0);
       if (value->is_filter)
         radius = 2 * radius;
 
@@ -617,10 +613,10 @@ gtk_css_shadow_value_snapshot_inset (const GtkCssValue    *value,
       if (gdk_rgba_is_clear (color))
         continue;
 
-      dx = gtk_css_number_value_get (shadow->hoffset, 0);
-      dy = gtk_css_number_value_get (shadow->voffset, 0);
-      spread = gtk_css_number_value_get (shadow->spread, 0);
-      radius = gtk_css_number_value_get (shadow->radius, 0);
+      dx = _gtk_css_number_value_get (shadow->hoffset, 0);
+      dy = _gtk_css_number_value_get (shadow->voffset, 0);
+      spread = _gtk_css_number_value_get (shadow->spread, 0);
+      radius = _gtk_css_number_value_get (shadow->radius, 0);
       if (value->is_filter)
         radius = 2 * radius;
 
@@ -715,63 +711,60 @@ gboolean
 gtk_css_shadow_value_push_snapshot (const GtkCssValue *value,
                                     GtkSnapshot       *snapshot)
 {
-  GskShadow *shadows;
+  gboolean need_shadow = FALSE;
   guint i;
 
-  if (gtk_css_shadow_value_is_clear (value))
-    return FALSE;
-
-  shadows = g_newa (GskShadow, value->n_shadows);
-
   for (i = 0; i < value->n_shadows; i++)
     {
       const ShadowValue *shadow = &value->shadows[i];
 
-      shadows[i].color = *gtk_css_color_value_get_rgba (shadow->color);
-
-      shadows[i].dx = gtk_css_number_value_get (shadow->hoffset, 0);
-      shadows[i].dy = gtk_css_number_value_get (shadow->voffset, 0);
-      shadows[i].radius = gtk_css_number_value_get (shadow->radius, 0);
-      if (value->is_filter)
-        shadows[i].radius *= 2;
+      if (!gdk_rgba_is_clear (gtk_css_color_value_get_rgba (shadow->color)))
+        {
+          need_shadow = TRUE;
+          break;
+        }
     }
 
-  gtk_snapshot_push_shadow (snapshot, shadows, value->n_shadows);
+  if (need_shadow)
+    {
+      GskShadow *shadows = g_newa (GskShadow, value->n_shadows);
 
-  return TRUE;
+      for (i = 0; i < value->n_shadows; i++)
+        {
+          const ShadowValue *shadow = &value->shadows[i];
+
+          shadows[i].dx = _gtk_css_number_value_get (shadow->hoffset, 0);
+          shadows[i].dy = _gtk_css_number_value_get (shadow->voffset, 0);
+          shadows[i].color = *gtk_css_color_value_get_rgba (shadow->color);
+          shadows[i].radius = _gtk_css_number_value_get (shadow->radius, 0);
+          if (value->is_filter)
+            shadows[i].radius *= 2;
+        }
+
+      gtk_snapshot_push_shadow (snapshot, shadows, value->n_shadows);
+    }
+
+  return need_shadow;
 }
 
 void
 gtk_css_shadow_value_pop_snapshot (const GtkCssValue *value,
                                    GtkSnapshot       *snapshot)
 {
-  if (!gtk_css_shadow_value_is_clear (value))
-    gtk_snapshot_pop (snapshot);
-}
-
-GtkCssValue *
-gtk_css_shadow_value_resolve (GtkCssValue *value,
-                              GtkCssValue *current_color)
-{
+  gboolean need_shadow = FALSE;
   guint i;
-  ShadowValue *shadows;
-
-  if (!gtk_css_value_contains_current_color (value))
-    return gtk_css_value_ref (value);
-
-  shadows = g_alloca (sizeof (ShadowValue) * value->n_shadows);
 
   for (i = 0; i < value->n_shadows; i++)
     {
       const ShadowValue *shadow = &value->shadows[i];
 
-      shadows[i].hoffset = gtk_css_value_ref (shadow->hoffset);
-      shadows[i].voffset = gtk_css_value_ref (shadow->voffset);
-      shadows[i].radius = gtk_css_value_ref (shadow->radius);
-      shadows[i].spread = gtk_css_value_ref (shadow->spread);
-      shadows[i].color = gtk_css_color_value_resolve (shadow->color, NULL, current_color);
-      shadows[i].inset = shadow->inset;
+      if (!gdk_rgba_is_clear (gtk_css_color_value_get_rgba (shadow->color)))
+        {
+          need_shadow = TRUE;
+          break;
+        }
     }
 
-  return gtk_css_shadow_value_new (shadows, value->n_shadows, value->is_filter);
+  if (need_shadow)
+    gtk_snapshot_pop (snapshot);
 }

gtk/gtkcssshadowvalueprivate.h

@@ -56,8 +56,5 @@ gboolean        gtk_css_shadow_value_push_snapshot    (const GtkCssValue
 void            gtk_css_shadow_value_pop_snapshot     (const GtkCssValue        *value,
                                                        GtkSnapshot              *snapshot);
 
-GtkCssValue *   gtk_css_shadow_value_resolve          (GtkCssValue              *value,
-                                                       GtkCssValue              *current_color);
-
 G_END_DECLS
 

gtk/gtkcssshorthandproperty.c

@@ -104,7 +104,7 @@ gtk_css_shorthand_property_parse_value (GtkStyleProperty *property,
       for (i = 0; i < n_props; i++)
         {
           if (data[i] != NULL)
-            gtk_css_value_unref (data[i]);
+            _gtk_css_value_unref (data[i]);
         }
       return NULL;
     }

gtk/gtkcssshorthandpropertyimpl.c

@@ -64,7 +64,7 @@ parse_four_numbers (GtkCssShorthandProperty  *shorthand,
       if (!gtk_css_number_value_can_parse (parser))
         break;
 
-      values[i] = gtk_css_number_value_parse (parser, flags);
+      values[i] = _gtk_css_number_value_parse (parser, flags);
       if (values[i] == NULL)
         return FALSE;
     }
@@ -77,7 +77,7 @@ parse_four_numbers (GtkCssShorthandProperty  *shorthand,
 
   for (; i < 4; i++)
     {
-      values[i] = gtk_css_value_ref (values[(i - 1) >> 1]);
+      values[i] = _gtk_css_value_ref (values[(i - 1) >> 1]);
     }
 
   return TRUE;
@@ -130,10 +130,10 @@ parse_border_radius (GtkCssShorthandProperty  *shorthand,
     {
       if (!gtk_css_number_value_can_parse (parser))
         break;
-      x[i] = gtk_css_number_value_parse (parser,
-                                         GTK_CSS_POSITIVE_ONLY
-                                         | GTK_CSS_PARSE_PERCENT
-                                         | GTK_CSS_PARSE_LENGTH);
+      x[i] = _gtk_css_number_value_parse (parser,
+                                          GTK_CSS_POSITIVE_ONLY
+                                          | GTK_CSS_PARSE_PERCENT
+                                          | GTK_CSS_PARSE_LENGTH);
       if (x[i] == NULL)
         goto fail;
     }
@@ -148,7 +148,7 @@ parse_border_radius (GtkCssShorthandProperty  *shorthand,
    * according to spec. Feel free to check the 4 cases
    */
   for (; i < 4; i++)
-    x[i] = gtk_css_value_ref (x[(i - 1) >> 1]);
+    x[i] = _gtk_css_value_ref (x[(i - 1) >> 1]);
 
   if (gtk_css_parser_try_delim (parser, '/'))
     {
@@ -156,10 +156,10 @@ parse_border_radius (GtkCssShorthandProperty  *shorthand,
         {
           if (!gtk_css_number_value_can_parse (parser))
             break;
-          y[i] = gtk_css_number_value_parse (parser,
-                                             GTK_CSS_POSITIVE_ONLY
-                                             | GTK_CSS_PARSE_PERCENT
-                                             | GTK_CSS_PARSE_LENGTH);
+          y[i] = _gtk_css_number_value_parse (parser,
+                                              GTK_CSS_POSITIVE_ONLY
+                                              | GTK_CSS_PARSE_PERCENT
+                                              | GTK_CSS_PARSE_LENGTH);
           if (y[i] == NULL)
             goto fail;
         }
@@ -171,12 +171,12 @@ parse_border_radius (GtkCssShorthandProperty  *shorthand,
         }
 
       for (; i < 4; i++)
-        y[i] = gtk_css_value_ref (y[(i - 1) >> 1]);
+        y[i] = _gtk_css_value_ref (y[(i - 1) >> 1]);
     }
   else
     {
       for (i = 0; i < 4; i++)
-        y[i] = gtk_css_value_ref (x[i]);
+        y[i] = _gtk_css_value_ref (x[i]);
     }
 
   for (i = 0; i < 4; i++)
@@ -190,9 +190,9 @@ fail:
   for (i = 0; i < 4; i++)
     {
       if (x[i])
-        gtk_css_value_unref (x[i]);
+        _gtk_css_value_unref (x[i]);
       if (y[i])
-        gtk_css_value_unref (y[i]);
+        _gtk_css_value_unref (y[i]);
     }
   return FALSE;
 }
@@ -206,7 +206,7 @@ parse_border_color (GtkCssShorthandProperty  *shorthand,
 
   for (i = 0; i < 4; i++)
     {
-      values[i] = gtk_css_color_value_parse (parser);
+      values[i] = _gtk_css_color_value_parse (parser);
       if (values[i] == NULL)
         return FALSE;
 
@@ -216,7 +216,7 @@ parse_border_color (GtkCssShorthandProperty  *shorthand,
 
   for (i++; i < 4; i++)
     {
-      values[i] = gtk_css_value_ref (values[(i - 1) >> 1]);
+      values[i] = _gtk_css_value_ref (values[(i - 1) >> 1]);
     }
 
   return TRUE;
@@ -243,7 +243,7 @@ parse_border_style (GtkCssShorthandProperty  *shorthand,
     }
 
   for (; i < 4; i++)
-    values[i] = gtk_css_value_ref (values[(i - 1) >> 1]);
+    values[i] = _gtk_css_value_ref (values[(i - 1) >> 1]);
 
   return TRUE;
 }
@@ -325,9 +325,9 @@ parse_border_side (GtkCssShorthandProperty  *shorthand,
     if (values[0] == NULL &&
         gtk_css_number_value_can_parse (parser))
       {
-        values[0] = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_POSITIVE_ONLY
-                                                | GTK_CSS_PARSE_LENGTH);
+        values[0] = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_POSITIVE_ONLY
+                                                 | GTK_CSS_PARSE_LENGTH);
         if (values[0] == NULL)
           return FALSE;
       }
@@ -338,7 +338,7 @@ parse_border_side (GtkCssShorthandProperty  *shorthand,
       }
     else if (values[2] == NULL)
       {
-        values[2] = gtk_css_color_value_parse (parser);
+        values[2] = _gtk_css_color_value_parse (parser);
         if (values[2] == NULL)
           return FALSE;
       }
@@ -366,31 +366,31 @@ parse_border (GtkCssShorthandProperty  *shorthand,
     if (values[0] == NULL &&
         gtk_css_number_value_can_parse (parser))
       {
-        values[0] = gtk_css_number_value_parse (parser,
-                                                GTK_CSS_POSITIVE_ONLY
-                                                | GTK_CSS_PARSE_LENGTH);
+        values[0] = _gtk_css_number_value_parse (parser,
+                                                 GTK_CSS_POSITIVE_ONLY
+                                                 | GTK_CSS_PARSE_LENGTH);
         if (values[0] == NULL)
           return FALSE;
-        values[1] = gtk_css_value_ref (values[0]);
-        values[2] = gtk_css_value_ref (values[0]);
-        values[3] = gtk_css_value_ref (values[0]);
+        values[1] = _gtk_css_value_ref (values[0]);
+        values[2] = _gtk_css_value_ref (values[0]);
+        values[3] = _gtk_css_value_ref (values[0]);
       }
     else if (values[4] == NULL &&
              (values[4] = _gtk_css_border_style_value_try_parse (parser)))
       {
-        values[5] = gtk_css_value_ref (values[4]);
-        values[6] = gtk_css_value_ref (values[4]);
-        values[7] = gtk_css_value_ref (values[4]);
+        values[5] = _gtk_css_value_ref (values[4]);
+        values[6] = _gtk_css_value_ref (values[4]);
+        values[7] = _gtk_css_value_ref (values[4]);
       }
     else if (values[8] == NULL)
       {
-        values[8] = gtk_css_color_value_parse (parser);
+        values[8] = _gtk_css_color_value_parse (parser);
         if (values[8] == NULL)
           return FALSE;
 
-        values[9] = gtk_css_value_ref (values[8]);
-        values[10] = gtk_css_value_ref (values[8]);
-        values[11] = gtk_css_value_ref (values[8]);
+        values[9] = _gtk_css_value_ref (values[8]);
+        values[10] = _gtk_css_value_ref (values[8]);
+        values[11] = _gtk_css_value_ref (values[8]);
       }
     else
       {
@@ -449,11 +449,11 @@ parse_font (GtkCssShorthandProperty  *shorthand,
           if (values[3] == NULL && gtk_css_number_value_can_parse (parser))
             {
               /* This needs to check for font-size, too */
-              GtkCssValue *num = gtk_css_number_value_parse (parser,
-                                                             GTK_CSS_PARSE_NUMBER |
-                                                             GTK_CSS_PARSE_LENGTH |
-                                                             GTK_CSS_PARSE_PERCENT |
-                                                             GTK_CSS_POSITIVE_ONLY);
+              GtkCssValue *num = _gtk_css_number_value_parse (parser,
+                                                              GTK_CSS_PARSE_NUMBER |
+                                                              GTK_CSS_PARSE_LENGTH |
+                                                              GTK_CSS_PARSE_PERCENT |
+                                                              GTK_CSS_POSITIVE_ONLY);
               if (num == NULL)
                 return FALSE;
 
@@ -464,8 +464,8 @@ parse_font (GtkCssShorthandProperty  *shorthand,
                 }
 
               values[3] = num;
-              if (gtk_css_number_value_get (values[3], 100) < 1 || 
-                  gtk_css_number_value_get (values[3], 100) > 1000)
+              if (_gtk_css_number_value_get (values[3], 100) < 1 || 
+                  _gtk_css_number_value_get (values[3], 100) > 1000)
                 {
                   gtk_css_parser_error_value (parser, "Font weight values must be between 1 and 1000");
                   g_clear_pointer (&values[3], gtk_css_value_unref);
@@ -555,9 +555,9 @@ parse_one_background (GtkCssShorthandProperty  *shorthand,
         }
       else if (values[6] == NULL)
         {
-          value = gtk_css_color_value_parse (parser);
+          value = _gtk_css_color_value_parse (parser);
           if (value == NULL)
-            values[6] = gtk_css_value_ref (_gtk_css_style_property_get_initial_value 
+            values[6] = _gtk_css_value_ref (_gtk_css_style_property_get_initial_value 
                                             (_gtk_css_shorthand_property_get_subproperty (shorthand, 6)));
           else
             values[6] = value;
@@ -576,7 +576,7 @@ parse_one_background (GtkCssShorthandProperty  *shorthand,
   while (!value_is_done_parsing (parser));
 
   if (values[5] != NULL && values[4] == NULL)
-    values[4] = gtk_css_value_ref (values[5]);
+    values[4] = _gtk_css_value_ref (values[5]);
 
   return TRUE;
 }
@@ -603,7 +603,7 @@ parse_background (GtkCssShorthandProperty  *shorthand,
       {
         for (i = 0; i < 6; i++)
           {
-            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) gtk_css_value_unref);
+            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) _gtk_css_value_unref);
             g_ptr_array_unref (arrays[i]);
           }
         return FALSE;
@@ -615,7 +615,7 @@ parse_background (GtkCssShorthandProperty  *shorthand,
             {
               GtkCssValue *initial = _gtk_css_style_property_get_initial_value (
                                          _gtk_css_shorthand_property_get_subproperty (shorthand, i));
-              step_values[i] = gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
+              step_values[i] = _gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
             }
 
           g_ptr_array_add (arrays[i], step_values[i]);
@@ -662,7 +662,7 @@ parse_transition_time (GtkCssParser *parser,
 {
   GtkCssValue **value = option_data;
 
-  *value = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
+  *value = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
 
   return *value != NULL;
 }
@@ -714,7 +714,7 @@ parse_transition (GtkCssShorthandProperty  *shorthand,
       {
         for (i = 0; i < 4; i++)
           {
-            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) gtk_css_value_unref);
+            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) _gtk_css_value_unref);
             g_ptr_array_unref (arrays[i]);
           }
         return FALSE;
@@ -726,7 +726,7 @@ parse_transition (GtkCssShorthandProperty  *shorthand,
             {
               GtkCssValue *initial = _gtk_css_style_property_get_initial_value (
                                          _gtk_css_shorthand_property_get_subproperty (shorthand, i));
-              step_values[i] = gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
+              step_values[i] = _gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
             }
 
           g_ptr_array_add (arrays[i], step_values[i]);
@@ -752,17 +752,17 @@ parse_one_animation (GtkCssShorthandProperty  *shorthand,
     {
       if (values[1] == NULL && gtk_css_parser_try_ident (parser, "infinite"))
         {
-          values[1] = gtk_css_number_value_new (HUGE_VAL, GTK_CSS_NUMBER);
+          values[1] = _gtk_css_number_value_new (HUGE_VAL, GTK_CSS_NUMBER);
         }
       else if ((values[1] == NULL || values[3] == NULL) &&
                gtk_css_number_value_can_parse (parser))
         {
           GtkCssValue *value;
           
-          value = gtk_css_number_value_parse (parser,
-                                              GTK_CSS_POSITIVE_ONLY
-                                              | (values[1] == NULL ? GTK_CSS_PARSE_NUMBER : 0)
-                                              | (values[3] == NULL ? GTK_CSS_PARSE_TIME : 0));
+          value = _gtk_css_number_value_parse (parser,
+                                               GTK_CSS_POSITIVE_ONLY
+                                               | (values[1] == NULL ? GTK_CSS_PARSE_NUMBER : 0)
+                                               | (values[3] == NULL ? GTK_CSS_PARSE_TIME : 0));
           if (value == NULL)
             return FALSE;
 
@@ -831,7 +831,7 @@ parse_animation (GtkCssShorthandProperty  *shorthand,
       {
         for (i = 0; i < 7; i++)
           {
-            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) gtk_css_value_unref);
+            g_ptr_array_set_free_func (arrays[i], (GDestroyNotify) _gtk_css_value_unref);
             g_ptr_array_unref (arrays[i]);
           }
         return FALSE;
@@ -843,7 +843,7 @@ parse_animation (GtkCssShorthandProperty  *shorthand,
             {
               GtkCssValue *initial = _gtk_css_style_property_get_initial_value (
                                          _gtk_css_shorthand_property_get_subproperty (shorthand, i));
-              step_values[i] = gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
+              step_values[i] = _gtk_css_value_ref (_gtk_css_array_value_get_nth (initial, 0));
             }
 
           g_ptr_array_add (arrays[i], step_values[i]);
@@ -891,7 +891,7 @@ parse_text_decoration (GtkCssShorthandProperty  *shorthand,
       }
     else if (values[2] == NULL)
       {
-        values[2] = gtk_css_color_value_parse (parser);
+        values[2] = _gtk_css_color_value_parse (parser);
         if (values[2] == NULL)
           return FALSE;
       }

gtk/gtkcssstaticstyle.c

@@ -39,7 +39,6 @@
 #include "gtkstyleproviderprivate.h"
 #include "gtkcssdimensionvalueprivate.h"
 
-
 static void gtk_css_static_style_compute_value (GtkCssStaticStyle    *style,
                                                 guint                 id,
                                                 GtkCssValue          *specified,
@@ -57,17 +56,14 @@ gtk_css_## NAME ## _values_compute_changes_and_affects (GtkCssStyle *style1, \
 { \
   GtkCssValue **g1 = GET_VALUES (style1->NAME); \
   GtkCssValue **g2 = GET_VALUES (style2->NAME); \
-  GtkCssValue **u1 = GET_VALUES (style1->used); \
-  GtkCssValue **u2 = GET_VALUES (style2->used); \
   int i; \
   for (i = 0; i < G_N_ELEMENTS (NAME ## _props); i++) \
     { \
-      guint id = NAME ## _props[i]; \
-      int j = used_props_map[id]; \
-      GtkCssValue *v1 = j < 0 ? g1[i] : u1[j]; \
-      GtkCssValue *v2 = j < 0 ? g2[i] : u2[j]; \
-      if (!gtk_css_value_equal (v1, v2)) \
+      GtkCssValue *v1 = g1[i] ? g1[i] : style1->core->color; \
+      GtkCssValue *v2 = g2[i] ? g2[i] : style2->core->color; \
+      if (!_gtk_css_value_equal (v1, v2)) \
         { \
+          guint id = NAME ## _props[i]; \
           *changes = _gtk_bitmask_set (*changes, id, TRUE); \
           *affects |= _gtk_css_style_property_get_affects (_gtk_css_style_property_lookup_by_id (id)); \
         } \
@@ -174,26 +170,11 @@ verify_style_groups (void)
 
 #undef VERIFY_MASK
 
-static void
-verify_used_map (void)
-{
-  for (guint id = 0; id < GTK_CSS_PROPERTY_N_PROPERTIES; id++)
-    {
-      if (used_props_map[id] != -1)
-        g_assert (used_props[used_props_map[id]] == id);
-    }
-
-  for (guint i = 0; i < G_N_ELEMENTS (used_props); i++)
-    {
-      g_assert (used_props_map[used_props[i]] == i);
-    }
-}
-
 G_DEFINE_TYPE (GtkCssStaticStyle, gtk_css_static_style, GTK_TYPE_CSS_STYLE)
 
 static GtkCssSection *
 gtk_css_static_style_get_section (GtkCssStyle *style,
-                                  guint        id)
+                                    guint        id)
 {
   GtkCssStaticStyle *sstyle = GTK_CSS_STATIC_STYLE (style);
 
@@ -268,7 +249,6 @@ gtk_css_static_style_class_init (GtkCssStaticStyleClass *klass)
   gtk_css_other_values_init ();
 
   verify_style_groups ();
-  verify_used_map ();
 }
 
 static void
@@ -287,7 +267,7 @@ static void
 maybe_unref_value (gpointer value)
 {
   if (value)
-    gtk_css_value_unref (value);
+    _gtk_css_value_unref (value);
 }
 
 static inline void
@@ -610,7 +590,7 @@ gtk_css_static_style_set_value (GtkCssStaticStyle *sstyle,
   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));
+      _gtk_css_value_unref (g_ptr_array_index (sstyle->original_values, id));
       g_ptr_array_index (sstyle->original_values, id) = NULL;
     }
 
@@ -620,7 +600,7 @@ gtk_css_static_style_set_value (GtkCssStaticStyle *sstyle,
         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);
+      g_ptr_array_index (sstyle->original_values, id) = _gtk_css_value_ref (original_value);
     }
 }
 
@@ -657,18 +637,12 @@ gtk_css_static_style_get_default (void)
   return default_style;
 }
 
-static inline GtkCssValue *
-initial_color (void)
-{
-  return _gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (GTK_CSS_PROPERTY_COLOR));
-}
-
 static GtkCssValues *
 gtk_css_core_create_initial_values (void)
 {
   return NULL;
-}
 
+}
 static GtkCssValues *
 gtk_css_background_create_initial_values (void)
 {
@@ -710,10 +684,10 @@ gtk_css_border_create_initial_values (void)
   values->border_top_right_radius = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS, &context);
   values->border_bottom_left_radius = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS, &context);
   values->border_bottom_right_radius = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS, &context);
-  values->border_top_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_TOP_COLOR, &context);
-  values->border_right_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR, &context);
-  values->border_bottom_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR, &context);
-  values->border_left_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_LEFT_COLOR, &context);
+  values->border_top_color = NULL;
+  values->border_right_color = NULL;
+  values->border_bottom_color = NULL;
+  values->border_left_color = NULL;
   values->border_image_source = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE, &context);
   values->border_image_repeat = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT, &context);
   values->border_image_slice = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE, &context);
@@ -733,7 +707,7 @@ gtk_css_outline_create_initial_values (void)
   values->outline_style = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_OUTLINE_STYLE, &context);
   values->outline_width = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_OUTLINE_WIDTH, &context);
   values->outline_offset = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_OUTLINE_OFFSET, &context);
-  values->outline_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_OUTLINE_COLOR, &context);
+  values->outline_color = NULL;
 
   return (GtkCssValues *)values;
 }
@@ -759,7 +733,7 @@ gtk_css_font_variant_create_initial_values (void)
   values = (GtkCssFontVariantValues *)gtk_css_values_new (GTK_CSS_FONT_VARIANT_INITIAL_VALUES);
 
   values->text_decoration_line = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_TEXT_DECORATION_LINE, &context);
-  values->text_decoration_color = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR, &context);
+  values->text_decoration_color = NULL;
   values->text_decoration_style = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE, &context);
   values->text_transform = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_TEXT_TRANSFORM, &context);
   values->font_kerning = _gtk_css_initial_value_new_compute (GTK_CSS_PROPERTY_FONT_KERNING, &context);
@@ -890,7 +864,6 @@ gtk_css_lookup_resolve (GtkCssLookup      *lookup,
     }
   else if (parent_style && parent_style->variables)
     {
-      g_clear_pointer (&style->variables, gtk_css_variable_set_unref);
       style->variables = gtk_css_variable_set_ref (parent_style->variables);
     }
 
@@ -923,8 +896,6 @@ gtk_css_lookup_resolve (GtkCssLookup      *lookup,
           gtk_css_font_values_new_compute (sstyle, lookup, &context);
         }
 
-      gtk_css_style_resolve_used_values (style, &context);
-
       return;
     }
 
@@ -983,8 +954,6 @@ gtk_css_lookup_resolve (GtkCssLookup      *lookup,
   else
     gtk_css_other_values_new_compute (sstyle, lookup, &context);
 
-  gtk_css_style_resolve_used_values (style, &context);
-
   for (unsigned int i = 0; i < GTK_CSS_SHORTHAND_PROPERTY_N_PROPERTIES; i++)
     {
       if (shorthands[i])
@@ -1081,7 +1050,7 @@ gtk_css_static_style_compute_value (GtkCssStaticStyle    *style,
    */
   if (specified)
     {
-      value = gtk_css_value_compute (specified, id, context);
+      value = _gtk_css_value_compute (specified, id, context);
 
       if (gtk_css_value_contains_variables (specified))
         original_value = specified;
@@ -1093,7 +1062,7 @@ gtk_css_static_style_compute_value (GtkCssStaticStyle    *style,
       GtkCssValue *parent_original_value;
 
       /* Just take the style from the parent */
-      value = gtk_css_value_ref (gtk_css_style_get_computed_value (context->parent_style, id));
+      value = _gtk_css_value_ref (gtk_css_style_get_value (context->parent_style, id));
 
       parent_original_value = gtk_css_style_get_original_value (context->parent_style, id);
 

gtk/gtkcssstringvalue.c

@@ -39,7 +39,7 @@ gtk_css_value_string_compute (GtkCssValue          *value,
                               guint                 property_id,
                               GtkCssComputeContext *context)
 {
-  return gtk_css_value_ref (value);
+  return _gtk_css_value_ref (value);
 }
 
 static gboolean
@@ -148,7 +148,7 @@ _gtk_css_string_value_new_take (char *string)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_STRING);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_STRING);
   result->string = string;
   result->is_computed = TRUE;
 
@@ -189,7 +189,7 @@ _gtk_css_ident_value_new_take (char *ident)
 {
   GtkCssValue *result;
 
-  result = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_IDENT);
+  result = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_IDENT);
   result->string = ident;
   result->is_computed = TRUE;
 

gtk/gtkcssstyle.c

@@ -26,13 +26,11 @@
 #include "gtkcssarrayvalueprivate.h"
 #include "gtkcsscustompropertypoolprivate.h"
 #include "gtkcssenumvalueprivate.h"
-#include "gtkcssimagevalueprivate.h"
 #include "gtkcssinheritvalueprivate.h"
 #include "gtkcssinitialvalueprivate.h"
 #include "gtkcssnumbervalueprivate.h"
 #include "gtkcsscolorvalueprivate.h"
 #include "gtkcsspalettevalueprivate.h"
-#include "gtkcssshadowvalueprivate.h"
 #include "gtkcssshorthandpropertyprivate.h"
 #include "gtkcssstringvalueprivate.h"
 #include "gtkcssfontvariationsvalueprivate.h"
@@ -43,7 +41,6 @@
 #include "gtkstyleanimationprivate.h"
 #include "gtkstylepropertyprivate.h"
 #include "gtkstyleproviderprivate.h"
-#include "gtkcssvaluesprivate.h"
 
 G_DEFINE_ABSTRACT_TYPE (GtkCssStyle, gtk_css_style, G_TYPE_OBJECT)
 
@@ -103,209 +100,6 @@ gtk_css_style_init (GtkCssStyle *style)
 GtkCssValue *
 gtk_css_style_get_value (GtkCssStyle *style,
                          guint        id)
-{
-  return gtk_css_style_get_used_value (style, id);
-}
-
-GtkCssValue *
-gtk_css_style_get_used_value (GtkCssStyle *style,
-                              guint        id)
-{
-  switch (id)
-    {
-    case GTK_CSS_PROPERTY_COLOR:
-      return style->used->color;
-    case GTK_CSS_PROPERTY_DPI:
-      return style->core->dpi;
-    case GTK_CSS_PROPERTY_FONT_SIZE:
-      return style->core->font_size;
-    case GTK_CSS_PROPERTY_ICON_PALETTE:
-      return style->used->icon_palette;
-    case GTK_CSS_PROPERTY_BACKGROUND_COLOR:
-      return style->used->background_color;
-    case GTK_CSS_PROPERTY_FONT_FAMILY:
-      return style->font->font_family;
-    case GTK_CSS_PROPERTY_FONT_STYLE:
-      return style->font->font_style;
-    case GTK_CSS_PROPERTY_FONT_WEIGHT:
-      return style->font->font_weight;
-    case GTK_CSS_PROPERTY_FONT_STRETCH:
-      return style->font->font_stretch;
-    case GTK_CSS_PROPERTY_LETTER_SPACING:
-      return style->font->letter_spacing;
-    case GTK_CSS_PROPERTY_LINE_HEIGHT:
-      return style->font->line_height;
-    case GTK_CSS_PROPERTY_TEXT_DECORATION_LINE:
-      return style->font_variant->text_decoration_line;
-    case GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR:
-      return style->used->text_decoration_color;
-    case GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE:
-      return style->font_variant->text_decoration_style;
-    case GTK_CSS_PROPERTY_TEXT_TRANSFORM:
-      return style->font_variant->text_transform;
-    case GTK_CSS_PROPERTY_FONT_KERNING:
-      return style->font_variant->font_kerning;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_LIGATURES:
-      return style->font_variant->font_variant_ligatures;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_POSITION:
-      return style->font_variant->font_variant_position;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_CAPS:
-      return style->font_variant->font_variant_caps;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_NUMERIC:
-      return style->font_variant->font_variant_numeric;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_ALTERNATES:
-      return style->font_variant->font_variant_alternates;
-    case GTK_CSS_PROPERTY_FONT_VARIANT_EAST_ASIAN:
-      return style->font_variant->font_variant_east_asian;
-    case GTK_CSS_PROPERTY_TEXT_SHADOW:
-      return style->used->text_shadow;
-    case GTK_CSS_PROPERTY_BOX_SHADOW:
-      return style->used->box_shadow;
-    case GTK_CSS_PROPERTY_MARGIN_TOP:
-      return style->size->margin_top;
-    case GTK_CSS_PROPERTY_MARGIN_LEFT:
-      return style->size->margin_left;
-    case GTK_CSS_PROPERTY_MARGIN_BOTTOM:
-      return style->size->margin_bottom;
-    case GTK_CSS_PROPERTY_MARGIN_RIGHT:
-      return style->size->margin_right;
-    case GTK_CSS_PROPERTY_PADDING_TOP:
-      return style->size->padding_top;
-    case GTK_CSS_PROPERTY_PADDING_LEFT:
-      return style->size->padding_left;
-    case GTK_CSS_PROPERTY_PADDING_BOTTOM:
-      return style->size->padding_bottom;
-    case GTK_CSS_PROPERTY_PADDING_RIGHT:
-      return style->size->padding_right;
-    case GTK_CSS_PROPERTY_BORDER_TOP_STYLE:
-      return style->border->border_top_style;
-    case GTK_CSS_PROPERTY_BORDER_TOP_WIDTH:
-      return style->border->border_top_width;
-    case GTK_CSS_PROPERTY_BORDER_LEFT_STYLE:
-      return style->border->border_left_style;
-    case GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH:
-      return style->border->border_left_width;
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE:
-      return style->border->border_bottom_style;
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH:
-      return style->border->border_bottom_width;
-    case GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE:
-      return style->border->border_right_style;
-    case GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH:
-      return style->border->border_right_width;
-    case GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS:
-      return style->border->border_top_left_radius;
-    case GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS:
-      return style->border->border_top_right_radius;
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS:
-      return style->border->border_bottom_right_radius;
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS:
-      return style->border->border_bottom_left_radius;
-    case GTK_CSS_PROPERTY_OUTLINE_STYLE:
-      return style->outline->outline_style;
-    case GTK_CSS_PROPERTY_OUTLINE_WIDTH:
-      return style->outline->outline_width;
-    case GTK_CSS_PROPERTY_OUTLINE_OFFSET:
-      return style->outline->outline_offset;
-    case GTK_CSS_PROPERTY_BACKGROUND_CLIP:
-      return style->background->background_clip;
-    case GTK_CSS_PROPERTY_BACKGROUND_ORIGIN:
-      return style->background->background_origin;
-    case GTK_CSS_PROPERTY_BACKGROUND_SIZE:
-      return style->background->background_size;
-    case GTK_CSS_PROPERTY_BACKGROUND_POSITION:
-      return style->background->background_position;
-    case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
-      return style->used->border_top_color;
-    case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
-      return style->used->border_right_color;
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
-      return style->used->border_bottom_color;
-    case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
-      return style->used->border_left_color;
-    case GTK_CSS_PROPERTY_OUTLINE_COLOR:
-      return style->used->outline_color;
-    case GTK_CSS_PROPERTY_BACKGROUND_REPEAT:
-      return style->background->background_repeat;
-    case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
-      return style->used->background_image;
-    case GTK_CSS_PROPERTY_BACKGROUND_BLEND_MODE:
-      return style->background->background_blend_mode;
-    case GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE:
-      return style->used->border_image_source;
-    case GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT:
-      return style->border->border_image_repeat;
-    case GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE:
-      return style->border->border_image_slice;
-    case GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH:
-      return style->border->border_image_width;
-    case GTK_CSS_PROPERTY_ICON_SOURCE:
-      return style->used->icon_source;
-    case GTK_CSS_PROPERTY_ICON_SIZE:
-      return style->icon->icon_size;
-    case GTK_CSS_PROPERTY_ICON_SHADOW:
-      return style->used->icon_shadow;
-    case GTK_CSS_PROPERTY_ICON_STYLE:
-      return style->icon->icon_style;
-    case GTK_CSS_PROPERTY_ICON_TRANSFORM:
-      return style->other->icon_transform;
-    case GTK_CSS_PROPERTY_ICON_FILTER:
-      return style->other->icon_filter;
-    case GTK_CSS_PROPERTY_BORDER_SPACING:
-      return style->size->border_spacing;
-    case GTK_CSS_PROPERTY_TRANSFORM:
-      return style->other->transform;
-    case GTK_CSS_PROPERTY_TRANSFORM_ORIGIN:
-      return style->other->transform_origin;
-    case GTK_CSS_PROPERTY_MIN_WIDTH:
-      return style->size->min_width;
-    case GTK_CSS_PROPERTY_MIN_HEIGHT:
-      return style->size->min_height;
-    case GTK_CSS_PROPERTY_TRANSITION_PROPERTY:
-      return style->transition->transition_property;
-    case GTK_CSS_PROPERTY_TRANSITION_DURATION:
-      return style->transition->transition_duration;
-    case GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION:
-      return style->transition->transition_timing_function;
-    case GTK_CSS_PROPERTY_TRANSITION_DELAY:
-      return style->transition->transition_delay;
-    case GTK_CSS_PROPERTY_ANIMATION_NAME:
-      return style->animation->animation_name;
-    case GTK_CSS_PROPERTY_ANIMATION_DURATION:
-      return style->animation->animation_duration;
-    case GTK_CSS_PROPERTY_ANIMATION_TIMING_FUNCTION:
-      return style->animation->animation_timing_function;
-    case GTK_CSS_PROPERTY_ANIMATION_ITERATION_COUNT:
-      return style->animation->animation_iteration_count;
-    case GTK_CSS_PROPERTY_ANIMATION_DIRECTION:
-      return style->animation->animation_direction;
-    case GTK_CSS_PROPERTY_ANIMATION_PLAY_STATE:
-      return style->animation->animation_play_state;
-    case GTK_CSS_PROPERTY_ANIMATION_DELAY:
-      return style->animation->animation_delay;
-    case GTK_CSS_PROPERTY_ANIMATION_FILL_MODE:
-      return style->animation->animation_fill_mode;
-    case GTK_CSS_PROPERTY_OPACITY:
-      return style->other->opacity;
-    case GTK_CSS_PROPERTY_FILTER:
-      return style->other->filter;
-    case GTK_CSS_PROPERTY_CARET_COLOR:
-      return style->used->caret_color;
-    case GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR:
-      return style->used->secondary_caret_color;
-    case GTK_CSS_PROPERTY_FONT_FEATURE_SETTINGS:
-      return style->font->font_feature_settings;
-    case GTK_CSS_PROPERTY_FONT_VARIATION_SETTINGS:
-      return style->font->font_variation_settings;
-
-    default:
-      g_assert_not_reached ();
-    }
-}
-
-GtkCssValue *
-gtk_css_style_get_computed_value (GtkCssStyle *style,
-                                  guint        id)
 {
   switch (id)
     {
@@ -334,7 +128,7 @@ gtk_css_style_get_computed_value (GtkCssStyle *style,
     case GTK_CSS_PROPERTY_TEXT_DECORATION_LINE:
       return style->font_variant->text_decoration_line;
     case GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR:
-      return style->font_variant->text_decoration_color;
+      return style->font_variant->text_decoration_color ? style->font_variant->text_decoration_color : style->core->color;
     case GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE:
       return style->font_variant->text_decoration_style;
     case GTK_CSS_PROPERTY_TEXT_TRANSFORM:
@@ -412,15 +206,15 @@ gtk_css_style_get_computed_value (GtkCssStyle *style,
     case GTK_CSS_PROPERTY_BACKGROUND_POSITION:
       return style->background->background_position;
     case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
-      return style->border->border_top_color;
+      return style->border->border_top_color ? style->border->border_top_color : style->core->color;
     case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
-      return style->border->border_right_color;
+      return style->border->border_right_color ? style->border->border_right_color : style->core->color;
     case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
-      return style->border->border_bottom_color;
+      return style->border->border_bottom_color ? style->border->border_bottom_color : style->core->color;
     case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
-      return style->border->border_left_color;
+      return style->border->border_left_color ? style->border->border_left_color: style->core->color;
     case GTK_CSS_PROPERTY_OUTLINE_COLOR:
-      return style->outline->outline_color;
+      return style->outline->outline_color ? style->outline->outline_color : style->core->color;
     case GTK_CSS_PROPERTY_BACKGROUND_REPEAT:
       return style->background->background_repeat;
     case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
@@ -486,9 +280,9 @@ gtk_css_style_get_computed_value (GtkCssStyle *style,
     case GTK_CSS_PROPERTY_FILTER:
       return style->other->filter;
     case GTK_CSS_PROPERTY_CARET_COLOR:
-      return style->font->caret_color;
+      return style->font->caret_color ? style->font->caret_color : style->core->color;
     case GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR:
-      return style->font->secondary_caret_color;
+      return style->font->secondary_caret_color ? style->font->secondary_caret_color : style->core->color;
     case GTK_CSS_PROPERTY_FONT_FEATURE_SETTINGS:
       return style->font->font_feature_settings;
     case GTK_CSS_PROPERTY_FONT_VARIATION_SETTINGS:
@@ -561,26 +355,19 @@ gtk_css_style_print (GtkCssStyle *style,
     {
       GtkCssSection *section;
       GtkCssStyleProperty *prop;
-      GtkCssValue *value, *computed, *initial;
+      GtkCssValue *value;
       const char *name;
 
+      section = gtk_css_style_get_section (style, i);
+      if (!section && skip_initial)
+        continue;
+
       prop = _gtk_css_style_property_lookup_by_id (i);
       name = _gtk_style_property_get_name (GTK_STYLE_PROPERTY (prop));
-      computed = gtk_css_style_get_computed_value (style, i);
-      value = gtk_css_style_get_used_value (style, i);
-      initial = _gtk_css_style_property_get_initial_value (prop);
-
-      section = gtk_css_style_get_section (style, i);
-      if (skip_initial)
-        {
-          if (!section &&
-              (computed == initial ||
-               !gtk_css_value_contains_current_color (computed)))
-            continue;
-        }
+      value = gtk_css_style_get_value (style, i);
 
       g_string_append_printf (string, "%*s%s: ", indent, "", name);
-      gtk_css_value_print (value, string);
+      _gtk_css_value_print (value, string);
       g_string_append_c (string, ';');
 
       if (section)
@@ -860,22 +647,20 @@ gtk_css_style_get_pango_attributes (GtkCssStyle *style)
   GtkTextDecorationStyle decoration_style;
   const GdkRGBA *color;
   const GdkRGBA *decoration_color;
-  gboolean has_decoration_color;
   double letter_spacing;
 
   /* text-decoration */
   decoration_line = _gtk_css_text_decoration_line_value_get (style->font_variant->text_decoration_line);
   decoration_style = _gtk_css_text_decoration_style_value_get (style->font_variant->text_decoration_style);
-
-  color = gtk_css_color_value_get_rgba (style->used->color);
-  decoration_color = gtk_css_color_value_get_rgba (style->used->text_decoration_color);
-
-  has_decoration_color = !gdk_rgba_equal (color, decoration_color);
+  color = gtk_css_color_value_get_rgba (style->core->color);
+  decoration_color = gtk_css_color_value_get_rgba (style->font_variant->text_decoration_color
+                                                   ? style->font_variant->text_decoration_color
+                                                   : style->core->color);
 
   if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_UNDERLINE)
     {
       attrs = add_pango_attr (attrs, pango_attr_underline_new (get_pango_underline_from_style (decoration_style)));
-      if (has_decoration_color)
+      if (!gdk_rgba_equal (color, decoration_color))
         attrs = add_pango_attr (attrs, pango_attr_underline_color_new (decoration_color->red * 65535. + 0.5,
                                                                        decoration_color->green * 65535. + 0.5,
                                                                        decoration_color->blue * 65535. + 0.5));
@@ -883,7 +668,7 @@ gtk_css_style_get_pango_attributes (GtkCssStyle *style)
   if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_OVERLINE)
     {
       attrs = add_pango_attr (attrs, pango_attr_overline_new (get_pango_overline_from_style (decoration_style)));
-      if (has_decoration_color)
+      if (!gdk_rgba_equal (color, decoration_color))
         attrs = add_pango_attr (attrs, pango_attr_overline_color_new (decoration_color->red * 65535. + 0.5,
                                                                       decoration_color->green * 65535. + 0.5,
                                                                       decoration_color->blue * 65535. + 0.5));
@@ -891,14 +676,14 @@ gtk_css_style_get_pango_attributes (GtkCssStyle *style)
   if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_LINE_THROUGH)
     {
       attrs = add_pango_attr (attrs, pango_attr_strikethrough_new (TRUE));
-      if (!has_decoration_color)
+      if (!gdk_rgba_equal (color, decoration_color))
         attrs = add_pango_attr (attrs, pango_attr_strikethrough_color_new (decoration_color->red * 65535. + 0.5,
                                                                            decoration_color->green * 65535. + 0.5,
                                                                            decoration_color->blue * 65535. + 0.5));
     }
 
   /* letter-spacing */
-  letter_spacing = gtk_css_number_value_get (style->font->letter_spacing, 100);
+  letter_spacing = _gtk_css_number_value_get (style->font->letter_spacing, 100);
   if (letter_spacing != 0)
     {
       attrs = add_pango_attr (attrs, pango_attr_letter_spacing_new (letter_spacing * PANGO_SCALE));
@@ -996,13 +781,13 @@ gtk_css_style_get_pango_font (GtkCssStyle *style)
     }
 
   v = style->core->font_size;
-  pango_font_description_set_absolute_size (description, round (gtk_css_number_value_get (v, 100) * PANGO_SCALE));
+  pango_font_description_set_absolute_size (description, round (_gtk_css_number_value_get (v, 100) * PANGO_SCALE));
 
   v = style->font->font_style;
   pango_font_description_set_style (description, _gtk_css_font_style_value_get (v));
 
   v = style->font->font_weight;
-  pango_font_description_set_weight (description, gtk_css_number_value_get (v, 100));
+  pango_font_description_set_weight (description, _gtk_css_number_value_get (v, 100));
 
   v = style->font->font_stretch;
   pango_font_description_set_stretch (description, _gtk_css_font_stretch_value_get (v));
@@ -1020,22 +805,24 @@ 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_out[GTK_SYMBOLIC_COLOR_FOREGROUND] = *gtk_css_color_value_get_rgba (style->used->color);
+  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++)
     {
-      GtkCssValue *lookup;
-
-      lookup = gtk_css_palette_value_get_color (style->used->icon_palette, names[i]);
+      const GdkRGBA *lookup;
 
+      lookup = gtk_css_palette_value_get_color (palette, names[i]);
       if (lookup)
-        color_out[i] = *gtk_css_color_value_get_rgba (lookup);
+        color_out[i] = *lookup;
       else
         color_out[i] = color_out[GTK_SYMBOLIC_COLOR_FOREGROUND];
     }
@@ -1054,8 +841,7 @@ static const int values_size[] = {
   sizeof (GtkCssAnimationValues),
   sizeof (GtkCssTransitionValues),
   sizeof (GtkCssSizeValues),
-  sizeof (GtkCssOtherValues),
-  sizeof (GtkCssUsedValues)
+  sizeof (GtkCssOtherValues)
 };
 
 #define TYPE_INDEX(type) ((type) - ((type) % 2))
@@ -1074,9 +860,10 @@ GtkCssValues *gtk_css_values_ref (GtkCssValues *values)
 static void
 gtk_css_values_free (GtkCssValues *values)
 {
+  int i;
   GtkCssValue **v = GET_VALUES (values);
 
-  for (int i = 0; i < N_VALUES (values->type); i++)
+  for (i = 0; i < N_VALUES (values->type); i++)
     {
       if (v[i])
         gtk_css_value_unref (v[i]);
@@ -1101,13 +888,14 @@ gtk_css_values_copy (GtkCssValues *values)
 {
   GtkCssValues *copy;
   GtkCssValue **v, **v2;
+  int i;
 
-  copy = gtk_css_values_new (TYPE_INDEX (values->type));
+  copy = gtk_css_values_new (TYPE_INDEX(values->type));
 
   v = GET_VALUES (values);
   v2 = GET_VALUES (copy);
 
-  for (int i = 0; i < N_VALUES (values->type); i++)
+  for (i = 0; i < N_VALUES (values->type); i++)
     {
       if (v[i])
         v2[i] = gtk_css_value_ref (v[i]);
@@ -1121,7 +909,7 @@ gtk_css_values_new (GtkCssValuesType type)
 {
   GtkCssValues *values;
 
-  values = (GtkCssValues *) g_malloc0 (VALUES_SIZE (type));
+  values = (GtkCssValues *)g_malloc0 (VALUES_SIZE(type));
   values->ref_count = 1;
   values->type = type;
 
@@ -1146,97 +934,3 @@ gtk_css_style_list_custom_properties (GtkCssStyle *style)
 
   return NULL;
 }
-
-static GtkCssValue *
-gtk_css_style_resolve_used_value (GtkCssStyle          *style,
-                                  GtkCssValue          *value,
-                                  guint                 id,
-                                  GtkCssComputeContext *context)
-{
-  GtkCssValue *used;
-
-  switch (id)
-    {
-    case GTK_CSS_PROPERTY_COLOR:
-      {
-        GtkCssValue *current;
-
-        if (context->parent_style)
-          current = context->parent_style->used->color;
-        else
-          current = _gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (GTK_CSS_PROPERTY_COLOR));
-
-        used = gtk_css_color_value_resolve (value, NULL, current);
-      }
-      break;
-
-    case GTK_CSS_PROPERTY_BACKGROUND_COLOR:
-    case GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
-    case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
-    case GTK_CSS_PROPERTY_OUTLINE_COLOR:
-    case GTK_CSS_PROPERTY_CARET_COLOR:
-    case GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR:
-      used = gtk_css_color_value_resolve (value, NULL, style->used->color);
-      break;
-
-    case GTK_CSS_PROPERTY_BOX_SHADOW:
-    case GTK_CSS_PROPERTY_TEXT_SHADOW:
-    case GTK_CSS_PROPERTY_ICON_SHADOW:
-      used = gtk_css_shadow_value_resolve (value, style->used->color);
-      break;
-
-    case GTK_CSS_PROPERTY_ICON_PALETTE:
-      used = gtk_css_palette_value_resolve (value, style->used->color);
-      break;
-
-    case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
-    case GTK_CSS_PROPERTY_ICON_SOURCE:
-    case GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE:
-      used = gtk_css_image_value_resolve (value, style->used->color);
-      break;
-
-    default:
-      return NULL;
-    }
-
-  g_assert (!gtk_css_value_contains_current_color (used));
-
-  return used;
-}
-
-static inline void
-gtk_css_take_value (GtkCssValue **variable,
-                    GtkCssValue  *value)
-{
-  if (*variable)
-    gtk_css_value_unref (*variable);
-  *variable = value;
-}
-
-void
-gtk_css_style_resolve_used_values (GtkCssStyle          *style,
-                                   GtkCssComputeContext *context)
-{
-  GtkCssValue **values;
-
-  style->used = (GtkCssUsedValues *) gtk_css_values_new (GTK_CSS_USED_VALUES);
-  values = &style->used->color;
-
-  for (guint i = 0; i < G_N_ELEMENTS (used_props); i++)
-    {
-      guint id = used_props[i];
-      GtkCssValue *value, *used;
-
-      value = gtk_css_style_get_computed_value (style, id);
-
-      if (gtk_css_value_contains_current_color (value))
-        used = gtk_css_style_resolve_used_value (style, value, id, context);
-      else
-        used = gtk_css_value_ref (value);
-
-      gtk_css_take_value (&values[i], used);
-    }
-}

gtk/gtkcssstylechange.c

@@ -26,8 +26,7 @@ compute_change (GtkCssStyleChange *change)
 {
   gboolean color_changed = FALSE;
 
-  if (change->old_style->core != change->new_style->core ||
-      gtk_css_value_contains_current_color (change->old_style->core->color))
+  if (change->old_style->core != change->new_style->core)
     {
       gtk_css_core_values_compute_changes_and_affects (change->old_style,
                                                        change->new_style,
@@ -36,51 +35,45 @@ compute_change (GtkCssStyleChange *change)
       color_changed = _gtk_bitmask_get (change->changes, GTK_CSS_PROPERTY_COLOR);
     }
 
-  if (change->old_style->background != change->new_style->background ||
-      (color_changed && (gtk_css_value_contains_current_color (change->old_style->background->background_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->background->box_shadow) ||
-                         gtk_css_value_contains_current_color (change->old_style->background->background_image))))
+  if (change->old_style->background != change->new_style->background)
     gtk_css_background_values_compute_changes_and_affects (change->old_style,
                                                            change->new_style,
                                                            &change->changes,
                                                            &change->affects);
 
   if (change->old_style->border != change->new_style->border ||
-      (color_changed && (gtk_css_value_contains_current_color (change->old_style->border->border_top_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->border->border_right_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->border->border_bottom_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->border->border_left_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->border->border_image_source))))
+      (color_changed && (change->old_style->border->border_top_color == NULL ||
+                         change->old_style->border->border_right_color == NULL ||
+                         change->old_style->border->border_bottom_color == NULL ||
+                         change->old_style->border->border_left_color == NULL)))
     gtk_css_border_values_compute_changes_and_affects (change->old_style,
                                                        change->new_style,
                                                        &change->changes,
                                                        &change->affects);
 
-  if (change->old_style->icon != change->new_style->icon ||
-      (color_changed && (gtk_css_value_contains_current_color (change->old_style->icon->icon_shadow))))
+  if (change->old_style->icon != change->new_style->icon)
     gtk_css_icon_values_compute_changes_and_affects (change->old_style,
                                                      change->new_style,
                                                      &change->changes,
                                                      &change->affects);
 
   if (change->old_style->outline != change->new_style->outline ||
-      (color_changed && gtk_css_value_contains_current_color (change->old_style->outline->outline_color)))
+      (color_changed && change->old_style->outline->outline_color == NULL))
     gtk_css_outline_values_compute_changes_and_affects (change->old_style,
                                                         change->new_style,
                                                         &change->changes,
                                                         &change->affects);
 
   if (change->old_style->font != change->new_style->font ||
-      (color_changed && (gtk_css_value_contains_current_color (change->old_style->font->caret_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->font->secondary_caret_color) ||
-                         gtk_css_value_contains_current_color (change->old_style->font->text_shadow))))
+      (color_changed && (change->old_style->font->caret_color == NULL ||
+                         change->old_style->font->secondary_caret_color == NULL)))
     gtk_css_font_values_compute_changes_and_affects (change->old_style,
                                                      change->new_style,
                                                      &change->changes,
                                                      &change->affects);
 
   if (change->old_style->font_variant != change->new_style->font_variant ||
-      (color_changed && gtk_css_value_contains_current_color (change->old_style->font_variant->text_decoration_color)))
+      (color_changed && change->old_style->font_variant->text_decoration_color == NULL))
     gtk_css_font_variant_values_compute_changes_and_affects (change->old_style,
                                                              change->new_style,
                                                              &change->changes,
@@ -104,8 +97,7 @@ compute_change (GtkCssStyleChange *change)
                                                      &change->changes,
                                                      &change->affects);
 
-  if (change->old_style->other != change->new_style->other ||
-      (color_changed && gtk_css_value_contains_current_color (change->old_style->other->icon_source)))
+  if (change->old_style->other != change->new_style->other)
     gtk_css_other_values_compute_changes_and_affects (change->old_style,
                                                       change->new_style,
                                                       &change->changes,
@@ -194,12 +186,12 @@ gtk_css_style_change_print (GtkCssStyleChange *change,
 
           g_string_append_printf (string, "%s: ", name);
           value = gtk_css_style_get_value (old, i);
-          gtk_css_value_print (value, string);
+          _gtk_css_value_print (value, string);
           g_string_append (string, "\n");
 
           g_string_append_printf (string, "%s: ", name);
           value = gtk_css_style_get_value (new, i);
-          gtk_css_value_print (value, string);
+          _gtk_css_value_print (value, string);
           g_string_append (string, "\n");
         }
     }

gtk/gtkcssstyleprivate.h

@@ -59,7 +59,6 @@ typedef enum {
   GTK_CSS_SIZE_INITIAL_VALUES,
   GTK_CSS_OTHER_VALUES,
   GTK_CSS_OTHER_INITIAL_VALUES,
-  GTK_CSS_USED_VALUES,
 } GtkCssValuesType;
 
 typedef struct _GtkCssValues GtkCssValues;
@@ -74,7 +73,6 @@ typedef struct _GtkCssAnimationValues GtkCssAnimationValues;
 typedef struct _GtkCssTransitionValues GtkCssTransitionValues;
 typedef struct _GtkCssSizeValues GtkCssSizeValues;
 typedef struct _GtkCssOtherValues GtkCssOtherValues;
-typedef struct _GtkCssUsedValues GtkCssUsedValues;
 
 struct _GtkCssValues {
   int ref_count;
@@ -83,7 +81,6 @@ struct _GtkCssValues {
 
 struct _GtkCssCoreValues {
   GtkCssValues base;
-
   GtkCssValue *color;
   GtkCssValue *dpi;
   GtkCssValue *font_size;
@@ -92,7 +89,6 @@ struct _GtkCssCoreValues {
 
 struct _GtkCssBackgroundValues {
   GtkCssValues base;
-
   GtkCssValue *background_color;
   GtkCssValue *box_shadow;
   GtkCssValue *background_clip;
@@ -106,7 +102,6 @@ struct _GtkCssBackgroundValues {
 
 struct _GtkCssBorderValues {
   GtkCssValues base;
-
   GtkCssValue *border_top_style;
   GtkCssValue *border_top_width;
   GtkCssValue *border_left_style;
@@ -119,10 +114,10 @@ struct _GtkCssBorderValues {
   GtkCssValue *border_top_right_radius;
   GtkCssValue *border_bottom_right_radius;
   GtkCssValue *border_bottom_left_radius;
-  GtkCssValue *border_top_color;
-  GtkCssValue *border_right_color;
-  GtkCssValue *border_bottom_color;
-  GtkCssValue *border_left_color;
+  GtkCssValue *border_top_color; // NULL if currentColor
+  GtkCssValue *border_right_color; // NULL if currentColor
+  GtkCssValue *border_bottom_color; // NULL if currentColor
+  GtkCssValue *border_left_color; // NULL if currentColor
   GtkCssValue *border_image_source;
   GtkCssValue *border_image_repeat;
   GtkCssValue *border_image_slice;
@@ -131,7 +126,6 @@ struct _GtkCssBorderValues {
 
 struct _GtkCssIconValues {
   GtkCssValues base;
-
   GtkCssValue *icon_size;
   GtkCssValue *icon_shadow;
   GtkCssValue *icon_style;
@@ -140,24 +134,22 @@ struct _GtkCssIconValues {
 
 struct _GtkCssOutlineValues {
   GtkCssValues base;
-
   GtkCssValue *outline_style;
   GtkCssValue *outline_width;
   GtkCssValue *outline_offset;
-  GtkCssValue *outline_color;
+  GtkCssValue *outline_color; // NULL if currentColor
 };
 
 struct _GtkCssFontValues {
   GtkCssValues base;
-
   GtkCssValue *font_family;
   GtkCssValue *font_style;
   GtkCssValue *font_weight;
   GtkCssValue *font_stretch;
   GtkCssValue *letter_spacing;
   GtkCssValue *text_shadow;
-  GtkCssValue *caret_color;
-  GtkCssValue *secondary_caret_color;
+  GtkCssValue *caret_color; // NULL if currentColor
+  GtkCssValue *secondary_caret_color; // NULL if currentColor
   GtkCssValue *font_feature_settings;
   GtkCssValue *font_variation_settings;
   GtkCssValue *line_height;
@@ -165,9 +157,8 @@ struct _GtkCssFontValues {
 
 struct _GtkCssFontVariantValues {
   GtkCssValues base;
-
   GtkCssValue *text_decoration_line;
-  GtkCssValue *text_decoration_color;
+  GtkCssValue *text_decoration_color; // NULL if currentColor
   GtkCssValue *text_decoration_style;
   GtkCssValue *text_transform;
   GtkCssValue *font_kerning;
@@ -181,7 +172,6 @@ struct _GtkCssFontVariantValues {
 
 struct _GtkCssAnimationValues {
   GtkCssValues base;
-
   GtkCssValue *animation_name;
   GtkCssValue *animation_duration;
   GtkCssValue *animation_timing_function;
@@ -194,7 +184,6 @@ struct _GtkCssAnimationValues {
 
 struct _GtkCssTransitionValues {
   GtkCssValues base;
-
   GtkCssValue *transition_property;
   GtkCssValue *transition_duration;
   GtkCssValue *transition_timing_function;
@@ -203,7 +192,6 @@ struct _GtkCssTransitionValues {
 
 struct _GtkCssSizeValues {
   GtkCssValues base;
-
   GtkCssValue *margin_top;
   GtkCssValue *margin_left;
   GtkCssValue *margin_bottom;
@@ -219,7 +207,6 @@ struct _GtkCssSizeValues {
 
 struct _GtkCssOtherValues {
   GtkCssValues base;
-
   GtkCssValue *icon_source;
   GtkCssValue *icon_transform;
   GtkCssValue *icon_filter;
@@ -229,28 +216,6 @@ struct _GtkCssOtherValues {
   GtkCssValue *filter;
 };
 
-struct _GtkCssUsedValues {
-  GtkCssValues base;
-
-  GtkCssValue *color;
-  GtkCssValue *icon_palette;
-  GtkCssValue *background_color;
-  GtkCssValue *box_shadow;
-  GtkCssValue *background_image;
-  GtkCssValue *border_top_color;
-  GtkCssValue *border_right_color;
-  GtkCssValue *border_bottom_color;
-  GtkCssValue *border_left_color;
-  GtkCssValue *border_image_source;
-  GtkCssValue *icon_shadow;
-  GtkCssValue *outline_color;
-  GtkCssValue *caret_color;
-  GtkCssValue *secondary_caret_color;
-  GtkCssValue *text_shadow;
-  GtkCssValue *text_decoration_color;
-  GtkCssValue *icon_source;
-};
-
 /* typedef struct _GtkCssStyle           GtkCssStyle; */
 typedef struct _GtkCssStyleClass      GtkCssStyleClass;
 
@@ -269,8 +234,6 @@ struct _GtkCssStyle
   GtkCssTransitionValues  *transition;
   GtkCssSizeValues        *size;
   GtkCssOtherValues       *other;
-  GtkCssUsedValues        *used;
-
   GtkCssVariableSet       *variables;
 
   GtkCssValue             *variable_values;
@@ -298,10 +261,6 @@ GType                   gtk_css_style_get_type                  (void) G_GNUC_CO
 
 GtkCssValue *           gtk_css_style_get_value                 (GtkCssStyle            *style,
                                                                  guint                   id) G_GNUC_PURE;
-GtkCssValue *           gtk_css_style_get_computed_value        (GtkCssStyle            *style,
-                                                                 guint                   id) G_GNUC_PURE;
-GtkCssValue *           gtk_css_style_get_used_value            (GtkCssStyle            *style,
-                                                                 guint                   id) G_GNUC_PURE;
 GtkCssSection *         gtk_css_style_get_section               (GtkCssStyle            *style,
                                                                  guint                   id) G_GNUC_PURE;
 gboolean                gtk_css_style_is_static                 (GtkCssStyle            *style) G_GNUC_PURE;
@@ -328,9 +287,6 @@ GtkCssVariableValue *   gtk_css_style_get_custom_property       (GtkCssStyle
                                                                  int                     id);
 GArray *                gtk_css_style_list_custom_properties    (GtkCssStyle            *style);
 
-void                    gtk_css_style_resolve_used_values       (GtkCssStyle            *style,
-                                                                 GtkCssComputeContext   *context);
-
 GtkCssValues *gtk_css_values_new   (GtkCssValuesType  type);
 GtkCssValues *gtk_css_values_ref   (GtkCssValues     *values);
 void          gtk_css_values_unref (GtkCssValues     *values);

gtk/gtkcssstylepropertyimpl.c

@@ -84,7 +84,7 @@ gtk_css_style_property_register (const char *                   name,
 
   node->parse_value = parse_value;
 
-  gtk_css_value_unref (initial_value);
+  _gtk_css_value_unref (initial_value);
 
   g_assert (_gtk_css_style_property_get_id (node) == expected_id);
 }
@@ -95,7 +95,7 @@ static GtkCssValue *
 color_parse (GtkCssStyleProperty *property,
              GtkCssParser        *parser)
 {
-  return gtk_css_color_value_parse (parser);
+  return _gtk_css_color_value_parse (parser);
 }
 
 static GtkCssValue *
@@ -163,12 +163,12 @@ font_weight_parse (GtkCssStyleProperty *property,
   value = gtk_css_font_weight_value_try_parse (parser);
   if (value == NULL)
     {
-      value = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_POSITIVE_ONLY);
+      value = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_POSITIVE_ONLY);
       if (value == NULL)
         return NULL;
 
-      if (gtk_css_number_value_get (value, 100) < 1 || 
-          gtk_css_number_value_get (value, 100) > 1000)
+      if (_gtk_css_number_value_get (value, 100) < 1 || 
+          _gtk_css_number_value_get (value, 100) > 1000)
         {
           gtk_css_parser_error_value (parser, "Font weight values must be between 1 and 1000");
           g_clear_pointer (&value, gtk_css_value_unref);
@@ -242,7 +242,7 @@ static GtkCssValue *
 opacity_parse (GtkCssStyleProperty *property,
 	       GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+  return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
 }
 
 static GtkCssValue *
@@ -285,10 +285,10 @@ static GtkCssValue *
 icon_size_parse (GtkCssStyleProperty *property,
 		 GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser, 
-                                     GTK_CSS_PARSE_LENGTH
-                                     | GTK_CSS_PARSE_PERCENT
-                                     | GTK_CSS_POSITIVE_ONLY);
+  return _gtk_css_number_value_parse (parser, 
+                                      GTK_CSS_PARSE_LENGTH
+                                      | GTK_CSS_PARSE_PERCENT
+                                      | GTK_CSS_POSITIVE_ONLY);
 }
 
 static GtkCssValue *
@@ -314,7 +314,7 @@ static GtkCssValue *
 parse_letter_spacing (GtkCssStyleProperty *property,
                       GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH);
+  return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH);
 }
 
 static gboolean
@@ -597,7 +597,7 @@ static GtkCssValue *
 dpi_parse (GtkCssStyleProperty *property,
 	   GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+  return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
 }
 
 GtkCssValue *
@@ -609,10 +609,10 @@ gtk_css_font_size_value_parse (GtkCssParser *parser)
   if (value)
     return value;
 
-  return gtk_css_number_value_parse (parser,
-                                     GTK_CSS_PARSE_LENGTH
-                                     | GTK_CSS_PARSE_PERCENT
-                                     | GTK_CSS_POSITIVE_ONLY);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_PARSE_LENGTH
+                                      | GTK_CSS_PARSE_PERCENT
+                                      | GTK_CSS_POSITIVE_ONLY);
 }
 
 static GtkCssValue *
@@ -626,8 +626,8 @@ static GtkCssValue *
 outline_parse (GtkCssStyleProperty *property,
                GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser,
-                                     GTK_CSS_PARSE_LENGTH);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_PARSE_LENGTH);
 }
 
 static GtkCssValue *
@@ -674,9 +674,9 @@ static GtkCssValue *
 minmax_parse (GtkCssStyleProperty *property,
               GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser,
-                                     GTK_CSS_PARSE_LENGTH
-                                     | GTK_CSS_POSITIVE_ONLY);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_PARSE_LENGTH
+                                      | GTK_CSS_POSITIVE_ONLY);
 }
 
 static GtkCssValue *
@@ -705,7 +705,7 @@ transition_property_parse (GtkCssStyleProperty *property,
 static GtkCssValue *
 transition_time_parse_one (GtkCssParser *parser)
 {
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
+  return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
 }
 
 static GtkCssValue *
@@ -726,9 +726,9 @@ static GtkCssValue *
 iteration_count_parse_one (GtkCssParser *parser)
 {
   if (gtk_css_parser_try_ident (parser, "infinite"))
-    return gtk_css_number_value_new (HUGE_VAL, GTK_CSS_NUMBER);
+    return _gtk_css_number_value_new (HUGE_VAL, GTK_CSS_NUMBER);
 
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_POSITIVE_ONLY);
+  return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER | GTK_CSS_POSITIVE_ONLY);
 }
 
 static GtkCssValue *
@@ -742,25 +742,26 @@ static GtkCssValue *
 parse_margin (GtkCssStyleProperty *property,
               GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_PARSE_LENGTH);
 }
 
 static GtkCssValue *
 parse_padding (GtkCssStyleProperty *property,
                GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser,
-                                     GTK_CSS_POSITIVE_ONLY
-                                     | GTK_CSS_PARSE_LENGTH);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_POSITIVE_ONLY
+                                      | GTK_CSS_PARSE_LENGTH);
 }
 
 static GtkCssValue *
 parse_border_width (GtkCssStyleProperty *property,
                     GtkCssParser        *parser)
 {
-  return gtk_css_number_value_parse (parser,
-                                     GTK_CSS_POSITIVE_ONLY
-                                     | GTK_CSS_PARSE_LENGTH);
+  return _gtk_css_number_value_parse (parser,
+                                      GTK_CSS_POSITIVE_ONLY
+                                      | GTK_CSS_PARSE_LENGTH);
 }
 
 static GtkCssValue *
@@ -853,7 +854,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE | GTK_CSS_AFFECTS_TEXT_SIZE,
                                           dpi_parse,
-                                          gtk_css_number_value_new (96.0, GTK_CSS_NUMBER));
+                                          _gtk_css_number_value_new (96.0, GTK_CSS_NUMBER));
   gtk_css_style_property_register        ("font-size",
                                           GTK_CSS_PROPERTY_FONT_SIZE,
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
@@ -894,7 +895,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_TEXT_SIZE,
                                           font_weight_parse,
-                                          gtk_css_number_value_new (PANGO_WEIGHT_NORMAL, GTK_CSS_NUMBER));
+                                          _gtk_css_number_value_new (PANGO_WEIGHT_NORMAL, GTK_CSS_NUMBER));
   gtk_css_style_property_register        ("font-stretch",
                                           GTK_CSS_PROPERTY_FONT_STRETCH,
                                           GTK_STYLE_PROPERTY_INHERIT,
@@ -907,7 +908,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_TEXT_ATTRS | GTK_CSS_AFFECTS_TEXT_SIZE,
                                           parse_letter_spacing,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 
   gtk_css_style_property_register        ("text-decoration-line",
                                           GTK_CSS_PROPERTY_TEXT_DECORATION_LINE,
@@ -920,7 +921,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_TEXT_ATTRS,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("text-decoration-style",
                                           GTK_CSS_PROPERTY_TEXT_DECORATION_STYLE,
                                           0,
@@ -994,49 +995,49 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_margin,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("margin-left",
                                           GTK_CSS_PROPERTY_MARGIN_LEFT,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_margin,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("margin-bottom",
                                           GTK_CSS_PROPERTY_MARGIN_BOTTOM,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_margin,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("margin-right",
                                           GTK_CSS_PROPERTY_MARGIN_RIGHT,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_margin,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("padding-top",
                                           GTK_CSS_PROPERTY_PADDING_TOP,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_padding,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("padding-left",
                                           GTK_CSS_PROPERTY_PADDING_LEFT,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_padding,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("padding-bottom",
                                           GTK_CSS_PROPERTY_PADDING_BOTTOM,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_padding,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("padding-right",
                                           GTK_CSS_PROPERTY_PADDING_RIGHT,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           parse_padding,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   /* IMPORTANT: the border-width properties must come after border-style properties,
    * they depend on them for their value computation.
    */
@@ -1051,7 +1052,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER | GTK_CSS_AFFECTS_SIZE,
                                           parse_border_width,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("border-left-style",
                                           GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
                                           0,
@@ -1063,7 +1064,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER | GTK_CSS_AFFECTS_SIZE,
                                           parse_border_width,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("border-bottom-style",
                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE,
                                           0,
@@ -1075,7 +1076,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER | GTK_CSS_AFFECTS_SIZE,
                                           parse_border_width,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("border-right-style",
                                           GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
                                           0,
@@ -1087,36 +1088,36 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER | GTK_CSS_AFFECTS_SIZE,
                                           parse_border_width,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 
   gtk_css_style_property_register        ("border-top-left-radius",
                                           GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BACKGROUND | GTK_CSS_AFFECTS_BORDER,
                                           border_corner_radius_value_parse,
-                                          _gtk_css_corner_value_new (gtk_css_number_value_new (0, GTK_CSS_PX),
-                                                                     gtk_css_number_value_new (0, GTK_CSS_PX)));
+                                          _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
+                                                                     _gtk_css_number_value_new (0, GTK_CSS_PX)));
   gtk_css_style_property_register        ("border-top-right-radius",
                                           GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BACKGROUND | GTK_CSS_AFFECTS_BORDER,
                                           border_corner_radius_value_parse,
-                                          _gtk_css_corner_value_new (gtk_css_number_value_new (0, GTK_CSS_PX),
-                                                                     gtk_css_number_value_new (0, GTK_CSS_PX)));
+                                          _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
+                                                                     _gtk_css_number_value_new (0, GTK_CSS_PX)));
   gtk_css_style_property_register        ("border-bottom-right-radius",
                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BACKGROUND | GTK_CSS_AFFECTS_BORDER,
                                           border_corner_radius_value_parse,
-                                          _gtk_css_corner_value_new (gtk_css_number_value_new (0, GTK_CSS_PX),
-                                                                     gtk_css_number_value_new (0, GTK_CSS_PX)));
+                                          _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
+                                                                     _gtk_css_number_value_new (0, GTK_CSS_PX)));
   gtk_css_style_property_register        ("border-bottom-left-radius",
                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BACKGROUND | GTK_CSS_AFFECTS_BORDER,
                                           border_corner_radius_value_parse,
-                                          _gtk_css_corner_value_new (gtk_css_number_value_new (0, GTK_CSS_PX),
-                                                                     gtk_css_number_value_new (0, GTK_CSS_PX)));
+                                          _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
+                                                                     _gtk_css_number_value_new (0, GTK_CSS_PX)));
 
   gtk_css_style_property_register        ("outline-style",
                                           GTK_CSS_PROPERTY_OUTLINE_STYLE,
@@ -1129,13 +1130,13 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_OUTLINE,
                                           parse_border_width,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("outline-offset",
                                           GTK_CSS_PROPERTY_OUTLINE_OFFSET,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_OUTLINE,
                                           outline_parse,
-                                          gtk_css_number_value_new (0.0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0.0, GTK_CSS_PX));
   gtk_css_style_property_register        ("background-clip",
                                           GTK_CSS_PROPERTY_BACKGROUND_CLIP,
                                           0,
@@ -1159,39 +1160,39 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BACKGROUND,
                                           background_position_parse,
-                                          _gtk_css_position_value_new (gtk_css_number_value_new (0, GTK_CSS_PERCENT),
-                                                                       gtk_css_number_value_new (0, GTK_CSS_PERCENT)));
+                                          _gtk_css_position_value_new (_gtk_css_number_value_new (0, GTK_CSS_PERCENT),
+                                                                       _gtk_css_number_value_new (0, GTK_CSS_PERCENT)));
 
   gtk_css_style_property_register        ("border-top-color",
                                           GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("border-right-color",
                                           GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("border-bottom-color",
                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("border-left-color",
                                           GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_BORDER,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("outline-color",
                                           GTK_CSS_PROPERTY_OUTLINE_COLOR,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_OUTLINE,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
 
   gtk_css_style_property_register        ("background-repeat",
                                           GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
@@ -1233,19 +1234,19 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           GTK_CSS_AFFECTS_BORDER,
                                           border_image_slice_parse,
-                                          _gtk_css_border_value_new (gtk_css_number_value_new (100, GTK_CSS_PERCENT),
-                                                                     gtk_css_number_value_new (100, GTK_CSS_PERCENT),
-                                                                     gtk_css_number_value_new (100, GTK_CSS_PERCENT),
-                                                                     gtk_css_number_value_new (100, GTK_CSS_PERCENT)));
+                                          _gtk_css_border_value_new (_gtk_css_number_value_new (100, GTK_CSS_PERCENT),
+                                                                     _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
+                                                                     _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
+                                                                     _gtk_css_number_value_new (100, GTK_CSS_PERCENT)));
   gtk_css_style_property_register        ("border-image-width",
                                           GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH,
                                           0,
                                           GTK_CSS_AFFECTS_BORDER,
                                           border_image_width_parse,
-                                          _gtk_css_border_value_new (gtk_css_number_value_new (1, GTK_CSS_NUMBER),
-                                                                     gtk_css_number_value_new (1, GTK_CSS_NUMBER),
-                                                                     gtk_css_number_value_new (1, GTK_CSS_NUMBER),
-                                                                     gtk_css_number_value_new (1, GTK_CSS_NUMBER)));
+                                          _gtk_css_border_value_new (_gtk_css_number_value_new (1, GTK_CSS_NUMBER),
+                                                                     _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
+                                                                     _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
+                                                                     _gtk_css_number_value_new (1, GTK_CSS_NUMBER)));
 
   gtk_css_style_property_register        ("-gtk-icon-source",
                                           GTK_CSS_PROPERTY_ICON_SOURCE,
@@ -1258,7 +1259,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE | GTK_CSS_AFFECTS_ICON_SIZE,
                                           icon_size_parse,
-                                          gtk_css_number_value_new (16, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (16, GTK_CSS_PX));
   gtk_css_style_property_register        ("-gtk-icon-shadow",
                                           GTK_CSS_PROPERTY_ICON_SHADOW,
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
@@ -1288,8 +1289,8 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           border_spacing_value_parse,
-                                          _gtk_css_position_value_new (gtk_css_number_value_new (0, GTK_CSS_PX),
-                                                                       gtk_css_number_value_new (0, GTK_CSS_PX)));
+                                          _gtk_css_position_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
+                                                                       _gtk_css_number_value_new (0, GTK_CSS_PX)));
 
   gtk_css_style_property_register        ("transform",
                                           GTK_CSS_PROPERTY_TRANSFORM,
@@ -1302,20 +1303,20 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_TRANSFORM,
                                           transform_origin_parse,
-                                          _gtk_css_position_value_new (gtk_css_number_value_new (50, GTK_CSS_PERCENT),
-                                                                       gtk_css_number_value_new (50, GTK_CSS_PERCENT)));
+                                          _gtk_css_position_value_new (_gtk_css_number_value_new (50, GTK_CSS_PERCENT),
+                                                                       _gtk_css_number_value_new (50, GTK_CSS_PERCENT)));
   gtk_css_style_property_register        ("min-width",
                                           GTK_CSS_PROPERTY_MIN_WIDTH,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           minmax_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0, GTK_CSS_PX));
   gtk_css_style_property_register        ("min-height",
                                           GTK_CSS_PROPERTY_MIN_HEIGHT,
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_SIZE,
                                           minmax_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_PX));
+                                          _gtk_css_number_value_new (0, GTK_CSS_PX));
 
   gtk_css_style_property_register        ("transition-property",
                                           GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
@@ -1328,7 +1329,7 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           0,
                                           transition_time_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_S));
+                                          _gtk_css_number_value_new (0, GTK_CSS_S));
   gtk_css_style_property_register        ("transition-timing-function",
                                           GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
                                           0,
@@ -1340,7 +1341,7 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           0,
                                           transition_time_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_S));
+                                          _gtk_css_number_value_new (0, GTK_CSS_S));
 
   gtk_css_style_property_register        ("animation-name",
                                           GTK_CSS_PROPERTY_ANIMATION_NAME,
@@ -1353,7 +1354,7 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           0,
                                           transition_time_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_S));
+                                          _gtk_css_number_value_new (0, GTK_CSS_S));
   gtk_css_style_property_register        ("animation-timing-function",
                                           GTK_CSS_PROPERTY_ANIMATION_TIMING_FUNCTION,
                                           0,
@@ -1365,7 +1366,7 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           0,
                                           iteration_count_parse,
-                                          gtk_css_number_value_new (1, GTK_CSS_NUMBER));
+                                          _gtk_css_number_value_new (1, GTK_CSS_NUMBER));
   gtk_css_style_property_register        ("animation-direction",
                                           GTK_CSS_PROPERTY_ANIMATION_DIRECTION,
                                           0,
@@ -1383,7 +1384,7 @@ _gtk_css_style_property_init_properties (void)
                                           0,
                                           0,
                                           transition_time_parse,
-                                          gtk_css_number_value_new (0, GTK_CSS_S));
+                                          _gtk_css_number_value_new (0, GTK_CSS_S));
   gtk_css_style_property_register        ("animation-fill-mode",
                                           GTK_CSS_PROPERTY_ANIMATION_FILL_MODE,
                                           0,
@@ -1396,7 +1397,7 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_POSTEFFECT,
                                           opacity_parse,
-                                          gtk_css_number_value_new (1, GTK_CSS_NUMBER));
+                                          _gtk_css_number_value_new (1, GTK_CSS_NUMBER));
   gtk_css_style_property_register        ("filter",
                                           GTK_CSS_PROPERTY_FILTER,
                                           GTK_STYLE_PROPERTY_ANIMATED,
@@ -1409,13 +1410,13 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_CONTENT,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("-gtk-secondary-caret-color",
                                           GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR,
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_CONTENT,
                                           color_parse,
-                                          gtk_css_color_value_new_current_color ());
+                                          _gtk_css_color_value_new_current_color ());
   gtk_css_style_property_register        ("font-feature-settings",
                                           GTK_CSS_PROPERTY_FONT_FEATURE_SETTINGS,
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
@@ -1433,5 +1434,5 @@ _gtk_css_style_property_init_properties (void)
                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
                                           GTK_CSS_AFFECTS_TEXT_ATTRS | GTK_CSS_AFFECTS_TEXT_SIZE,
                                           parse_line_height,
-                                          gtk_css_value_ref (gtk_css_line_height_value_get_default ()));
+                                          _gtk_css_value_ref (gtk_css_line_height_value_get_default ()));
 }

gtk/gtkcsstransformvalue.c

@@ -90,33 +90,33 @@ gtk_css_transform_clear (GtkCssTransform *transform)
     case GTK_CSS_TRANSFORM_MATRIX:
       break;
     case GTK_CSS_TRANSFORM_TRANSLATE:
-      gtk_css_value_unref (transform->translate.x);
-      gtk_css_value_unref (transform->translate.y);
-      gtk_css_value_unref (transform->translate.z);
+      _gtk_css_value_unref (transform->translate.x);
+      _gtk_css_value_unref (transform->translate.y);
+      _gtk_css_value_unref (transform->translate.z);
       break;
     case GTK_CSS_TRANSFORM_ROTATE:
-      gtk_css_value_unref (transform->rotate.x);
-      gtk_css_value_unref (transform->rotate.y);
-      gtk_css_value_unref (transform->rotate.z);
-      gtk_css_value_unref (transform->rotate.angle);
+      _gtk_css_value_unref (transform->rotate.x);
+      _gtk_css_value_unref (transform->rotate.y);
+      _gtk_css_value_unref (transform->rotate.z);
+      _gtk_css_value_unref (transform->rotate.angle);
       break;
     case GTK_CSS_TRANSFORM_SCALE:
-      gtk_css_value_unref (transform->scale.x);
-      gtk_css_value_unref (transform->scale.y);
-      gtk_css_value_unref (transform->scale.z);
+      _gtk_css_value_unref (transform->scale.x);
+      _gtk_css_value_unref (transform->scale.y);
+      _gtk_css_value_unref (transform->scale.z);
       break;
     case GTK_CSS_TRANSFORM_SKEW:
-      gtk_css_value_unref (transform->skew.x);
-      gtk_css_value_unref (transform->skew.y);
+      _gtk_css_value_unref (transform->skew.x);
+      _gtk_css_value_unref (transform->skew.y);
       break;
     case GTK_CSS_TRANSFORM_SKEW_X:
-      gtk_css_value_unref (transform->skew_x.skew);
+      _gtk_css_value_unref (transform->skew_x.skew);
       break;
     case GTK_CSS_TRANSFORM_SKEW_Y:
-      gtk_css_value_unref (transform->skew_y.skew);
+      _gtk_css_value_unref (transform->skew_y.skew);
       break;
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
-      gtk_css_value_unref (transform->perspective.depth);
+      _gtk_css_value_unref (transform->perspective.depth);
       break;
     case GTK_CSS_TRANSFORM_NONE:
     default:
@@ -135,30 +135,30 @@ gtk_css_transform_init_identity (GtkCssTransform     *transform,
       graphene_matrix_init_identity (&transform->matrix.matrix);
       break;
     case GTK_CSS_TRANSFORM_TRANSLATE:
-      transform->translate.x = gtk_css_number_value_new (0, GTK_CSS_PX);
-      transform->translate.y = gtk_css_number_value_new (0, GTK_CSS_PX);
-      transform->translate.z = gtk_css_number_value_new (0, GTK_CSS_PX);
+      transform->translate.x = _gtk_css_number_value_new (0, GTK_CSS_PX);
+      transform->translate.y = _gtk_css_number_value_new (0, GTK_CSS_PX);
+      transform->translate.z = _gtk_css_number_value_new (0, GTK_CSS_PX);
       break;
     case GTK_CSS_TRANSFORM_ROTATE:
-      transform->rotate.x = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-      transform->rotate.y = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-      transform->rotate.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-      transform->rotate.angle = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      transform->rotate.x = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+      transform->rotate.y = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+      transform->rotate.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      transform->rotate.angle = _gtk_css_number_value_new (0, GTK_CSS_DEG);
       break;
     case GTK_CSS_TRANSFORM_SCALE:
-      transform->scale.x = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-      transform->scale.y = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-      transform->scale.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      transform->scale.x = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      transform->scale.y = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+      transform->scale.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
       break;
     case GTK_CSS_TRANSFORM_SKEW:
-      transform->skew.x = gtk_css_number_value_new (0, GTK_CSS_DEG);
-      transform->skew.y = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      transform->skew.x = _gtk_css_number_value_new (0, GTK_CSS_DEG);
+      transform->skew.y = _gtk_css_number_value_new (0, GTK_CSS_DEG);
       break;
     case GTK_CSS_TRANSFORM_SKEW_X:
-      transform->skew_x.skew = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      transform->skew_x.skew = _gtk_css_number_value_new (0, GTK_CSS_DEG);
       break;
     case GTK_CSS_TRANSFORM_SKEW_Y:
-      transform->skew_y.skew = gtk_css_number_value_new (0, GTK_CSS_DEG);
+      transform->skew_y.skew = _gtk_css_number_value_new (0, GTK_CSS_DEG);
       break;
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
       return FALSE;
@@ -188,9 +188,9 @@ gtk_css_transform_apply (const GtkCssTransform   *transform,
     case GTK_CSS_TRANSFORM_TRANSLATE:
       return gsk_transform_translate_3d (next,
                                          &GRAPHENE_POINT3D_INIT (
-                                             gtk_css_number_value_get (transform->translate.x, 100),
-                                             gtk_css_number_value_get (transform->translate.y, 100),
-                                             gtk_css_number_value_get (transform->translate.z, 100)
+                                             _gtk_css_number_value_get (transform->translate.x, 100),
+                                             _gtk_css_number_value_get (transform->translate.y, 100),
+                                              _gtk_css_number_value_get (transform->translate.z, 100)
                                          ));
 
     case GTK_CSS_TRANSFORM_ROTATE:
@@ -198,41 +198,41 @@ gtk_css_transform_apply (const GtkCssTransform   *transform,
         graphene_vec3_t axis;
 
         graphene_vec3_init (&axis,
-                            gtk_css_number_value_get (transform->rotate.x, 1),
-                            gtk_css_number_value_get (transform->rotate.y, 1),
-                            gtk_css_number_value_get (transform->rotate.z, 1));
+                            _gtk_css_number_value_get (transform->rotate.x, 1),
+                            _gtk_css_number_value_get (transform->rotate.y, 1),
+                            _gtk_css_number_value_get (transform->rotate.z, 1));
         return gsk_transform_rotate_3d (next,
-                                        gtk_css_number_value_get (transform->rotate.angle, 100),
+                                        _gtk_css_number_value_get (transform->rotate.angle, 100),
                                         &axis);
       }
 
     case GTK_CSS_TRANSFORM_SCALE:
       return gsk_transform_scale_3d (next,
-                                     gtk_css_number_value_get (transform->scale.x, 1),
-                                     gtk_css_number_value_get (transform->scale.y, 1),
-                                     gtk_css_number_value_get (transform->scale.z, 1));
+                                     _gtk_css_number_value_get (transform->scale.x, 1),
+                                     _gtk_css_number_value_get (transform->scale.y, 1),
+                                     _gtk_css_number_value_get (transform->scale.z, 1));
 
     case GTK_CSS_TRANSFORM_SKEW:
       graphene_matrix_init_skew (&skew,
-                                 gtk_css_number_value_get (transform->skew.x, 100) / 180.0f * G_PI,
-                                 gtk_css_number_value_get (transform->skew.y, 100) / 180.0f * G_PI);
+                                 _gtk_css_number_value_get (transform->skew.x, 100) / 180.0f * G_PI,
+                                 _gtk_css_number_value_get (transform->skew.y, 100) / 180.0f * G_PI);
       return gsk_transform_matrix (next, &skew);
 
     case GTK_CSS_TRANSFORM_SKEW_X:
       graphene_matrix_init_skew (&skew,
-                                 gtk_css_number_value_get (transform->skew_x.skew, 100) / 180.0f * G_PI,
+                                 _gtk_css_number_value_get (transform->skew_x.skew, 100) / 180.0f * G_PI,
                                  0);
       return gsk_transform_matrix (next, &skew);
 
     case GTK_CSS_TRANSFORM_SKEW_Y:
       graphene_matrix_init_skew (&skew,
                                  0,
-                                 gtk_css_number_value_get (transform->skew_y.skew, 100) / 180.0f * G_PI);
+                                 _gtk_css_number_value_get (transform->skew_y.skew, 100) / 180.0f * G_PI);
       return gsk_transform_matrix (next, &skew);
 
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
       return gsk_transform_perspective (next,
-                                        gtk_css_number_value_get (transform->perspective.depth, 100));
+                                        _gtk_css_number_value_get (transform->perspective.depth, 100));
 
     case GTK_CSS_TRANSFORM_NONE:
     default:
@@ -286,41 +286,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, context);
-      dest->translate.y = gtk_css_value_compute (src->translate.y, property_id, context);
-      dest->translate.z = gtk_css_value_compute (src->translate.z, property_id, context);
+      dest->translate.x = _gtk_css_value_compute (src->translate.x, property_id, context);
+      dest->translate.y = _gtk_css_value_compute (src->translate.y, property_id, context);
+      dest->translate.z = _gtk_css_value_compute (src->translate.z, property_id, context);
       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, context);
-      dest->rotate.y = gtk_css_value_compute (src->rotate.y, property_id, context);
-      dest->rotate.z = gtk_css_value_compute (src->rotate.z, property_id, context);
-      dest->rotate.angle = gtk_css_value_compute (src->rotate.angle, property_id, context);
+      dest->rotate.x = _gtk_css_value_compute (src->rotate.x, property_id, context);
+      dest->rotate.y = _gtk_css_value_compute (src->rotate.y, property_id, context);
+      dest->rotate.z = _gtk_css_value_compute (src->rotate.z, property_id, context);
+      dest->rotate.angle = _gtk_css_value_compute (src->rotate.angle, property_id, context);
       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, context);
-      dest->scale.y = gtk_css_value_compute (src->scale.y, property_id, context);
-      dest->scale.z = gtk_css_value_compute (src->scale.z, property_id, context);
+      dest->scale.x = _gtk_css_value_compute (src->scale.x, property_id, context);
+      dest->scale.y = _gtk_css_value_compute (src->scale.y, property_id, context);
+      dest->scale.z = _gtk_css_value_compute (src->scale.z, property_id, context);
       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, context);
-      dest->skew.y = gtk_css_value_compute (src->skew.y, property_id, context);
+      dest->skew.x = _gtk_css_value_compute (src->skew.x, property_id, context);
+      dest->skew.y = _gtk_css_value_compute (src->skew.y, property_id, context);
       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, context);
+      dest->skew_x.skew = _gtk_css_value_compute (src->skew_x.skew, property_id, context);
       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, context);
+      dest->skew_y.skew = _gtk_css_value_compute (src->skew_y.skew, property_id, context);
       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, context);
+      dest->perspective.depth = _gtk_css_value_compute (src->perspective.depth, property_id, context);
       return dest->perspective.depth == src->perspective.depth;
     case GTK_CSS_TRANSFORM_NONE:
     default:
@@ -340,7 +340,7 @@ gtk_css_value_transform_compute (GtkCssValue          *value,
 
   /* Special case the 99% case of "none" */
   if (gtk_css_transform_value_is_none (value))
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
   changes = FALSE;
   result = gtk_css_transform_value_alloc (value->n_transforms);
@@ -355,8 +355,8 @@ gtk_css_value_transform_compute (GtkCssValue          *value,
 
   if (!changes)
     {
-      gtk_css_value_unref (result);
-      result = gtk_css_value_ref (value);
+      _gtk_css_value_unref (result);
+      result = _gtk_css_value_ref (value);
     }
 
   return result;
@@ -385,27 +385,27 @@ gtk_css_transform_equal (const GtkCssTransform *transform1,
         return TRUE;
       }
     case GTK_CSS_TRANSFORM_TRANSLATE:
-      return gtk_css_value_equal (transform1->translate.x, transform2->translate.x)
-          && gtk_css_value_equal (transform1->translate.y, transform2->translate.y)
-          && gtk_css_value_equal (transform1->translate.z, transform2->translate.z);
+      return _gtk_css_value_equal (transform1->translate.x, transform2->translate.x)
+          && _gtk_css_value_equal (transform1->translate.y, transform2->translate.y)
+          && _gtk_css_value_equal (transform1->translate.z, transform2->translate.z);
     case GTK_CSS_TRANSFORM_ROTATE:
-      return gtk_css_value_equal (transform1->rotate.x, transform2->rotate.x)
-          && gtk_css_value_equal (transform1->rotate.y, transform2->rotate.y)
-          && gtk_css_value_equal (transform1->rotate.z, transform2->rotate.z)
-          && gtk_css_value_equal (transform1->rotate.angle, transform2->rotate.angle);
+      return _gtk_css_value_equal (transform1->rotate.x, transform2->rotate.x)
+          && _gtk_css_value_equal (transform1->rotate.y, transform2->rotate.y)
+          && _gtk_css_value_equal (transform1->rotate.z, transform2->rotate.z)
+          && _gtk_css_value_equal (transform1->rotate.angle, transform2->rotate.angle);
     case GTK_CSS_TRANSFORM_SCALE:
-      return gtk_css_value_equal (transform1->scale.x, transform2->scale.x)
-          && gtk_css_value_equal (transform1->scale.y, transform2->scale.y)
-          && gtk_css_value_equal (transform1->scale.z, transform2->scale.z);
+      return _gtk_css_value_equal (transform1->scale.x, transform2->scale.x)
+          && _gtk_css_value_equal (transform1->scale.y, transform2->scale.y)
+          && _gtk_css_value_equal (transform1->scale.z, transform2->scale.z);
     case GTK_CSS_TRANSFORM_SKEW:
-      return gtk_css_value_equal (transform1->skew.x, transform2->skew.x)
-          && gtk_css_value_equal (transform1->skew.y, transform2->skew.y);
+      return _gtk_css_value_equal (transform1->skew.x, transform2->skew.x)
+          && _gtk_css_value_equal (transform1->skew.y, transform2->skew.y);
     case GTK_CSS_TRANSFORM_SKEW_X:
-      return gtk_css_value_equal (transform1->skew_x.skew, transform2->skew_x.skew);
+      return _gtk_css_value_equal (transform1->skew_x.skew, transform2->skew_x.skew);
     case GTK_CSS_TRANSFORM_SKEW_Y:
-      return gtk_css_value_equal (transform1->skew_y.skew, transform2->skew_y.skew);
+      return _gtk_css_value_equal (transform1->skew_y.skew, transform2->skew_y.skew);
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
-      return gtk_css_value_equal (transform1->perspective.depth, transform2->perspective.depth);
+      return _gtk_css_value_equal (transform1->perspective.depth, transform2->perspective.depth);
     case GTK_CSS_TRANSFORM_NONE:
     default:
       g_assert_not_reached ();
@@ -498,30 +498,30 @@ gtk_css_transform_transition (GtkCssTransform       *result,
                                    &result->matrix.matrix);
       break;
     case GTK_CSS_TRANSFORM_TRANSLATE:
-      result->translate.x = gtk_css_value_transition (start->translate.x, end->translate.x, property_id, progress);
-      result->translate.y = gtk_css_value_transition (start->translate.y, end->translate.y, property_id, progress);
-      result->translate.z = gtk_css_value_transition (start->translate.z, end->translate.z, property_id, progress);
+      result->translate.x = _gtk_css_value_transition (start->translate.x, end->translate.x, property_id, progress);
+      result->translate.y = _gtk_css_value_transition (start->translate.y, end->translate.y, property_id, progress);
+      result->translate.z = _gtk_css_value_transition (start->translate.z, end->translate.z, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_ROTATE:
-      result->rotate.x = gtk_css_value_transition (start->rotate.x, end->rotate.x, property_id, progress);
-      result->rotate.y = gtk_css_value_transition (start->rotate.y, end->rotate.y, property_id, progress);
-      result->rotate.z = gtk_css_value_transition (start->rotate.z, end->rotate.z, property_id, progress);
-      result->rotate.angle = gtk_css_value_transition (start->rotate.angle, end->rotate.angle, property_id, progress);
+      result->rotate.x = _gtk_css_value_transition (start->rotate.x, end->rotate.x, property_id, progress);
+      result->rotate.y = _gtk_css_value_transition (start->rotate.y, end->rotate.y, property_id, progress);
+      result->rotate.z = _gtk_css_value_transition (start->rotate.z, end->rotate.z, property_id, progress);
+      result->rotate.angle = _gtk_css_value_transition (start->rotate.angle, end->rotate.angle, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_SCALE:
-      result->scale.x = gtk_css_value_transition (start->scale.x, end->scale.x, property_id, progress);
-      result->scale.y = gtk_css_value_transition (start->scale.y, end->scale.y, property_id, progress);
-      result->scale.z = gtk_css_value_transition (start->scale.z, end->scale.z, property_id, progress);
+      result->scale.x = _gtk_css_value_transition (start->scale.x, end->scale.x, property_id, progress);
+      result->scale.y = _gtk_css_value_transition (start->scale.y, end->scale.y, property_id, progress);
+      result->scale.z = _gtk_css_value_transition (start->scale.z, end->scale.z, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_SKEW:
-      result->skew.x = gtk_css_value_transition (start->skew.x, end->skew.x, property_id, progress);
-      result->skew.y = gtk_css_value_transition (start->skew.y, end->skew.y, property_id, progress);
+      result->skew.x = _gtk_css_value_transition (start->skew.x, end->skew.x, property_id, progress);
+      result->skew.y = _gtk_css_value_transition (start->skew.y, end->skew.y, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_SKEW_X:
-      result->skew_x.skew = gtk_css_value_transition (start->skew_x.skew, end->skew_x.skew, property_id, progress);
+      result->skew_x.skew = _gtk_css_value_transition (start->skew_x.skew, end->skew_x.skew, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_SKEW_Y:
-      result->skew_y.skew = gtk_css_value_transition (start->skew_y.skew, end->skew_y.skew, property_id, progress);
+      result->skew_y.skew = _gtk_css_value_transition (start->skew_y.skew, end->skew_y.skew, property_id, progress);
       break;
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
       gtk_css_transform_transition_default (result, start, end, property_id, progress);
@@ -545,7 +545,7 @@ gtk_css_value_transform_transition (GtkCssValue *start,
   if (gtk_css_transform_value_is_none (start))
     {
       if (gtk_css_transform_value_is_none (end))
-        return gtk_css_value_ref (start);
+        return _gtk_css_value_ref (start);
 
       n = 0;
     }
@@ -693,67 +693,67 @@ gtk_css_transform_print (const GtkCssTransform *transform,
       break;
     case GTK_CSS_TRANSFORM_TRANSLATE:
       g_string_append (string, "translate3d(");
-      gtk_css_value_print (transform->translate.x, string);
+      _gtk_css_value_print (transform->translate.x, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->translate.y, string);
+      _gtk_css_value_print (transform->translate.y, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->translate.z, string);
+      _gtk_css_value_print (transform->translate.z, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_ROTATE:
       g_string_append (string, "rotate3d(");
-      gtk_css_value_print (transform->rotate.x, string);
+      _gtk_css_value_print (transform->rotate.x, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->rotate.y, string);
+      _gtk_css_value_print (transform->rotate.y, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->rotate.z, string);
+      _gtk_css_value_print (transform->rotate.z, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->rotate.angle, string);
+      _gtk_css_value_print (transform->rotate.angle, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_SCALE:
-      if (gtk_css_number_value_get (transform->scale.z, 100) == 1)
+      if (_gtk_css_number_value_get (transform->scale.z, 100) == 1)
         {
           g_string_append (string, "scale(");
-          gtk_css_value_print (transform->scale.x, string);
-          if (!gtk_css_value_equal (transform->scale.x, transform->scale.y))
+          _gtk_css_value_print (transform->scale.x, string);
+          if (!_gtk_css_value_equal (transform->scale.x, transform->scale.y))
             {
               g_string_append (string, ", ");
-              gtk_css_value_print (transform->scale.y, string);
+              _gtk_css_value_print (transform->scale.y, string);
             }
           g_string_append (string, ")");
         }
       else
         {
           g_string_append (string, "scale3d(");
-          gtk_css_value_print (transform->scale.x, string);
+          _gtk_css_value_print (transform->scale.x, string);
           g_string_append (string, ", ");
-          gtk_css_value_print (transform->scale.y, string);
+          _gtk_css_value_print (transform->scale.y, string);
           g_string_append (string, ", ");
-          gtk_css_value_print (transform->scale.z, string);
+          _gtk_css_value_print (transform->scale.z, string);
           g_string_append (string, ")");
         }
       break;
     case GTK_CSS_TRANSFORM_SKEW:
       g_string_append (string, "skew(");
-      gtk_css_value_print (transform->skew.x, string);
+      _gtk_css_value_print (transform->skew.x, string);
       g_string_append (string, ", ");
-      gtk_css_value_print (transform->skew.y, string);
+      _gtk_css_value_print (transform->skew.y, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_SKEW_X:
       g_string_append (string, "skewX(");
-      gtk_css_value_print (transform->skew_x.skew, string);
+      _gtk_css_value_print (transform->skew_x.skew, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_SKEW_Y:
       g_string_append (string, "skewY(");
-      gtk_css_value_print (transform->skew_y.skew, string);
+      _gtk_css_value_print (transform->skew_y.skew, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_PERSPECTIVE:
       g_string_append (string, "perspective(");
-      gtk_css_value_print (transform->perspective.depth, string);
+      _gtk_css_value_print (transform->perspective.depth, string);
       g_string_append (string, ")");
       break;
     case GTK_CSS_TRANSFORM_NONE:
@@ -795,7 +795,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_TRANSFORM = {
   gtk_css_value_transform_print
 };
 
-static GtkCssValue transform_none_singleton = { &GTK_CSS_VALUE_TRANSFORM, 1, 1, 0, 0, 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)
@@ -804,7 +804,7 @@ gtk_css_transform_value_alloc (guint n_transforms)
            
   g_return_val_if_fail (n_transforms > 0, NULL);
          
-  result = gtk_css_value_alloc (&GTK_CSS_VALUE_TRANSFORM, sizeof (GtkCssValue) + sizeof (GtkCssTransform) * (n_transforms - 1));
+  result = _gtk_css_value_alloc (&GTK_CSS_VALUE_TRANSFORM, sizeof (GtkCssValue) + sizeof (GtkCssTransform) * (n_transforms - 1));
   result->n_transforms = n_transforms;
             
   return result;
@@ -813,7 +813,7 @@ gtk_css_transform_value_alloc (guint n_transforms)
 GtkCssValue *
 _gtk_css_transform_value_new_none (void)
 {
-  return gtk_css_value_ref (&transform_none_singleton);
+  return _gtk_css_value_ref (&transform_none_singleton);
 }
 
 static gboolean
@@ -844,7 +844,7 @@ gtk_css_transform_parse_length (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_LENGTH);
   if (values[n] == NULL)
     return 0;
 
@@ -858,7 +858,7 @@ gtk_css_transform_parse_angle (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
   if (values[n] == NULL)
     return 0;
 
@@ -872,7 +872,7 @@ gtk_css_transform_parse_number (GtkCssParser *parser,
 {
   GtkCssValue **values = data;
 
-  values[n] = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+  values[n] = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
   if (values[n] == NULL)
     return 0;
 
@@ -889,25 +889,25 @@ gtk_css_transform_parse_rotate3d (GtkCssParser *parser,
   switch (n)
   {
     case 0:
-      transform->rotate.x = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+      transform->rotate.x = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
       if (transform->rotate.x == NULL)
         return 0;
       break;
 
     case 1:
-      transform->rotate.y = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+      transform->rotate.y = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
       if (transform->rotate.y == NULL)
         return 0;
       break;
 
     case 2:
-      transform->rotate.z = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
+      transform->rotate.z = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_NUMBER);
       if (transform->rotate.z == NULL)
         return 0;
       break;
 
     case 3:
-      transform->rotate.angle = gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
+      transform->rotate.angle = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
       if (transform->rotate.angle == NULL)
         return 0;
       break;
@@ -972,9 +972,9 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_ROTATE;
-          transform.rotate.x = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-          transform.rotate.y = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-          transform.rotate.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.rotate.x = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.y = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.rotate.angle);
         }
       else if (gtk_css_parser_has_function (parser, "rotate3d"))
@@ -1000,9 +1000,9 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_ROTATE;
-          transform.rotate.x = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-          transform.rotate.y = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-          transform.rotate.z = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.x = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.rotate.y = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.z = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.rotate.angle);
         }
       else if (gtk_css_parser_has_function (parser, "rotateY"))
@@ -1011,9 +1011,9 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_ROTATE;
-          transform.rotate.x = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
-          transform.rotate.y = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-          transform.rotate.z = gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.x = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
+          transform.rotate.y = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.rotate.z = _gtk_css_number_value_new (0, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.rotate.angle);
         }
       else if (gtk_css_parser_has_function (parser, "scale"))
@@ -1033,7 +1033,7 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             transform.scale.y = values[1];
           else
             transform.scale.y = gtk_css_value_ref (values[0]);
-          transform.scale.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.scale.x) &&
                                  gtk_css_value_is_computed (transform.scale.y);
         }
@@ -1063,8 +1063,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_SCALE;
-          transform.scale.y = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-          transform.scale.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.y = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.scale.x);
         }
       else if (gtk_css_parser_has_function (parser, "scaleY"))
@@ -1073,8 +1073,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_SCALE;
-          transform.scale.x = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-          transform.scale.z = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.x = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.z = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.scale.y);
         }
       else if (gtk_css_parser_has_function (parser, "scaleZ"))
@@ -1083,8 +1083,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_SCALE;
-          transform.scale.x = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
-          transform.scale.y = gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.x = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
+          transform.scale.y = _gtk_css_number_value_new (1, GTK_CSS_NUMBER);
           computed = computed && gtk_css_value_is_computed (transform.scale.z);
         }
       else if (gtk_css_parser_has_function (parser, "skew"))
@@ -1136,8 +1136,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
           if (values[1])
             transform.translate.y = values[1];
           else
-            transform.translate.y = gtk_css_number_value_new (0, GTK_CSS_PX);
-          transform.translate.z = gtk_css_number_value_new (0, GTK_CSS_PX);
+            transform.translate.y = _gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.z = _gtk_css_number_value_new (0, GTK_CSS_PX);
           computed = computed && gtk_css_value_is_computed (transform.translate.x) &&
                                  gtk_css_value_is_computed (transform.translate.y);
         }
@@ -1167,8 +1167,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_TRANSLATE;
-          transform.translate.y = gtk_css_number_value_new (0, GTK_CSS_PX);
-          transform.translate.z = gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.y = _gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.z = _gtk_css_number_value_new (0, GTK_CSS_PX);
           computed = computed && gtk_css_value_is_computed (transform.translate.x);
         }
       else if (gtk_css_parser_has_function (parser, "translateY"))
@@ -1177,8 +1177,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_TRANSLATE;
-          transform.translate.x = gtk_css_number_value_new (0, GTK_CSS_PX);
-          transform.translate.z = gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.x = _gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.z = _gtk_css_number_value_new (0, GTK_CSS_PX);
           computed = computed && gtk_css_value_is_computed (transform.translate.y);
         }
       else if (gtk_css_parser_has_function (parser, "translateZ"))
@@ -1187,8 +1187,8 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
             goto fail;
 
           transform.type = GTK_CSS_TRANSFORM_TRANSLATE;
-          transform.translate.x = gtk_css_number_value_new (0, GTK_CSS_PX);
-          transform.translate.y = gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.x = _gtk_css_number_value_new (0, GTK_CSS_PX);
+          transform.translate.y = _gtk_css_number_value_new (0, GTK_CSS_PX);
           computed = computed && gtk_css_value_is_computed (transform.translate.z);
         }
       else

gtk/gtkcsstransition.c

@@ -57,22 +57,22 @@ gtk_css_transition_apply_values (GtkStyleAnimation   *style_animation,
   state = gtk_progress_tracker_get_state (&transition->tracker);
 
   if (state == GTK_PROGRESS_STATE_BEFORE)
-    value = gtk_css_value_ref (transition->start);
+    value = _gtk_css_value_ref (transition->start);
   else if (state == GTK_PROGRESS_STATE_DURING)
     {
       progress = gtk_progress_tracker_get_progress (&transition->tracker, FALSE);
       progress = _gtk_css_ease_value_transform (transition->ease, progress);
 
-      value = gtk_css_value_transition (transition->start,
-                                        end,
-                                        transition->property,
-                                        progress);
+      value = _gtk_css_value_transition (transition->start,
+                                         end,
+                                         transition->property,
+                                         progress);
     }
   else
     return;
 
   if (value == NULL)
-    value = gtk_css_value_ref (end);
+    value = _gtk_css_value_ref (end);
 
   gtk_css_animated_style_set_animated_value (style, transition->property, value);
 }
@@ -124,8 +124,8 @@ gtk_css_transition_advance (GtkStyleAnimation    *style_animation,
   transition->parent.ref_count = 1;
 
   transition->property = source->property;
-  transition->start = gtk_css_value_ref (source->start);
-  transition->ease = gtk_css_value_ref (source->ease);
+  transition->start = _gtk_css_value_ref (source->start);
+  transition->ease = _gtk_css_value_ref (source->ease);
 
   gtk_progress_tracker_init_copy (&source->tracker, &transition->tracker);
   gtk_progress_tracker_advance_frame (&transition->tracker, timestamp);
@@ -151,8 +151,8 @@ _gtk_css_transition_new (guint        property,
   transition->parent.ref_count = 1;
 
   transition->property = property;
-  transition->start = gtk_css_value_ref (start);
-  transition->ease = gtk_css_value_ref (ease);
+  transition->start = _gtk_css_value_ref (start);
+  transition->ease = _gtk_css_value_ref (ease);
   gtk_progress_tracker_start (&transition->tracker, duration_us, delay_us, 1.0);
   gtk_progress_tracker_advance_frame (&transition->tracker, timestamp);
   transition->finished = gtk_progress_tracker_get_state (&transition->tracker) == GTK_PROGRESS_STATE_AFTER;

gtk/gtkcssunsetvalue.c

@@ -49,7 +49,7 @@ gtk_css_value_unset_compute (GtkCssValue          *value,
   else
     unset_value = _gtk_css_initial_value_get ();
 
-  return gtk_css_value_compute (unset_value, property_id, context);
+  return _gtk_css_value_compute (unset_value, property_id, context);
 }
 
 static gboolean
@@ -91,5 +91,5 @@ static GtkCssValue unset = { &GTK_CSS_VALUE_UNSET, 1 };
 GtkCssValue *
 _gtk_css_unset_value_new (void)
 {
-  return gtk_css_value_ref (&unset);
+  return _gtk_css_value_ref (&unset);
 }

gtk/gtkcssvalue.c

@@ -27,7 +27,7 @@ struct _GtkCssValue {
   GTK_CSS_VALUE_BASE
 };
 
-G_DEFINE_BOXED_TYPE (GtkCssValue, gtk_css_value, gtk_css_value_ref, gtk_css_value_unref)
+G_DEFINE_BOXED_TYPE (GtkCssValue, _gtk_css_value, _gtk_css_value_ref, _gtk_css_value_unref)
 
 #undef CSS_VALUE_ACCOUNTING
 
@@ -137,8 +137,8 @@ get_accounting_data (const char *class)
 #endif
 
 GtkCssValue *
-gtk_css_value_alloc (const GtkCssValueClass *klass,
-                     gsize                   size)
+_gtk_css_value_alloc (const GtkCssValueClass *klass,
+                      gsize                   size)
 {
   GtkCssValue *value;
 
@@ -161,7 +161,7 @@ gtk_css_value_alloc (const GtkCssValueClass *klass,
 }
 
 GtkCssValue *
-(gtk_css_value_ref) (GtkCssValue *value)
+gtk_css_value_ref (GtkCssValue *value)
 {
   gtk_internal_return_val_if_fail (value != NULL, NULL);
 
@@ -171,7 +171,7 @@ GtkCssValue *
 }
 
 void
-(gtk_css_value_unref) (GtkCssValue *value)
+gtk_css_value_unref (GtkCssValue *value)
 {
   if (value == NULL)
     return;
@@ -193,7 +193,7 @@ void
 }
 
 /**
- * gtk_css_value_compute:
+ * _gtk_css_value_compute:
  * @value: the value to compute from
  * @property_id: the ID of the property to compute
  * @provider: Style provider for looking up extra information
@@ -210,12 +210,12 @@ void
  * Returns: the computed value
  **/
 GtkCssValue *
-gtk_css_value_compute (GtkCssValue          *value,
-                       guint                 property_id,
-                       GtkCssComputeContext *context)
+_gtk_css_value_compute (GtkCssValue          *value,
+                        guint                 property_id,
+                        GtkCssComputeContext *context)
 {
   if (gtk_css_value_is_computed (value))
-    return gtk_css_value_ref (value);
+    return _gtk_css_value_ref (value);
 
 #ifdef CSS_VALUE_ACCOUNTING
   get_accounting_data (value->class->type_name)->computed++;
@@ -225,8 +225,8 @@ gtk_css_value_compute (GtkCssValue          *value,
 }
 
 gboolean
-gtk_css_value_equal (const GtkCssValue *value1,
-                     const GtkCssValue *value2)
+_gtk_css_value_equal (const GtkCssValue *value1,
+                      const GtkCssValue *value2)
 {
   gtk_internal_return_val_if_fail (value1 != NULL, FALSE);
   gtk_internal_return_val_if_fail (value2 != NULL, FALSE);
@@ -241,8 +241,8 @@ gtk_css_value_equal (const GtkCssValue *value1,
 }
 
 gboolean
-gtk_css_value_equal0 (const GtkCssValue *value1,
-                      const GtkCssValue *value2)
+_gtk_css_value_equal0 (const GtkCssValue *value1,
+                       const GtkCssValue *value2)
 {
   /* Includes both values being NULL */
   if (value1 == value2)
@@ -251,14 +251,14 @@ gtk_css_value_equal0 (const GtkCssValue *value1,
   if (value1 == NULL || value2 == NULL)
     return FALSE;
 
-  return gtk_css_value_equal (value1, value2);
+  return _gtk_css_value_equal (value1, value2);
 }
 
 GtkCssValue *
-gtk_css_value_transition (GtkCssValue *start,
-                          GtkCssValue *end,
-                          guint        property_id,
-                          double       progress)
+_gtk_css_value_transition (GtkCssValue *start,
+                           GtkCssValue *end,
+                           guint        property_id,
+                           double       progress)
 {
   gtk_internal_return_val_if_fail (start != NULL, NULL);
   gtk_internal_return_val_if_fail (end != NULL, NULL);
@@ -267,13 +267,13 @@ gtk_css_value_transition (GtkCssValue *start,
     return NULL;
 
   if (progress == 0)
-    return gtk_css_value_ref (start);
+    return _gtk_css_value_ref (start);
 
   if (progress == 1)
-    return gtk_css_value_ref (end);
+    return _gtk_css_value_ref (end);
 
   if (start == end)
-    return gtk_css_value_ref (start);
+    return _gtk_css_value_ref (start);
 
 #ifdef CSS_VALUE_ACCOUNTING
   get_accounting_data (start->class->type_name)->transitioned++;
@@ -283,19 +283,19 @@ gtk_css_value_transition (GtkCssValue *start,
 }
 
 char *
-gtk_css_value_to_string (const GtkCssValue *value)
+_gtk_css_value_to_string (const GtkCssValue *value)
 {
   GString *string;
 
   gtk_internal_return_val_if_fail (value != NULL, NULL);
 
   string = g_string_new (NULL);
-  gtk_css_value_print (value, string);
+  _gtk_css_value_print (value, string);
   return g_string_free (string, FALSE);
 }
 
 /**
- * gtk_css_value_print:
+ * _gtk_css_value_print:
  * @value: the value to print
  * @string: the string to print to
  *
@@ -304,8 +304,8 @@ gtk_css_value_to_string (const GtkCssValue *value)
  * via _gtk_style_property_assign().
  **/
 void
-gtk_css_value_print (const GtkCssValue *value,
-                     GString           *string)
+_gtk_css_value_print (const GtkCssValue *value,
+                      GString           *string)
 {
   gtk_internal_return_if_fail (value != NULL);
   gtk_internal_return_if_fail (string != NULL);
@@ -361,3 +361,15 @@ gtk_css_value_get_dynamic_value (GtkCssValue *value,
 
   return value->class->get_dynamic_value (value, monotonic_time);
 }
+
+gboolean
+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

@@ -27,7 +27,7 @@
 
 G_BEGIN_DECLS
 
-#define GTK_TYPE_CSS_VALUE           (gtk_css_value_get_type ())
+#define GTK_TYPE_CSS_VALUE           (_gtk_css_value_get_type ())
 
 /* A GtkCssValue is a refcounted immutable value type */
 
@@ -39,8 +39,7 @@ typedef struct _GtkCssValueClass      GtkCssValueClass;
   const GtkCssValueClass *class; \
   int ref_count; \
   guint is_computed: 1; \
-  guint contains_variables: 1; \
-  guint contains_current_color: 1;
+  guint contains_variables: 1;
 
 typedef struct {
   GtkStyleProvider   *provider;
@@ -70,86 +69,37 @@ struct _GtkCssValueClass {
                                                        GString                    *string);
 };
 
-GType         gtk_css_value_get_type                  (void) G_GNUC_CONST;
+GType        _gtk_css_value_get_type                  (void) G_GNUC_CONST;
 
-GtkCssValue * gtk_css_value_alloc                     (const GtkCssValueClass     *klass,
+GtkCssValue *_gtk_css_value_alloc                     (const GtkCssValueClass     *klass,
                                                        gsize                       size);
-#define gtk_css_value_new(name, klass) ((name *) gtk_css_value_alloc ((klass), sizeof (name)))
+#define _gtk_css_value_new(_name, _klass) ((_name *) _gtk_css_value_alloc ((_klass), sizeof (_name)))
 
-GtkCssValue * (gtk_css_value_ref)                     (GtkCssValue                *value);
-void          (gtk_css_value_unref)                   (GtkCssValue                *value);
+#define _gtk_css_value_ref gtk_css_value_ref
+GtkCssValue *   gtk_css_value_ref                     (GtkCssValue                *value);
+#define _gtk_css_value_unref gtk_css_value_unref
+void            gtk_css_value_unref                   (GtkCssValue                *value);
 
-GtkCssValue * gtk_css_value_compute                   (GtkCssValue                *value,
+GtkCssValue *_gtk_css_value_compute                   (GtkCssValue                *value,
                                                        guint                       property_id,
                                                        GtkCssComputeContext       *context) G_GNUC_PURE;
-gboolean      gtk_css_value_equal                     (const GtkCssValue          *value1,
+gboolean     _gtk_css_value_equal                     (const GtkCssValue          *value1,
                                                        const GtkCssValue          *value2) G_GNUC_PURE;
-gboolean      gtk_css_value_equal0                    (const GtkCssValue          *value1,
+gboolean     _gtk_css_value_equal0                    (const GtkCssValue          *value1,
                                                        const GtkCssValue          *value2) G_GNUC_PURE;
-GtkCssValue * gtk_css_value_transition                (GtkCssValue                *start,
+GtkCssValue *_gtk_css_value_transition                (GtkCssValue                *start,
                                                        GtkCssValue                *end,
                                                        guint                       property_id,
                                                        double                      progress);
-gboolean       gtk_css_value_is_dynamic               (const GtkCssValue          *value) G_GNUC_PURE;
-GtkCssValue *  gtk_css_value_get_dynamic_value        (GtkCssValue                *value,
+gboolean        gtk_css_value_is_dynamic              (const GtkCssValue          *value) G_GNUC_PURE;
+GtkCssValue *   gtk_css_value_get_dynamic_value       (GtkCssValue                *value,
                                                        gint64                      monotonic_time);
 
-char *         gtk_css_value_to_string                (const GtkCssValue          *value);
-void           gtk_css_value_print                    (const GtkCssValue          *value,
+char *       _gtk_css_value_to_string                 (const GtkCssValue          *value);
+void         _gtk_css_value_print                     (const GtkCssValue          *value,
                                                        GString                    *string);
-
-typedef struct { GTK_CSS_VALUE_BASE } GtkCssValueBase;
-
-static inline GtkCssValue *
-gtk_css_value_ref_inline (GtkCssValue *value)
-{
-  GtkCssValueBase *value_base = (GtkCssValueBase *) value;
-
-  value_base->ref_count += 1;
-
-  return value;
-}
-
-static inline void
-gtk_css_value_unref_inline (GtkCssValue *value)
-{
-  GtkCssValueBase *value_base = (GtkCssValueBase *) value;
-
-  if (value_base && value_base->ref_count > 1)
-    {
-      value_base->ref_count -= 1;
-      return;
-    }
-
-  (gtk_css_value_unref) (value);
-}
-
-#define gtk_css_value_ref(value) gtk_css_value_ref_inline (value)
-#define gtk_css_value_unref(value) gtk_css_value_unref_inline (value)
-
-static inline gboolean
-gtk_css_value_is_computed (const GtkCssValue *value)
-{
-  GtkCssValueBase *value_base = (GtkCssValueBase *) value;
-
-  return value_base->is_computed;
-}
-
-static inline gboolean
-gtk_css_value_contains_variables (const GtkCssValue *value)
-{
-  GtkCssValueBase *value_base = (GtkCssValueBase *) value;
-
-  return value_base->contains_variables;
-}
-
-static inline gboolean
-gtk_css_value_contains_current_color (const GtkCssValue *value)
-{
-  GtkCssValueBase *value_base = (GtkCssValueBase *) value;
-
-  return value_base->contains_current_color;
-}
+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

@@ -148,65 +148,4 @@ static const int other_props[] = {
   GTK_CSS_PROPERTY_FILTER,
 };
 
-static const int used_props[] = {
-  GTK_CSS_PROPERTY_COLOR,
-  GTK_CSS_PROPERTY_ICON_PALETTE,
-  GTK_CSS_PROPERTY_BACKGROUND_COLOR,
-  GTK_CSS_PROPERTY_BOX_SHADOW,
-  GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
-  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_ICON_SHADOW,
-  GTK_CSS_PROPERTY_OUTLINE_COLOR,
-  GTK_CSS_PROPERTY_CARET_COLOR,
-  GTK_CSS_PROPERTY_SECONDARY_CARET_COLOR,
-  GTK_CSS_PROPERTY_TEXT_SHADOW,
-  GTK_CSS_PROPERTY_TEXT_DECORATION_COLOR,
-  GTK_CSS_PROPERTY_ICON_SOURCE,
-};
-
-/* Maps back from css property ids to position in used_props.
- * -1 means 'not present'.
- */
-static const int used_props_map[] = {
-  0, /* color */
-  -1, -1,
-  1, /* icon-palette */
-  2, /* background-color */
-  -1, -1, -1, -1, -1, -1,
-  15, /* text-decoration-color */
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1,
-  14, /* text-shadow */
-  3, /* box-shadow */
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1,
-  5, /* border-top-color */
-  6, /* border-right-color */
-  7, /* border-bottom-color */
-  8, /* border-left-color */
-  11, /* outline-color */
-  -1,
-  4, /* background-image */
-  -1,
-  9, /* border-image-source */
-  -1, -1, -1,
-  16, /* icon-source */
-  -1,
-  10, /* icon-shadow */
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1,
-  12, /* caret-color */
-  13, /* secondary-caret-color */
-  -1, -1, -1,
-};
-
-G_STATIC_ASSERT (G_N_ELEMENTS (used_props_map) == GTK_CSS_PROPERTY_N_PROPERTIES);
-
 G_END_DECLS

gtk/gtkdebug.h

@@ -96,7 +96,6 @@ typedef enum {
   GTK_DEBUG_A11Y            = 1 << 17,
   GTK_DEBUG_ICONFALLBACK    = 1 << 18,
   GTK_DEBUG_INVERT_TEXT_DIR = 1 << 19,
-  GTK_DEBUG_CSS             = 1 << 20,
 } GtkDebugFlags;
 
 #define GTK_DEBUG_CHECK(type) G_UNLIKELY (gtk_get_debug_flags () & GTK_DEBUG_##type)

gtk/gtkflowbox.c

@@ -2609,8 +2609,8 @@ G_GNUC_END_IGNORE_DEPRECATIONS
           cairo_append_path (cr, path);
           cairo_path_destroy (path);
 
-          border_color = gtk_css_color_value_get_rgba (style->used->border_top_color);
-          border_width = round (gtk_css_number_value_get (style->border->border_left_width, 100));
+          border_color = gtk_css_color_value_get_rgba (style->border->border_top_color ? style->border->border_top_color : style->core->color);
+          border_width = round (_gtk_css_number_value_get (style->border->border_left_width, 100));
 
           cairo_set_line_width (cr, border_width);
           gdk_cairo_set_source_rgba (cr, border_color);

gtk/gtkfontchooserwidget.c

@@ -23,7 +23,6 @@
 
 #include "deprecated/gtkfontchooserwidget.h"
 #include "gtkfontchooserwidgetprivate.h"
-#include "gtkfontfilterprivate.h"
 
 #include "gtkadjustment.h"
 #include "gtkbuildable.h"
@@ -109,10 +108,10 @@ struct _GtkFontChooserWidget
   GtkWidget    *family_face_list;
   GtkWidget    *list_stack;
   GtkSingleSelection *selection;
-  GtkCustomFilter    *custom_filter;
-  GtkFontFilter      *user_filter;
-  GtkCustomFilter    *multi_filter;
-  GtkFilterListModel *filter_model;
+  GtkCustomFilter      *custom_filter;
+  GtkCustomFilter      *user_filter;
+  GtkCustomFilter      *multi_filter;
+  GtkFilterListModel   *filter_model;
 
   GtkWidget       *preview;
   GtkWidget       *preview2;
@@ -131,12 +130,16 @@ struct _GtkFontChooserWidget
   GtkWidget       *axis_grid;
   GtkWidget       *feature_box;
 
-  GtkCheckButton    *language_button;
+  GtkFrame          *language_button;
   GtkFrame          *language_frame;
   GtkWidget         *language_list;
   GtkStringList     *languages;
   GHashTable        *language_table;
 
+  PangoLanguage     *filter_language;
+  gboolean           filter_by_language;
+  gboolean           filter_by_monospace;
+
   PangoFontMap         *font_map;
 
   PangoFontDescription *font_desc;
@@ -345,29 +348,77 @@ output_cb (GtkSpinButton *spin,
   return TRUE;
 }
 
-static void
-update_filter_language (GtkFontChooserWidget *self)
+static gboolean
+user_filter_cb (gpointer item,
+                gpointer data)
 {
-  gboolean should_filter_language;
+  GtkFontChooserWidget *self = GTK_FONT_CHOOSER_WIDGET (data);
+  PangoFontFamily *family;
+  PangoFontFace *face;
 
-  should_filter_language = gtk_check_button_get_active (self->language_button);
-  if (!should_filter_language)
+  if (PANGO_IS_FONT_FAMILY (item))
     {
-      _gtk_font_filter_set_language (self->user_filter, NULL);
+      family = item;
+      face = pango_font_family_get_face (family, NULL);
     }
   else
     {
-      GtkSelectionModel *model;
-      gpointer obj;
-      PangoLanguage *language = NULL;
-
-      model = gtk_list_view_get_model (GTK_LIST_VIEW (self->language_list));
-      obj = gtk_single_selection_get_selected_item (GTK_SINGLE_SELECTION (model));
-      if (obj)
-        language = pango_language_from_string (gtk_string_object_get_string (obj));
-
-      _gtk_font_filter_set_language (self->user_filter, language);
+      face = PANGO_FONT_FACE (item);
+      family = pango_font_face_get_family (face);
     }
+
+  if (self->filter_by_monospace &&
+      !pango_font_family_is_monospace (family))
+    return FALSE;
+
+  if (self->filter_by_language &&
+      self->filter_language)
+    {
+      PangoFontDescription *desc;
+      PangoContext *context;
+      PangoFont *font;
+      gboolean ret;
+      PangoLanguage **langs;
+
+      desc = pango_font_face_describe (face);
+      pango_font_description_set_size (desc, 20);
+
+      context = gtk_widget_get_pango_context (GTK_WIDGET (self));
+      font = pango_context_load_font (context, desc);
+
+      ret = FALSE;
+
+      langs = pango_font_get_languages (font);
+      if (langs)
+        {
+          for (int i = 0; langs[i]; i++)
+            {
+              if (langs[i] == self->filter_language)
+                {
+                  ret = TRUE;
+                  break;
+                }
+            }
+        }
+
+      g_object_unref (font);
+      pango_font_description_free (desc);
+
+      return ret;
+    }
+
+  return TRUE;
+}
+
+static void
+monospace_check_changed (GtkCheckButton       *check,
+                         GParamSpec           *pspec,
+                         GtkFontChooserWidget *self)
+{
+  self->filter_by_monospace = gtk_check_button_get_active (check);
+  gtk_filter_changed (GTK_FILTER (self->user_filter),
+                      self->filter_by_monospace ? GTK_FILTER_CHANGE_MORE_STRICT
+                                                : GTK_FILTER_CHANGE_LESS_STRICT);
 }
 
 static void
@@ -375,7 +426,10 @@ language_check_changed (GtkCheckButton       *check,
                         GParamSpec           *pspec,
                         GtkFontChooserWidget *self)
 {
-  update_filter_language (self);
+  self->filter_by_language = gtk_check_button_get_active (check);
+  gtk_filter_changed (GTK_FILTER (self->user_filter),
+                      self->filter_by_language ? GTK_FILTER_CHANGE_MORE_STRICT
+                                               : GTK_FILTER_CHANGE_LESS_STRICT);
 }
 
 static void
@@ -497,7 +551,6 @@ maybe_update_preview_text (GtkFontChooserWidget *self,
 {
   PangoContext *context;
   PangoFont *font;
-  PangoLanguage *filter_lang;
   const char *sample;
   PangoLanguage **languages;
   GHashTable *langs = NULL;
@@ -511,10 +564,9 @@ maybe_update_preview_text (GtkFontChooserWidget *self,
   if (self->preview_text_set)
     return;
 
-  filter_lang = _gtk_font_filter_get_language (self->user_filter);
-  if (filter_lang != NULL)
+  if (self->filter_by_language && self->filter_language)
     {
-      sample = pango_language_get_sample_string (filter_lang);
+      sample = pango_language_get_sample_string (self->filter_language);
       gtk_font_chooser_widget_set_preview_text (self, sample);
       return;
     }
@@ -788,23 +840,15 @@ gtk_font_chooser_widget_unmap (GtkWidget *widget)
 static void
 gtk_font_chooser_widget_root (GtkWidget *widget)
 {
-  GtkFontChooserWidget *self = GTK_FONT_CHOOSER_WIDGET (widget);
-
   GTK_WIDGET_CLASS (gtk_font_chooser_widget_parent_class)->root (widget);
 
   g_signal_connect_swapped (gtk_widget_get_root (widget), "notify::focus-widget",
                             G_CALLBACK (update_key_capture), widget);
-  _gtk_font_filter_set_pango_context (self->user_filter,
-                                      gtk_widget_get_pango_context (widget));
 }
 
 static void
 gtk_font_chooser_widget_unroot (GtkWidget *widget)
 {
-  GtkFontChooserWidget *self = GTK_FONT_CHOOSER_WIDGET (widget);
-
-  _gtk_font_filter_set_pango_context (self->user_filter,
-                                      gtk_widget_get_pango_context (widget));
   g_signal_handlers_disconnect_by_func (gtk_widget_get_root (widget),
                                         update_key_capture, widget);
 
@@ -836,7 +880,6 @@ gtk_font_chooser_widget_class_init (GtkFontChooserWidgetClass *klass)
   GParamSpec *pspec;
 
   g_type_ensure (G_TYPE_THEMED_ICON);
-  g_type_ensure (GTK_TYPE_FONT_FILTER);
 
   widget_class->root = gtk_font_chooser_widget_root;
   widget_class->unroot = gtk_font_chooser_widget_unroot;
@@ -902,6 +945,7 @@ gtk_font_chooser_widget_class_init (GtkFontChooserWidgetClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, output_cb);
   gtk_widget_class_bind_template_callback (widget_class, selection_changed_cb);
   gtk_widget_class_bind_template_callback (widget_class, resize_by_scroll_cb);
+  gtk_widget_class_bind_template_callback (widget_class, monospace_check_changed);
   gtk_widget_class_bind_template_callback (widget_class, language_check_changed);
 
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
@@ -1168,7 +1212,17 @@ language_selection_changed (GtkSelectionModel    *model,
                             guint                 n_items,
                             GtkFontChooserWidget *self)
 {
-  update_filter_language (self);
+  gpointer obj;
+
+  obj = gtk_single_selection_get_selected_item (GTK_SINGLE_SELECTION (model));
+
+  if (obj)
+    self->filter_language = pango_language_from_string (gtk_string_object_get_string (obj));
+  else
+    self->filter_language = NULL;
+
+  if (self->filter_by_language)
+    gtk_filter_changed (GTK_FILTER (self->user_filter), GTK_FILTER_CHANGE_DIFFERENT);
 }
 
 static gboolean
@@ -1239,6 +1293,8 @@ gtk_font_chooser_widget_init (GtkFontChooserWidget *self)
 
   gtk_font_chooser_widget_take_font_desc (self, NULL);
 
+  gtk_custom_filter_set_filter_func (self->user_filter, user_filter_cb, self, NULL);
+
   setup_language_list (self);
 }
 

gtk/gtkfontfilter.c

@@ -1,272 +0,0 @@
-/* GTK - The GIMP Toolkit
- * gtkfontfilter.c:
- * Copyright (C) 2024 Niels De Graef <nielsdegraef@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 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/>.
- */
-
-#include "config.h"
-
-#include <stdlib.h>
-#include <glib/gprintf.h>
-#include <string.h>
-
-#include "gtkfontfilterprivate.h"
-#include "gtkprivate.h"
-
-struct _GtkFontFilter
-{
-  GtkFilter parent_instance;
-
-  PangoContext *pango_context;
-
-  gboolean monospace;
-  PangoLanguage *language;
-};
-
-enum {
-  PROP_0,
-  PROP_PANGO_CONTEXT,
-  PROP_MONOSPACE,
-  PROP_LANGUAGE,
-  N_PROPS
-};
-static GParamSpec *properties[N_PROPS] = { NULL, };
-
-G_DEFINE_TYPE (GtkFontFilter, gtk_font_filter, GTK_TYPE_FILTER)
-
-static void
-gtk_font_filter_set_property (GObject         *object,
-                              guint            prop_id,
-                              const GValue    *value,
-                              GParamSpec      *pspec)
-{
-  GtkFontFilter *self = GTK_FONT_FILTER (object);
-
-  switch (prop_id)
-    {
-    case PROP_PANGO_CONTEXT:
-      _gtk_font_filter_set_pango_context (self, g_value_get_object (value));
-      break;
-    case PROP_MONOSPACE:
-      _gtk_font_filter_set_monospace (self, g_value_get_boolean (value));
-      break;
-    case PROP_LANGUAGE:
-      _gtk_font_filter_set_language (self, g_value_get_boxed (value));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-gtk_font_filter_get_property (GObject         *object,
-                              guint            prop_id,
-                              GValue          *value,
-                              GParamSpec      *pspec)
-{
-  GtkFontFilter *self = GTK_FONT_FILTER (object);
-
-  switch (prop_id)
-    {
-    case PROP_PANGO_CONTEXT:
-      g_value_set_object (value, self->pango_context);
-      break;
-    case PROP_MONOSPACE:
-      g_value_set_boolean (value, _gtk_font_filter_get_monospace (self));
-      break;
-    case PROP_LANGUAGE:
-      g_value_set_boxed (value, _gtk_font_filter_get_language (self));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static gboolean
-gtk_font_filter_match (GtkFilter *filter,
-                       gpointer   item)
-{
-  GtkFontFilter *self = GTK_FONT_FILTER (filter);
-  PangoFontFamily *family;
-  PangoFontFace *face;
-
-  if (PANGO_IS_FONT_FAMILY (item))
-    {
-      family = item;
-      face = pango_font_family_get_face (family, NULL);
-    }
-  else
-    {
-      face = PANGO_FONT_FACE (item);
-      family = pango_font_face_get_family (face);
-    }
-
-  if (self->monospace &&
-      !pango_font_family_is_monospace (family))
-    return FALSE;
-
-  if (self->language)
-    {
-      PangoFontDescription *desc;
-      PangoFont *font;
-      PangoLanguage **langs;
-      gboolean ret = FALSE;
-
-      desc = pango_font_face_describe (face);
-      pango_font_description_set_size (desc, 20);
-
-      font = pango_context_load_font (self->pango_context, desc);
-
-      langs = pango_font_get_languages (font);
-      if (langs)
-        {
-          for (int i = 0; langs[i]; i++)
-            {
-              if (langs[i] == self->language)
-                {
-                  ret = TRUE;
-                  break;
-                }
-            }
-        }
-
-      g_object_unref (font);
-      pango_font_description_free (desc);
-
-      return ret;
-    }
-
-  return TRUE;
-}
-
-static GtkFilterMatch
-gtk_font_filter_get_strictness (GtkFilter *filter)
-{
-  GtkFontFilter *self = GTK_FONT_FILTER (filter);
-
-  if (!self->monospace && self->language == NULL)
-    return GTK_FILTER_MATCH_ALL;
-
-  return GTK_FILTER_MATCH_SOME;
-}
-
-static void
-gtk_font_filter_class_init (GtkFontFilterClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  GtkFilterClass *filter_class = GTK_FILTER_CLASS (klass);
-
-  filter_class->match = gtk_font_filter_match;
-  filter_class->get_strictness = gtk_font_filter_get_strictness;
-
-  gobject_class->set_property = gtk_font_filter_set_property;
-  gobject_class->get_property = gtk_font_filter_get_property;
-
-  properties[PROP_PANGO_CONTEXT] =
-    g_param_spec_object ("pango-context", NULL, NULL,
-                         PANGO_TYPE_CONTEXT,
-                         GTK_PARAM_READWRITE);
-  properties[PROP_MONOSPACE] =
-    g_param_spec_boolean ("monospace", NULL, NULL,
-                          FALSE,
-                          GTK_PARAM_READWRITE);
-  properties[PROP_LANGUAGE] =
-    g_param_spec_boxed ("language", NULL, NULL,
-                        PANGO_TYPE_LANGUAGE,
-                        GTK_PARAM_READWRITE);
-
-  g_object_class_install_properties (gobject_class, N_PROPS, properties);
-}
-
-static void
-gtk_font_filter_init (GtkFontFilter *self)
-{
-}
-
-void
-_gtk_font_filter_set_pango_context (GtkFontFilter *self,
-                                    PangoContext  *context)
-{
-  g_return_if_fail (GTK_IS_FONT_FILTER (self));
-  g_return_if_fail (PANGO_IS_CONTEXT (context));
-
-  if (self->pango_context == context)
-    return;
-
-  self->pango_context = context;
-  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PANGO_CONTEXT]);
-}
-
-gboolean
-_gtk_font_filter_get_monospace (GtkFontFilter *self)
-{
-  g_return_val_if_fail (GTK_IS_FONT_FILTER (self), FALSE);
-
-  return self->monospace;
-}
-
-void
-_gtk_font_filter_set_monospace (GtkFontFilter *self,
-                                gboolean       monospace)
-{
-  g_return_if_fail (GTK_IS_FONT_FILTER (self));
-
-  if (self->monospace == monospace)
-    return;
-
-  self->monospace = monospace;
-  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MONOSPACE]);
-  gtk_filter_changed (GTK_FILTER (self),
-                      monospace ? GTK_FILTER_CHANGE_MORE_STRICT
-                                : GTK_FILTER_CHANGE_LESS_STRICT);
-}
-
-PangoLanguage *
-_gtk_font_filter_get_language (GtkFontFilter *self)
-{
-  g_return_val_if_fail (GTK_IS_FONT_FILTER (self), NULL);
-
-  return self->language;
-}
-
-void
-_gtk_font_filter_set_language (GtkFontFilter *self,
-                               PangoLanguage *lang)
-{
-  GtkFilterChange filter_change = GTK_FILTER_CHANGE_DIFFERENT;
-
-  g_return_if_fail (GTK_IS_FONT_FILTER (self));
-
-  if (self->language == lang)
-    return;
-
-  if (lang == NULL || self->language == NULL)
-    {
-      filter_change = (lang != NULL) ? GTK_FILTER_CHANGE_MORE_STRICT
-                                     : GTK_FILTER_CHANGE_LESS_STRICT;
-    }
-
-  self->language = lang;
-  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LANGUAGE]);
-  gtk_filter_changed (GTK_FILTER (self), filter_change);
-}
-
-GtkFilter *
-_gtk_font_filter_new (void)
-{
-  return g_object_new (GTK_TYPE_FONT_FILTER, NULL);
-}

gtk/gtkfontfilterprivate.h

@@ -1,46 +0,0 @@
-/* GTK - The GIMP Toolkit
- * gtkfontfilterprivate.h:
- * Copyright (C) 2024 Niels De Graef <nielsdegraef@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <gtk/gtkfilter.h>
-
-G_BEGIN_DECLS
-
-#define GTK_TYPE_FONT_FILTER (gtk_font_filter_get_type ())
-G_DECLARE_FINAL_TYPE (GtkFontFilter, gtk_font_filter,
-                      GTK, FONT_FILTER,
-                      GtkFilter)
-
-GtkFilter *        _gtk_font_filter_new                    (void);
-
-void               _gtk_font_filter_set_pango_context      (GtkFontFilter *self,
-                                                            PangoContext  *context);
-
-gboolean           _gtk_font_filter_get_monospace          (GtkFontFilter *self);
-
-void               _gtk_font_filter_set_monospace          (GtkFontFilter *self,
-                                                            gboolean       monospace);
-
-PangoLanguage *    _gtk_font_filter_get_language           (GtkFontFilter *self);
-
-void               _gtk_font_filter_set_language           (GtkFontFilter *self,
-                                                            PangoLanguage *language);
-
-G_END_DECLS
-

gtk/gtkiconhelper.c

@@ -456,7 +456,7 @@ gtk_icon_helper_get_size (GtkIconHelper *self)
     return self->pixel_size;
 
   style = gtk_css_node_get_style (self->node);
-  return gtk_css_number_value_get (style->icon->icon_size, 100);
+  return _gtk_css_number_value_get (style->icon->icon_size, 100);
 }
 
 void

gtk/gtklabel.c

@@ -839,8 +839,7 @@ gtk_label_update_layout_attributes (GtkLabel      *self,
               g_slist_free (attributes);
             }
 
-          link_color = gtk_css_color_value_get_rgba (style->used->color);
-
+          link_color = gtk_css_color_value_get_rgba (style->core->color);
           attr = pango_attr_foreground_new (link_color->red * 65535,
                                             link_color->green * 65535,
                                             link_color->blue * 65535);

gtk/gtkmain.c

@@ -200,7 +200,6 @@ static const GdkDebugKey gtk_debug_keys[] = {
   { "accessibility", GTK_DEBUG_A11Y, "Information about accessibility state changes" },
   { "iconfallback", GTK_DEBUG_ICONFALLBACK, "Information about icon fallback" },
   { "invert-text-dir", GTK_DEBUG_INVERT_TEXT_DIR, "Invert the default text direction" },
-  { "css", GTK_DEBUG_CSS, "Information about deprecated CSS features" },
 };
 
 /* This checks to see if the process is running suid or sgid

gtk/gtknative.c

@@ -341,11 +341,15 @@ subtract_decoration_corners_from_region (cairo_region_t        *region,
 }
 
 static int
-get_translucent_border_edge (GtkCssValue *border_color,
-                             GtkCssValue *border_width)
+get_translucent_border_edge (const GtkCssValue *color,
+                             const GtkCssValue *border_color,
+                             const GtkCssValue *border_width)
 {
+  if (border_color == NULL)
+    border_color = color;
+
   if (!gdk_rgba_is_opaque (gtk_css_color_value_get_rgba (border_color)))
-    return round (gtk_css_number_value_get (border_width, 100));
+    return round (_gtk_css_number_value_get (border_width, 100));
 
   return 0;
 }
@@ -357,36 +361,29 @@ get_translucent_border_width (GtkWidget *widget,
   GtkCssNode *css_node = gtk_widget_get_css_node (widget);
   GtkCssStyle *style = gtk_css_node_get_style (css_node);
 
-  border->top = get_translucent_border_edge (style->used->border_top_color,
+  border->top = get_translucent_border_edge (style->core->color,
+                                             style->border->border_top_color,
                                              style->border->border_top_width);
-  border->bottom = get_translucent_border_edge (style->used->border_bottom_color,
+  border->bottom = get_translucent_border_edge (style->core->color,
+                                                style->border->border_bottom_color,
                                                 style->border->border_bottom_width);
-  border->left = get_translucent_border_edge (style->used->border_left_color,
+  border->left = get_translucent_border_edge (style->core->color,
+                                              style->border->border_left_color,
                                               style->border->border_left_width);
-  border->right = get_translucent_border_edge (style->used->border_right_color,
+  border->right = get_translucent_border_edge (style->core->color,
+                                               style->border->border_right_color,
                                                style->border->border_right_width);
 }
 
 static gboolean
 get_opaque_rect (GtkWidget             *widget,
+                 const GtkCssStyle     *style,
                  cairo_rectangle_int_t *rect)
 {
-  gboolean is_opaque;
+  gboolean is_opaque = gdk_rgba_is_opaque (gtk_css_color_value_get_rgba (style->background->background_color));
 
-  if (gtk_widget_get_opacity (widget) < 1)
+  if (is_opaque && gtk_widget_get_opacity (widget) < 1.0)
     is_opaque = FALSE;
-  else
-    {
-      GtkCssNode *node;
-      GtkCssStyle *style;
-      const GdkRGBA *color;
-
-      node = gtk_widget_get_css_node (widget);
-      style = gtk_css_node_get_style (node);
-
-      color = gtk_css_color_value_get_rgba (style->used->background_color);
-      is_opaque = gdk_rgba_is_opaque (color);
-    }
 
   if (is_opaque)
     {
@@ -432,6 +429,8 @@ gtk_native_update_opaque_region (GtkNative  *native,
 {
   cairo_rectangle_int_t rect;
   cairo_region_t *opaque_region = NULL;
+  const GtkCssStyle *style;
+  GtkCssNode *css_node;
   GdkSurface *surface;
   GtkBorder shadow;
 
@@ -445,14 +444,17 @@ gtk_native_update_opaque_region (GtkNative  *native,
       !_gtk_widget_get_realized (contents))
     return;
 
+  css_node = gtk_widget_get_css_node (contents);
+
   if (subtract_shadow)
     get_shadow_width (contents, &shadow, resize_handle_size);
   else
     shadow = (GtkBorder) {0, 0, 0, 0};
 
   surface = gtk_native_get_surface (native);
+  style = gtk_css_node_get_style (css_node);
 
-  if (get_opaque_rect (contents, &rect))
+  if (get_opaque_rect (contents, style, &rect))
     {
       double native_x, native_y;
 
@@ -474,12 +476,7 @@ gtk_native_update_opaque_region (GtkNative  *native,
       opaque_region = cairo_region_create_rectangle (&rect);
 
       if (subtract_decoration_corners)
-        {
-          GtkCssStyle *style;
-
-          style = gtk_css_node_get_style (gtk_widget_get_css_node (contents));
-          subtract_decoration_corners_from_region (opaque_region, &rect, style);
-        }
+        subtract_decoration_corners_from_region (opaque_region, &rect, style);
     }
 
   gdk_surface_set_opaque_region (surface, opaque_region);

gtk/gtkpicture.c

@@ -215,7 +215,7 @@ gtk_picture_measure (GtkWidget      *widget,
     }
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
-  default_size = gtk_css_number_value_get (style->icon->icon_size, 100);
+  default_size = _gtk_css_number_value_get (style->icon->icon_size, 100);
 
   if (self->can_shrink)
     {

gtk/gtkpopover.c

@@ -1246,9 +1246,9 @@ gtk_popover_get_gap_coords (GtkPopover *popover,
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (priv->contents_widget));
   border_radius = round (get_border_radius (widget));
-  border_top = gtk_css_number_value_get (style->border->border_top_width, 100);
-  border_right = gtk_css_number_value_get (style->border->border_right_width, 100);
-  border_bottom = gtk_css_number_value_get (style->border->border_bottom_width, 100);
+  border_top = _gtk_css_number_value_get (style->border->border_top_width, 100);
+  border_right = _gtk_css_number_value_get (style->border->border_right_width, 100);
+  border_bottom = _gtk_css_number_value_get (style->border->border_bottom_width, 100);
 
   gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
 
@@ -1327,10 +1327,10 @@ get_border (GtkCssNode *node,
 
   style = gtk_css_node_get_style (node);
 
-  border->top = gtk_css_number_value_get (style->border->border_top_width, 100);
-  border->right = gtk_css_number_value_get (style->border->border_right_width, 100);
-  border->bottom = gtk_css_number_value_get (style->border->border_bottom_width, 100);
-  border->left = gtk_css_number_value_get (style->border->border_left_width, 100);
+  border->top = _gtk_css_number_value_get (style->border->border_top_width, 100);
+  border->right = _gtk_css_number_value_get (style->border->border_right_width, 100);
+  border->bottom = _gtk_css_number_value_get (style->border->border_bottom_width, 100);
+  border->left = _gtk_css_number_value_get (style->border->border_left_width, 100);
 }
 
 static void
@@ -1627,7 +1627,7 @@ create_arrow_render_node (GtkPopover *popover)
     {
       const GdkRGBA *border_color;
 
-      border_color = gtk_css_color_value_get_rgba (style->used->border_left_color);
+      border_color = gtk_css_color_value_get_rgba (style->border->border_left_color ? style->border->border_left_color : style->core->color);
 
       gtk_popover_apply_tail_path (popover, cr);
       gdk_cairo_set_source_rgba (cr, border_color);

gtk/gtkrenderbackground.c

@@ -49,11 +49,10 @@ gtk_theming_background_snapshot_color (GtkCssBoxes       *boxes,
                                        const GdkRGBA     *bg_color,
                                        guint              n_bg_values)
 {
-  GtkCssStyle *style = boxes->style;
   const GskRoundedRect *box;
   GtkCssArea clip;
 
-  clip = _gtk_css_area_value_get (_gtk_css_array_value_get_nth (style->background->background_clip, n_bg_values - 1));
+  clip = _gtk_css_area_value_get (_gtk_css_array_value_get_nth (boxes->style->background->background_clip, n_bg_values - 1));
   box = gtk_css_boxes_get_box (boxes, clip);
 
   if (gsk_rounded_rect_is_rectilinear (box))
@@ -77,7 +76,7 @@ gtk_theming_background_snapshot_layer (GtkCssBoxes *bg,
                                        guint        idx,
                                        GtkSnapshot *snapshot)
 {
-  GtkCssStyle *style = bg->style;
+  GtkCssBackgroundValues *background = bg->style->background;
   GtkCssRepeatStyle hrepeat, vrepeat;
   const GtkCssValue *pos, *repeat;
   GtkCssImage *image;
@@ -86,17 +85,17 @@ gtk_theming_background_snapshot_layer (GtkCssBoxes *bg,
   double width, height;
   double x, y;
 
-  image = _gtk_css_image_value_get_image (_gtk_css_array_value_get_nth (style->used->background_image, idx));
+  image = _gtk_css_image_value_get_image (_gtk_css_array_value_get_nth (background->background_image, idx));
 
   if (image == NULL)
     return;
 
-  pos = _gtk_css_array_value_get_nth (style->background->background_position, idx);
-  repeat = _gtk_css_array_value_get_nth (style->background->background_repeat, idx);
+  pos = _gtk_css_array_value_get_nth (background->background_position, idx);
+  repeat = _gtk_css_array_value_get_nth (background->background_repeat, idx);
 
   origin = gtk_css_boxes_get_box (bg,
                                   _gtk_css_area_value_get (
-                                      _gtk_css_array_value_get_nth (style->background->background_origin, idx)));
+                                      _gtk_css_array_value_get_nth (background->background_origin, idx)));
 
   width = origin->bounds.size.width;
   height = origin->bounds.size.height;
@@ -106,9 +105,9 @@ gtk_theming_background_snapshot_layer (GtkCssBoxes *bg,
 
   clip = gtk_css_boxes_get_box (bg,
                                 _gtk_css_area_value_get (
-                                    _gtk_css_array_value_get_nth (style->background->background_clip, idx)));
+                                    _gtk_css_array_value_get_nth (background->background_clip, idx)));
 
-  _gtk_css_bg_size_value_compute_size (_gtk_css_array_value_get_nth (style->background->background_size, idx),
+  _gtk_css_bg_size_value_compute_size (_gtk_css_array_value_get_nth (background->background_size, idx),
                                        image,
                                        width,
                                        height,
@@ -246,7 +245,7 @@ void
 gtk_css_style_snapshot_background (GtkCssBoxes *boxes,
                                    GtkSnapshot *snapshot)
 {
-  GtkCssStyle *style = boxes->style;
+  const GtkCssBackgroundValues *background = boxes->style->background;
   GtkCssValue *background_image;
   const GdkRGBA *bg_color;
   const GtkCssValue *box_shadow;
@@ -256,12 +255,12 @@ gtk_css_style_snapshot_background (GtkCssBoxes *boxes,
   int idx;
   guint number_of_layers;
 
-  if (style->background->base.type == GTK_CSS_BACKGROUND_INITIAL_VALUES)
+  if (background->base.type == GTK_CSS_BACKGROUND_INITIAL_VALUES)
     return;
 
-  background_image = style->used->background_image;
-  bg_color = gtk_css_color_value_get_rgba (style->used->background_color);
-  box_shadow = style->used->box_shadow;
+  background_image = background->background_image;
+  bg_color = gtk_css_color_value_get_rgba (background->background_color);
+  box_shadow = background->box_shadow;
 
   has_bg_color = !gdk_rgba_is_clear (bg_color);
   has_bg_image = _gtk_css_image_value_get_image (_gtk_css_array_value_get_nth (background_image, 0)) != NULL;
@@ -282,7 +281,7 @@ gtk_css_style_snapshot_background (GtkCssBoxes *boxes,
 
   if (has_bg_image)
     {
-      GtkCssValue *blend_modes = style->background->background_blend_mode;
+      GtkCssValue *blend_modes = background->background_blend_mode;
       GskBlendMode *blend_mode_values = g_alloca (sizeof (GskBlendMode) * number_of_layers);
 
       for (idx = number_of_layers - 1; idx >= 0; idx--)

gtk/gtkrenderborder.c

@@ -83,13 +83,13 @@ gtk_border_image_compute_border_size (GtkBorderImageSliceSize  sizes[3],
   double start, end;
 
   if (gtk_css_number_value_get_dimension (start_border) == GTK_CSS_DIMENSION_NUMBER)
-    start = start_border_width * gtk_css_number_value_get (start_border, 100);
+    start = start_border_width * _gtk_css_number_value_get (start_border, 100);
   else
-    start = gtk_css_number_value_get (start_border, area_size);
+    start = _gtk_css_number_value_get (start_border, area_size);
   if (gtk_css_number_value_get_dimension (end_border) == GTK_CSS_DIMENSION_NUMBER)
-    end = end_border_width * gtk_css_number_value_get (end_border, 100);
+    end = end_border_width * _gtk_css_number_value_get (end_border, 100);
   else
-    end = gtk_css_number_value_get (end_border, area_size);
+    end = _gtk_css_number_value_get (end_border, area_size);
 
   /* XXX: reduce vertical and horizontal by the same factor */
   if (start + end > area_size)
@@ -271,12 +271,12 @@ gtk_border_image_render (GtkBorderImage        *image,
 
   gtk_border_image_compute_slice_size (horizontal_slice,
                                        source_width, 
-                                       gtk_css_number_value_get (_gtk_css_border_value_get_left (image->slice), source_width),
-                                       gtk_css_number_value_get (_gtk_css_border_value_get_right (image->slice), source_width));
+                                       _gtk_css_number_value_get (_gtk_css_border_value_get_left (image->slice), source_width),
+                                       _gtk_css_number_value_get (_gtk_css_border_value_get_right (image->slice), source_width));
   gtk_border_image_compute_slice_size (vertical_slice,
                                        source_height, 
-                                       gtk_css_number_value_get (_gtk_css_border_value_get_top (image->slice), source_height),
-                                       gtk_css_number_value_get (_gtk_css_border_value_get_bottom (image->slice), source_height));
+                                       _gtk_css_number_value_get (_gtk_css_border_value_get_top (image->slice), source_height),
+                                       _gtk_css_number_value_get (_gtk_css_border_value_get_bottom (image->slice), source_height));
   gtk_border_image_compute_border_size (horizontal_border,
                                         rect->origin.x,
                                         rect->size.width,
@@ -569,7 +569,7 @@ snapshot_border (GtkSnapshot          *snapshot,
                 else
                   dont_draw |= (1 << j);
               }
-
+            
             snapshot_frame_stroke (snapshot, border_box, border_width, colors, dont_draw, border_style[i]);
           }
           break;
@@ -647,22 +647,22 @@ void
 gtk_css_style_snapshot_border (GtkCssBoxes *boxes,
                                GtkSnapshot *snapshot)
 {
-  GtkCssStyle *style = boxes->style;
+  const GtkCssBorderValues *border = boxes->style->border;
   GtkBorderImage border_image;
   float border_width[4];
 
-  if (style->border->base.type == GTK_CSS_BORDER_INITIAL_VALUES)
+  if (border->base.type == GTK_CSS_BORDER_INITIAL_VALUES)
     return;
 
-  if (gtk_border_image_init (&border_image, style))
+  if (gtk_border_image_init (&border_image, boxes->style))
     {
       cairo_t *cr;
       const graphene_rect_t *bounds;
 
-      border_width[0] = gtk_css_number_value_get (style->border->border_top_width, 100);
-      border_width[1] = gtk_css_number_value_get (style->border->border_right_width, 100);
-      border_width[2] = gtk_css_number_value_get (style->border->border_bottom_width, 100);
-      border_width[3] = gtk_css_number_value_get (style->border->border_left_width, 100);
+      border_width[0] = _gtk_css_number_value_get (border->border_top_width, 100);
+      border_width[1] = _gtk_css_number_value_get (border->border_right_width, 100);
+      border_width[2] = _gtk_css_number_value_get (border->border_bottom_width, 100);
+      border_width[3] = _gtk_css_number_value_get (border->border_left_width, 100);
 
       bounds = gtk_css_boxes_get_border_rect (boxes);
 
@@ -683,24 +683,24 @@ gtk_css_style_snapshot_border (GtkCssBoxes *boxes,
                           gtk_css_boxes_get_padding_rect (boxes)))
         return;
 
-      colors[0] = *gtk_css_color_value_get_rgba (style->used->border_top_color);
-      colors[1] = *gtk_css_color_value_get_rgba (style->used->border_right_color);
-      colors[2] = *gtk_css_color_value_get_rgba (style->used->border_bottom_color);
-      colors[3] = *gtk_css_color_value_get_rgba (style->used->border_left_color);
+      colors[0] = *gtk_css_color_value_get_rgba (border->border_top_color ? border->border_top_color : boxes->style->core->color);
+      colors[1] = *gtk_css_color_value_get_rgba (border->border_right_color ? border->border_right_color : boxes->style->core->color);
+      colors[2] = *gtk_css_color_value_get_rgba (border->border_bottom_color ? border->border_bottom_color : boxes->style->core->color);
+      colors[3] = *gtk_css_color_value_get_rgba (border->border_left_color ? border->border_left_color : boxes->style->core->color);
 
       alpha_test_vector = graphene_simd4f_init (colors[0].alpha, colors[1].alpha, colors[2].alpha, colors[3].alpha);
       if (graphene_simd4f_is_zero4 (alpha_test_vector))
         return;
 
-      border_style[0] = _gtk_css_border_style_value_get (style->border->border_top_style);
-      border_style[1] = _gtk_css_border_style_value_get (style->border->border_right_style);
-      border_style[2] = _gtk_css_border_style_value_get (style->border->border_bottom_style);
-      border_style[3] = _gtk_css_border_style_value_get (style->border->border_left_style);
+      border_style[0] = _gtk_css_border_style_value_get (border->border_top_style);
+      border_style[1] = _gtk_css_border_style_value_get (border->border_right_style);
+      border_style[2] = _gtk_css_border_style_value_get (border->border_bottom_style);
+      border_style[3] = _gtk_css_border_style_value_get (border->border_left_style);
 
-      border_width[0] = gtk_css_number_value_get (style->border->border_top_width, 100);
-      border_width[1] = gtk_css_number_value_get (style->border->border_right_width, 100);
-      border_width[2] = gtk_css_number_value_get (style->border->border_bottom_width, 100);
-      border_width[3] = gtk_css_number_value_get (style->border->border_left_width, 100);
+      border_width[0] = _gtk_css_number_value_get (border->border_top_width, 100);
+      border_width[1] = _gtk_css_number_value_get (border->border_right_width, 100);
+      border_width[2] = _gtk_css_number_value_get (border->border_bottom_width, 100);
+      border_width[3] = _gtk_css_number_value_get (border->border_left_width, 100);
 
       gtk_snapshot_push_debug (snapshot, "CSS border");
       if (border_style[0] <= GTK_BORDER_STYLE_SOLID &&
@@ -730,22 +730,21 @@ void
 gtk_css_style_snapshot_outline (GtkCssBoxes *boxes,
                                 GtkSnapshot *snapshot)
 {
-  GtkCssStyle *style = boxes->style;
+  GtkCssOutlineValues *outline = boxes->style->outline;
   GtkBorderStyle border_style[4];
   float border_width[4];
   GdkRGBA colors[4];
 
-  border_style[0] = _gtk_css_border_style_value_get (style->outline->outline_style);
+  border_style[0] = _gtk_css_border_style_value_get (outline->outline_style);
   if (border_style[0] != GTK_BORDER_STYLE_NONE)
     {
-      const GdkRGBA *color;
-
-      color = gtk_css_color_value_get_rgba (style->used->outline_color);
-
+      const GdkRGBA *color = gtk_css_color_value_get_rgba (outline->outline_color ?
+                                                           outline->outline_color :
+                                                           boxes->style->core->color);
       if (gdk_rgba_is_clear (color))
         return;
 
-      border_width[0] = gtk_css_number_value_get (style->outline->outline_width, 100);
+      border_width[0] = _gtk_css_number_value_get (outline->outline_width, 100);
 
       if (G_APPROX_VALUE (border_width[0], 0, FLT_EPSILON))
         return;

gtk/gtkrendericon.c

@@ -35,22 +35,22 @@
 #include <math.h>
 
 void
-gtk_css_style_snapshot_icon (GtkCssStyle *style,
-                             GtkSnapshot *snapshot,
-                             double       width,
-                             double       height)
+gtk_css_style_snapshot_icon (GtkCssStyle            *style,
+                             GtkSnapshot            *snapshot,
+                             double                  width,
+                             double                  height)
 {
   GskTransform *transform;
   GtkCssImage *image;
   gboolean has_shadow;
 
-  g_return_if_fail (style != NULL);
+  g_return_if_fail (GTK_IS_CSS_STYLE (style));
   g_return_if_fail (snapshot != NULL);
 
   if (width == 0.0 || height == 0.0)
     return;
 
-  image = _gtk_css_image_value_get_image (style->used->icon_source);
+  image = _gtk_css_image_value_get_image (style->other->icon_source);
   if (image == NULL)
     return;
 
@@ -60,7 +60,7 @@ gtk_css_style_snapshot_icon (GtkCssStyle *style,
 
   gtk_css_filter_value_push_snapshot (style->other->icon_filter, snapshot);
 
-  has_shadow = gtk_css_shadow_value_push_snapshot (style->used->icon_shadow, snapshot);
+  has_shadow = gtk_css_shadow_value_push_snapshot (style->icon->icon_shadow, snapshot);
 
   if (transform == NULL)
     {
@@ -102,7 +102,7 @@ gtk_css_style_snapshot_icon_paintable (GtkCssStyle  *style,
   gboolean is_symbolic_paintable;
   GdkRGBA colors[4];
 
-  g_return_if_fail (style != NULL);
+  g_return_if_fail (GTK_IS_CSS_STYLE (style));
   g_return_if_fail (snapshot != NULL);
   g_return_if_fail (GDK_IS_PAINTABLE (paintable));
   g_return_if_fail (width > 0);
@@ -112,7 +112,7 @@ gtk_css_style_snapshot_icon_paintable (GtkCssStyle  *style,
 
   gtk_css_filter_value_push_snapshot (style->other->icon_filter, snapshot);
 
-  has_shadow = gtk_css_shadow_value_push_snapshot (style->used->icon_shadow, snapshot);
+  has_shadow = gtk_css_shadow_value_push_snapshot (style->icon->icon_shadow, snapshot);
 
   is_symbolic_paintable = GTK_IS_SYMBOLIC_PAINTABLE (paintable);
   if (is_symbolic_paintable)

gtk/gtkrenderlayout.c

@@ -47,9 +47,8 @@ gtk_css_style_snapshot_layout (GtkCssBoxes *boxes,
     }
 
   style = boxes->style;
-  color = gtk_css_color_value_get_rgba (style->used->color);
-
-  has_shadow = gtk_css_shadow_value_push_snapshot (style->used->text_shadow, snapshot);
+  color = gtk_css_color_value_get_rgba (style->core->color);
+  has_shadow = gtk_css_shadow_value_push_snapshot (style->font->text_shadow, snapshot);
 
   gtk_snapshot_append_layout (snapshot, layout, color);
 
@@ -188,12 +187,12 @@ snapshot_insertion_cursor (GtkSnapshot     *snapshot,
                            PangoDirection   direction,
                            gboolean         draw_arrow)
 {
-  const GdkRGBA *color;
+  GdkRGBA color;
 
   if (is_primary)
-    color = gtk_css_color_value_get_rgba (style->used->caret_color);
+    color = *gtk_css_color_value_get_rgba (style->font->caret_color ? style->font->caret_color : style->core->color);
   else
-    color = gtk_css_color_value_get_rgba (style->used->secondary_caret_color);
+    color = *gtk_css_color_value_get_rgba (style->font->secondary_caret_color ? style->font->secondary_caret_color : style->core->color);
 
   if (width != 0 || draw_arrow)
     {
@@ -203,7 +202,7 @@ snapshot_insertion_cursor (GtkSnapshot     *snapshot,
       get_insertion_cursor_bounds (width, height, aspect_ratio, direction, draw_arrow, &bounds);
       cr = gtk_snapshot_append_cairo (snapshot, &bounds);
 
-      draw_insertion_cursor (cr, 0, 0, width, height, aspect_ratio, color, direction, draw_arrow);
+      draw_insertion_cursor (cr, 0, 0, width, height, aspect_ratio, &color, direction, draw_arrow);
 
       cairo_destroy (cr);
     }
@@ -221,7 +220,7 @@ snapshot_insertion_cursor (GtkSnapshot     *snapshot,
         offset = stem_width - stem_width / 2;
 
       gtk_snapshot_append_color (snapshot,
-                                 color,
+                                 &color,
                                  &GRAPHENE_RECT_INIT (- offset, 0, stem_width, height));
     }
 }

gtk/gtksizerequest.c

@@ -84,7 +84,7 @@ fetch_request_mode (GtkWidget *widget)
 static int
 get_number (GtkCssValue *value)
 {
-  double d = gtk_css_number_value_get (value, 100);
+  double d = _gtk_css_number_value_get (value, 100);
 
   if (d < 1)
     return ceil (d);
@@ -96,7 +96,7 @@ get_number (GtkCssValue *value)
 static int
 get_number_ceil (GtkCssValue *value)
 {
-  return ceil (gtk_css_number_value_get (value, 100));
+  return ceil (_gtk_css_number_value_get (value, 100));
 }
 
 static void

gtk/gtkspinner.c

@@ -64,8 +64,6 @@ typedef struct _GtkSpinnerClass GtkSpinnerClass;
 struct _GtkSpinner
 {
   GtkWidget parent;
-
-  guint spinning : 1;
 };
 
 struct _GtkSpinnerClass
@@ -83,17 +81,6 @@ G_DEFINE_TYPE (GtkSpinner, gtk_spinner, GTK_TYPE_WIDGET)
 
 #define DEFAULT_SIZE 16
 
-static void
-update_state_flags (GtkSpinner *spinner)
-{
-  if (spinner->spinning && gtk_widget_get_mapped (GTK_WIDGET (spinner)))
-    gtk_widget_set_state_flags (GTK_WIDGET (spinner),
-                                GTK_STATE_FLAG_CHECKED, FALSE);
-  else
-    gtk_widget_unset_state_flags (GTK_WIDGET (spinner),
-                                  GTK_STATE_FLAG_CHECKED);
-}
-
 static void
 gtk_spinner_measure (GtkWidget      *widget,
                      GtkOrientation  orientation,
@@ -106,7 +93,7 @@ gtk_spinner_measure (GtkWidget      *widget,
   GtkCssStyle *style;
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
-  *minimum = *natural = gtk_css_number_value_get (style->icon->icon_size, 100);
+  *minimum = *natural = _gtk_css_number_value_get (style->icon->icon_size, 100);
 }
 
 static void
@@ -121,26 +108,6 @@ gtk_spinner_snapshot (GtkWidget   *widget,
                                gtk_widget_get_height (widget));
 }
 
-static void
-gtk_spinner_map (GtkWidget *widget)
-{
-  GtkSpinner *spinner = GTK_SPINNER (widget);
-
-  GTK_WIDGET_CLASS (gtk_spinner_parent_class)->map (widget);
-
-  update_state_flags (spinner);
-}
-
-static void
-gtk_spinner_unmap (GtkWidget *widget)
-{
-  GtkSpinner *spinner = GTK_SPINNER (widget);
-
-  GTK_WIDGET_CLASS (gtk_spinner_parent_class)->unmap (widget);
-
-  update_state_flags (spinner);
-}
-
 static void
 gtk_spinner_css_changed (GtkWidget         *widget,
                          GtkCssStyleChange *change)
@@ -172,7 +139,7 @@ gtk_spinner_get_spinning (GtkSpinner *spinner)
 {
   g_return_val_if_fail (GTK_IS_SPINNER (spinner), FALSE);
 
-  return spinner->spinning;
+  return (gtk_widget_get_state_flags ((GtkWidget *)spinner) & GTK_STATE_FLAG_CHECKED) > 0;
 }
 
 /**
@@ -190,14 +157,17 @@ gtk_spinner_set_spinning (GtkSpinner *spinner,
 
   spinning = !!spinning;
 
-  if (spinning == spinner->spinning)
-    return;
+  if (spinning != gtk_spinner_get_spinning (spinner))
+    {
+      g_object_notify (G_OBJECT (spinner), "spinning");
 
-  spinner->spinning = spinning;
-
-  update_state_flags (spinner);
-
-  g_object_notify (G_OBJECT (spinner), "spinning");
+      if (spinning)
+        gtk_widget_set_state_flags (GTK_WIDGET (spinner),
+                                    GTK_STATE_FLAG_CHECKED, FALSE);
+      else
+        gtk_widget_unset_state_flags (GTK_WIDGET (spinner),
+                                      GTK_STATE_FLAG_CHECKED);
+    }
 }
 
 static void
@@ -245,8 +215,6 @@ gtk_spinner_class_init (GtkSpinnerClass *klass)
   widget_class = GTK_WIDGET_CLASS(klass);
   widget_class->snapshot = gtk_spinner_snapshot;
   widget_class->measure = gtk_spinner_measure;
-  widget_class->map = gtk_spinner_map;
-  widget_class->unmap = gtk_spinner_unmap;
   widget_class->css_changed = gtk_spinner_css_changed;
 
   /**

gtk/gtktext.c

@@ -4834,7 +4834,7 @@ gtk_text_draw_cursor (GtkText     *self,
       gtk_css_boxes_init_border_box (&boxes, style, 0, 0, width, height);
       gtk_snapshot_push_clip (snapshot, &bounds);
       gtk_css_style_snapshot_background (&boxes, snapshot);
-      gtk_css_style_snapshot_layout (&boxes, snapshot, x, y, layout);
+      gtk_css_style_snapshot_layout (&boxes,snapshot, x, y, layout);
       gtk_snapshot_pop (snapshot);
     }
 

gtk/gtktexthandle.c

@@ -118,10 +118,10 @@ gtk_text_handle_get_padding (GtkTextHandle *handle,
   GtkWidget *widget = GTK_WIDGET (handle);
   GtkCssStyle *style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
 
-  padding->left = gtk_css_number_value_get (style->size->padding_left, 100);
-  padding->right = gtk_css_number_value_get (style->size->padding_right, 100);
-  padding->top = gtk_css_number_value_get (style->size->padding_top, 100);
-  padding->bottom = gtk_css_number_value_get (style->size->padding_bottom, 100);
+  padding->left = _gtk_css_number_value_get (style->size->padding_left, 100);
+  padding->right = _gtk_css_number_value_get (style->size->padding_right, 100);
+  padding->top = _gtk_css_number_value_get (style->size->padding_top, 100);
+  padding->bottom = _gtk_css_number_value_get (style->size->padding_bottom, 100);
 }
 
 static void

gtk/gtktextlayout.c

@@ -4030,9 +4030,8 @@ render_para (GskPangoRenderer   *crenderer,
                    (line_display->insert_index < byte_offset + pango_layout_line_get_length (line) ||
                     (at_last_line && line_display->insert_index == byte_offset + pango_layout_line_get_length (line))))
             {
-              GtkCssNode *node;
               GtkCssStyle *style;
-              const GdkRGBA *cursor_color;
+              GdkRGBA cursor_color;
               graphene_rect_t bounds = {
                 .origin.x = line_display->x_offset + line_display->block_cursor.x,
                 .origin.y = line_display->block_cursor.y + line_display->top_margin,
@@ -4043,13 +4042,11 @@ render_para (GskPangoRenderer   *crenderer,
               /* we draw text using base color on filled cursor rectangle
                * of cursor color (normally white on black)
                */
-              node = gtk_widget_get_css_node (crenderer->widget);
-              style = gtk_css_node_get_style (node);
-
-              cursor_color = gtk_css_color_value_get_rgba (style->used->caret_color);
+              style = gtk_css_node_get_style (gtk_widget_get_css_node (crenderer->widget));
+              cursor_color = *gtk_css_color_value_get_rgba (style->font->caret_color ? style->font->caret_color : style->core->color);
 
               gtk_snapshot_push_opacity (crenderer->snapshot, cursor_alpha);
-              gtk_snapshot_append_color (crenderer->snapshot, cursor_color, &bounds);
+              gtk_snapshot_append_color (crenderer->snapshot, &cursor_color, &bounds);
 
               /* draw text under the cursor if any */
               if (!line_display->cursor_at_line_end)
@@ -4104,12 +4101,11 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
   gboolean have_selection;
   gboolean draw_selection_text;
   const GdkRGBA *selection;
-  const GdkRGBA *color;
+  GdkRGBA color;
   GtkSnapshot *cursor_snapshot;
   GtkTextBTree *btree;
   GtkTextLine *first_line;
   GtkTextLine *last_line;
-  GtkCssNode *node;
   GtkCssStyle *style;
 
   g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
@@ -4132,10 +4128,8 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
   if (last_line == NULL)
     last_line = _gtk_text_btree_get_end_iter_line (btree);
 
-  node = gtk_widget_get_css_node (widget);
-  style = gtk_css_node_get_style (node);
-
-  color = gtk_css_color_value_get_rgba (style->used->color);
+  style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
+  color = *gtk_css_color_value_get_rgba (style->core->color);
 
   gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (0, offset_y));
   offset_y = 0;
@@ -4148,7 +4142,7 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
 
   crenderer->widget = widget;
   crenderer->snapshot = snapshot;
-  crenderer->fg_color = color;
+  crenderer->fg_color = &color;
 
   have_selection = gtk_text_buffer_get_selection_bounds (layout->buffer,
                                                          &selection_start,
@@ -4156,7 +4150,7 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
   if (have_selection)
     {
       GtkCssNode *selection_node;
-      const GdkRGBA *text_color;
+      GdkRGBA text_color;
 
       selection_start_line = gtk_text_iter_get_line (&selection_start);
       selection_end_line = gtk_text_iter_get_line (&selection_end);
@@ -4164,10 +4158,10 @@ gtk_text_layout_snapshot (GtkTextLayout      *layout,
       selection_node = gtk_text_view_get_selection_node ((GtkTextView*)widget);
       style = gtk_css_node_get_style (selection_node);
 
-      selection = gtk_css_color_value_get_rgba (style->used->background_color);
-      text_color = gtk_css_color_value_get_rgba (style->used->color);
+      selection = gtk_css_color_value_get_rgba (style->background->background_color);
+      text_color = *gtk_css_color_value_get_rgba (style->core->color);
 
-      draw_selection_text = text_color->alpha > 0;
+      draw_selection_text = text_color.alpha > 0;
     }
   else
     {

gtk/gtktextutil.c

@@ -132,7 +132,7 @@ gtk_text_util_create_drag_icon (GtkWidget *widget,
   snapshot = gtk_snapshot_new ();
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
-  color = gtk_css_color_value_get_rgba (style->used->color);
+  color = gtk_css_color_value_get_rgba (style->core->color);
 
   display = gtk_widget_get_display (widget);
 
@@ -179,8 +179,8 @@ set_attributes_from_style (GtkWidget         *widget,
 
   style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
 
-  *values->appearance.bg_rgba = *gtk_css_color_value_get_rgba (style->used->background_color);
-  *values->appearance.fg_rgba = *gtk_css_color_value_get_rgba (style->used->color);
+  *values->appearance.bg_rgba = *gtk_css_color_value_get_rgba (style->background->background_color);
+  *values->appearance.fg_rgba = *gtk_css_color_value_get_rgba (style->core->color);
 
   if (values->font)
     pango_font_description_free (values->font);

gtk/gtktextview.c

@@ -7836,6 +7836,7 @@ gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
 {
   GtkCssStyle *style;
   const GdkRGBA black = { 0, };
+  const GdkRGBA *color;
   const GdkRGBA *decoration_color;
   GtkTextDecorationLine decoration_line;
   GtkTextDecorationStyle decoration_style;
@@ -7845,10 +7846,12 @@ gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
   if (!values->appearance.fg_rgba)
     values->appearance.fg_rgba = gdk_rgba_copy (&black);
 
-  style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (text_view)));;
+  style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (text_view)));
 
-  *values->appearance.bg_rgba = *gtk_css_color_value_get_rgba (style->used->background_color);
-  *values->appearance.fg_rgba = *gtk_css_color_value_get_rgba (style->used->color);
+  color = gtk_css_color_value_get_rgba (style->background->background_color);
+  *values->appearance.bg_rgba = *color;
+  color = gtk_css_color_value_get_rgba (style->core->color);
+  *values->appearance.fg_rgba = *color;
 
   if (values->font)
     pango_font_description_free (values->font);
@@ -7859,7 +7862,9 @@ gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
 
   decoration_line = _gtk_css_text_decoration_line_value_get (style->font_variant->text_decoration_line);
   decoration_style = _gtk_css_text_decoration_style_value_get (style->font_variant->text_decoration_style);
-  decoration_color = gtk_css_color_value_get_rgba (style->used->text_decoration_color);
+  decoration_color = gtk_css_color_value_get_rgba (style->font_variant->text_decoration_color
+                                                   ? style->font_variant->text_decoration_color
+                                                   : style->core->color);
 
   if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_UNDERLINE)
     {
@@ -7917,9 +7922,10 @@ gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
     }
 
   /* letter-spacing */
-  values->letter_spacing = gtk_css_number_value_get (style->font->letter_spacing, 100) * PANGO_SCALE;
+  values->letter_spacing = _gtk_css_number_value_get (style->font->letter_spacing, 100) * PANGO_SCALE;
 
   /* line-height */
+
   values->line_height = gtk_css_line_height_value_get (style->font->line_height);
   values->line_height_is_absolute = FALSE;
   if (values->line_height != 0.0)

gtk/gtkwidget.c

@@ -3683,7 +3683,7 @@ gtk_widget_get_frame_clock (GtkWidget *widget)
 static int
 get_number (GtkCssValue *value)
 {
-  double d = gtk_css_number_value_get (value, 100);
+  double d = _gtk_css_number_value_get (value, 100);
 
   if (d < 1)
     return ceil (d);
@@ -6478,7 +6478,7 @@ gtk_widget_update_pango_context (GtkWidget        *widget,
                                          ? PANGO_DIRECTION_LTR
                                          : PANGO_DIRECTION_RTL);
 
-  pango_cairo_context_set_resolution (context, gtk_css_number_value_get (style->core->dpi, 100));
+  pango_cairo_context_set_resolution (context, _gtk_css_number_value_get (style->core->dpi, 100));
 
   pango_context_set_font_map (context, gtk_widget_get_effective_font_map (widget));
 
@@ -11857,7 +11857,7 @@ gtk_widget_create_render_node (GtkWidget   *widget,
 
   style = gtk_css_node_get_style (priv->cssnode);
 
-  css_opacity = gtk_css_number_value_get (style->other->opacity, 100);
+  css_opacity = _gtk_css_number_value_get (style->other->opacity, 100);
   opacity = CLAMP (css_opacity, 0.0, 1.0) * priv->user_alpha / 255.0;
 
   if (opacity <= 0.0)
@@ -13172,7 +13172,7 @@ gtk_widget_get_color (GtkWidget *widget,
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
   style = gtk_css_node_get_style (priv->cssnode);
-  *color = *gtk_css_color_value_get_rgba (style->used->color);
+  *color = *gtk_css_color_value_get_rgba (style->core->color);
 }
 
 /*< private >

gtk/gtkwindow.c

@@ -1395,7 +1395,7 @@ constraints_for_edge (GdkSurfaceEdge edge)
 static int
 get_number (GtkCssValue *value)
 {
-  double d = gtk_css_number_value_get (value, 100);
+  double d = _gtk_css_number_value_get (value, 100);
 
   if (d < 1)
     return ceil (d);

gtk/inspector/css-node-tree.c

@@ -822,7 +822,7 @@ gtk_inspector_css_node_tree_update_style (GtkInspectorCssNodeTree *cnt,
 
       if (new_style)
         {
-          value = gtk_css_value_to_string (gtk_css_style_get_value (new_style, i));
+          value = _gtk_css_value_to_string (gtk_css_style_get_value (new_style, i));
 
           section = gtk_css_style_get_section (new_style, i);
           if (section)

gtk/inspector/layoutoverlay.c

@@ -23,7 +23,7 @@ G_DEFINE_TYPE (GtkLayoutOverlay, gtk_layout_overlay, GTK_TYPE_INSPECTOR_OVERLAY)
 static int
 get_number (GtkCssValue *value)
 {
-  double d = gtk_css_number_value_get (value, 100);
+  double d = _gtk_css_number_value_get (value, 100);
 
   if (d < 1)
     return ceil (d);

gtk/meson.build

@@ -113,7 +113,6 @@ gtk_private_sources = files([
   'gtkfilechoosercell.c',
   'gtkfilesystemmodel.c',
   'gtkfilethumbnail.c',
-  'gtkfontfilter.c',
   'gtkgizmo.c',
   'gtkiconcache.c',
   'gtkiconcachevalidator.c',
@@ -413,7 +412,6 @@ gtk_public_sources += gtk_print_sources
 
 gtk_private_type_headers = files([
   'gtkcsstypesprivate.h',
-  'gtkfontfilterprivate.h',
   'gtktexthandleprivate.h',
   'gtkplacessidebarprivate.h',
 ])

gtk/print/gtkprintunixdialog.c

@@ -2425,16 +2425,14 @@ draw_page (GtkDrawingArea *da,
     }
 
   style = gtk_css_node_get_style (dialog->page_layout_paper_node);
-  color = *gtk_css_color_value_get_rgba (style->used->color);
+  color = *gtk_css_color_value_get_rgba (style->core->color);
 
   pos_x = (width - w) / 2;
   pos_y = (height - h) / 2 - 10;
   cairo_translate (cr, pos_x, pos_y);
 
   snapshot = gtk_snapshot_new ();
-  gtk_css_boxes_init_border_box (&boxes,
-                                 gtk_css_node_get_style (dialog->page_layout_paper_node),
-                                 1, 1, w, h);
+  gtk_css_boxes_init_border_box (&boxes, style, 1, 1, w, h);
   gtk_css_style_snapshot_background (&boxes, snapshot);
   gtk_css_style_snapshot_border (&boxes, snapshot);