css: Track selected state separately

Like the previous change, this reduces the number of
css nodes reacting to parent-state changes. The remaining
parent-state cases here are due to :link.

Before (numbers from widget-factory with Adwaita):
2247 nodes
class 612
name 2246
id 2
first-child 148
last-child 156
state 2245
hover 562
disabled 859
backdrop 1080
sibling-name 63
sibling-disabled 51
parent-class 586
parent-name 788
parent-id 2
parent-first-child 78
parent-last-child 78
parent-state 236
parent-hover 5
parent-disabled 91
parent-backdrop 4

After:
2247 nodes
class 612
name 2246
id 2
first-child 148
last-child 156
state 2245
hover 562
disabled 859
backdrop 1080
selected 579
sibling-name 63
sibling-disabled 51
parent-class 586
parent-name 788
parent-id 2
parent-first-child 78
parent-last-child 78
parent-state 115
parent-hover 5
parent-disabled 91
parent-backdrop 4
parent-selected 144

gtk/gtkcssanimatedstyle.c

@@ -79,6 +79,15 @@ gtk_css_animated_style_is_static (GtkCssStyle *style)
   return TRUE;
 }
 
+static GtkCssStyle *
+gtk_css_animated_style_get_static_style (GtkCssStyle *style)
+{
+  /* This is called a lot, so we avoid a dynamic type check here */
+  GtkCssAnimatedStyle *animated = (GtkCssAnimatedStyle *) style;
+
+  return animated->style;
+}
+
 static void
 gtk_css_animated_style_dispose (GObject *object)
 {
@@ -123,6 +132,7 @@ gtk_css_animated_style_class_init (GtkCssAnimatedStyleClass *klass)
   style_class->get_value = gtk_css_animated_style_get_value;
   style_class->get_section = gtk_css_animated_style_get_section;
   style_class->is_static = gtk_css_animated_style_is_static;
+  style_class->get_static_style = gtk_css_animated_style_get_static_style;
 }
 
 static void

gtk/gtkcssmatcher.c

@@ -22,6 +22,7 @@
 #include "gtkcssnodedeclarationprivate.h"
 #include "gtkcssnodeprivate.h"
 #include "gtkwidgetpath.h"
+#include "gtkprivate.h"
 
 /* GTK_CSS_MATCHER_WIDGET_PATH */
 
@@ -158,7 +159,17 @@ gtk_css_matcher_widget_path_has_position (const GtkCssMatcher *matcher,
   return x / a >= 0;
 }
 
+static void
+gtk_css_matcher_widget_path_print (const GtkCssMatcher *matcher,
+                                   GString             *string)
+{
+  char *s = gtk_widget_path_to_string (matcher->path.path);
+  g_string_append (string, s);
+  g_free (s);
+}
+
 static const GtkCssMatcherClass GTK_CSS_MATCHER_WIDGET_PATH = {
+  GTK_CSS_MATCHER_TYPE_WIDGET_PATH,
   gtk_css_matcher_widget_path_get_parent,
   gtk_css_matcher_widget_path_get_previous,
   gtk_css_matcher_widget_path_get_state,
@@ -166,7 +177,7 @@ static const GtkCssMatcherClass GTK_CSS_MATCHER_WIDGET_PATH = {
   gtk_css_matcher_widget_path_has_class,
   gtk_css_matcher_widget_path_has_id,
   gtk_css_matcher_widget_path_has_position,
-  FALSE
+  gtk_css_matcher_widget_path_print
 };
 
 gboolean
@@ -334,7 +345,15 @@ gtk_css_matcher_node_has_position (const GtkCssMatcher *matcher,
                                          a, b);
 }
 
