css: Give each style its own variable set

gtk_css_style_print relies on this to limit printing of custom
variables to each styles' own variables. Without this, :root
variables get printed for every single style that doesn't define
its own.

gtk/deprecated/gtkstylecontext.c

@@ -778,10 +778,10 @@ 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),
-                                      NULL);
+  val = gtk_css_color_value_resolve (color,
+                                     GTK_STYLE_PROVIDER (priv->cascade),
+                                     _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR));
+
   if (val == NULL)
     return FALSE;
 

gtk/gtkapplication-quartz.c

@@ -76,13 +76,19 @@ G_DEFINE_TYPE (GtkApplicationImplQuartz, gtk_application_impl_quartz, GTK_TYPE_A
 
 -(NSApplicationTerminateReply) applicationShouldTerminate:(NSApplication *)sender
 {
-  /* 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;
+  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;
 }
 
 -(void)application:(NSApplication *)theApplication openFiles:(NSArray *)filenames

gtk/gtkcsscolorvalue.c

@@ -60,7 +60,7 @@ struct _GtkCssValue
       GtkCssValue *color2;
       double factor;
     } mix;
-  } sym_col;
+  };
 };
 
 static void
@@ -72,17 +72,17 @@ gtk_css_value_color_free (GtkCssValue *color)
   switch (color->type)
     {
     case COLOR_TYPE_NAME:
-      g_free (color->sym_col.name);
+      g_free (color->name);
       break;
     case COLOR_TYPE_SHADE:
-      gtk_css_value_unref (color->sym_col.shade.color);
+      gtk_css_value_unref (color->shade.color);
       break;
     case COLOR_TYPE_ALPHA:
-      gtk_css_value_unref (color->sym_col.alpha.color);
+      gtk_css_value_unref (color->alpha.color);
       break;
     case COLOR_TYPE_MIX:
-      gtk_css_value_unref (color->sym_col.mix.color1);
-      gtk_css_value_unref (color->sym_col.mix.color2);
+      gtk_css_value_unref (color->mix.color1);
+      gtk_css_value_unref (color->mix.color2);
       break;
     case COLOR_TYPE_LITERAL:
     case COLOR_TYPE_CURRENT_COLOR:
@@ -121,7 +121,7 @@ gtk_css_value_color_get_fallback (guint                 property_id,
         return gtk_css_value_ref (context->style->core->color);
       default:
         if (property_id < GTK_CSS_PROPERTY_N_PROPERTIES)
-          g_warning ("No fallback color defined for property '%s'", 
+          g_warning ("No fallback color defined for property '%s'",
                      _gtk_style_property_get_name (GTK_STYLE_PROPERTY (_gtk_css_style_property_lookup_by_id (property_id))));
         return gtk_css_color_value_new_transparent ();
     }
@@ -136,7 +136,7 @@ gtk_css_value_color_compute (GtkCssValue          *value,
 
   /* The computed value of the ‘currentColor’ keyword is the computed
    * value of the ‘color’ property. If the ‘currentColor’ keyword is
-   * set on the ‘color’ property itself, it is treated as ‘color: inherit’. 
+   * set on the ‘color’ property itself, it is treated as ‘color: inherit’.
    */
   if (property_id == GTK_CSS_PROPERTY_COLOR)
     {
@@ -147,10 +147,9 @@ gtk_css_value_color_compute (GtkCssValue          *value,
       else
         current = NULL;
 
-      resolved = _gtk_css_color_value_resolve (value,
-                                               context->provider,
-                                               current,
-                                               NULL);
+      resolved = gtk_css_color_value_resolve (value,
+                                              context->provider,
+                                              current);
     }
   else if (value->type == COLOR_TYPE_LITERAL)
     {
@@ -160,10 +159,9 @@ gtk_css_value_color_compute (GtkCssValue          *value,
     {
       GtkCssValue *current = context->style->core->color;
 
-      resolved = _gtk_css_color_value_resolve (value,
-                                               context->provider,
-                                               current,
-                                               NULL);
+      resolved = gtk_css_color_value_resolve (value,
+                                              context->provider,
+                                              current);
     }
 
   if (resolved == NULL)
@@ -182,23 +180,23 @@ gtk_css_value_color_equal (const GtkCssValue *value1,
   switch (value1->type)
     {
     case COLOR_TYPE_LITERAL:
-      return gdk_rgba_equal (&value1->sym_col.rgba, &value2->sym_col.rgba);
+      return gdk_rgba_equal (&value1->rgba, &value2->rgba);
     case COLOR_TYPE_NAME:
-      return g_str_equal (value1->sym_col.name, value2->sym_col.name);
+      return g_str_equal (value1->name, value2->name);
     case COLOR_TYPE_SHADE:
-      return value1->sym_col.shade.factor == value2->sym_col.shade.factor &&
-             gtk_css_value_equal (value1->sym_col.shade.color,
-                                  value2->sym_col.shade.color);
+      return value1->shade.factor == value2->shade.factor &&
+             gtk_css_value_equal (value1->shade.color,
+                                  value2->shade.color);
     case COLOR_TYPE_ALPHA:
-      return value1->sym_col.alpha.factor == value2->sym_col.alpha.factor &&
-             gtk_css_value_equal (value1->sym_col.alpha.color,
-                                  value2->sym_col.alpha.color);
+      return value1->alpha.factor == value2->alpha.factor &&
+             gtk_css_value_equal (value1->alpha.color,
+                                  value2->alpha.color);
     case COLOR_TYPE_MIX:
-      return value1->sym_col.mix.factor == value2->sym_col.mix.factor &&
-             gtk_css_value_equal (value1->sym_col.mix.color1,
-                                  value2->sym_col.mix.color1) &&
-             gtk_css_value_equal (value1->sym_col.mix.color2,
-                                  value2->sym_col.mix.color2);
+      return value1->mix.factor == value2->mix.factor &&
+             gtk_css_value_equal (value1->mix.color1,
+                                  value2->mix.color1) &&
+             gtk_css_value_equal (value1->mix.color2,
+                                  value2->mix.color2);
     case COLOR_TYPE_CURRENT_COLOR:
       return TRUE;
     default:
@@ -213,7 +211,7 @@ gtk_css_value_color_transition (GtkCssValue *start,
                                 guint        property_id,
                                 double       progress)
 {
-  return _gtk_css_color_value_new_mix (start, end, progress);
+  return gtk_css_color_value_new_mix (start, end, progress);
 }
 
 static void
@@ -224,23 +222,23 @@ gtk_css_value_color_print (const GtkCssValue *value,
     {
     case COLOR_TYPE_LITERAL:
       {
-        char *s = gdk_rgba_to_string (&value->sym_col.rgba);
+        char *s = gdk_rgba_to_string (&value->rgba);
         g_string_append (string, s);
         g_free (s);
       }
       break;
     case COLOR_TYPE_NAME:
       g_string_append (string, "@");
-      g_string_append (string, value->sym_col.name);
+      g_string_append (string, value->name);
       break;
     case COLOR_TYPE_SHADE:
       {
         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 
         g_string_append (string, "shade(");
-        gtk_css_value_print (value->sym_col.shade.color, string);
+        gtk_css_value_print (value->shade.color, string);
         g_string_append (string, ", ");
-        g_ascii_dtostr (factor, sizeof (factor), value->sym_col.shade.factor);
+        g_ascii_dtostr (factor, sizeof (factor), value->shade.factor);
         g_string_append (string, factor);
         g_string_append (string, ")");
       }
@@ -250,9 +248,9 @@ gtk_css_value_color_print (const GtkCssValue *value,
         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 
         g_string_append (string, "alpha(");
-        gtk_css_value_print (value->sym_col.alpha.color, string);
+        gtk_css_value_print (value->alpha.color, string);
         g_string_append (string, ", ");
-        g_ascii_dtostr (factor, sizeof (factor), value->sym_col.alpha.factor);
+        g_ascii_dtostr (factor, sizeof (factor), value->alpha.factor);
         g_string_append (string, factor);
         g_string_append (string, ")");
       }
@@ -262,11 +260,11 @@ gtk_css_value_color_print (const GtkCssValue *value,
         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 
         g_string_append (string, "mix(");
-        gtk_css_value_print (value->sym_col.mix.color1, string);
+        gtk_css_value_print (value->mix.color1, string);
         g_string_append (string, ", ");
-        gtk_css_value_print (value->sym_col.mix.color2, string);
+        gtk_css_value_print (value->mix.color2, string);
         g_string_append (string, ", ");
-        g_ascii_dtostr (factor, sizeof (factor), value->sym_col.mix.factor);
+        g_ascii_dtostr (factor, sizeof (factor), value->mix.factor);
         g_string_append (string, factor);
         g_string_append (string, ")");
       }
@@ -341,11 +339,11 @@ apply_mix (const GdkRGBA *in1,
     }
 }
 
-GtkCssValue *
-_gtk_css_color_value_resolve (GtkCssValue      *color,
-                              GtkStyleProvider *provider,
-                              GtkCssValue      *current,
-                              GSList           *cycle_list)
+static GtkCssValue *
+gtk_css_color_value_do_resolve (GtkCssValue      *color,
+                                GtkStyleProvider *provider,
+                                GtkCssValue      *current,
+                                GSList           *cycle_list)
 {
   GtkCssValue *value;
 
@@ -357,7 +355,7 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
       return gtk_css_value_ref (color);
     case COLOR_TYPE_NAME:
       {
-	GtkCssValue *named;
+        GtkCssValue *named;
         GSList cycle = { color, cycle_list };
 
         /* If color exists in cycle_list, we're currently resolving it.
@@ -365,13 +363,13 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
         if (g_slist_find (cycle_list, color))
           return NULL;
 
-        named = gtk_style_provider_get_color (provider, color->sym_col.name);
-	if (named == NULL)
-	  return NULL;
+        named = gtk_style_provider_get_color (provider, color->name);
+        if (named == NULL)
+          return NULL;
 
-        value = _gtk_css_color_value_resolve (named, provider, current, &cycle);
-	if (value == NULL)
-	  return NULL;
+        value = gtk_css_color_value_do_resolve (named, provider, current, &cycle);
+        if (value == NULL)
+          return NULL;
       }
 
       break;
@@ -381,14 +379,14 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
         GtkCssValue *val;
         GdkRGBA shade;
 
-        val = _gtk_css_color_value_resolve (color->sym_col.shade.color, provider, current, cycle_list);
+        val = gtk_css_color_value_do_resolve (color->shade.color, provider, current, cycle_list);
         if (val == NULL)
           return NULL;
         c = gtk_css_color_value_get_rgba (val);
 
-        apply_shade (c, &shade, color->sym_col.shade.factor);
+        apply_shade (c, &shade, color->shade.factor);
 
-        value = _gtk_css_color_value_new_literal (&shade);
+        value = gtk_css_color_value_new_literal (&shade);
         gtk_css_value_unref (val);
       }
 
@@ -399,14 +397,14 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
         GtkCssValue *val;
         GdkRGBA alpha;
 
-        val = _gtk_css_color_value_resolve (color->sym_col.alpha.color, provider, current, cycle_list);
+        val = gtk_css_color_value_do_resolve (color->alpha.color, provider, current, cycle_list);
         if (val == NULL)
           return NULL;
         c = gtk_css_color_value_get_rgba (val);
 
-        apply_alpha (c, &alpha, color->sym_col.alpha.factor);
+        apply_alpha (c, &alpha, color->alpha.factor);
 
-        value = _gtk_css_color_value_new_literal (&alpha);
+        value = gtk_css_color_value_new_literal (&alpha);
         gtk_css_value_unref (val);
       }
       break;
@@ -417,45 +415,34 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
         GtkCssValue *val1, *val2;
         GdkRGBA res;
 
-        val1 = _gtk_css_color_value_resolve (color->sym_col.mix.color1, provider, current, cycle_list);
+        val1 = gtk_css_color_value_do_resolve (color->mix.color1, provider, current, cycle_list);
         if (val1 == NULL)
           return NULL;
         color1 = gtk_css_color_value_get_rgba (val1);
 
-        val2 = _gtk_css_color_value_resolve (color->sym_col.mix.color2, provider, current, cycle_list);
+        val2 = gtk_css_color_value_do_resolve (color->mix.color2, provider, current, cycle_list);
         if (val2 == NULL)
           return NULL;
         color2 = gtk_css_color_value_get_rgba (val2);
 
-        apply_mix (color1, color2, &res, color->sym_col.mix.factor);
+        apply_mix (color1, color2, &res, color->mix.factor);
 
-        value = _gtk_css_color_value_new_literal (&res);
+        value = gtk_css_color_value_new_literal (&res);
         gtk_css_value_unref (val1);
         gtk_css_value_unref (val2);
       }
 
       break;
     case COLOR_TYPE_CURRENT_COLOR:
-      if (current)
+      if (current == NULL)
         {
-          return gtk_css_value_ref (current);
-        }
-      else
-        {
-          GtkCssValue *initial = _gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (GTK_CSS_PROPERTY_COLOR));
+          current = _gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (GTK_CSS_PROPERTY_COLOR));
 
-          if (initial->class == &GTK_CSS_VALUE_COLOR)
-            {
-              return _gtk_css_color_value_resolve (initial,
-                                                   provider,
-                                                   NULL,
-                                                   cycle_list);
-            }
-          else
-            {
-              return gtk_css_value_ref (initial);
-            }
+          g_assert (current->class == &GTK_CSS_VALUE_COLOR);
+          g_assert (current->type == COLOR_TYPE_LITERAL);
         }
+
+        value = gtk_css_value_ref (current);
       break;
     default:
       value = NULL;
@@ -478,10 +465,18 @@ _gtk_css_color_value_resolve (GtkCssValue      *color,
   return value;
 }
 
+GtkCssValue *
+gtk_css_color_value_resolve (GtkCssValue      *color,
+                             GtkStyleProvider *provider,
+                             GtkCssValue      *current)
+{
+  return gtk_css_color_value_do_resolve (color, provider, current, NULL);
+}
+
 static GtkCssValue transparent_black_singleton = { &GTK_CSS_VALUE_COLOR, 1, TRUE, FALSE, COLOR_TYPE_LITERAL, NULL,
-                                                   .sym_col.rgba = {0, 0, 0, 0} };
+                                                   .rgba = {0, 0, 0, 0} };
 static GtkCssValue white_singleton             = { &GTK_CSS_VALUE_COLOR, 1, TRUE, FALSE, COLOR_TYPE_LITERAL, NULL,
-                                                   .sym_col.rgba = {1, 1, 1, 1} };
+                                                   .rgba = {1, 1, 1, 1} };
 
 
 GtkCssValue *
@@ -497,28 +492,28 @@ gtk_css_color_value_new_white (void)
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_literal (const GdkRGBA *color)
+gtk_css_color_value_new_literal (const GdkRGBA *color)
 {
   GtkCssValue *value;
 
   g_return_val_if_fail (color != NULL, NULL);
 
-  if (gdk_rgba_equal (color, &white_singleton.sym_col.rgba))
+  if (gdk_rgba_equal (color, &white_singleton.rgba))
     return gtk_css_value_ref (&white_singleton);
 
-  if (gdk_rgba_equal (color, &transparent_black_singleton.sym_col.rgba))
+  if (gdk_rgba_equal (color, &transparent_black_singleton.rgba))
     return gtk_css_value_ref (&transparent_black_singleton);
 
   value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_COLOR);
   value->type = COLOR_TYPE_LITERAL;
   value->is_computed = TRUE;
-  value->sym_col.rgba = *color;
+  value->rgba = *color;
 
   return value;
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_name (const char *name)
+gtk_css_color_value_new_name (const char *name)
 {
   GtkCssValue *value;
 
@@ -526,14 +521,14 @@ _gtk_css_color_value_new_name (const char *name)
 
   value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_COLOR);
   value->type = COLOR_TYPE_NAME;
-  value->sym_col.name = g_strdup (name);
+  value->name = g_strdup (name);
 
   return value;
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_shade (GtkCssValue *color,
-                                double       factor)
+gtk_css_color_value_new_shade (GtkCssValue *color,
+                               double       factor)
 {
   GtkCssValue *value;
 
@@ -543,22 +538,22 @@ _gtk_css_color_value_new_shade (GtkCssValue *color,
     {
       GdkRGBA c;
 
-      apply_shade (&color->sym_col.rgba, &c, factor);
+      apply_shade (&color->rgba, &c, factor);
 
-      return _gtk_css_color_value_new_literal (&c);
+      return gtk_css_color_value_new_literal (&c);
     }
 
   value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_COLOR);
   value->type = COLOR_TYPE_SHADE;
-  value->sym_col.shade.color = gtk_css_value_ref (color);
-  value->sym_col.shade.factor = factor;
+  value->shade.color = gtk_css_value_ref (color);
+  value->shade.factor = factor;
 
   return value;
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_alpha (GtkCssValue *color,
-                                double       factor)
+gtk_css_color_value_new_alpha (GtkCssValue *color,
+                               double       factor)
 {
   GtkCssValue *value;
 
@@ -568,23 +563,23 @@ _gtk_css_color_value_new_alpha (GtkCssValue *color,
     {
       GdkRGBA c;
 
-      apply_alpha (&color->sym_col.rgba, &c, factor);
+      apply_alpha (&color->rgba, &c, factor);
 
-      return _gtk_css_color_value_new_literal (&c);
+      return gtk_css_color_value_new_literal (&c);
     }
 
   value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_COLOR);
   value->type = COLOR_TYPE_ALPHA;
-  value->sym_col.alpha.color = gtk_css_value_ref (color);
-  value->sym_col.alpha.factor = factor;
+  value->alpha.color = gtk_css_value_ref (color);
+  value->alpha.factor = factor;
 
   return value;
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_mix (GtkCssValue *color1,
-                              GtkCssValue *color2,
-                              double       factor)
+gtk_css_color_value_new_mix (GtkCssValue *color1,
+                             GtkCssValue *color2,
+                             double       factor)
 {
   GtkCssValue *value;
 
@@ -596,30 +591,30 @@ _gtk_css_color_value_new_mix (GtkCssValue *color1,
     {
       GdkRGBA result;
 
-      apply_mix (&color1->sym_col.rgba, &color2->sym_col.rgba, &result, factor);
+      apply_mix (&color1->rgba, &color2->rgba, &result, factor);
 
-      return _gtk_css_color_value_new_literal (&result);
+      return gtk_css_color_value_new_literal (&result);
 
     }
 
   value = gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_COLOR);
   value->type = COLOR_TYPE_MIX;
-  value->sym_col.mix.color1 = gtk_css_value_ref (color1);
-  value->sym_col.mix.color2 = gtk_css_value_ref (color2);
-  value->sym_col.mix.factor = factor;
+  value->mix.color1 = gtk_css_value_ref (color1);
+  value->mix.color2 = gtk_css_value_ref (color2);
+  value->mix.factor = factor;
 
   return value;
 }
 
 GtkCssValue *
-_gtk_css_color_value_new_current_color (void)
+gtk_css_color_value_new_current_color (void)
 {
   static GtkCssValue current_color = { &GTK_CSS_VALUE_COLOR, 1, FALSE, FALSE, COLOR_TYPE_CURRENT_COLOR, NULL, };
 
   return gtk_css_value_ref (&current_color);
 }
 
-typedef struct 
+typedef struct
 {
   GtkCssValue *color;
   GtkCssValue *color2;
@@ -636,13 +631,13 @@ parse_color_mix (GtkCssParser *parser,
   switch (arg)
   {
     case 0:
-      data->color = _gtk_css_color_value_parse (parser);
+      data->color = gtk_css_color_value_parse (parser);
       if (data->color == NULL)
         return 0;
       return 1;
 
     case 1:
-      data->color2 = _gtk_css_color_value_parse (parser);
+      data->color2 = gtk_css_color_value_parse (parser);
       if (data->color2 == NULL)
         return 0;
       return 1;
@@ -667,7 +662,7 @@ parse_color_number (GtkCssParser *parser,
   switch (arg)
   {
     case 0:
-      data->color = _gtk_css_color_value_parse (parser);
+      data->color = gtk_css_color_value_parse (parser);
       if (data->color == NULL)
         return 0;
       return 1;
@@ -702,7 +697,7 @@ gtk_css_color_value_can_parse (GtkCssParser *parser)
 }
 
 GtkCssValue *
-_gtk_css_color_value_parse (GtkCssParser *parser)
+gtk_css_color_value_parse (GtkCssParser *parser)
 {
   ColorFunctionData data = { NULL, };
   GtkCssValue *value;
@@ -710,13 +705,13 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
 
   if (gtk_css_parser_try_ident (parser, "currentColor"))
     {
-      return _gtk_css_color_value_new_current_color ();
+      return gtk_css_color_value_new_current_color ();
     }
   else if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_AT_KEYWORD))
     {
       const GtkCssToken *token = gtk_css_parser_get_token (parser);
 
-      value = _gtk_css_color_value_new_name (gtk_css_token_get_string (token));
+      value = gtk_css_color_value_new_name (gtk_css_token_get_string (token));
       gtk_css_parser_consume_token (parser);
 
       return value;
@@ -724,7 +719,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
   else if (gtk_css_parser_has_function (parser, "lighter"))
     {
       if (gtk_css_parser_consume_function (parser, 1, 1, parse_color_number, &data))
-        value = _gtk_css_color_value_new_shade (data.color, 1.3);
+        value = gtk_css_color_value_new_shade (data.color, 1.3);
       else
         value = NULL;
 
@@ -734,7 +729,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
   else if (gtk_css_parser_has_function (parser, "darker"))
     {
       if (gtk_css_parser_consume_function (parser, 1, 1, parse_color_number, &data))
-        value = _gtk_css_color_value_new_shade (data.color, 0.7);
+        value = gtk_css_color_value_new_shade (data.color, 0.7);
       else
         value = NULL;
 
@@ -744,7 +739,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
   else if (gtk_css_parser_has_function (parser, "shade"))
     {
       if (gtk_css_parser_consume_function (parser, 2, 2, parse_color_number, &data))
-        value = _gtk_css_color_value_new_shade (data.color, data.value);
+        value = gtk_css_color_value_new_shade (data.color, data.value);
       else
         value = NULL;
 
@@ -754,7 +749,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
   else if (gtk_css_parser_has_function (parser, "alpha"))
     {
       if (gtk_css_parser_consume_function (parser, 2, 2, parse_color_number, &data))
-        value = _gtk_css_color_value_new_alpha (data.color, data.value);
+        value = gtk_css_color_value_new_alpha (data.color, data.value);
       else
         value = NULL;
 
@@ -764,7 +759,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
   else if (gtk_css_parser_has_function (parser, "mix"))
     {
       if (gtk_css_parser_consume_function (parser, 3, 3, parse_color_mix, &data))
-        value = _gtk_css_color_value_new_mix (data.color, data.color2, data.value);
+        value = gtk_css_color_value_new_mix (data.color, data.color2, data.value);
       else
         value = NULL;
 
@@ -774,7 +769,7 @@ _gtk_css_color_value_parse (GtkCssParser *parser)
     }
 
   if (gdk_rgba_parser_parse (parser, &rgba))
-    return _gtk_css_color_value_new_literal (&rgba);
+    return gtk_css_color_value_new_literal (&rgba);
   else
     return NULL;
 }
@@ -785,5 +780,5 @@ gtk_css_color_value_get_rgba (const GtkCssValue *color)
   g_assert (color->class == &GTK_CSS_VALUE_COLOR);
   g_assert (color->type == COLOR_TYPE_LITERAL);
 
-  return &color->sym_col.rgba;
+  return &color->rgba;
 }

gtk/gtkcsscolorvalueprivate.h

@@ -27,24 +27,23 @@ 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,
-                                                         GSList           *cycle_list);
+                                                         GtkCssValue      *current);
 const GdkRGBA * gtk_css_color_value_get_rgba            (const GtkCssValue *color) G_GNUC_CONST;
 
 

gtk/gtkcssimageconic.c

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

gtk/gtkcssimagecrossfade.c

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

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

gtk/gtkcssimagelinear.c

@@ -273,7 +273,7 @@ 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;
 

gtk/gtkcssimageradial.c

@@ -223,7 +223,7 @@ 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;
 

gtk/gtkcsspalettevalue.c

@@ -280,11 +280,11 @@ 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 */
     }
 
@@ -314,7 +314,7 @@ gtk_css_palette_value_parse (GtkCssParser *parser)
         return NULL;
       }
 
-    color = _gtk_css_color_value_parse (parser);
+    color = gtk_css_color_value_parse (parser);
     if (color == NULL)
       {
         g_free (ident);

gtk/gtkcssprovider.c

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

gtk/gtkcssshadowvalue.c

@@ -426,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;
 
@@ -459,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];

gtk/gtkcssshorthandpropertyimpl.c

@@ -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;
 
@@ -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;
       }
@@ -384,7 +384,7 @@ parse_border (GtkCssShorthandProperty  *shorthand,
       }
     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;
 
@@ -555,7 +555,7 @@ 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 
                                             (_gtk_css_shorthand_property_get_subproperty (shorthand, 6)));
@@ -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

@@ -864,7 +864,10 @@ gtk_css_lookup_resolve (GtkCssLookup      *lookup,
     }
   else if (parent_style && parent_style->variables)
     {
-      style->variables = gtk_css_variable_set_ref (parent_style->variables);
+      g_clear_pointer (&style->variables, gtk_css_variable_set_unref);
+      style->variables = gtk_css_variable_set_new ();
+      gtk_css_variable_set_set_parent (style->variables,
+                                       parent_style->variables);
     }
 
   context.provider = provider;

gtk/gtkcssstylepropertyimpl.c

@@ -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 *
@@ -921,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,
@@ -1168,31 +1168,31 @@ _gtk_css_style_property_init_properties (void)
                                           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,
@@ -1410,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,