Refurbish GtkWidgetPath API.

The foreach() function is now gone, there's now API to get
GTypes and names from the position in the path.

gtk/gtkcssprovider.c

@@ -271,15 +271,12 @@ struct ComparePathData
 };
 
 static gboolean
-compare_path_foreach (GType        type,
+compare_selector_element (GtkWidgetPath   *path,
-                      const gchar *name,
+                          guint            index,
-                      gpointer     user_data)
+                          SelectorElement *elem,
+                          guint8          *score)
 {
-  ComparePathData *data;
+  *score = 0;
-  SelectorElement *elem;
-
-  data = user_data;
-  elem = data->iter->data;
 
   if (elem->elem_type == SELECTOR_TYPE_NAME)
     {
@@ -295,8 +292,7 @@ compare_path_foreach (GType        type,
           /* Type couldn't be resolved, so the selector
            * clearly doesn't affect the given widget path
            */
-          data->score = 0;
+          return FALSE;
-          return TRUE;
         }
 
       elem->elem_type = SELECTOR_GTYPE;
@@ -305,84 +301,95 @@ compare_path_foreach (GType        type,
 
   if (elem->elem_type == SELECTOR_GTYPE)
     {
+      GType type;
+
+      type = gtk_widget_path_get_element_type (path, index);
+
       if (!g_type_is_a (type, elem->type))
-        {
-          /* Selector definitely doesn't match */
-          if (elem->combinator == COMBINATOR_CHILD)
-            {
-              data->score = 0;
-              return TRUE;
-            }
-          else
-            {
-              /* Keep checking descendants for a match */
         return FALSE;
-            }
+
-        }
+      if (type == elem->type)
-      else if (type == elem->type)
+        *score |= 0xF;
-        data->score |= 0xF;
       else
         {
           GType parent = type;
-          guint8 score = 0xE;
+
+          *score = 0xE;
 
           while ((parent = g_type_parent (parent)) != G_TYPE_INVALID)
             {
               if (parent == elem->type)
                 break;
 
-              score--;
+              *score -= 1;
 
-              if (score == 1)
+              if (*score == 1)
                 {
                   g_warning ("Hierarchy is higher than expected.");
                   break;
                 }
             }
-
-          data->score |= score;
         }
+
+      return TRUE;
     }
   else if (elem->elem_type == SELECTOR_GLOB)
     {
       /* Treat as lowest matching type */
-      data->score++;
+      *score = 1;
-    }
-
-  data->iter = data->iter->next;
-
-  if (data->iter)
-    {
-      data->score <<= 4;
-      return FALSE;
-    }
-
       return TRUE;
     }
 
+  return FALSE;
+}
+
 static guint64
 compare_selector (GtkWidgetPath *path,
                   SelectorPath  *selector)
 {
-  ComparePathData data;
+  GSList *elements = selector->elements;
+  gboolean match = TRUE;
+  guint64 score = 0;
+  guint i = 0;
 
-  data.score = 0;
+  while (elements && match &&
-  data.path = selector;
+         i < gtk_widget_path_length (path))
-  data.iter = selector->elements;
-
-  gtk_widget_path_foreach (path,
-                           compare_path_foreach,
-                           &data);
-
-  if (data.iter)
     {
-      /* There is remaining data to compare,
+      SelectorElement *elem;
-       * so don't take it as a match.
+      guint8 elem_score;
+
+      elem = elements->data;
+      elements = elements->next;
+
+      match = compare_selector_element (path, i, elem, &elem_score);
+      i++;
+
+      if (!match && elem->combinator == COMBINATOR_DESCENDANT)
+        {
+          /* With descendant combinators there may
+           * be intermediate chidren in the hierarchy
            */
-      data.score = 0;
+          match = TRUE;
         }
 
-  return data.score;
+      if (match)
+        {
+          score <<= 4;
+          score |= elem_score;
+        }
+    }
+
+  /* If there are pending selector
+   * elements to compare, it's not
+   * a match.
+   */
+  if (elements)
+    match = FALSE;
+
+  if (!match)
+    score = 0;
+
+  return score;
 }
 
 typedef struct StylePriorityInfo StylePriorityInfo;

gtk/gtkwidget.c

@@ -13191,9 +13191,7 @@ gtk_widget_get_path (GtkWidget *widget)
 
   while (widget)
     {
-      gtk_widget_path_prepend_widget_desc (path,
+      gtk_widget_path_prepend_type (path, G_OBJECT_TYPE (widget));
-                                           G_OBJECT_TYPE (widget),
-                                           widget->name);
       widget = widget->parent;
     }
 

gtk/gtkwidgetpath.c