+static void
+gtk_css_matcher_node_print (const GtkCssMatcher *matcher,
+                            GString             *string)
+{
+  gtk_css_node_print (matcher->node.node, 0, string, 0);
+}
+
 static const GtkCssMatcherClass GTK_CSS_MATCHER_NODE = {
+  GTK_CSS_MATCHER_TYPE_NODE,
   gtk_css_matcher_node_get_parent,
   gtk_css_matcher_node_get_previous,
   gtk_css_matcher_node_get_state,
@@ -342,7 +361,7 @@ static const GtkCssMatcherClass GTK_CSS_MATCHER_NODE = {
   gtk_css_matcher_node_has_class,
   gtk_css_matcher_node_has_id,
   gtk_css_matcher_node_has_position,
-  FALSE
+  gtk_css_matcher_node_print
 };
 
 void
@@ -383,10 +402,20 @@ gtk_css_matcher_any_get_state (const GtkCssMatcher *matcher)
 {
   /* XXX: This gets tricky when we implement :not() */
 
-  return GTK_STATE_FLAG_ACTIVE | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED
-    | GTK_STATE_FLAG_INSENSITIVE | GTK_STATE_FLAG_INCONSISTENT
-    | GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_BACKDROP | GTK_STATE_FLAG_LINK
-    | GTK_STATE_FLAG_VISITED;
+  return GTK_STATE_FLAG_ACTIVE |
+         GTK_STATE_FLAG_PRELIGHT |
+         GTK_STATE_FLAG_SELECTED |
+         GTK_STATE_FLAG_INSENSITIVE |
+         GTK_STATE_FLAG_INCONSISTENT |
+         GTK_STATE_FLAG_FOCUSED |
+         GTK_STATE_FLAG_BACKDROP |
+         GTK_STATE_FLAG_DIR_LTR |
+         GTK_STATE_FLAG_DIR_RTL |
+         GTK_STATE_FLAG_LINK |
+         GTK_STATE_FLAG_VISITED |
+         GTK_STATE_FLAG_CHECKED |
+         GTK_STATE_FLAG_DROP_ACTIVE |
+         GTK_STATE_FLAG_FOCUS_VISIBLE;
 }
 
 static gboolean
@@ -419,7 +448,15 @@ gtk_css_matcher_any_has_position (const GtkCssMatcher *matcher,
   return TRUE;
 }
 
+static void
+gtk_css_matcher_any_print (const GtkCssMatcher *matcher,
+                           GString             *string)
+{
+  g_string_append (string, "ANY");
+}
+
 static const GtkCssMatcherClass GTK_CSS_MATCHER_ANY = {
+  GTK_CSS_MATCHER_TYPE_ANY,
   gtk_css_matcher_any_get_parent,
   gtk_css_matcher_any_get_previous,
   gtk_css_matcher_any_get_state,
@@ -427,7 +464,7 @@ static const GtkCssMatcherClass GTK_CSS_MATCHER_ANY = {
   gtk_css_matcher_any_has_class,
   gtk_css_matcher_any_has_id,
   gtk_css_matcher_any_has_position,
-  TRUE
+  gtk_css_matcher_any_print
 };
 
 void
@@ -442,9 +479,17 @@ static gboolean
 gtk_css_matcher_superset_get_parent (GtkCssMatcher       *matcher,
                                      const GtkCssMatcher *child)
 {
-  _gtk_css_matcher_any_init (matcher);
+  gboolean ret = TRUE;
 
-  return TRUE;
+  if (child->klass->type == GTK_CSS_MATCHER_TYPE_NODE)
+    {
+      ret = gtk_css_matcher_node_get_parent (matcher, child);
+      matcher->klass = child->klass;
+     }
+  else
+    _gtk_css_matcher_any_init (matcher);
+
+  return ret;
 }
 
 static gboolean
@@ -456,83 +501,89 @@ gtk_css_matcher_superset_get_previous (GtkCssMatcher       *matcher,
   return TRUE;
 }
 
-static GtkStateFlags
-gtk_css_matcher_superset_get_state (const GtkCssMatcher *matcher)
+static void
+gtk_css_matcher_superset_print (const GtkCssMatcher *matcher,
+                                GString             *string)
 {
-  /* XXX: This gets tricky when we implement :not() */
-
-  if (matcher->superset.relevant & GTK_CSS_CHANGE_STATE)
-    return _gtk_css_matcher_get_state (matcher->superset.subset);
+  g_string_append (string, "SUPERSET(");
+  if (matcher->klass->type == GTK_CSS_MATCHER_TYPE_NODE)
+    gtk_css_node_print (matcher->node.node, 0, string, 0);
   else
-    return GTK_STATE_FLAG_ACTIVE | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED
-      | GTK_STATE_FLAG_INSENSITIVE | GTK_STATE_FLAG_INCONSISTENT
-      | GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_BACKDROP | GTK_STATE_FLAG_LINK
-      | GTK_STATE_FLAG_VISITED;
-}
-
-static gboolean
-gtk_css_matcher_superset_has_name (const GtkCssMatcher     *matcher,
-                                   /*interned*/ const char *name)
-{
-  if (matcher->superset.relevant & GTK_CSS_CHANGE_NAME)
-    return _gtk_css_matcher_has_name (matcher->superset.subset, name);
-  else
-    return TRUE;
-}
-
-static gboolean
-gtk_css_matcher_superset_has_class (const GtkCssMatcher *matcher,
-                                    GQuark               class_name)
-{
-  if (matcher->superset.relevant & GTK_CSS_CHANGE_CLASS)
-    return _gtk_css_matcher_has_class (matcher->superset.subset, class_name);
-  else
-    return TRUE;
-}
-
-static gboolean
-gtk_css_matcher_superset_has_id (const GtkCssMatcher *matcher,
-                                 const char          *id)
-{
-  if (matcher->superset.relevant & GTK_CSS_CHANGE_NAME)
-    return _gtk_css_matcher_has_id (matcher->superset.subset, id);
-  else
-    return TRUE;
-}
-
-static gboolean
-gtk_css_matcher_superset_has_position (const GtkCssMatcher *matcher,
-                                       gboolean             forward,
-                                       int                  a,
-                                       int                  b)
-{
-  if (matcher->superset.relevant & GTK_CSS_CHANGE_POSITION)
-    return _gtk_css_matcher_has_position (matcher->superset.subset, forward, a, b);
-  else
-    return TRUE;
+    g_string_append (string, "...");
+  g_string_append (string, ")");
 }
 
 static const GtkCssMatcherClass GTK_CSS_MATCHER_SUPERSET = {
+  0,
   gtk_css_matcher_superset_get_parent,
   gtk_css_matcher_superset_get_previous,
-  gtk_css_matcher_superset_get_state,
-  gtk_css_matcher_superset_has_name,
-  gtk_css_matcher_superset_has_class,
-  gtk_css_matcher_superset_has_id,
-  gtk_css_matcher_superset_has_position,
-  FALSE
+  gtk_css_matcher_any_get_state,
+  gtk_css_matcher_any_has_name,
+  gtk_css_matcher_any_has_class,
+  gtk_css_matcher_any_has_id,
+  gtk_css_matcher_any_has_position,
+  gtk_css_matcher_superset_print
 };
 
 void
 _gtk_css_matcher_superset_init (GtkCssMatcher       *matcher,
                                 const GtkCssMatcher *subset,
+                                GtkCssMatcherClass  *klass,
                                 GtkCssChange         relevant)
 {
   g_return_if_fail (subset != NULL);
-  g_return_if_fail ((relevant & ~(GTK_CSS_CHANGE_CLASS | GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_POSITION | GTK_CSS_CHANGE_STATE)) == 0);
+  g_return_if_fail ((relevant & ~(GTK_CSS_CHANGE_CLASS |
+                                  GTK_CSS_CHANGE_NAME |
+                                  GTK_CSS_CHANGE_ID |
+                                  GTK_CSS_CHANGE_POSITION |
+                                  GTK_CSS_CHANGE_STATE |
+                                  GTK_CSS_CHANGE_DISABLED |
+                                  GTK_CSS_CHANGE_BACKDROP |
+                                  GTK_CSS_CHANGE_HOVER)) == 0);
 
-  matcher->superset.klass = &GTK_CSS_MATCHER_SUPERSET;
-  matcher->superset.subset = subset;
-  matcher->superset.relevant = relevant;
+  switch (subset->klass->type)
+    {
+    case GTK_CSS_MATCHER_TYPE_NODE:
+      matcher->node = subset->node;
+      break;
+    case GTK_CSS_MATCHER_TYPE_WIDGET_PATH:
+      matcher->path = subset->path;
+      break;
+    case GTK_CSS_MATCHER_TYPE_ANY:
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  *klass = GTK_CSS_MATCHER_SUPERSET;
+  klass->type = subset->klass->type;
+
+  if (relevant & GTK_CSS_CHANGE_CLASS)
+    klass->has_class = subset->klass->has_class;
+  if (relevant & GTK_CSS_CHANGE_NAME)
+    klass->has_name = subset->klass->has_name;
+  if (relevant & GTK_CSS_CHANGE_ID)
+    klass->has_id = subset->klass->has_id;
+  if (relevant & GTK_CSS_CHANGE_POSITION)
+    klass->has_position = subset->klass->has_position;
+  if (relevant & (GTK_CSS_CHANGE_STATE|GTK_CSS_CHANGE_HOVER|GTK_CSS_CHANGE_DISABLED|GTK_CSS_CHANGE_BACKDROP))
+    klass->get_state = subset->klass->get_state;
+
+  matcher->klass = klass;
 }
 
+void
+gtk_css_matcher_print (const GtkCssMatcher *matcher,
+                       GString             *string)
+{
+  matcher->klass->print (matcher, string);
+}
+
+char *
+gtk_css_matcher_to_string (const GtkCssMatcher *matcher)
+{
+  GString *string = g_string_new ("");
+  gtk_css_matcher_print (matcher, string);
+  return g_string_free (string, FALSE);
+}

gtk/gtkcssmatcherprivate.h

@@ -29,7 +29,14 @@ typedef struct _GtkCssMatcherSuperset GtkCssMatcherSuperset;
 typedef struct _GtkCssMatcherWidgetPath GtkCssMatcherWidgetPath;
 typedef struct _GtkCssMatcherClass GtkCssMatcherClass;
 
+typedef enum {
+  GTK_CSS_MATCHER_TYPE_NODE,
+  GTK_CSS_MATCHER_TYPE_WIDGET_PATH,
+ GTK_CSS_MATCHER_TYPE_ANY
+} GtkCssMatcherType;
+
 struct _GtkCssMatcherClass {
+  GtkCssMatcherType type;
   gboolean        (* get_parent)                  (GtkCssMatcher          *matcher,
                                                    const GtkCssMatcher    *child);
   gboolean        (* get_previous)                (GtkCssMatcher          *matcher,
@@ -46,7 +53,8 @@ struct _GtkCssMatcherClass {
                                                    gboolean               forward,
                                                    int                    a,
                                                    int                    b);
-  gboolean is_any;
+  void            (* print)                       (const GtkCssMatcher   *matcher,
+                                                   GString               *string);
 };
 
 struct _GtkCssMatcherWidgetPath {
@@ -67,17 +75,10 @@ struct _GtkCssMatcherNode {
   guint                     n_classes;
 };
 
-struct _GtkCssMatcherSuperset {
-  const GtkCssMatcherClass *klass;
-  const GtkCssMatcher      *subset;
-  GtkCssChange              relevant;
-};
-
 union _GtkCssMatcher {
   const GtkCssMatcherClass *klass;
   GtkCssMatcherWidgetPath   path;
   GtkCssMatcherNode         node;
-  GtkCssMatcherSuperset     superset;
 };
 
 gboolean          _gtk_css_matcher_init           (GtkCssMatcher          *matcher,
@@ -88,6 +89,7 @@ void              _gtk_css_matcher_node_init      (GtkCssMatcher          *match
 void              _gtk_css_matcher_any_init       (GtkCssMatcher          *matcher);
 void              _gtk_css_matcher_superset_init  (GtkCssMatcher          *matcher,
                                                    const GtkCssMatcher    *subset,
+                                                   GtkCssMatcherClass     *klass,
                                                    GtkCssChange            relevant);
 
 
@@ -144,9 +146,12 @@ _gtk_css_matcher_has_position (const GtkCssMatcher *matcher,
 static inline gboolean
 _gtk_css_matcher_matches_any (const GtkCssMatcher *matcher)
 {
-  return matcher->klass->is_any;
+  return matcher->klass->type == GTK_CSS_MATCHER_TYPE_ANY;
 }
 
+void    gtk_css_matcher_print    (const GtkCssMatcher *matcher,
+                                  GString             *string);
+char * gtk_css_matcher_to_string (const GtkCssMatcher *matcher);
 
 G_END_DECLS
 

gtk/gtkcssnode.c

@@ -348,12 +348,14 @@ store_in_global_parent_cache (GtkCssNode                  *node,
 }
 
 static GtkCssStyle *
-gtk_css_node_create_style (GtkCssNode *cssnode)
+gtk_css_node_create_style (GtkCssNode   *cssnode,
+                           GtkCssChange  change)
 {
   const GtkCssNodeDeclaration *decl;
   GtkCssMatcher matcher;
   GtkCssStyle *parent;
   GtkCssStyle *style;
+  gboolean compute_change;
 
   decl = gtk_css_node_get_declaration (cssnode);
 
@@ -363,14 +365,24 @@ gtk_css_node_create_style (GtkCssNode *cssnode)
 
   parent = cssnode->parent ? cssnode->parent->style : NULL;
 
+  compute_change = change & (GTK_CSS_CHANGE_ID | GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_CLASS | GTK_CSS_CHANGE_SOURCE);
+
   if (gtk_css_node_init_matcher (cssnode, &matcher))
     style = gtk_css_static_style_new_compute (gtk_css_node_get_style_provider (cssnode),
                                               &matcher,
-                                              parent);
+                                              parent,
+                                              compute_change);
   else
     style = gtk_css_static_style_new_compute (gtk_css_node_get_style_provider (cssnode),
                                               NULL,
-                                              parent);
+                                              parent,
+                                              compute_change);
+
+  if (!compute_change)
+    {
+      GtkCssStyle *old_style = gtk_css_style_get_static_style (cssnode->style);
+      ((GtkCssStaticStyle *)style)->change = ((GtkCssStaticStyle *)old_style)->change;
+    }
 
   store_in_global_parent_cache (cssnode, decl, style);
 
@@ -407,17 +419,10 @@ gtk_css_node_real_update_style (GtkCssNode   *cssnode,
 {
   GtkCssStyle *static_style, *new_static_style, *new_style;
 
-  if (GTK_IS_CSS_ANIMATED_STYLE (style))
-    {
-      static_style = GTK_CSS_ANIMATED_STYLE (style)->style;
-    }
-  else
-    {
-      static_style = style;
-    }
+  static_style = gtk_css_style_get_static_style (style);
 
   if (gtk_css_style_needs_recreation (static_style, change))
-    new_static_style = gtk_css_node_create_style (cssnode);
+    new_static_style = gtk_css_node_create_style (cssnode, change);
   else
     new_static_style = g_object_ref (static_style);
 
@@ -436,7 +441,7 @@ gtk_css_node_real_update_style (GtkCssNode   *cssnode,
     }
   else if (static_style != style && (change & GTK_CSS_CHANGE_TIMESTAMP))
     {
-      new_style = gtk_css_animated_style_new_advance (GTK_CSS_ANIMATED_STYLE (style),
+      new_style = gtk_css_animated_style_new_advance ((GtkCssAnimatedStyle *)style,
                                                       static_style,
                                                       timestamp);
     }
@@ -1138,9 +1143,27 @@ void
 gtk_css_node_set_state (GtkCssNode    *cssnode,
                         GtkStateFlags  state_flags)
 {
+  GtkStateFlags old_state;
+
+  old_state = gtk_css_node_declaration_get_state (cssnode->decl);
+
   if (gtk_css_node_declaration_set_state (&cssnode->decl, state_flags))
     {
-      gtk_css_node_invalidate (cssnode, GTK_CSS_CHANGE_STATE);
+      GtkStateFlags states = old_state ^ state_flags;
+      GtkCssChange change = 0;
+
+      if (states & GTK_STATE_FLAG_PRELIGHT)
+        change |= GTK_CSS_CHANGE_HOVER;
+      if (states & GTK_STATE_FLAG_INSENSITIVE)
+        change |= GTK_CSS_CHANGE_DISABLED;
+      if (states & ~GTK_STATE_FLAG_PRELIGHT)
+        change |= GTK_CSS_CHANGE_STATE;
+      if (states & ~GTK_STATE_FLAG_BACKDROP)
+        change |= GTK_CSS_CHANGE_BACKDROP;
+      if (states & ~GTK_STATE_FLAG_SELECTED)
+        change |= GTK_CSS_CHANGE_SELECTED;
+
+      gtk_css_node_invalidate (cssnode, change);
       g_object_notify_by_pspec (G_OBJECT (cssnode), cssnode_properties[PROP_STATE]);
     }
 }

gtk/gtkcssprovider.c

@@ -425,61 +425,43 @@ verify_tree_match_results (GtkCssProvider *provider,
 #endif
 }
 
-static void
-verify_tree_get_change_results (GtkCssProvider *provider,
-				const GtkCssMatcher *matcher,
-				GtkCssChange change)
+static GtkCssChange
+get_change (GtkCssProvider      *provider,
+            const GtkCssMatcher *matcher)
 {
-#ifdef VERIFY_TREE
+  GtkCssProviderPrivate *priv = gtk_css_provider_get_instance_private (provider);
+  GtkCssChange change = 0;
+  GPtrArray *tree_rules;
+  int i;
+
+  tree_rules = _gtk_css_selector_tree_match_all (priv->tree, matcher);
+  if (tree_rules)
+    {
+      for (i = tree_rules->len - 1; i >= 0; i--)
+        {
+	  GtkCssRuleset *ruleset;
+
+          ruleset = tree_rules->pdata[i];
+
+          change |= _gtk_css_selector_get_change (ruleset->selector);
+        }
+
+      g_ptr_array_free (tree_rules, TRUE);
+   }
+
+#if 0
   {
-    GtkCssProviderPrivate *priv = gtk_css_provider_get_instance_private (provider);
-    GtkCssChange verify_change = 0;
-    GPtrArray *tree_rules;
-    int i;
-
-    tree_rules = _gtk_css_selector_tree_match_all (priv->tree, matcher);
-    if (tree_rules)
-      {
-        verify_tree_match_results (provider, matcher, tree_rules);
-
-        for (i = tree_rules->len - 1; i >= 0; i--)
-          {
-	    GtkCssRuleset *ruleset;
-
-            ruleset = tree_rules->pdata[i];
-
-            verify_change |= _gtk_css_selector_get_change (ruleset->selector);
-          }
-
-        g_ptr_array_free (tree_rules, TRUE);
-      }
-
-    if (change != verify_change)
-      {
-	GString *s;
-
-	s = g_string_new ("");
-	g_string_append (s, "expected change ");
-        gtk_css_change_print (verify_change, s);
-        g_string_append (s, ", but it was ");
-        gtk_css_change_print (change, s);
-	if ((change & ~verify_change) != 0)
-          {
-	    g_string_append (s, ", unexpectedly set: ");
-            gtk_css_change_print (change & ~verify_change, s);
-          }
-	if ((~change & verify_change) != 0)
-          {
-	    g_string_append_printf (s, ", unexpectedly not set: ");
-            gtk_css_change_print (~change & verify_change, s);
-          }
-	g_warning (s->str);
-	g_string_free (s, TRUE);
-      }
+    char *s = gtk_css_matcher_to_string (matcher);
+    char *d = gtk_css_change_to_string (change);
+    int n = tree_rules ? tree_rules->len : 0;
+    g_print ("change for %s from %d rules: %s\n", s, n, d);
+    g_free (s);
+    g_free (d);
   }
 #endif
-}
 
+  return change;
+}
 
 static GtkCssValue *
 gtk_css_style_provider_get_color (GtkStyleProvider *provider,
@@ -553,11 +535,11 @@ gtk_css_style_provider_lookup (GtkStyleProvider    *provider,
   if (change)
     {
       GtkCssMatcher change_matcher;
+      GtkCssMatcherClass matcher_class;
 
-      _gtk_css_matcher_superset_init (&change_matcher, matcher, GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_CLASS);
+      _gtk_css_matcher_superset_init (&change_matcher, matcher, &matcher_class, GTK_CSS_CHANGE_CLASS | GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_ID);
 
-      *change = _gtk_css_selector_tree_get_change_all (priv->tree, &change_matcher);
-      verify_tree_get_change_results (css_provider, &change_matcher, *change);
+      *change = get_change (css_provider, &change_matcher);
     }
 }
 
@@ -1048,6 +1030,7 @@ gtk_css_provider_postprocess (GtkCssProvider *css_provider)
   priv->tree = _gtk_css_selector_tree_builder_build (builder);
   _gtk_css_selector_tree_builder_free (builder);
 
+#if 0
 #ifndef VERIFY_TREE
   for (i = 0; i < priv->rulesets->len; i++)
     {
@@ -1059,6 +1042,7 @@ gtk_css_provider_postprocess (GtkCssProvider *css_provider)
       ruleset->selector = NULL;
     }
 #endif
+#endif
 }
 
 static void

gtk/gtkcssselector.c

@@ -30,13 +30,15 @@
 # include <intrin.h>
 #endif
 
+#undef PRINT_TREE
+
 typedef struct _GtkCssSelectorClass GtkCssSelectorClass;
 typedef gboolean (* GtkCssSelectorForeachFunc) (const GtkCssSelector *selector,
                                                 const GtkCssMatcher  *matcher,
                                                 gpointer              data);
 
 struct _GtkCssSelectorClass {
-  const char        *name;
+  const char         *name;
 
   void              (* print)       (const GtkCssSelector       *selector,
                                      GString                    *string);
@@ -728,6 +730,30 @@ comp_pseudoclass_state (const GtkCssSelector *a,
   return a->state.state - b->state.state;
 }
 
+#define GTK_CSS_CHANGE_PSEUDOCLASS_HOVER GTK_CSS_CHANGE_HOVER
+DEFINE_SIMPLE_SELECTOR(pseudoclass_hover, PSEUDOCLASS_HOVER, print_pseudoclass_state,
+                       match_pseudoclass_state, hash_pseudoclass_state, comp_pseudoclass_state,
+                       FALSE, TRUE, FALSE)
+#undef GTK_CSS_CHANGE_PSEUDOCLASS_HOVER
+
+#define GTK_CSS_CHANGE_PSEUDOCLASS_DISABLED GTK_CSS_CHANGE_DISABLED
+DEFINE_SIMPLE_SELECTOR(pseudoclass_disabled, PSEUDOCLASS_DISABLED, print_pseudoclass_state,
+                       match_pseudoclass_state, hash_pseudoclass_state, comp_pseudoclass_state,
+                       FALSE, TRUE, FALSE)
+#undef GTK_CSS_CHANGE_PSEUDOCLASS_DISABLED
+
+#define GTK_CSS_CHANGE_PSEUDOCLASS_BACKDROP GTK_CSS_CHANGE_BACKDROP
+DEFINE_SIMPLE_SELECTOR(pseudoclass_backdrop, PSEUDOCLASS_BACKDROP, print_pseudoclass_state,
+                       match_pseudoclass_state, hash_pseudoclass_state, comp_pseudoclass_state,
+                       FALSE, TRUE, FALSE)
+#undef GTK_CSS_CHANGE_PSEUDOCLASS_BACKDROP
+
+#define GTK_CSS_CHANGE_PSEUDOCLASS_SELECTED GTK_CSS_CHANGE_SELECTED
+DEFINE_SIMPLE_SELECTOR(pseudoclass_selected, PSEUDOCLASS_SELECTED, print_pseudoclass_state,
+                       match_pseudoclass_state, hash_pseudoclass_state, comp_pseudoclass_state,
+                       FALSE, TRUE, FALSE)
+#undef GTK_CSS_CHANGE_PSEUDOCLASS_SELECTED
+
 #define GTK_CSS_CHANGE_PSEUDOCLASS_STATE GTK_CSS_CHANGE_STATE
 DEFINE_SIMPLE_SELECTOR(pseudoclass_state, PSEUDOCLASS_STATE, print_pseudoclass_state,
                        match_pseudoclass_state, hash_pseudoclass_state, comp_pseudoclass_state,
@@ -1288,9 +1314,26 @@ gtk_css_selector_parse_selector_pseudo_class (GtkCssParser   *parser,
             {
               if (pseudo_classes[i].state_flag)
                 {
-                  selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_STATE
-                                                          : &GTK_CSS_SELECTOR_PSEUDOCLASS_STATE,
-                                                   selector);
+                  if (pseudo_classes[i].state_flag == GTK_STATE_FLAG_PRELIGHT)
+                    selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_HOVER
+                                                            : &GTK_CSS_SELECTOR_PSEUDOCLASS_HOVER,
+                                                     selector);
+                  else if (pseudo_classes[i].state_flag == GTK_STATE_FLAG_INSENSITIVE)
+                    selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_DISABLED
+                                                            : &GTK_CSS_SELECTOR_PSEUDOCLASS_DISABLED,
+                                                     selector);
+                  else if (pseudo_classes[i].state_flag == GTK_STATE_FLAG_BACKDROP)
+                    selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_BACKDROP
+                                                            : &GTK_CSS_SELECTOR_PSEUDOCLASS_BACKDROP,
+                                                     selector);
+                  else if (pseudo_classes[i].state_flag == GTK_STATE_FLAG_SELECTED)
+                    selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_SELECTED
+                                                            : &GTK_CSS_SELECTOR_PSEUDOCLASS_SELECTED,
+                                                     selector);
+                  else 
+                    selector = gtk_css_selector_new (negate ? &GTK_CSS_SELECTOR_NOT_PSEUDOCLASS_STATE
+                                                            : &GTK_CSS_SELECTOR_PSEUDOCLASS_STATE,
+                                                     selector);
                   selector->state.state = pseudo_classes[i].state_flag;
                 }
               else
@@ -1836,86 +1879,23 @@ _gtk_css_selector_tree_match_all (const GtkCssSelectorTree *tree,
   return array;
 }
 
-/* When checking for changes via the tree we need to know if a rule further
-   down the tree matched, because if so we need to add "our bit" to the
-   Change. For instance in a match like *.class:active we'll
-   get a tree that first checks :active, if that matches we continue down
-   to the tree, and if we get a match we add CHANGE_CLASS. However, the
-   end of the tree where we have a match is an ANY which doesn't actually
-   modify the change, so we don't know if we have a match or not. We fix
-   this by setting GTK_CSS_CHANGE_GOT_MATCH which lets us guarantee
-   that change != 0 on any match. */
-#define GTK_CSS_CHANGE_GOT_MATCH GTK_CSS_CHANGE_RESERVED_BIT
-
-static GtkCssChange
-gtk_css_selector_tree_collect_change (const GtkCssSelectorTree *tree)
-{
-  GtkCssChange change = 0;
-  const GtkCssSelectorTree *prev;
-
-  for (prev = gtk_css_selector_tree_get_previous (tree);
-       prev != NULL;
-       prev = gtk_css_selector_tree_get_sibling (prev))
-    change |= gtk_css_selector_tree_collect_change (prev);
-
-  change = tree->selector.class->get_change (&tree->selector, change);
-
-  return change;
-}
-
-static GtkCssChange
-gtk_css_selector_tree_get_change (const GtkCssSelectorTree *tree,
-				  const GtkCssMatcher      *matcher)
-{
-  GtkCssChange change = 0;
-  const GtkCssSelectorTree *prev;
-
-  if (!gtk_css_selector_match (&tree->selector, matcher))
-    return 0;
-
-  if (!tree->selector.class->is_simple)
-    return gtk_css_selector_tree_collect_change (tree) | GTK_CSS_CHANGE_GOT_MATCH;
-
-  for (prev = gtk_css_selector_tree_get_previous (tree);
-       prev != NULL;
-       prev = gtk_css_selector_tree_get_sibling (prev))
-    change |= gtk_css_selector_tree_get_change (prev, matcher);
-
-  if (change || gtk_css_selector_tree_get_matches (tree))
-    change = tree->selector.class->get_change (&tree->selector, change & ~GTK_CSS_CHANGE_GOT_MATCH) | GTK_CSS_CHANGE_GOT_MATCH;
-
-  return change;
-}
-
 gboolean
 _gtk_css_selector_tree_is_empty (const GtkCssSelectorTree *tree)
 {
   return tree == NULL;
 }
 
-GtkCssChange
-_gtk_css_selector_tree_get_change_all (const GtkCssSelectorTree *tree,
-				       const GtkCssMatcher *matcher)
-{
-  GtkCssChange change;
-
-  change = 0;
-
-  /* no need to foreach here because we abort for non-simple selectors */
-  for (; tree != NULL;
-       tree = gtk_css_selector_tree_get_sibling (tree))
-    change |= gtk_css_selector_tree_get_change (tree, matcher);
-
-  /* Never return reserved bit set */
-  return change & ~GTK_CSS_CHANGE_RESERVED_BIT;
-}
-
 #ifdef PRINT_TREE
+
 static void
-_gtk_css_selector_tree_print (const GtkCssSelectorTree *tree, GString *str, char *prefix)
+_gtk_css_selector_tree_print_recurse (const GtkCssSelectorTree *tree,
+                                      GString                  *str,
+                                      const char               *prefix,
+                                      GHashTable               *counts)
 {
   gboolean first = TRUE;
   int len, i;
+  int count;
 
   for (; tree != NULL; tree = gtk_css_selector_tree_get_sibling (tree), first = FALSE)
     {
@@ -1941,6 +1921,10 @@ _gtk_css_selector_tree_print (const GtkCssSelectorTree *tree, GString *str, char
       tree->selector.class->print (&tree->selector, str);
       len = str->len - len;
 
+      count = GPOINTER_TO_INT (g_hash_table_lookup (counts, (gpointer)tree->selector.class->name));
+      count++;
+      g_hash_table_insert (counts, (gpointer)tree->selector.class->name, GINT_TO_POINTER (count));
+
       if (gtk_css_selector_tree_get_previous (tree))
 	{
 	  GString *prefix2 = g_string_new (prefix);
@@ -1952,13 +1936,35 @@ _gtk_css_selector_tree_print (const GtkCssSelectorTree *tree, GString *str, char
 	  for (i = 0; i < len; i++)
 	    g_string_append_c (prefix2, ' ');
 
-	  _gtk_css_selector_tree_print (gtk_css_selector_tree_get_previous (tree), str, prefix2->str);
+	  _gtk_css_selector_tree_print_recurse (gtk_css_selector_tree_get_previous (tree), str, prefix2->str, counts);
 	  g_string_free (prefix2, TRUE);
 	}
       else
 	g_string_append (str, "\n");
     }
 }
+
+static void
+_gtk_css_selector_tree_print (const GtkCssSelectorTree *tree, GString *str, const char *prefix)
+{
+  GHashTable *counts;
+  GHashTableIter iter;
+  const char *key;
+  gpointer value;
+
+  counts = g_hash_table_new (g_str_hash, g_str_equal);
+
+  _gtk_css_selector_tree_print_recurse (tree, str, prefix, counts);
+
+  g_string_append (str, "\n\nSelector counts:\n");
+  g_hash_table_iter_init (&iter, counts);
+  while (g_hash_table_iter_next (&iter, (gpointer *)&key, &value))
+    g_string_append_printf (str, "%-*s    %4d\n", (int)strlen ("not_pseudoclass_position"), key, GPOINTER_TO_INT (value));
+
+  g_string_append (str, "\n");
+
+  g_hash_table_unref (counts);
+}
 #endif
 
 void

gtk/gtkcssselectorprivate.h

@@ -43,8 +43,6 @@ int               _gtk_css_selector_compare         (const GtkCssSelector   *a,
 void         _gtk_css_selector_tree_free             (GtkCssSelectorTree       *tree);
 GPtrArray *  _gtk_css_selector_tree_match_all        (const GtkCssSelectorTree *tree,
 						      const GtkCssMatcher      *matcher);
-GtkCssChange _gtk_css_selector_tree_get_change_all   (const GtkCssSelectorTree *tree,
-						      const GtkCssMatcher *matcher);
 void         _gtk_css_selector_tree_match_print      (const GtkCssSelectorTree *tree,
 						      GString                  *str);
 gboolean     _gtk_css_selector_tree_is_empty         (const GtkCssSelectorTree *tree) G_GNUC_CONST;

gtk/gtkcssstaticstyle.c

@@ -158,7 +158,8 @@ gtk_css_static_style_get_default (void)
       settings = gtk_settings_get_default ();
       default_style = gtk_css_static_style_new_compute (GTK_STYLE_PROVIDER (settings),
                                                         NULL,
-                                                        NULL);
+                                                        NULL,
+                                                        TRUE);
       g_object_set_data_full (G_OBJECT (settings), I_("gtk-default-style"),
                               default_style, clear_default_style);
     }
@@ -169,7 +170,8 @@ gtk_css_static_style_get_default (void)
 GtkCssStyle *
 gtk_css_static_style_new_compute (GtkStyleProvider    *provider,
                                   const GtkCssMatcher *matcher,
-                                  GtkCssStyle         *parent)
+                                  GtkCssStyle         *parent,
+                                  gboolean             compute_change)
 {
   GtkCssStaticStyle *result;
   GtkCssLookup lookup;
@@ -181,7 +183,7 @@ gtk_css_static_style_new_compute (GtkStyleProvider    *provider,
     gtk_style_provider_lookup (provider,
                                matcher,
                                &lookup,
-                               &change);
+                               compute_change ? &change : NULL);
 
   result = g_object_new (GTK_TYPE_CSS_STATIC_STYLE, NULL);
 

gtk/gtkcssstaticstyleprivate.h

@@ -55,7 +55,8 @@ GType                   gtk_css_static_style_get_type           (void) G_GNUC_CO
 GtkCssStyle *           gtk_css_static_style_get_default        (void);
 GtkCssStyle *           gtk_css_static_style_new_compute        (GtkStyleProvider       *provider,
                                                                  const GtkCssMatcher    *matcher,
-                                                                 GtkCssStyle            *parent);
+                                                                 GtkCssStyle            *parent,
+                                                                 gboolean                compute_change);
 
 void                    gtk_css_static_style_compute_value      (GtkCssStaticStyle      *style,
                                                                  GtkStyleProvider       *provider,

gtk/gtkcssstyle.c

@@ -37,6 +37,7 @@
 #include "gtkstyleanimationprivate.h"
 #include "gtkstylepropertyprivate.h"
 #include "gtkstyleproviderprivate.h"
+#include "gtksettings.h"
 
 G_DEFINE_ABSTRACT_TYPE (GtkCssStyle, gtk_css_style, G_TYPE_OBJECT)
 
@@ -53,11 +54,18 @@ gtk_css_style_real_is_static (GtkCssStyle *style)
   return TRUE;
 }
 
+static GtkCssStyle *
+gtk_css_style_real_get_static_style (GtkCssStyle *style)
+{
+  return style;
+}
+
 static void
 gtk_css_style_class_init (GtkCssStyleClass *klass)
 {
   klass->get_section = gtk_css_style_real_get_section;
   klass->is_static = gtk_css_style_real_is_static;
+  klass->get_static_style = gtk_css_style_real_get_static_style;
 }
 
 static void
@@ -89,6 +97,14 @@ gtk_css_style_is_static (GtkCssStyle *style)
   return GTK_CSS_STYLE_GET_CLASS (style)->is_static (style);
 }
 
+GtkCssStyle *
+gtk_css_style_get_static_style (GtkCssStyle *style)
+{
+  gtk_internal_return_val_if_fail (GTK_IS_CSS_STYLE (style), NULL);
+
+  return GTK_CSS_STYLE_GET_CLASS (style)->get_static_style (style);
+}
+
 /*
  * gtk_css_style_print:
  * @style: a #GtkCssStyle
@@ -122,13 +138,24 @@ gtk_css_style_print (GtkCssStyle *style,
       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));
       value = gtk_css_style_get_value (style, i);
+      prop = _gtk_css_style_property_lookup_by_id (i);
+      if (skip_initial)
+        { 
+          GtkCssValue *initial = _gtk_css_style_property_get_initial_value (prop);
+          GtkCssStyle *default_style = gtk_css_static_style_get_default ();
+          GtkCssValue *computed = _gtk_css_value_compute (initial, i,
+                                                          GTK_STYLE_PROVIDER (gtk_settings_get_default ()),
+                                                          default_style,
+                                                          default_style);
+          gboolean is_initial = _gtk_css_value_equal (value, computed);
+          gtk_css_value_unref (computed);
+          if (is_initial)
+            continue;
+        }
+
+      section = gtk_css_style_get_section (style, i);
+      name = _gtk_style_property_get_name (GTK_STYLE_PROPERTY (prop));
 
       g_string_append_printf (string, "%*s%s: ", indent, "", name);
       _gtk_css_value_print (value, string);

gtk/gtkcssstyleprivate.h

@@ -56,6 +56,8 @@ struct _GtkCssStyleClass
                                                                  guint                   id);
   /* TRUE if this style will require changes based on timestamp */
   gboolean              (* is_static)                           (GtkCssStyle            *style);
+
+  GtkCssStyle *         (* get_static_style)                    (GtkCssStyle            *style);
 };
 
 GType                   gtk_css_style_get_type                  (void) G_GNUC_CONST;
@@ -74,6 +76,7 @@ gboolean                gtk_css_style_print                     (GtkCssStyle
 PangoAttrList *         gtk_css_style_get_pango_attributes      (GtkCssStyle            *style);
 
 PangoFontDescription *  gtk_css_style_get_pango_font            (GtkCssStyle            *style);
+GtkCssStyle *           gtk_css_style_get_static_style          (GtkCssStyle            *style);
 
 G_END_DECLS
 

gtk/gtkcsstypes.c

@@ -74,19 +74,20 @@ _gtk_css_change_for_sibling (GtkCssChange match)
                     | GTK_CSS_CHANGE_LAST_CHILD \
                     | GTK_CSS_CHANGE_NTH_CHILD \
                     | GTK_CSS_CHANGE_NTH_LAST_CHILD \
-                    | GTK_CSS_CHANGE_STATE )
+                    | GTK_CSS_CHANGE_STATE \
+                    | GTK_CSS_CHANGE_HOVER \
+                    | GTK_CSS_CHANGE_DISABLED \
+                    | GTK_CSS_CHANGE_SELECTED \
+                    | GTK_CSS_CHANGE_BACKDROP)
 
 #define KEEP_STATES ( ~(BASE_STATES|GTK_CSS_CHANGE_SOURCE|GTK_CSS_CHANGE_PARENT_STYLE) \
                     | GTK_CSS_CHANGE_NTH_CHILD \
                     | GTK_CSS_CHANGE_NTH_LAST_CHILD)
 
-#define SIBLING_SHIFT 8
-
-  return (match & KEEP_STATES) | ((match & BASE_STATES) << SIBLING_SHIFT);
+  return (match & KEEP_STATES) | ((match & BASE_STATES) << GTK_CSS_CHANGE_SIBLING_SHIFT);
 
 #undef BASE_STATES
 #undef KEEP_STATES
-#undef SIBLING_SHIFT
 }
 
 GtkCssChange
@@ -100,6 +101,10 @@ _gtk_css_change_for_child (GtkCssChange match)
                     | GTK_CSS_CHANGE_NTH_CHILD \
                     | GTK_CSS_CHANGE_NTH_LAST_CHILD \
                     | GTK_CSS_CHANGE_STATE \
+                    | GTK_CSS_CHANGE_HOVER \
+                    | GTK_CSS_CHANGE_DISABLED \
+                    | GTK_CSS_CHANGE_BACKDROP \
+                    | GTK_CSS_CHANGE_SELECTED \
                     | GTK_CSS_CHANGE_SIBLING_CLASS \
                     | GTK_CSS_CHANGE_SIBLING_NAME \
                     | GTK_CSS_CHANGE_SIBLING_ID \
@@ -107,14 +112,18 @@ _gtk_css_change_for_child (GtkCssChange match)
                     | GTK_CSS_CHANGE_SIBLING_LAST_CHILD \
                     | GTK_CSS_CHANGE_SIBLING_NTH_CHILD \
                     | GTK_CSS_CHANGE_SIBLING_NTH_LAST_CHILD \
-                    | GTK_CSS_CHANGE_SIBLING_STATE )
+                    | GTK_CSS_CHANGE_SIBLING_STATE \
+                    | GTK_CSS_CHANGE_SIBLING_HOVER \
+                    | GTK_CSS_CHANGE_SIBLING_DISABLED \
+                    | GTK_CSS_CHANGE_SIBLING_BACKDROP \
+                    | GTK_CSS_CHANGE_SIBLING_SELECTED)
 
-#define PARENT_SHIFT 16
+#define KEEP_STATES (~(BASE_STATES|GTK_CSS_CHANGE_SOURCE|GTK_CSS_CHANGE_PARENT_STYLE))
 
-  return (match & ~(BASE_STATES|GTK_CSS_CHANGE_SOURCE|GTK_CSS_CHANGE_PARENT_STYLE)) | ((match & BASE_STATES) << PARENT_SHIFT);
+  return (match & KEEP_STATES) | ((match & BASE_STATES) << GTK_CSS_CHANGE_PARENT_SHIFT);
 
 #undef BASE_STATES
-#undef PARENT_SHIFT
+#undef KEEP_STATES
 }
 
 void
