columnview: Clarify docs

Mention that gtk_column_view_sort_by_column
can be called multiple times to ste up
complex sorting.

gtk/gtk.h

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

gtk/gtkcolumnview.c

@@ -27,6 +27,7 @@
 #include "gtkcolumnviewcolumnprivate.h"
 #include "gtkcolumnviewlayoutprivate.h"
 #include "gtkcolumnviewsorterprivate.h"
+#include "gtkmultisorter.h"
 #include "gtkcssnodeprivate.h"
 #include "gtkdropcontrollermotion.h"
 #include "gtklistviewprivate.h"
@@ -1303,7 +1304,7 @@ gtk_column_view_init (GtkColumnView *self)
   g_signal_connect (controller, "leave", G_CALLBACK (gtk_column_view_drag_leave), NULL);
   gtk_widget_add_controller (GTK_WIDGET (self), controller);
 
-  self->sorter = GTK_SORTER (gtk_column_view_sorter_new ());
+  self->sorter = GTK_SORTER (gtk_multi_sorter_new ());
   self->factory = gtk_column_list_item_factory_new (self);
   self->listview = GTK_LIST_VIEW (g_object_new (GTK_TYPE_COLUMN_LIST_VIEW, NULL));
   gtk_list_view_set_factory (self->listview, GTK_LIST_ITEM_FACTORY (self->factory));
@@ -1537,7 +1538,7 @@ gtk_column_view_remove_column (GtkColumnView       *self,
         break;
     }
 
-  gtk_column_view_sorter_remove_column (GTK_COLUMN_VIEW_SORTER (self->sorter), column);
+  gtk_column_view_sorter_remove_column (self->sorter, column);
   gtk_column_view_column_set_column_view (column, NULL);
   g_list_store_remove (self->columns, i);
 }
@@ -1688,6 +1689,13 @@ gtk_column_view_get_sorter (GtkColumnView *self)
  * on @column to associate a sorter with the column.
  *
  * If @column is %NULL, the view will be unsorted.