@@ -34,8 +34,7 @@ struct GtkPathElement
 
 struct GtkWidgetPath
 {
-  GSList *elems;
+  GArray *elems; /* First element contains the described widget */
-  GSList *last; /* Last element contains the described widget */
 };
 
 GtkWidgetPath *
@@ -44,78 +43,31 @@ gtk_widget_path_new (void)
   GtkWidgetPath *path;
 
   path = g_slice_new0 (GtkWidgetPath);
+  path->elems = g_array_new (FALSE, TRUE, sizeof (GtkPathElement));
 
   return path;
 }
 
-static GtkPathElement *
-path_element_new (GType        type,
-                  const gchar *name)
-{
-  GtkPathElement *elem;
-
-  elem = g_slice_new (GtkPathElement);
-  elem->type = type;
-  elem->name = g_strdup (name);
-
-  return elem;
-}
-
-static void
-path_element_free (GtkPathElement *elem)
-{
-  g_free (elem->name);
-  g_slice_free (GtkPathElement, elem);
-}
-
-void
-gtk_widget_path_prepend_widget_desc (GtkWidgetPath *path,
-                                     GType          type,
-                                     const gchar   *name)
-{
-  g_return_if_fail (path != NULL);
-  g_return_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET));
-
-  if (!path->elems)
-    {
-      path->elems = g_slist_prepend (NULL, path_element_new (type, name));
-      path->last = path->elems;
-    }
-  else
-    {
-      path->last->next = g_slist_alloc ();
-      path->last->next->data = path_element_new (type, name);
-      path->last = path->last->next;
-    }
-}
-
 GtkWidgetPath *
-gtk_widget_path_copy (GtkWidgetPath *path)
+gtk_widget_path_copy (const GtkWidgetPath *path)
 {
   GtkWidgetPath *new_path;
-  GSList *elems;
+  guint i;
+
+  g_return_val_if_fail (path != NULL, NULL);
 
   new_path = gtk_widget_path_new ();
-  elems = path->elems;
 
-  while (elems)
+  for (i = 0; i < path->elems->len; i++)
     {
-      GtkPathElement *elem;
+      GtkPathElement *elem, new = { 0 };
-      GSList *link;
 
-      elem = elems->data;
+      elem = &g_array_index (path->elems, GtkPathElement, i);
-      link = g_slist_alloc ();
-      link->data = path_element_new (elem->type, elem->name);
 
-      if (!new_path->elems)
+      new.type = elem->type;
-        new_path->last = new_path->elems = link;
+      new.name = g_strdup (elem->name);
-      else
-        {
-          new_path->last->next = link;
-          new_path->last = link;
-        }
 
-      elems = elems->next;
+      g_array_append_val (new_path->elems, new);
     }
 
   return new_path;
@@ -124,59 +76,124 @@ gtk_widget_path_copy (GtkWidgetPath *path)
 void
 gtk_widget_path_free (GtkWidgetPath *path)
 {
+  guint i;
+
   g_return_if_fail (path != NULL);
 
-  g_slist_foreach (path->elems, (GFunc) path_element_free, NULL);
+  for (i = 0; i < path->elems->len; i++)
-  g_slist_free (path->elems);
-
-  g_slice_free (GtkWidgetPath, path);
-}
-
-gboolean
-gtk_widget_path_has_parent (GtkWidgetPath *path,
-                            GType          type)
-{
-  g_return_val_if_fail (path != NULL, FALSE);
-  g_return_val_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET), FALSE);
-
-  GSList *elems = path->elems;
-
-  while (elems)
     {
       GtkPathElement *elem;
 
-      elem = elems->data;
+      elem = &g_array_index (path->elems, GtkPathElement, i);
+      g_free (elem->name);
+    }
+
+  g_array_free (path->elems, TRUE);
+  g_slice_free (GtkWidgetPath, path);
+}
+
+guint
+gtk_widget_path_length (GtkWidgetPath *path)
+{
+  g_return_val_if_fail (path != NULL, 0);
+
+  return path->elems->len;
+}
+
+guint
+gtk_widget_path_prepend_type (GtkWidgetPath *path,
+                              GType          type)
+{
+  GtkPathElement new = { 0 };
+
+  g_return_val_if_fail (path != NULL, 0);
+  g_return_val_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET), 0);
+
+  new.type = type;
+  g_array_append_val (path->elems, new);
+
+  return path->elems->len - 1;
+}
+
+GType
+gtk_widget_path_get_element_type (GtkWidgetPath *path,
+                                  guint          pos)
+{
+  GtkPathElement *elem;
+
+  g_return_val_if_fail (path != NULL, G_TYPE_INVALID);
+  g_return_val_if_fail (pos < path->elems->len, G_TYPE_INVALID);
+
+  elem = &g_array_index (path->elems, GtkPathElement, pos);
+  return elem->type;
+}
+
+void
+gtk_widget_path_set_element_type (GtkWidgetPath *path,
+                                  guint          pos,
+                                  GType          type)
+{
+  GtkPathElement *elem;
+
+  g_return_if_fail (path != NULL);
+  g_return_if_fail (pos < path->elems->len);
+  g_return_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET));
+
+  elem = &g_array_index (path->elems, GtkPathElement, pos);
+  elem->type = type;
+}
+
+G_CONST_RETURN gchar *
+gtk_widget_path_get_element_name (GtkWidgetPath *path,
+                                  guint          pos)
+{
+  GtkPathElement *elem;
+
+  g_return_val_if_fail (path != NULL, NULL);
+  g_return_val_if_fail (pos < path->elems->len, NULL);
+
+  elem = &g_array_index (path->elems, GtkPathElement, pos);
+  return elem->name;
+}
+
+void
+gtk_widget_path_set_element_name (GtkWidgetPath *path,
+                                  guint          pos,
+                                  const gchar   *name)
+{
+  GtkPathElement *elem;
+
+  g_return_if_fail (path != NULL);
+  g_return_if_fail (pos < path->elems->len);
+  g_return_if_fail (name != NULL);
+
+  elem = &g_array_index (path->elems, GtkPathElement, pos);
+
+  if (elem->name)
+    g_free (elem->name);
+
+  elem->name = g_strdup (name);
+}
+
+gboolean
+gtk_widget_path_has_parent (const GtkWidgetPath *path,
+                            GType                type)
+{
+  guint i;
+
+  g_return_val_if_fail (path != NULL, FALSE);
+  g_return_val_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET), FALSE);
+
+  for (i = 1; i < path->elems->len; i++)
+    {
+      GtkPathElement *elem;
+
+      elem = &g_array_index (path->elems, GtkPathElement, i);
 
       if (elem->type == type ||
           g_type_is_a (elem->type, type))
         return TRUE;
-
-      elems = elems->next;
     }
 
   return FALSE;
 }