@@ -133,6 +142,11 @@ gtk_css_change_print (GtkCssChange  change,
     { GTK_CSS_CHANGE_NTH_CHILD, "nth-child" },
     { GTK_CSS_CHANGE_NTH_LAST_CHILD, "nth-last-child" },
     { GTK_CSS_CHANGE_STATE, "state" },
+    { GTK_CSS_CHANGE_HOVER, "hover" },
+    { GTK_CSS_CHANGE_DISABLED, "disabled" },
+    { GTK_CSS_CHANGE_BACKDROP, "backdrop" },
+    { GTK_CSS_CHANGE_SELECTED, "selected" },
+
     { GTK_CSS_CHANGE_SIBLING_CLASS, "sibling-class" },
     { GTK_CSS_CHANGE_SIBLING_NAME, "sibling-name" },
     { GTK_CSS_CHANGE_SIBLING_ID, "sibling-id" },
@@ -141,6 +155,11 @@ gtk_css_change_print (GtkCssChange  change,
     { GTK_CSS_CHANGE_SIBLING_NTH_CHILD, "sibling-nth-child" },
     { GTK_CSS_CHANGE_SIBLING_NTH_LAST_CHILD, "sibling-nth-last-child" },
     { GTK_CSS_CHANGE_SIBLING_STATE, "sibling-state" },
+    { GTK_CSS_CHANGE_SIBLING_HOVER, "sibling-hover" },
+    { GTK_CSS_CHANGE_SIBLING_DISABLED, "sibling-disabled" },
+    { GTK_CSS_CHANGE_SIBLING_BACKDROP, "sibling-backdrop" },
+    { GTK_CSS_CHANGE_SIBLING_SELECTED, "sibling-selected" },
+
     { GTK_CSS_CHANGE_PARENT_CLASS, "parent-class" },
     { GTK_CSS_CHANGE_PARENT_NAME, "parent-name" },
     { GTK_CSS_CHANGE_PARENT_ID, "parent-id" },
@@ -149,6 +168,11 @@ gtk_css_change_print (GtkCssChange  change,
     { GTK_CSS_CHANGE_PARENT_NTH_CHILD, "parent-nth-child" },
     { GTK_CSS_CHANGE_PARENT_NTH_LAST_CHILD, "parent-nth-last-child" },
     { GTK_CSS_CHANGE_PARENT_STATE, "parent-state" },
+    { GTK_CSS_CHANGE_PARENT_HOVER, "parent-hover" },
+    { GTK_CSS_CHANGE_PARENT_DISABLED, "parent-disabled" },
+    { GTK_CSS_CHANGE_PARENT_BACKDROP, "parent-backdrop" },
+    { GTK_CSS_CHANGE_PARENT_SELECTED, "parent-selected" },
+
     { GTK_CSS_CHANGE_PARENT_SIBLING_CLASS, "parent-sibling-" },
     { GTK_CSS_CHANGE_PARENT_SIBLING_NAME, "parent-sibling-name" },
     { GTK_CSS_CHANGE_PARENT_SIBLING_ID, "parent-sibling-id" },
@@ -157,6 +181,11 @@ gtk_css_change_print (GtkCssChange  change,
     { GTK_CSS_CHANGE_PARENT_SIBLING_NTH_CHILD, "parent-sibling-nth-child" },
     { GTK_CSS_CHANGE_PARENT_SIBLING_NTH_LAST_CHILD, "parent-sibling-nth-last-child" },
     { GTK_CSS_CHANGE_PARENT_SIBLING_STATE, "parent-sibling-state" },
+    { GTK_CSS_CHANGE_PARENT_SIBLING_HOVER, "parent-sibling-hover" },
+    { GTK_CSS_CHANGE_PARENT_SIBLING_DISABLED, "parent-sibling-disabled" },
+    { GTK_CSS_CHANGE_PARENT_SIBLING_BACKDROP, "parent-sibling-backdrop" },
+    { GTK_CSS_CHANGE_PARENT_SIBLING_SELECTED, "parent-sibling-selected" },
+
     { GTK_CSS_CHANGE_SOURCE, "source" },
     { GTK_CSS_CHANGE_PARENT_STYLE, "parent-style" },
     { GTK_CSS_CHANGE_TIMESTAMP, "timestamp" },

gtk/gtkcsstypesprivate.h

@@ -36,61 +36,93 @@ typedef struct _GtkCssStyle GtkCssStyle;
 #define GTK_CSS_CHANGE_NTH_CHILD                      (1ULL <<  5)
 #define GTK_CSS_CHANGE_NTH_LAST_CHILD                 (1ULL <<  6)
 #define GTK_CSS_CHANGE_STATE                          (1ULL <<  7)
-#define GTK_CSS_CHANGE_SIBLING_CLASS                  (1ULL <<  8)
-#define GTK_CSS_CHANGE_SIBLING_NAME                   (1ULL <<  9)
-#define GTK_CSS_CHANGE_SIBLING_ID                     (1ULL << 10)
-#define GTK_CSS_CHANGE_SIBLING_FIRST_CHILD            (1ULL << 11)
-#define GTK_CSS_CHANGE_SIBLING_LAST_CHILD             (1ULL << 12)
-#define GTK_CSS_CHANGE_SIBLING_NTH_CHILD              (1ULL << 13)
-#define GTK_CSS_CHANGE_SIBLING_NTH_LAST_CHILD         (1ULL << 14)
-#define GTK_CSS_CHANGE_SIBLING_STATE                  (1ULL << 15)
-#define GTK_CSS_CHANGE_PARENT_CLASS                   (1ULL << 16)
-#define GTK_CSS_CHANGE_PARENT_NAME                    (1ULL << 17)
-#define GTK_CSS_CHANGE_PARENT_ID                      (1ULL << 18)
-#define GTK_CSS_CHANGE_PARENT_FIRST_CHILD             (1ULL << 19)
-#define GTK_CSS_CHANGE_PARENT_LAST_CHILD              (1ULL << 20)
-#define GTK_CSS_CHANGE_PARENT_NTH_CHILD               (1ULL << 21)
-#define GTK_CSS_CHANGE_PARENT_NTH_LAST_CHILD          (1ULL << 22)
-#define GTK_CSS_CHANGE_PARENT_STATE                   (1ULL << 23)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_CLASS           (1ULL << 24)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_ID              (1ULL << 25)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_NAME            (1ULL << 26)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_FIRST_CHILD     (1ULL << 27)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_LAST_CHILD      (1ULL << 28)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_NTH_CHILD       (1ULL << 29)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_NTH_LAST_CHILD  (1ULL << 30)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_STATE           (1ULL << 31)
+#define GTK_CSS_CHANGE_HOVER                          (1ULL <<  8)
+#define GTK_CSS_CHANGE_DISABLED                       (1ULL <<  9)
+#define GTK_CSS_CHANGE_BACKDROP                       (1ULL << 10)
+#define GTK_CSS_CHANGE_SELECTED                       (1ULL << 11)
+
+#define GTK_CSS_CHANGE_SIBLING_SHIFT 12 
+
+#define GTK_CSS_CHANGE_SIBLING_CLASS                  (1ULL << 12)
+#define GTK_CSS_CHANGE_SIBLING_NAME                   (1ULL << 13)
+#define GTK_CSS_CHANGE_SIBLING_ID                     (1ULL << 14)
+#define GTK_CSS_CHANGE_SIBLING_FIRST_CHILD            (1ULL << 15)
+#define GTK_CSS_CHANGE_SIBLING_LAST_CHILD             (1ULL << 16)
+#define GTK_CSS_CHANGE_SIBLING_NTH_CHILD              (1ULL << 17)
+#define GTK_CSS_CHANGE_SIBLING_NTH_LAST_CHILD         (1ULL << 18)
+#define GTK_CSS_CHANGE_SIBLING_STATE                  (1ULL << 19)
+#define GTK_CSS_CHANGE_SIBLING_HOVER                  (1ULL << 20)
+#define GTK_CSS_CHANGE_SIBLING_DISABLED               (1ULL << 21)
+#define GTK_CSS_CHANGE_SIBLING_BACKDROP               (1ULL << 22)
+#define GTK_CSS_CHANGE_SIBLING_SELECTED               (1ULL << 23)
+
+#define GTK_CSS_CHANGE_PARENT_SHIFT (GTK_CSS_CHANGE_SIBLING_SHIFT + GTK_CSS_CHANGE_SIBLING_SHIFT)
+
+#define GTK_CSS_CHANGE_PARENT_CLASS                   (1ULL << 24)
+#define GTK_CSS_CHANGE_PARENT_NAME                    (1ULL << 25)
+#define GTK_CSS_CHANGE_PARENT_ID                      (1ULL << 26)
+#define GTK_CSS_CHANGE_PARENT_FIRST_CHILD             (1ULL << 27)
+#define GTK_CSS_CHANGE_PARENT_LAST_CHILD              (1ULL << 28)
+#define GTK_CSS_CHANGE_PARENT_NTH_CHILD               (1ULL << 29)
+#define GTK_CSS_CHANGE_PARENT_NTH_LAST_CHILD          (1ULL << 30)
+#define GTK_CSS_CHANGE_PARENT_STATE                   (1ULL << 31)
+#define GTK_CSS_CHANGE_PARENT_HOVER                   (1ULL << 32)
+#define GTK_CSS_CHANGE_PARENT_DISABLED                (1ULL << 33)
+#define GTK_CSS_CHANGE_PARENT_BACKDROP                (1ULL << 34)
+#define GTK_CSS_CHANGE_PARENT_SELECTED                (1ULL << 35)
+
+#define GTK_CSS_CHANGE_PARENT_SIBLING_SHIFT (GTK_CSS_CHANGE_PARENT_SHIFT + GTK_CSS_CHANGE_SIBLING_SHIFT)
+
+#define GTK_CSS_CHANGE_PARENT_SIBLING_CLASS           (1ULL << 36)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_ID              (1ULL << 37)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_NAME            (1ULL << 38)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_FIRST_CHILD     (1ULL << 39)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_LAST_CHILD      (1ULL << 40)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_NTH_CHILD       (1ULL << 41)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_NTH_LAST_CHILD  (1ULL << 42)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_STATE           (1ULL << 43)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_HOVER           (1ULL << 44)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_DISABLED        (1ULL << 45)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_BACKDROP        (1ULL << 46)
+#define GTK_CSS_CHANGE_PARENT_SIBLING_SELECTED        (1ULL << 47)
 
 /* add more */
-#define GTK_CSS_CHANGE_SOURCE                         (1ULL << 32)
-#define GTK_CSS_CHANGE_PARENT_STYLE                   (1ULL << 33)
-#define GTK_CSS_CHANGE_TIMESTAMP                      (1ULL << 34)
-#define GTK_CSS_CHANGE_ANIMATIONS                     (1ULL << 35)
+#define GTK_CSS_CHANGE_SOURCE                         (1ULL << 48)
+#define GTK_CSS_CHANGE_PARENT_STYLE                   (1ULL << 49)
+#define GTK_CSS_CHANGE_TIMESTAMP                      (1ULL << 50)
+#define GTK_CSS_CHANGE_ANIMATIONS                     (1ULL << 51)
 
 #define GTK_CSS_CHANGE_RESERVED_BIT                   (1ULL << 62) /* Used internally in gtkcssselector.c */
 
 typedef guint64 GtkCssChange;
 
-#define GTK_CSS_CHANGE_POSITION (GTK_CSS_CHANGE_FIRST_CHILD | GTK_CSS_CHANGE_LAST_CHILD | \
-                                 GTK_CSS_CHANGE_NTH_CHILD | GTK_CSS_CHANGE_NTH_LAST_CHILD)
-#define GTK_CSS_CHANGE_SIBLING_POSITION (GTK_CSS_CHANGE_SIBLING_FIRST_CHILD | GTK_CSS_CHANGE_SIBLING_LAST_CHILD | \
-                                         GTK_CSS_CHANGE_SIBLING_NTH_CHILD | GTK_CSS_CHANGE_SIBLING_NTH_LAST_CHILD)
-#define GTK_CSS_CHANGE_PARENT_POSITION (GTK_CSS_CHANGE_PARENT_FIRST_CHILD | GTK_CSS_CHANGE_PARENT_LAST_CHILD | \
-                                        GTK_CSS_CHANGE_PARENT_NTH_CHILD | GTK_CSS_CHANGE_PARENT_NTH_LAST_CHILD)
-#define GTK_CSS_CHANGE_PARENT_SIBLING_POSITION (GTK_CSS_CHANGE_PARENT_SIBLING_FIRST_CHILD | GTK_CSS_CHANGE_PARENT_SIBLING_LAST_CHILD | \
-                                                GTK_CSS_CHANGE_PARENT_SIBLING_NTH_CHILD | GTK_CSS_CHANGE_PARENT_SIBLING_NTH_LAST_CHILD)
+#define GTK_CSS_CHANGE_POSITION (GTK_CSS_CHANGE_FIRST_CHILD | \
+                                 GTK_CSS_CHANGE_LAST_CHILD  | \
+                                 GTK_CSS_CHANGE_NTH_CHILD   | \
+                                 GTK_CSS_CHANGE_NTH_LAST_CHILD)
+#define GTK_CSS_CHANGE_SIBLING_POSITION (GTK_CSS_CHANGE_POSITION << GTK_CSS_CHANGE_SIBLING_SHIFT)
 