+ *
+ * This function can be called multiple times to set up
+ * sorting with multiple columns:
+ *
+ *     gtk_column_view_sort_by_column (view, NULL, 0);
+ *     gtk_column_view_sort_by_column (view, col1, GTK_SORT_DESCENDING);
+ *     gtk_column_view_sort_by_column (view, col0, GTK_SORT_ASCENDING);
  */
 void
 gtk_column_view_sort_by_column (GtkColumnView       *self,
@@ -1699,11 +1707,9 @@ gtk_column_view_sort_by_column (GtkColumnView       *self,
   g_return_if_fail (column == NULL || gtk_column_view_column_get_column_view (column) == self);
 
   if (column == NULL)
-    gtk_column_view_sorter_clear (GTK_COLUMN_VIEW_SORTER (self->sorter));
+    gtk_column_view_sorter_clear (self->sorter);
   else
-    gtk_column_view_sorter_set_column (GTK_COLUMN_VIEW_SORTER (self->sorter),
-                                       column,
-                                       direction == GTK_SORT_DESCENDING);
+    gtk_column_view_sorter_set_column (self->sorter, column, direction);
 }
 
 /**

gtk/gtkcolumnviewcolumn.c

@@ -31,7 +31,7 @@
 #include "gtkrbtreeprivate.h"
 #include "gtksizegroup.h"
 #include "gtkwidgetprivate.h"
-#include "gtksorter.h"
+#include "gtkinvertiblesorter.h"
 
 /**
  * GtkColumnViewColumn:
@@ -56,7 +56,7 @@ struct _GtkColumnViewColumn
 
   GtkListItemFactory *factory;
   char *title;
-  GtkSorter *sorter;
+  GtkInvertibleSorter *invertible_sorter;
 
   /* data for the view */
   GtkColumnView *view;
@@ -114,7 +114,7 @@ gtk_column_view_column_dispose (GObject *object)
   g_assert (self->first_cell == NULL); /* no view = no children */
 
   g_clear_object (&self->factory);
-  g_clear_object (&self->sorter);
+  g_clear_object (&self->invertible_sorter);
   g_clear_pointer (&self->title, g_free);
   g_clear_object (&self->menu);
 
@@ -144,7 +144,7 @@ gtk_column_view_column_get_property (GObject    *object,
       break;
 
     case PROP_SORTER:
-      g_value_set_object (value, self->sorter);
+      g_value_set_object (value, gtk_column_view_column_get_sorter (self));
       break;
 
     case PROP_VISIBLE:
@@ -699,24 +699,13 @@ gtk_column_view_column_get_title (GtkColumnViewColumn *self)
   return self->title;
 }
 
-#if 0
-static void
-gtk_column_view_column_add_to_sorter (GtkColumnViewColumn *self)
-{
-  if (self->view == NULL)
-    return;
-  
-  gtk_column_view_sorter_add_column (GTK_COLUMN_VIEW_SORTER (gtk_column_view_get_sorter (self->view)), self);
-}
-#endif
-
 static void
 gtk_column_view_column_remove_from_sorter (GtkColumnViewColumn *self)
 {
   if (self->view == NULL)
     return;
   
-  gtk_column_view_sorter_remove_column (GTK_COLUMN_VIEW_SORTER (gtk_column_view_get_sorter (self->view)), self);
+  gtk_column_view_sorter_remove_column (gtk_column_view_get_sorter (self->view), self);
 }
 
 /**
@@ -742,9 +731,25 @@ gtk_column_view_column_set_sorter (GtkColumnViewColumn *self,
   g_return_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (self));
   g_return_if_fail (sorter == NULL || GTK_IS_SORTER (sorter));
 
-  if (!g_set_object (&self->sorter, sorter))
+  if (self->invertible_sorter == NULL && sorter == NULL)
     return;
 
+  if (self->invertible_sorter != NULL &&
+      sorter == gtk_invertible_sorter_get_sorter (self->invertible_sorter))
+    return;
+
+  if (sorter)
+    {
+      if (!self->invertible_sorter)
+        {
+          self->invertible_sorter = gtk_invertible_sorter_new (NULL);
+          g_object_set_data (G_OBJECT (self->invertible_sorter), "column", self);
+        }
+      gtk_invertible_sorter_set_sorter (self->invertible_sorter, sorter);
+    }
+  else
+    g_clear_object (&self->invertible_sorter);
+
   gtk_column_view_column_remove_from_sorter (self);
 
   if (self->header)
@@ -766,7 +771,10 @@ gtk_column_view_column_get_sorter (GtkColumnViewColumn *self)
 {
   g_return_val_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (self), NULL);
 
-  return self->sorter;
+  if (self->invertible_sorter)
+    return gtk_invertible_sorter_get_sorter (self->invertible_sorter);
+
+  return NULL;
 }
 
 void
@@ -1015,3 +1023,11 @@ gtk_column_view_column_get_header_allocation (GtkColumnViewColumn *self,
   if (size)
     *size = self->allocation_size;
 }
+
+
+GtkInvertibleSorter *
+gtk_column_view_column_get_invertible_sorter (GtkColumnViewColumn *self)
+{
+  return self->invertible_sorter;
+}
+

gtk/gtkcolumnviewcolumnprivate.h

@@ -23,6 +23,7 @@
 #include "gtk/gtkcolumnviewcolumn.h"
 
 #include "gtk/gtkcolumnviewcellprivate.h"
+#include "gtk/gtkinvertiblesorter.h"
 
 
 void                    gtk_column_view_column_set_column_view          (GtkColumnViewColumn    *self,
@@ -57,4 +58,6 @@ void                    gtk_column_view_column_get_header_allocation    (GtkColu
                                                                          int                    *offset,
                                                                          int                    *size);
 
+GtkInvertibleSorter *   gtk_column_view_column_get_invertible_sorter    (GtkColumnViewColumn *self);
+
 #endif  /* __GTK_COLUMN_VIEW_COLUMN_PRIVATE_H__ */

gtk/gtkcolumnviewsorter.c

@@ -20,311 +20,146 @@
 #include "config.h"
 
 #include "gtkcolumnviewsorterprivate.h"
-
 #include "gtkcolumnviewcolumnprivate.h"
 #include "gtktypebuiltins.h"
+#include "gtkmultisorter.h"
 
-typedef struct
+static GtkColumnViewColumn *
+get_column (GtkInvertibleSorter *sorter)
 {
-  GtkColumnViewColumn *column;
-  GtkSorter *sorter;
-  gboolean   inverted;
-  gulong     changed_id;
-} Sorter;
- 
-static void
-free_sorter (gpointer data)
-{
-  Sorter *s = data;
-
-  g_signal_handler_disconnect (s->sorter, s->changed_id);
-  g_object_unref (s->sorter);
-  g_object_unref (s->column);
-  g_free (s);
-}
-
-struct _GtkColumnViewSorter
-{
-  GtkSorter parent_instance;
-
-  GSequence *sorters;
-};
-
-G_DEFINE_TYPE (GtkColumnViewSorter, gtk_column_view_sorter, GTK_TYPE_SORTER)
-
-static GtkOrdering
-gtk_column_view_sorter_compare (GtkSorter *sorter,
-                                gpointer   item1,
-                                gpointer   item2)
-{
-  GtkColumnViewSorter *self = GTK_COLUMN_VIEW_SORTER (sorter);
-  GtkOrdering result = GTK_ORDERING_EQUAL;
-  GSequenceIter *iter;
-
-  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);
-
-      result = gtk_sorter_compare (s->sorter, item1, item2);
-      if (s->inverted)
-        result = - result;
-
-      if (result != GTK_ORDERING_EQUAL)
-        break;
-    }
-
-  return result;
-}
-
-static GtkSorterOrder
-gtk_column_view_sorter_get_order (GtkSorter *sorter)
-{
-  GtkColumnViewSorter *self = GTK_COLUMN_VIEW_SORTER (sorter);
-  GtkSorterOrder result = GTK_SORTER_ORDER_NONE;
-  GSequenceIter *iter;
-
-  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);
-
-      switch (gtk_sorter_get_order (s->sorter))
-        {
-          case GTK_SORTER_ORDER_PARTIAL:
-            result = GTK_SORTER_ORDER_PARTIAL;
-            break;
-          case GTK_SORTER_ORDER_NONE:
-            break;
-          case GTK_SORTER_ORDER_TOTAL:
-            return GTK_SORTER_ORDER_TOTAL;
-          default:
-            g_assert_not_reached ();
-            break;
-        }
-    }
-
-  return result;
+  return GTK_COLUMN_VIEW_COLUMN (g_object_get_data (G_OBJECT (sorter), "column"));
 }
 
 static void