-
-void
-gtk_widget_path_foreach (GtkWidgetPath            *path,
-                         GtkWidgetPathForeachFunc  func,
-                         gpointer                  user_data)
-{
-  GSList *elems;
-
-  g_return_if_fail (path != NULL);
-  g_return_if_fail (func != NULL);
-
-  elems = path->elems;
-
-  while (elems)
-    {
-      GtkPathElement *elem;
-
-      elem = elems->data;
-      elems = elems->next;
-
-      if ((func) (elem->type, elem->name, user_data))
-        return;
-    }
-}

gtk/gtkwidgetpath.h

@@ -21,31 +21,37 @@
 #define __GTK_WIDGET_PATH_H__
 
 #include <glib-object.h>
+#include "gtkenums.h"
 
 G_BEGIN_DECLS
 
 typedef struct GtkWidgetPath GtkWidgetPath;
 
-typedef gboolean (* GtkWidgetPathForeachFunc) (GType        type,
-                                               const gchar *name,
-                                               gpointer     user_data);
 
 GtkWidgetPath * gtk_widget_path_new (void);
 
-void            gtk_widget_path_prepend_widget_desc (GtkWidgetPath *path,
+GtkWidgetPath * gtk_widget_path_copy                (const GtkWidgetPath *path);
-                                                     GType          type,
-                                                     const gchar   *name);
-
-GtkWidgetPath * gtk_widget_path_copy                (GtkWidgetPath *path);
 void            gtk_widget_path_free                (GtkWidgetPath       *path);
 
-gboolean        gtk_widget_path_has_parent          (GtkWidgetPath *path,
+guint           gtk_widget_path_length              (GtkWidgetPath       *path);
+
+guint           gtk_widget_path_prepend_type        (GtkWidgetPath       *path,
                                                      GType                type);
 
-void            gtk_widget_path_foreach             (GtkWidgetPath            *path,
+GType               gtk_widget_path_get_element_type (GtkWidgetPath      *path,
-                                                     GtkWidgetPathForeachFunc  func,
+                                                      guint               pos);
-                                                     gpointer                  user_data);
+void                gtk_widget_path_set_element_type (GtkWidgetPath      *path,
+                                                      guint               pos,
+                                                      GType               type);
 
+G_CONST_RETURN gchar * gtk_widget_path_get_element_name (GtkWidgetPath   *path,
+                                                         guint            pos);
+void                   gtk_widget_path_set_element_name (GtkWidgetPath   *path,
+                                                         guint            pos,
+                                                         const gchar     *name);
+
+gboolean        gtk_widget_path_has_parent          (const GtkWidgetPath *path,
+                                                     GType                type);
 
 G_END_DECLS