+#define GTK_CSS_CHANGE_ANY_SELF (GTK_CSS_CHANGE_CLASS    | \
+                                 GTK_CSS_CHANGE_NAME     | \
+                                 GTK_CSS_CHANGE_ID       | \
+                                 GTK_CSS_CHANGE_POSITION | \
+                                 GTK_CSS_CHANGE_STATE    | \
+                                 GTK_CSS_CHANGE_DISABLED | \
+                                 GTK_CSS_CHANGE_BACKDROP | \
+                                 GTK_CSS_CHANGE_SELECTED | \
+                                 GTK_CSS_CHANGE_HOVER)
+#define GTK_CSS_CHANGE_ANY_SIBLING (GTK_CSS_CHANGE_ANY_SELF << GTK_CSS_CHANGE_SIBLING_SHIFT)
+#define GTK_CSS_CHANGE_ANY_PARENT (GTK_CSS_CHANGE_ANY_SELF << GTK_CSS_CHANGE_PARENT_SHIFT)
+#define GTK_CSS_CHANGE_ANY_PARENT_SIBLING (GTK_CSS_CHANGE_ANY_SELF << GTK_CSS_CHANGE_PARENT_SIBLING_SHIFT)
 
-#define GTK_CSS_CHANGE_ANY ((1 << 19) - 1)
-#define GTK_CSS_CHANGE_ANY_SELF (GTK_CSS_CHANGE_CLASS | GTK_CSS_CHANGE_NAME | GTK_CSS_CHANGE_ID | GTK_CSS_CHANGE_POSITION | GTK_CSS_CHANGE_STATE)
-#define GTK_CSS_CHANGE_ANY_SIBLING (GTK_CSS_CHANGE_SIBLING_CLASS | GTK_CSS_CHANGE_SIBLING_NAME | \
-                                    GTK_CSS_CHANGE_SIBLING_ID | \
-                                    GTK_CSS_CHANGE_SIBLING_POSITION | GTK_CSS_CHANGE_SIBLING_STATE)
-#define GTK_CSS_CHANGE_ANY_PARENT (GTK_CSS_CHANGE_PARENT_CLASS | GTK_CSS_CHANGE_PARENT_SIBLING_CLASS | \
-                                   GTK_CSS_CHANGE_PARENT_NAME | GTK_CSS_CHANGE_PARENT_SIBLING_NAME | \
-                                   GTK_CSS_CHANGE_PARENT_ID | GTK_CSS_CHANGE_PARENT_SIBLING_ID | \
-                                   GTK_CSS_CHANGE_PARENT_POSITION | GTK_CSS_CHANGE_PARENT_SIBLING_POSITION | \
-                                   GTK_CSS_CHANGE_PARENT_STATE | GTK_CSS_CHANGE_PARENT_SIBLING_STATE)
+#define GTK_CSS_CHANGE_ANY (GTK_CSS_CHANGE_ANY_SELF           | \
+                            GTK_CSS_CHANGE_ANY_SIBLING        | \
+                            GTK_CSS_CHANGE_ANY_PARENT         | \
+                            GTK_CSS_CHANGE_ANY_PARENT_SIBLING | \
+                            GTK_CSS_CHANGE_SOURCE             | \
+                            GTK_CSS_CHANGE_PARENT_STYLE       | \
+                            GTK_CSS_CHANGE_TIMESTAMP          | \
+                            GTK_CSS_CHANGE_ANIMATIONS)
 
 /*
  * GtkCssAffects:

testsuite/css/style/adjacent-states.nodes

@@ -6,8 +6,20 @@
         check:dir(ltr):checked
       label#label1:dir(ltr)
         color: rgb(255,0,0); /* adjacent-states.css:2:3-14 */