-gtk_column_view_sorter_dispose (GObject *object)
-{
-  GtkColumnViewSorter *self = GTK_COLUMN_VIEW_SORTER (object);
-
-  /* The sorter is owned by the columview and is unreffed
-   * after the columns, so the sequence must be empty at
-   * this point.
-   * The sorter can outlive the columview it comes from
-   * (the model might still have a ref), but that does
-   * not change the fact that all columns will be gone.
-   */
-  g_assert (g_sequence_is_empty (self->sorters));
-  g_clear_pointer (&self->sorters, g_sequence_free);
-
-  G_OBJECT_CLASS (gtk_column_view_sorter_parent_class)->dispose (object);
-}
-
-static void
-gtk_column_view_sorter_class_init (GtkColumnViewSorterClass *class)
-{
-  GtkSorterClass *sorter_class = GTK_SORTER_CLASS (class);
-  GObjectClass *object_class = G_OBJECT_CLASS (class);
-
-  sorter_class->compare = gtk_column_view_sorter_compare;
-  sorter_class->get_order = gtk_column_view_sorter_get_order;
-
-  object_class->dispose = gtk_column_view_sorter_dispose;
-}
-
-static void
-gtk_column_view_sorter_init (GtkColumnViewSorter *self)
-{
-  self->sorters = g_sequence_new (free_sorter);
-}
-
-GtkColumnViewSorter *
-gtk_column_view_sorter_new (void)
-{
-  return g_object_new (GTK_TYPE_COLUMN_VIEW_SORTER, NULL);
-}
-
-static void
-gtk_column_view_sorter_changed_cb (GtkSorter *sorter, int change, gpointer data)
-{
-  gtk_sorter_changed (GTK_SORTER (data), GTK_SORTER_CHANGE_DIFFERENT);
-}
-
-static gboolean
-remove_column (GtkColumnViewSorter *self,
+remove_column (GtkSorter           *self,
                GtkColumnViewColumn *column)
 {
-  GSequenceIter *iter;
+  GtkInvertibleSorter *sorter = gtk_column_view_column_get_invertible_sorter (column);
 
-  for (iter = g_sequence_get_begin_iter (self->sorters);
-       !g_sequence_iter_is_end (iter);
-       iter = g_sequence_iter_next (iter))
+  if (sorter == NULL)
+    return;
+
+  for (guint i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (self)); i++)
     {
-      Sorter *s = g_sequence_get (iter);
+      GtkInvertibleSorter *s;
 
-      if (s->column == column)
+      s = g_list_model_get_item (G_LIST_MODEL (self), i);
+      g_object_unref (s);
+
+      if (s == sorter)
         {
-          g_sequence_remove (iter);
-          return TRUE;
+          gtk_multi_sorter_remove (GTK_MULTI_SORTER (self), i);
+          break;
         }
     }
-
-  return FALSE;
-}
-
-gboolean
-gtk_column_view_sorter_add_column (GtkColumnViewSorter *self,
-                                   GtkColumnViewColumn *column)
-{
-  GSequenceIter *iter;
-  GtkSorter *sorter;
-  Sorter *s, *first;
-
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_SORTER (self), FALSE);
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column), FALSE);
-
-  sorter = gtk_column_view_column_get_sorter (column);
-  if (sorter == NULL)
-    return FALSE;
-
-  iter = g_sequence_get_begin_iter (self->sorters);
-  if (!g_sequence_iter_is_end (iter))
-    {
-      first = g_sequence_get (iter);
-      if (first->column == column)
-        {
-          first->inverted = !first->inverted;
-          goto out;
-        }
-    }
-  else
-    first = NULL;
-
-  remove_column (self, 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 = FALSE;
- 
-  g_sequence_insert_before (iter, s);
-
-  /* notify the previous first column to stop drawing an arrow */
-  if (first)
-    gtk_column_view_column_notify_sort (first->column);
-
-out:
-  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
-
-  gtk_column_view_column_notify_sort (column);
-
-  return TRUE;
-}
-
-gboolean
-gtk_column_view_sorter_remove_column (GtkColumnViewSorter *self,
-                                      GtkColumnViewColumn *column)
-{
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_SORTER (self), FALSE);
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column), FALSE);
-
-  if (remove_column (self, column))
-    {
-      gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
-      gtk_column_view_column_notify_sort (column);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-gboolean
-gtk_column_view_sorter_set_column (GtkColumnViewSorter *self,
-                                   GtkColumnViewColumn *column,
-                                   gboolean             inverted)
-{
-  GtkSorter *sorter;
-  Sorter *s;
-
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_SORTER (self), FALSE);
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column), FALSE);
-  
-  sorter = gtk_column_view_column_get_sorter (column);
-  if (sorter == NULL)
-    return FALSE;
-
-  g_object_ref (column);
-
-  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;
- 
-  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);
-
-  return TRUE;
 }
 
 void
