Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

columnview: Reimplement column view sorting

Browse Source 
Replace the private GtkColumnViewSorter implementation
with a GtkMultiSorter containing GtkInvertibleSorters
wrapping the individual column sorters.
This commit is contained in:
Matthias Clasen
2022-10-19 21:09:45 -04:00
parent 173f82772e
commit eb045fe936
6 changed files with 176 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
gtk/gtkcolumnview.c
View File

@@ -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);
}
@@ -1699,11 +1700,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);
}
/**

52
gtk/gtkcolumnviewcolumn.c
View File

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

3
gtk/gtkcolumnviewcolumnprivate.h
View File

@@ -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__ */

377
gtk/gtkcolumnviewsorter.c
View File

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

27
gtk/gtkcolumnviewsorterprivate.h
View File

@@ -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__ */

32
gtk/gtkcolumnviewtitle.c
View File

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