+        text-decoration-color: rgb(255,0,0);
+        border-top-color: rgb(255,0,0);
+        border-right-color: rgb(255,0,0);
+        border-bottom-color: rgb(255,0,0);
+        border-left-color: rgb(255,0,0);
+        outline-color: rgb(255,0,0);
     box.horizontal:dir(ltr)
       checkbutton:dir(ltr)
         check:dir(ltr)
       label#label2:dir(ltr)
         color: rgb(0,0,255); /* adjacent-states.css:6:3-15 */
+        text-decoration-color: rgb(0,0,255);
+        border-top-color: rgb(0,0,255);
+        border-right-color: rgb(0,0,255);
+        border-bottom-color: rgb(0,0,255);
+        border-left-color: rgb(0,0,255);
+        outline-color: rgb(0,0,255);

testsuite/css/style/currentcolor.nodes

@@ -2,6 +2,19 @@
   decoration:dir(ltr)
   box.horizontal:dir(ltr)
     color: rgb(255,0,0); /* currentcolor.css:2:3-14 */
+    text-decoration-color: rgb(255,0,0);
+    border-top-color: rgb(255,0,0);
+    border-right-color: rgb(255,0,0);
+    border-bottom-color: rgb(255,0,0);
+    border-left-color: rgb(255,0,0);
+    outline-color: rgb(255,0,0);
 
     label:dir(ltr)