-gtk_column_view_sorter_clear (GtkColumnViewSorter *self)
+gtk_column_view_sorter_activate_column (GtkSorter           *self,
+                                        GtkColumnViewColumn *column)
 {
-  GSequenceIter *iter;
-  Sorter *s;
-  GtkColumnViewColumn *column;
+  GtkMultiSorter *multi = GTK_MULTI_SORTER (self);
+  GtkInvertibleSorter *sorter, *s;
 
-  g_return_if_fail (GTK_IS_COLUMN_VIEW_SORTER (self));
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
+  g_return_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column));
 
-  if (g_sequence_is_empty (self->sorters))
+  sorter = gtk_column_view_column_get_invertible_sorter (column);
+  if (sorter == NULL)
     return;
 
-  iter = g_sequence_get_begin_iter (self->sorters);
-  s = g_sequence_get (iter);
+  if (g_list_model_get_n_items (G_LIST_MODEL (self)) > 0)
+    {
+      s = g_list_model_get_item (G_LIST_MODEL (self), 0);
+    }
+  else
+    s = NULL;
 
-  column = g_object_ref (s->column);
+  if (s == sorter)
+    {
+      /* column is already first, toggle sort order */
+      gtk_invertible_sorter_set_sort_order (s, 1 - gtk_invertible_sorter_get_sort_order (s));
 
-  g_sequence_remove_range (iter, g_sequence_get_end_iter (self->sorters));
+      gtk_column_view_column_notify_sort (column);
+    }
+  else
+    {
+      /* move column to the first position */
+      remove_column (self, column);
+      gtk_invertible_sorter_set_sort_order (GTK_INVERTIBLE_SORTER (sorter), GTK_SORT_ASCENDING);
+      g_object_ref (sorter);
+      gtk_multi_sorter_splice (multi, 0, 0, (GtkSorter **)&sorter, 1);
 
-  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
+      if (s)
+        {
+          gtk_column_view_column_notify_sort (get_column (s));
+          g_object_unref (s);
+        }
+      gtk_column_view_column_notify_sort (column);
+    }
+}
+
+void
+gtk_column_view_sorter_remove_column (GtkSorter           *self,
+                                      GtkColumnViewColumn *column)
+{
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
+  g_return_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column));
+
+  remove_column (self, column);
+}
+
+void
+gtk_column_view_sorter_set_column (GtkSorter           *self,
+                                   GtkColumnViewColumn *column,
+                                   GtkSortType          direction)
+{
+  GtkMultiSorter *multi = GTK_MULTI_SORTER (self);
+  GtkSorter *sorter;
+  GtkInvertibleSorter *s;
+
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
+  g_return_if_fail (GTK_IS_COLUMN_VIEW_COLUMN (column));
+
+  sorter = GTK_SORTER (gtk_column_view_column_get_invertible_sorter (column));
+  if (sorter == NULL)
+    return;
+
+  if (g_list_model_get_n_items (G_LIST_MODEL (self)) > 0)
+    s = g_list_model_get_item (G_LIST_MODEL (self), 0);
+  else
+    s = NULL;
+
+  remove_column (self, column);
+
+  gtk_invertible_sorter_set_sort_order (GTK_INVERTIBLE_SORTER (sorter), direction);
+  g_object_ref (sorter);
+  gtk_multi_sorter_splice (multi, 0, 0, &sorter, 1);
+
+  if (s)
+    {
+      gtk_column_view_column_notify_sort (get_column (s));
+      g_object_unref (s);
+    }
 
   gtk_column_view_column_notify_sort (column);
-
-  g_object_unref (column);
 }
 
