Add columnview sorter serialization

This can be useful in implementing columnview
sorting.

gtk/gtk.h

@@ -155,6 +155,7 @@
 #include <gtk/gtkimcontextsimple.h>
 #include <gtk/gtkimmulticontext.h>
 #include <gtk/gtkinfobar.h>
+#include <gtk/gtkinvertiblesorter.h>
 #include <gtk/gtklabel.h>
 #include <gtk/gtklayoutmanager.h>
 #include <gtk/gtklayoutchild.h>

gtk/gtkcolumnviewcolumn.c

@@ -56,6 +56,7 @@ struct _GtkColumnViewColumn
   GObject parent_instance;
 
   GtkListItemFactory *factory;
+  char *id;
   char *title;
   GtkSorter *sorter;
 
@@ -91,6 +92,7 @@ enum
   PROP_0,
   PROP_COLUMN_VIEW,
   PROP_FACTORY,
+  PROP_ID,
   PROP_TITLE,
   PROP_SORTER,
   PROP_VISIBLE,
@@ -140,6 +142,10 @@ gtk_column_view_column_get_property (GObject    *object,
       g_value_set_object (value, self->factory);
       break;
 
+    case PROP_ID:
+      g_value_set_string (value, self->id);
+      break;
+
     case PROP_TITLE:
       g_value_set_string (value, self->title);
       break;
@@ -188,6 +194,10 @@ gtk_column_view_column_set_property (GObject      *object,
       gtk_column_view_column_set_factory (self, g_value_get_object (value));
       break;
 
+    case PROP_ID:
+      gtk_column_view_column_set_id (self, g_value_get_string (value));
+      break;
+
     case PROP_TITLE:
       gtk_column_view_column_set_title (self, g_value_get_string (value));
       break;
@@ -251,6 +261,20 @@ gtk_column_view_column_class_init (GtkColumnViewColumnClass *klass)
                          GTK_TYPE_LIST_ITEM_FACTORY,
                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * GtkColumnViewColumn:id: (attributes org.gtk.Property.get=gtk_column_view_column_get_id org.gtk.Property.set=gtk_column_view_column_set_id)
+   *
+   * ID of the column.
+   *
+   * This is used when storing sort configuration.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_ID] =
+    g_param_spec_string ("id", NULL, NULL,
+                          NULL,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
+
   /**
    * GtkColumnViewColumn:title: (attributes org.gtk.Property.get=gtk_column_view_column_get_title org.gtk.Property.set=gtk_column_view_column_set_title)
    *
@@ -700,6 +724,54 @@ gtk_column_view_column_get_title (GtkColumnViewColumn *self)
   return self->title;
 }
 
+/**
+ * gtk_column_view_column_set_id: (attributes org.gtk.Method.set_property=id)
+ * @self: a `GtkColumnViewColumn`
+ * @id: (nullable): Id to use for this column
+ *
+ * Sets the id of this column.
+ *
+ * The id is used when storing sort configuration.
+ *
+ * Since: 4.8
+ */
+void
+gtk_column_view_column_set_id (GtkColumnViewColumn *self,
+                               const char          *id)
+{
+  g_return_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (self));
+
+  if (g_strcmp0 (self->id, id) == 0)
+    return;
+
+  if (!g_param_spec_is_valid_name (id))
+    {
+      g_warning ("%s is not a valid column ID", id);
+      return;
+    }
+
+  g_free (self->id);
+  self->id = g_strdup (id);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ID]);
+}
+
+/**
+ * gtk_column_view_column_get_id: (attributes org.gtk.Method.get_property=id)
+ * @self: a `GtkColumnViewColumn`
+ *
+ * Returns the id set with gtk_column_view_column_set_id().
+ *
+ * Returns: (nullable): The column's id
+ */
+const char *
+gtk_column_view_column_get_id (GtkColumnViewColumn *self)
+{
+  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (self), NULL);
+
+  return self->id;
+}
+
 #if 0
 static void
 gtk_column_view_column_add_to_sorter (GtkColumnViewColumn *self)

gtk/gtkcolumnviewcolumn.h