+      color: rgb(255,0,0);
       background-color: rgb(255,0,0); /* currentcolor.css:6:3-34 */
+      text-decoration-color: rgb(255,0,0);
+      border-top-color: rgb(255,0,0);
+      border-right-color: rgb(255,0,0);
+      border-bottom-color: rgb(255,0,0);
+      border-left-color: rgb(255,0,0);
+      outline-color: rgb(255,0,0);

testsuite/css/style/font.nodes

@@ -3,38 +3,22 @@
   box.horizontal:dir(ltr)
     font-size: 10px; /* font.css:2:3-27 */
     font-family: "Comic Sans"; /* font.css:2:3-27 */
-    font-style: normal; /* font.css:2:3-27 */
-    font-weight: 400; /* font.css:2:3-27 */
-    font-stretch: normal; /* font.css:2:3-27 */
-    font-variant-caps: normal; /* font.css:2:3-27 */
 
     label#label1:dir(ltr)
       font-size: 8.3333333333333339px; /* font.css:6:3-22 */
+      font-family: "Comic Sans";
     label#label2:dir(ltr)
-      font-size: 13.333333333333334px; /* font.css:10:3-36 */
       font-family: "Cantarell", "sans-serif"; /* font.css:10:3-36 */
-      font-style: normal; /* font.css:10:3-36 */
-      font-weight: 400; /* font.css:10:3-36 */
-      font-stretch: normal; /* font.css:10:3-36 */
-      font-variant-caps: normal; /* font.css:10:3-36 */
     label#label3:dir(ltr)
       font-size: 8px; /* font.css:14:3-35 */
       font-family: "monospace"; /* font.css:14:3-35 */
       font-style: italic; /* font.css:14:3-35 */
       font-weight: 700; /* font.css:14:3-35 */