-GtkColumnViewColumn *
-gtk_column_view_sorter_get_sort_column (GtkColumnViewSorter *self,
-                                        gboolean            *inverted)
+void
+gtk_column_view_sorter_clear (GtkSorter *self)
 {
-  GSequenceIter *iter;
-  Sorter *s;
+  GtkMultiSorter *multi = GTK_MULTI_SORTER (self);
+  GtkInvertibleSorter *s;
 
-  g_return_val_if_fail (GTK_IS_COLUMN_VIEW_SORTER (self), NULL);
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
 
-  if (g_sequence_is_empty (self->sorters))
-    return NULL;
+  if (g_list_model_get_n_items (G_LIST_MODEL (self)) == 0)
+    return;
 
-  iter = g_sequence_get_begin_iter (self->sorters);
-  s = g_sequence_get (iter);
+  s = g_list_model_get_item (G_LIST_MODEL (self), 0);
 
-  *inverted = s->inverted;
+  gtk_multi_sorter_splice (multi, 0, g_list_model_get_n_items (G_LIST_MODEL (self)), NULL, 0);
 
-  return s->column;
+  gtk_column_view_column_notify_sort (get_column (s));
+  g_object_unref (s);
 }

gtk/gtkcolumnviewsorterprivate.h

@@ -30,28 +30,19 @@
 
 G_BEGIN_DECLS
 
-#define GTK_TYPE_COLUMN_VIEW_SORTER             (gtk_column_view_sorter_get_type ())
+void      gtk_column_view_sorter_activate_column (GtkSorter           *self,
+                                                  GtkColumnViewColumn *column);
+void      gtk_column_view_sorter_remove_column   (GtkSorter           *self,
+                                                  GtkColumnViewColumn *column);
 
-G_DECLARE_FINAL_TYPE (GtkColumnViewSorter, gtk_column_view_sorter, GTK, COLUMN_VIEW_SORTER, GtkSorter)
+void      gtk_column_view_sorter_clear           (GtkSorter           *self);
 
-GtkColumnViewSorter *   gtk_column_view_sorter_new              (void);
-
-gboolean                gtk_column_view_sorter_add_column       (GtkColumnViewSorter    *self,
-                                                                 GtkColumnViewColumn    *column);
-gboolean                gtk_column_view_sorter_remove_column    (GtkColumnViewSorter    *self,
-                                                                 GtkColumnViewColumn    *column);
-
-void                    gtk_column_view_sorter_clear            (GtkColumnViewSorter    *self);
-
-GtkColumnViewColumn *   gtk_column_view_sorter_get_sort_column  (GtkColumnViewSorter    *self,
-                                                                 gboolean               *inverted);
-
-gboolean   gtk_column_view_sorter_set_column    (GtkColumnViewSorter *self,
-                                                 GtkColumnViewColumn *column,
-                                                 gboolean             inverted);
+void      gtk_column_view_sorter_set_column      (GtkSorter           *self,
+                                                  GtkColumnViewColumn *column,
+                                                  GtkSortType          direction);
 
 
 G_END_DECLS
 
-#endif /* __GTK_SORTER_H__ */
+#endif /* __GTK_COLUMN_VIEW_SORTER_H__ */
 

gtk/gtkcolumnviewtitle.c