@@ -54,6 +54,12 @@ void                    gtk_column_view_column_set_factory              (GtkColu
 GDK_AVAILABLE_IN_ALL
 GtkListItemFactory *    gtk_column_view_column_get_factory              (GtkColumnViewColumn    *self);
 
+GDK_AVAILABLE_IN_4_8
+void                    gtk_column_view_column_set_id                   (GtkColumnViewColumn    *self,
+                                                                         const char             *id);
+GDK_AVAILABLE_IN_4_8
+const char *            gtk_column_view_column_get_id                   (GtkColumnViewColumn    *self);
+
 GDK_AVAILABLE_IN_ALL
 void                    gtk_column_view_column_set_title                (GtkColumnViewColumn    *self,
                                                                          const char             *title);

gtk/gtkcolumnviewsorter.c

@@ -247,6 +247,26 @@ gtk_column_view_sorter_remove_column (GtkColumnViewSorter *self,
   return FALSE;
 }
 
+static Sorter *
+sorter_for_column (GtkColumnViewSorter *self,
+                   GtkColumnViewColumn *column,
+                   gboolean             inverted)
+{
+  Sorter *s;
+  GtkSorter *sorter;
+
+  sorter = gtk_column_view_column_get_sorter (column);
+
+  s = g_new (Sorter, 1);
+
+  s->column = g_object_ref (column);
+  s->sorter = g_object_ref (sorter);
+  s->changed_id = g_signal_connect (sorter, "changed", G_CALLBACK (gtk_column_view_sorter_changed_cb), self);
+  s->inverted = inverted;
+
+  return s;
+}
+
 gboolean
 gtk_column_view_sorter_set_column (GtkColumnViewSorter *self,
                                    GtkColumnViewColumn *column,
@@ -267,16 +287,11 @@ gtk_column_view_sorter_set_column (GtkColumnViewSorter *self,
   g_sequence_remove_range (g_sequence_get_begin_iter (self->sorters),
                            g_sequence_get_end_iter (self->sorters));
 
-  s = g_new (Sorter, 1);
-  s->column = g_object_ref (column);
-  s->sorter = g_object_ref (sorter);
-  s->changed_id = g_signal_connect (sorter, "changed", G_CALLBACK (gtk_column_view_sorter_changed_cb), self);
-  s->inverted = inverted;
- 
+  s = sorter_for_column (self, column, inverted);
+
   g_sequence_prepend (self->sorters, s);
 
   gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
-
   gtk_column_view_column_notify_sort (column);
 
   g_object_unref (column);
@@ -329,3 +344,87 @@ gtk_column_view_sorter_get_sort_column (GtkColumnViewSorter *self,
 
   return s->column;
 }
+
+char *
+gtk_column_view_sorter_serialize (GtkColumnViewSorter *self)
+{
+  GString *string;
+  GSequenceIter *iter;
+
+  string = g_string_new ("");
+
+  for (iter = g_sequence_get_begin_iter (self->sorters);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      Sorter *s = g_sequence_get (iter);
+
+      if (string->len > 0)
+        g_string_append_c (string, ',');
+      if (s->inverted)
+        g_string_append_c (string, '-');
+      g_string_append (string, gtk_column_view_column_get_id (s->column));
+    }
+
+  return g_string_free (string, FALSE);
+}
+
+static GtkColumnViewColumn *
+find_column_by_id (GtkColumnView *view,
+                   const char    *id)
+{
+  GListModel *columns = gtk_column_view_get_columns (view);
+
+  for (guint i = 0; i < g_list_model_get_n_items (columns); i++)
+    {
+      GtkColumnViewColumn *column = g_list_model_get_item (columns, i);
+      g_object_unref (column);
+      if (strcmp (id, gtk_column_view_column_get_id (column)) == 0)
+        return column;
+    }
+
+  return NULL;
+}
+
+void
+gtk_column_view_sorter_deserialize (GtkColumnViewSorter *self,
+                                    GtkColumnView       *view,
+                                    const char          *config)
+{
+  GtkColumnViewColumn *column;
+  GListModel *columns;
+  char **cols;
+
+  gtk_column_view_sorter_clear (self);
+
+  cols = g_strsplit (config, ",", 0);
+
+  for (int i = 0; cols[i]; i++)
+    {
+      const char *id = cols[i];
+      gboolean inverted = FALSE;
+      Sorter *s;
+
+      if (id[0] == '-')
+        {
+          inverted = TRUE;
+          id++;
+        }
+
+      column = find_column_by_id (view, id);
+      s = sorter_for_column (self, column, inverted);
+      g_sequence_append (self->sorters, s);
+    }
+
+  g_strfreev (cols);
+
+  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
+
+  columns = gtk_column_view_get_columns (view);
+  for (guint i = 0; i < g_list_model_get_n_items (columns); i++)
+    {
+      column = g_list_model_get_item (columns, i);
+      gtk_column_view_column_notify_sort (column);
+      g_object_unref (column);
+    }
+}

gtk/gtkcolumnviewsorterprivate.h

@@ -51,6 +51,11 @@ gboolean   gtk_column_view_sorter_set_column    (GtkColumnViewSorter *self,
                                                  gboolean             inverted);
 
 
+char *     gtk_column_view_sorter_serialize   (GtkColumnViewSorter *self);
+void       gtk_column_view_sorter_deserialize (GtkColumnViewSorter *self,
+                                               GtkColumnView       *view,
+                                               const char          *config);
+
 G_END_DECLS
 
 #endif /* __GTK_SORTER_H__ */

gtk/gtkinvertiblesorter.c

@@ -0,0 +1,282 @@
+/*
+ * Copyright © 2022 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include "gtkinvertiblesorter.h"
+
+#include "gtkintl.h"
+#include "gtksorterprivate.h"
+#include "gtktypebuiltins.h"
+
+#include <math.h>
+
+/**
+ * GtkInvertibleSorter:
+ *
+ * `GtkInvertibleSorter` is a `GtkSorter` that can invert
+ * the order produced by a sorter.
+ */
+
+struct _GtkInvertibleSorter
+{
+  GtkSorter parent_instance;
+
+  GtkSorter *sorter;
+  GtkSortType sort_order;
+};
+
+enum {
+  PROP_0,
+  PROP_SORTER,
+  PROP_SORT_ORDER,
+  NUM_PROPERTIES
+};
+
+G_DEFINE_TYPE (GtkInvertibleSorter, gtk_invertible_sorter, GTK_TYPE_SORTER)
+
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
+
+static void
+sorter_changed (GtkSorter *sorter, int change, gpointer data)
+{
+  gtk_sorter_changed (GTK_SORTER (data), GTK_SORTER_CHANGE_DIFFERENT);
+}
+
+static GtkOrdering
+gtk_invertible_sorter_compare (GtkSorter *sorter,
+                               gpointer   item1,
+                               gpointer   item2)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (sorter);
+  GtkOrdering result;
+
+  result = gtk_sorter_compare (self->sorter, item1, item2);
+
+  if (self->sort_order == GTK_SORT_DESCENDING)
+    result = - result;
+
+  return result;
+}
+
+static GtkSorterOrder
+gtk_invertible_sorter_get_order (GtkSorter *sorter)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (sorter);
+
+  return gtk_sorter_get_order (self->sorter);
+}
+
+static void
+gtk_invertible_sorter_set_property (GObject      *object,
+                                    guint         prop_id,
+                                    const GValue *value,
+                                    GParamSpec   *pspec)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (object);
+
+  switch (prop_id)
+    {
+    case PROP_SORTER:
+      {
+        GtkSorter *sorter;
+
+        sorter = g_value_get_object (value);
+        g_set_object (&self->sorter, sorter);
+        g_signal_connect (sorter, "changed", G_CALLBACK (sorter_changed), self);
+      }
+      break;
+
+    case PROP_SORT_ORDER:
+      gtk_invertible_sorter_set_sort_order (self, g_value_get_enum (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_invertible_sorter_get_property (GObject     *object,
+                                    guint        prop_id,
+                                    GValue      *value,
+                                    GParamSpec  *pspec)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (object);
+
+  switch (prop_id)
+    {
+    case PROP_SORTER:
+      g_value_set_object (value, self->sorter);
+      break;
+
+    case PROP_SORT_ORDER:
+      g_value_set_enum (value, self->sort_order);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_invertible_sorter_dispose (GObject *object)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (object);
+
+  g_signal_handlers_disconnect_by_func (self->sorter, sorter_changed, self);
+  g_clear_object (&self->sorter);
+
+  G_OBJECT_CLASS (gtk_invertible_sorter_parent_class)->dispose (object);
+}
+
+static void
+gtk_invertible_sorter_class_init (GtkInvertibleSorterClass *class)
+{
+  GtkSorterClass *sorter_class = GTK_SORTER_CLASS (class);
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  sorter_class->compare = gtk_invertible_sorter_compare;
+  sorter_class->get_order = gtk_invertible_sorter_get_order;
+
+  object_class->get_property = gtk_invertible_sorter_get_property;
+  object_class->set_property = gtk_invertible_sorter_set_property;
+  object_class->dispose = gtk_invertible_sorter_dispose;
+
+  /**
+   * GtkNumericSorter:sorter: (type GtkSorter) (attributes org.gtk.Property.get=gtk_invertible_sorter_get_sorter)
+   *
+   * The sorter.
+   */
+  properties[PROP_SORTER] =
+    g_param_spec_object ("sorter", NULL, NULL,
+                         GTK_TYPE_SORTER,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  /**
+   * GtkInvertibleSorter:sort-order: (attributes org.gtk.Property.get=gtk_invertible_sorter_get_sort_order org.gtk.Property.set=gtk_invertible_sorter_set_sort_order)
+   *
+   * Whether the sorter will sort smaller items first.
+   */
+  properties[PROP_SORT_ORDER] =
+    g_param_spec_enum ("sort-order", NULL, NULL,
+                       GTK_TYPE_SORT_TYPE,
+                       GTK_SORT_ASCENDING,
+                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+
+}
+
+static void
+gtk_invertible_sorter_init (GtkInvertibleSorter *self)
+{
+  self->sort_order = GTK_SORT_ASCENDING;
+
+  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_INVERTED);
+}
+
+/**
+ * gtk_invertible_sorter_new:
+ * @sorter: (transfer full): The sorter to use
+ *
+ * Creates a new invertible sorter using the given @sorter.
+ *
+ * Returns: a new `GtkInvertibleSorter`
+ *
+ * Since: 4.8
+ */
+GtkInvertibleSorter *
+gtk_invertible_sorter_new (GtkSorter   *sorter,
+                           GtkSortType  sort_order)
+{
+  GtkInvertibleSorter *result;
+
+  result = g_object_new (GTK_TYPE_INVERTIBLE_SORTER,
+                         "sorter", sorter,
+                         "sort-order", sort_order,
+                         NULL);
+
+  g_clear_object (&sorter);
+
+  return result;
+}
+
+/**
+ * gtk_invertible_sorter_get_sorter: (attributes org.gtk.Method.get_property=sorter)
+ * @self: a `GtkInvertibleSorter`
+ *
+ * Gets the sorter.
+ *
+ * Returns: (transfer none): the `GtkSorter`
+ *
+ * Since: 4.8
+ */
+GtkSorter *
+gtk_invertible_sorter_get_sorter (GtkInvertibleSorter *self)
+{
+  g_return_val_if_fail (GTK_IS_INVERTIBLE_SORTER (self), NULL);
+
+  return self->sorter;
+}
+
+/**
+ * gtk_invertible_sorter_set_sort_order: (attributes org.gtk.Method.set_property=sort-order)
+ * @self: a `GtkInvertibleSorter`
+ * @sort_order: whether to sort smaller items first
+ *
+ * Sets whether to sort smaller items before larger ones.
+ *
+ * Since: 4.8
+ */
+void
+gtk_invertible_sorter_set_sort_order (GtkInvertibleSorter *self,
+                                      GtkSortType          sort_order)
+{
+  g_return_if_fail (GTK_IS_INVERTIBLE_SORTER (self));
+
+  if (self->sort_order == sort_order)
+    return;
+
+  self->sort_order = sort_order;
+
+  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_INVERTED);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SORT_ORDER]);
+}
+
+/**
+ * gtk_invertible_sorter_get_sort_order: (attributes org.gtk.Method.get_property=sort-order)
+ * @self: a `GtkInvertibleSorter`
+ *
+ * Gets whether this sorter will sort smaller items first.
+ *
+ * Returns: the order of the items
+ *
+ * Since: 4.8
+ */
+GtkSortType
+gtk_invertible_sorter_get_sort_order (GtkInvertibleSorter *self)
+{
+  g_return_val_if_fail (GTK_IS_INVERTIBLE_SORTER (self), GTK_SORT_ASCENDING);
+
+  return self->sort_order;
+}

gtk/gtkinvertiblesorter.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2022 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#ifndef __GTK_INVERTIBLE_SORTER_H__
+#define __GTK_INVERTIBLE_SORTER_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtksorter.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_INVERTIBLE_SORTER             (gtk_invertible_sorter_get_type ())
+GDK_AVAILABLE_IN_4_8
+G_DECLARE_FINAL_TYPE (GtkInvertibleSorter, gtk_invertible_sorter, GTK, INVERTIBLE_SORTER, GtkSorter)
+
+GDK_AVAILABLE_IN_4_8
+GtkInvertibleSorter *   gtk_invertible_sorter_new            (GtkSorter           *sorter,
+                                                              GtkSortType          sort_order);
+
+GDK_AVAILABLE_IN_4_8
+GtkSorter *             gtk_invertible_sorter_get_sorter     (GtkInvertibleSorter *self);
+GDK_AVAILABLE_IN_4_8
+GtkSortType             gtk_invertible_sorter_get_sort_order (GtkInvertibleSorter *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_invertible_sorter_set_sort_order (GtkInvertibleSorter *self,
+                                                              GtkSortType          sort_order);
+
+G_END_DECLS
+
+#endif /* __GTK_INVERTIBLE_SORTER_H__ */

gtk/gtkmultisorter.c

@@ -408,6 +408,33 @@ gtk_multi_sorter_append (GtkMultiSorter *self,
                                 gtk_multi_sort_keys_new (self));
 }
 
+/**
+ * gtk_multi_sorter_prepend:
+ * @self: a `GtkMultiSorter`
+ * @sorter: (transfer full): a sorter to add
+ *
+ * Add @sorter to @self to use for sorting at the beginning.
+ *
+ * @self will consult @sorter first before all existing sorters.
+ *
+ * Since: 4.8
+ */
+void
+gtk_multi_sorter_prepend (GtkMultiSorter *self,
+                          GtkSorter      *sorter)
+{
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
+  g_return_if_fail (GTK_IS_SORTER (sorter));
+
+  g_signal_connect (sorter, "changed", G_CALLBACK (gtk_multi_sorter_changed_cb), self);
+
+  gtk_sorters_splice (&self->sorters, 0, 0, FALSE, &sorter, 1);
+
+  gtk_sorter_changed_with_keys (GTK_SORTER (self),
+                                GTK_SORTER_CHANGE_DIFFERENT,
+                                gtk_multi_sort_keys_new (self));
+}
+
 /**
  * gtk_multi_sorter_remove:
  * @self: a `GtkMultiSorter`

gtk/gtkmultisorter.h

@@ -40,6 +40,10 @@ GDK_AVAILABLE_IN_ALL
 void                    gtk_multi_sorter_append                 (GtkMultiSorter         *self,
                                                                  GtkSorter              *sorter);
 
+GDK_AVAILABLE_IN_4_8
+void                    gtk_multi_sorter_prepend                (GtkMultiSorter         *self,
+                                                                 GtkSorter              *sorter);
+
 GDK_AVAILABLE_IN_ALL
 void                    gtk_multi_sorter_remove                 (GtkMultiSorter         *self,
                                                                  guint                   position);

gtk/meson.build

@@ -114,6 +114,7 @@ gtk_private_sources = files([
   'gtkiconcache.c',
   'gtkiconcachevalidator.c',
   'gtkiconhelper.c',
+  'gtkinvertiblesorter.c',
   'gtkjoinedmenu.c',
   'gtkkineticscrolling.c',
   'gtkmagnifier.c',
@@ -570,6 +571,7 @@ gtk_public_headers = files([
   'gtkimmodule.h',
   'gtkimmulticontext.h',
   'gtkinfobar.h',
+  'gtkinvertiblesorter.h',
   'gtklabel.h',
   'gtklayoutchild.h',
   'gtklayoutmanager.h',