-      font-stretch: normal; /* font.css:14:3-35 */
-      font-variant-caps: normal; /* font.css:14:3-35 */
     label#label4:dir(ltr)
       font-size: 8px; /* font.css:18:3-41 */
       font-family: "serif"; /* font.css:18:3-41 */
       font-style: oblique; /* font.css:18:3-41 */
-      font-weight: 400; /* font.css:18:3-41 */
       font-stretch: expanded; /* font.css:18:3-41 */
-      font-variant-caps: normal; /* font.css:18:3-41 */
     label#label5:dir(ltr)
       font-size: 75.590551181102356px; /* font.css:22:3-29 */
       font-family: "21st Century"; /* font.css:22:3-29 */
-      font-style: normal; /* font.css:22:3-29 */
-      font-weight: 400; /* font.css:22:3-29 */
-      font-stretch: normal; /* font.css:22:3-29 */
-      font-variant-caps: normal; /* font.css:22:3-29 */

testsuite/css/style/inherit.nodes

@@ -2,9 +2,21 @@
   decoration:dir(ltr)
   box.horizontal:dir(ltr)
     color: rgb(255,0,0); /* inherit.css:2:3-14 */
+    text-decoration-color: rgb(255,0,0);
+    border-top-color: rgb(255,0,0);
+    border-right-color: rgb(255,0,0);
+    border-bottom-color: rgb(255,0,0);
+    border-left-color: rgb(255,0,0);
+    outline-color: rgb(255,0,0);
     opacity: 0.5; /* inherit.css:3:3-16 */
 
     label#label1:dir(ltr)
-      color: rgb(255,255,255); /* inherit.css:7:3-18 */
       opacity: 0.5; /* inherit.css:8:3-20 */
     label#label2:dir(ltr)
+      color: rgb(255,0,0);
+      text-decoration-color: rgb(255,0,0);
+      border-top-color: rgb(255,0,0);
+      border-right-color: rgb(255,0,0);
+      border-bottom-color: rgb(255,0,0);
+      border-left-color: rgb(255,0,0);
+      outline-color: rgb(255,0,0);

testsuite/css/style/label.nodes

@@ -5,3 +5,5 @@
     font-family: "Comic Sans"; /* label.css:2:3-29 */
 
     label:dir(ltr)
+      font-size: 10px;
+      font-family: "Comic Sans";