@@ -189,15 +189,15 @@ activate_sort (GtkColumnViewTitle *self)
 {
   GtkSorter *sorter;
   GtkColumnView *view;
-  GtkColumnViewSorter *view_sorter;
+  GtkSorter *view_sorter;
 
   sorter = gtk_column_view_column_get_sorter (self->column);
   if (sorter == NULL)
     return;
 
   view = gtk_column_view_column_get_column_view (self->column);
-  view_sorter = GTK_COLUMN_VIEW_SORTER (gtk_column_view_get_sorter (view));
-  gtk_column_view_sorter_add_column (view_sorter, self->column);
+  view_sorter = gtk_column_view_get_sorter (view);
+  gtk_column_view_sorter_activate_column (view_sorter, self->column);
 }
 
 static void
@@ -291,29 +291,35 @@ gtk_column_view_title_new (GtkColumnViewColumn *column)
 void
 gtk_column_view_title_update (GtkColumnViewTitle *self)
 {
-  GtkSorter *sorter;
-  GtkColumnView *view;
-  GtkColumnViewSorter *view_sorter;
-  gboolean inverted;
-  GtkColumnViewColumn *active;
+  GtkInvertibleSorter *sorter;
 
   gtk_label_set_label (GTK_LABEL (self->title), gtk_column_view_column_get_title (self->column));
 
-  sorter = gtk_column_view_column_get_sorter (self->column);
+  sorter = gtk_column_view_column_get_invertible_sorter (self->column);
 
   if (sorter)
     {
+      GtkColumnView *view;
+      GtkSorter *view_sorter;
+      GtkInvertibleSorter *active = NULL;
+      GtkSortType direction = GTK_SORT_ASCENDING;
+
       view = gtk_column_view_column_get_column_view (self->column);
-      view_sorter = GTK_COLUMN_VIEW_SORTER (gtk_column_view_get_sorter (view));
-      active = gtk_column_view_sorter_get_sort_column (view_sorter, &inverted);
+      view_sorter = gtk_column_view_get_sorter (view);
+      if (g_list_model_get_n_items (G_LIST_MODEL (view_sorter)) > 0)
+        {
+          active = g_list_model_get_item (G_LIST_MODEL (view_sorter), 0);
+          g_object_unref (active);
+          direction = gtk_invertible_sorter_get_sort_order (active);
+        }
 
       gtk_widget_show (self->sort);
       gtk_widget_remove_css_class (self->sort, "ascending");
       gtk_widget_remove_css_class (self->sort, "descending");
       gtk_widget_remove_css_class (self->sort, "unsorted");
-      if (self->column != active)
+      if (sorter != active)
         gtk_widget_add_css_class (self->sort, "unsorted");
-      else if (inverted)
+      else if (direction == GTK_SORT_DESCENDING)
         gtk_widget_add_css_class (self->sort, "descending");
       else
         gtk_widget_add_css_class (self->sort, "ascending");

gtk/gtkinvertiblesorter.c

@@ -0,0 +1,317 @@
+/*
+ * 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 "gtksorterprivate.h"
+#include "gtktypebuiltins.h"
+
+/**
+ * GtkInvertibleSorter:
+ *
+ * `GtkInvertibleSorter` wraps another sorter and
+ * makes it possible to invert its order.
+ */
+struct _GtkInvertibleSorter
+{
+  GtkSorter parent_instance;
+
+  GtkSorter *sorter;
+  GtkSortType sort_order;
+};
+
+enum {
+  PROP_0,
+  PROP_SORTER,
+  PROP_SORT_ORDER,
+
+  N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+
+G_DEFINE_TYPE (GtkInvertibleSorter, gtk_invertible_sorter, GTK_TYPE_SORTER)
+
+static GtkOrdering
+gtk_invertible_sorter_compare (GtkSorter *sorter,
+                               gpointer   item1,
+                               gpointer   item2)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (sorter);
+  GtkOrdering result = GTK_ORDERING_EQUAL;
+
+  if (self->sorter)
+    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);
+
+  if (self->sorter)
+    return gtk_sorter_get_order (self->sorter);
+
+  return GTK_SORTER_ORDER_NONE;
+}
+
+static void
+gtk_invertible_sorter_changed_cb (GtkSorter           *sorter,
+                                  GtkSorterChange      change,
+                                  GtkInvertibleSorter *self)
+{
+  gtk_sorter_changed (GTK_SORTER (self), change);
+}
+
+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_set_property (GObject      *object,
+                                    guint         prop_id,
+                                    const GValue *value,
+                                    GParamSpec   *pspec)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (object);
+
+  switch (prop_id)
+    {
+    case PROP_SORTER:
+      gtk_invertible_sorter_set_sorter (self, g_value_get_object (value));
+      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_dispose (GObject *object)
+{
+  GtkInvertibleSorter *self = GTK_INVERTIBLE_SORTER (object);
+
+  if (self->sorter)
+    g_signal_handlers_disconnect_by_func (self->sorter, G_CALLBACK (gtk_invertible_sorter_changed_cb), 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;
+
+  /**
+   * GtkInvertibleSorter:sorter: (attributes org.gtk.Property.get=gtk_invertible_sorter_get_sorter org.gtk.Property.set=gtk_invertible_sorter_set_sorter)
+   *
+   * The sorter.
+   *
+   * Since: 4.10
+   **/
+  properties[PROP_SORTER] =
+    g_param_spec_object ("sorter", NULL, NULL,
+                         GTK_TYPE_SORTER,
+                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * 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 order of the underlying sorter is inverted.
+   *
+   * The order of the underlying sorter is considered ascending.
+   *
+   * To make the invertible sorter invert the order,
+   * set this property to `GTK_SORT_DESCENDING`.
+   *
+   * Since: 4.10
+   **/
+  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_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gtk_invertible_sorter_init (GtkInvertibleSorter *self)
+{
+}
+
+/**
+ * gtk_invertible_sorter_new:
+ * @sorter: (nullable) (transfer full): the sorter
+ *
+ * Creates a new invertible sorter.
+ *
+ * This sorter compares items like @sorter, optionally
+ * inverting the order.
+ *
+ * Returns: a new `GtkInvertibleSorter`
+ *
+ * Since: 4.10
+ */
+GtkInvertibleSorter *
+gtk_invertible_sorter_new (GtkSorter *sorter)
+{
+  GtkInvertibleSorter *self;
+
+  self = g_object_new (GTK_TYPE_INVERTIBLE_SORTER,
+                       "sorter", sorter,
+                       NULL);
+  g_clear_object (&sorter);
+
+  return self;
+}
+
+/**
+ * gtk_invertible_sorter_set_sorter:
+ * @self: a `GtkInvertibleSorter`
+ * @sorter: (nullable): a sorter
+ *
+ * Sets the sorter.
+ *
+ * Since: 4.10
+ */
+void
+gtk_invertible_sorter_set_sorter (GtkInvertibleSorter *self,
+                                  GtkSorter           *sorter)
+{
+  g_return_if_fail (GTK_IS_INVERTIBLE_SORTER (self));
+  g_return_if_fail (sorter == NULL || GTK_IS_SORTER (sorter));
+
+  if (self->sorter)
+    g_signal_handlers_disconnect_by_func (self->sorter, G_CALLBACK (gtk_invertible_sorter_changed_cb), self);
+
+  if (sorter)
+    g_signal_connect (sorter, "changed", G_CALLBACK (gtk_invertible_sorter_changed_cb), self);
+
+  if (g_set_object (&self->sorter, sorter))
+    {
+      g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SORTER]);
+      gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_DIFFERENT);
+    }
+}
+
+/**
+ * gtk_invertible_sorter_get_sorter:
+ * @self: a `GtkInvertibleSorter`
+ *
+ * Returns the sorter.
+ *
+ * Returns: (nullable) (transfer none): the sorter
+ *
+ * Since: 4.10
+ */
+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:
+ * @self: a `GtkInvertibleSorter`
+ * @sort_order: the new sort order
+ *
+ * Sets whether to invert the order of the wrapped sorter.
+ *
+ * Since: 4.10
+ */
+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;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SORT_ORDER]);
+  gtk_sorter_changed (GTK_SORTER (self), GTK_SORTER_CHANGE_INVERTED);
+}
+
+/**
+ * gtk_invertible_sorter_get_sort_order:
+ * @self: a `GtkInvertibleSorter`
+ *
+ * Returns the sort order of @self.
+ *
+ * If the sort order is `GTK_SORT_DESCENDING`,
+ * then the underlying order is inverted.
+ *
+ * Returns: whether the order is inverted
+ *
+ * Since: 4.10
+ */
+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,55 @@
+/*
+ * 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/gtkexpression.h>
+#include <gtk/gtksorter.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_INVERTIBLE_SORTER             (gtk_invertible_sorter_get_type ())
+GDK_AVAILABLE_IN_4_10
+G_DECLARE_FINAL_TYPE (GtkInvertibleSorter, gtk_invertible_sorter, GTK, INVERTIBLE_SORTER, GtkSorter)
+
+GDK_AVAILABLE_IN_4_10
+GtkInvertibleSorter *   gtk_invertible_sorter_new               (GtkSorter              *sorter);
+
+GDK_AVAILABLE_IN_4_10
+void                    gtk_invertible_sorter_set_sorter        (GtkInvertibleSorter    *self,
+                                                                 GtkSorter              *sorter);
+
+GDK_AVAILABLE_IN_4_10
+GtkSorter *             gtk_invertible_sorter_get_sorter        (GtkInvertibleSorter    *self);
+
+GDK_AVAILABLE_IN_4_10
+void                    gtk_invertible_sorter_set_sort_order    (GtkInvertibleSorter    *self,
+                                                                 GtkSortType             sort_order);
+
+GDK_AVAILABLE_IN_4_10
+GtkSortType             gtk_invertible_sorter_get_sort_order    (GtkInvertibleSorter    *self);
+
+G_END_DECLS
+
+#endif /* __GTK_INVERTIBLE_SORTER_H__ */

gtk/gtkmultisorter.c

@@ -503,3 +503,56 @@ gtk_multi_sorter_remove (GtkMultiSorter *self,
                                 GTK_SORTER_CHANGE_LESS_STRICT,
                                 gtk_multi_sort_keys_new (self));
 }
+
+/**
+ * gtk_multi_sorter_splice:
+ * @self: a `GtkMultiSorter`
+ * @position: the position at which to make the change
+ * @n_removals: the number of items to remove
+ * @additions: (array length=n_additions) (element-type GtkSorter) (transfer full): the sorters to add
+ * @n_additions: the number of sorters to add
+ *
+ * Changes @self by removing @n_removals items and adding @n_additions
+ * sorters to it.
+ *
+ * This is the equivalent of [method@GLib.ListStore.splice].
+ *
+ * Note that @self takes ownership of the added sorters.
+ *
+ * Since: 4.10
+ */
+void
+gtk_multi_sorter_splice (GtkMultiSorter  *self,
+                         guint            position,
+                         guint            n_removals,
+                         GtkSorter      **additions,
+                         guint            n_additions)
+{
+  guint n_items;
+
+  g_return_if_fail (GTK_IS_MULTI_SORTER (self));
+  g_return_if_fail (position + n_removals >= position); /* overflow */
+
+  n_items = gtk_sorters_get_size (&self->sorters);
+  g_return_if_fail (position + n_removals <= n_items);
+
+
+  for (guint i = 0; i < n_removals; i++)
+    {
+      GtkSorter *sorter = gtk_sorters_get (&self->sorters, position + i);
+      g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
+    }
+  for (guint i = 0; i < n_additions; i++)
+    {
+      GtkSorter *sorter = additions[i];
+      g_signal_connect (sorter, "changed", G_CALLBACK (gtk_multi_sorter_changed_cb), self);
+    }
+  gtk_sorters_splice (&self->sorters, position, n_removals, FALSE, additions, n_additions);
+  g_list_model_items_changed (G_LIST_MODEL (self), position, n_removals, n_additions);
+  if (n_removals != n_additions)
+    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_N_ITEMS]);
+
+  gtk_sorter_changed_with_keys (GTK_SORTER (self),
+                                GTK_SORTER_CHANGE_DIFFERENT,
+                                gtk_multi_sort_keys_new (self));
+}

gtk/gtkmultisorter.h

@@ -44,6 +44,13 @@ GDK_AVAILABLE_IN_ALL
 void                    gtk_multi_sorter_remove                 (GtkMultiSorter         *self,
                                                                  guint                   position);
 
+GDK_AVAILABLE_IN_4_10
+void                    gtk_multi_sorter_splice                 (GtkMultiSorter         *self,
+                                                                 guint                   position,
+                                                                 guint                   n_removals,
+                                                                 GtkSorter             **additions,
+                                                                 guint                   n_additions);
+
 G_END_DECLS
 
 #endif /* __GTK_MULTI_SORTER_H__ */

gtk/meson.build

@@ -260,6 +260,7 @@ gtk_public_sources = files([
   'gtkimmulticontext.c',
   'gtkinfobar.c',
   'gtkinscription.c',
+  'gtkinvertiblesorter.c',
   'gtklabel.c',
   'gtklayoutchild.c',
   'gtklayoutmanager.c',
@@ -513,6 +514,7 @@ gtk_public_headers = files([
   'gtkimmulticontext.h',
   'gtkinfobar.h',
   'gtkinscription.h',
+  'gtkinvertiblesorter.h',
   'gtklabel.h',
   'gtklayoutchild.h',
   'gtklayoutmanager.h',