/*
* Copyright © 2019 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 .
*
* Authors: Matthias Clasen
*/
#include "config.h"
#include "gtkmultisorter.h"
#include "gtkbuildable.h"
#include "gtkintl.h"
#include "gtksorterprivate.h"
#include "gtktypebuiltins.h"
#define GDK_ARRAY_TYPE_NAME GtkSorters
#define GDK_ARRAY_NAME gtk_sorters
#define GDK_ARRAY_ELEMENT_TYPE GtkSorter *
#define GDK_ARRAY_FREE_FUNC g_object_unref
#include "gdk/gdkarrayimpl.c"
/**
* SECTION:gtkmultisorter
* @Title: GtkMultiSorter
* @Short_description: Combining multiple sorters
*
* GtkMultiSorter combines multiple sorters by trying them
* in turn. If the first sorter compares two items as equal,
* the second is tried next, and so on.
*/
struct _GtkMultiSorter
{
GtkSorter parent_instance;
GtkSorters sorters;
};
typedef struct _GtkMultiSortKey GtkMultiSortKey;
typedef struct _GtkMultiSortKeys GtkMultiSortKeys;
struct _GtkMultiSortKey
{
gsize offset;
GtkSortKeys *keys;
};
struct _GtkMultiSortKeys
{
GtkSortKeys parent_keys;
guint n_keys;
GtkMultiSortKey keys[];
};
static void
gtk_multi_sort_keys_free (GtkSortKeys *keys)
{
GtkMultiSortKeys *self = (GtkMultiSortKeys *) keys;
gsize i;
for (i = 0; i < self->n_keys; i++)
gtk_sort_keys_unref (self->keys[i].keys);
g_slice_free1 (sizeof (GtkMultiSortKeys) + self->n_keys * sizeof (GtkMultiSortKey), self);
}
static int
gtk_multi_sort_keys_compare (gconstpointer a,
gconstpointer b,
gpointer data)
{
GtkMultiSortKeys *self = (GtkMultiSortKeys *) data;
gsize i;
for (i = 0; i < self->n_keys; i++)
{
GtkOrdering result = gtk_sort_keys_compare (self->keys[i].keys,
((const char *) a) + self->keys[i].offset,
((const char *) b) + self->keys[i].offset);
if (result != GTK_ORDERING_EQUAL)
return result;
}
return GTK_ORDERING_EQUAL;
}
static gboolean
gtk_multi_sort_keys_is_compatible (GtkSortKeys *keys,
GtkSortKeys *other)
{
GtkMultiSortKeys *self = (GtkMultiSortKeys *) keys;
GtkMultiSortKeys *compare = (GtkMultiSortKeys *) other;
gsize i;
if (keys->klass != other->klass)
return FALSE;
if (self->n_keys != compare->n_keys)
return FALSE;
for (i = 0; i < self->n_keys; i++)
{
if (!gtk_sort_keys_is_compatible (self->keys[i].keys, compare->keys[i].keys))
return FALSE;
}
return TRUE;
}
static void
gtk_multi_sort_keys_init_key (GtkSortKeys *keys,
gpointer item,
gpointer key_memory)
{
GtkMultiSortKeys *self = (GtkMultiSortKeys *) keys;
char *key = (char *) key_memory;
gsize i;
for (i = 0; i < self->n_keys; i++)
gtk_sort_keys_init_key (self->keys[i].keys, item, key + self->keys[i].offset);
}
static void
gtk_multi_sort_keys_clear_key (GtkSortKeys *keys,
gpointer key_memory)
{
GtkMultiSortKeys *self = (GtkMultiSortKeys *) keys;
char *key = (char *) key_memory;
gsize i;
for (i = 0; i < self->n_keys; i++)
gtk_sort_keys_clear_key (self->keys[i].keys, key + self->keys[i].offset);
}
static const GtkSortKeysClass GTK_MULTI_SORT_KEYS_CLASS =
{
gtk_multi_sort_keys_free,
gtk_multi_sort_keys_compare,
gtk_multi_sort_keys_is_compatible,
gtk_multi_sort_keys_init_key,
gtk_multi_sort_keys_clear_key,
};
static GtkSortKeys *
gtk_multi_sort_keys_new (GtkMultiSorter *self)
{
GtkMultiSortKeys *result;
GtkSortKeys *keys;
gsize i;
if (gtk_sorters_get_size (&self->sorters) == 0)
return gtk_sort_keys_new_equal ();
else if (gtk_sorters_get_size (&self->sorters) == 1)
return gtk_sorter_get_keys (gtk_sorters_get (&self->sorters, 0));
keys = gtk_sort_keys_alloc (>K_MULTI_SORT_KEYS_CLASS,
sizeof (GtkMultiSortKeys) + gtk_sorters_get_size (&self->sorters) * sizeof (GtkMultiSortKey),
0, 1);
result = (GtkMultiSortKeys *) keys;
result->n_keys = gtk_sorters_get_size (&self->sorters);
for (i = 0; i < result->n_keys; i++)
{
result->keys[i].keys = gtk_sorter_get_keys (gtk_sorters_get (&self->sorters, i));
result->keys[i].offset = GTK_SORT_KEYS_ALIGN (keys->key_size, gtk_sort_keys_get_key_align (result->keys[i].keys));
keys->key_size = result->keys[i].offset + gtk_sort_keys_get_key_size (result->keys[i].keys);
keys->key_align = MAX (keys->key_align, gtk_sort_keys_get_key_align (result->keys[i].keys));
}
return keys;
}
static GType
gtk_multi_sorter_get_item_type (GListModel *list)
{
return GTK_TYPE_SORTER;
}
static guint
gtk_multi_sorter_get_n_items (GListModel *list)
{
GtkMultiSorter *self = GTK_MULTI_SORTER (list);
return gtk_sorters_get_size (&self->sorters);
}
static gpointer
gtk_multi_sorter_get_item (GListModel *list,
guint position)
{
GtkMultiSorter *self = GTK_MULTI_SORTER (list);
if (position < gtk_sorters_get_size (&self->sorters))
return g_object_ref (gtk_sorters_get (&self->sorters, position));
else
return NULL;
}
static void
gtk_multi_sorter_list_model_init (GListModelInterface *iface)
{
iface->get_item_type = gtk_multi_sorter_get_item_type;
iface->get_n_items = gtk_multi_sorter_get_n_items;
iface->get_item = gtk_multi_sorter_get_item;
}
static GtkBuildableIface *parent_buildable_iface;
static void
gtk_multi_sorter_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *type)
{
if (GTK_IS_SORTER (child))
gtk_multi_sorter_append (GTK_MULTI_SORTER (buildable), g_object_ref (GTK_SORTER (child)));
else
parent_buildable_iface->add_child (buildable, builder, child, type);
}
static void
gtk_multi_sorter_buildable_init (GtkBuildableIface *iface)
{
parent_buildable_iface = g_type_interface_peek_parent (iface);
iface->add_child = gtk_multi_sorter_buildable_add_child;
}
G_DEFINE_TYPE_WITH_CODE (GtkMultiSorter, gtk_multi_sorter, GTK_TYPE_SORTER,
G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, gtk_multi_sorter_list_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE, gtk_multi_sorter_buildable_init))
static GtkOrdering
gtk_multi_sorter_compare (GtkSorter *sorter,
gpointer item1,
gpointer item2)
{
GtkMultiSorter *self = GTK_MULTI_SORTER (sorter);
GtkOrdering result = GTK_ORDERING_EQUAL;
guint i;
for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
{
GtkSorter *child = gtk_sorters_get (&self->sorters, i);
result = gtk_sorter_compare (child, item1, item2);
if (result != GTK_ORDERING_EQUAL)
break;
}
return result;
}
static GtkSorterOrder
gtk_multi_sorter_get_order (GtkSorter *sorter)
{
GtkMultiSorter *self = GTK_MULTI_SORTER (sorter);
GtkSorterOrder result = GTK_SORTER_ORDER_NONE;
guint i;
for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
{
GtkSorter *child = gtk_sorters_get (&self->sorters, i);
GtkSorterOrder child_order;
child_order = gtk_sorter_get_order (child);
switch (child_order)
{
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;
}
static void
gtk_multi_sorter_changed_cb (GtkSorter *sorter,
GtkSorterChange change,
GtkMultiSorter *self)
{
/* Using an enum on purpose, so gcc complains about this case if
* new values are added to the enum
*/
switch (change)
{
case GTK_SORTER_CHANGE_INVERTED:
/* This could do a lot better with change handling, in particular in
* cases where self->n_sorters == 1 or if sorter == self->sorters[0]
*/
change = GTK_SORTER_CHANGE_DIFFERENT;
break;
case GTK_SORTER_CHANGE_DIFFERENT:
case GTK_SORTER_CHANGE_LESS_STRICT:
case GTK_SORTER_CHANGE_MORE_STRICT:
break;
default:
g_assert_not_reached ();
change = GTK_SORTER_CHANGE_DIFFERENT;
}
gtk_sorter_changed_with_keys (GTK_SORTER (self),
change,
gtk_multi_sort_keys_new (self));
}
static void
gtk_multi_sorter_dispose (GObject *object)
{
GtkMultiSorter *self = GTK_MULTI_SORTER (object);
guint i;
for (i = 0; i < gtk_sorters_get_size (&self->sorters); i++)
{
GtkSorter *sorter = gtk_sorters_get (&self->sorters, i);
g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
}
gtk_sorters_clear (&self->sorters);
G_OBJECT_CLASS (gtk_multi_sorter_parent_class)->dispose (object);
}
static void
gtk_multi_sorter_class_init (GtkMultiSorterClass *class)
{
GtkSorterClass *sorter_class = GTK_SORTER_CLASS (class);
GObjectClass *object_class = G_OBJECT_CLASS (class);
sorter_class->compare = gtk_multi_sorter_compare;
sorter_class->get_order = gtk_multi_sorter_get_order;
object_class->dispose = gtk_multi_sorter_dispose;
}
static void
gtk_multi_sorter_init (GtkMultiSorter *self)
{
gtk_sorters_init (&self->sorters);
gtk_sorter_changed_with_keys (GTK_SORTER (self),
GTK_SORTER_CHANGE_DIFFERENT,
gtk_multi_sort_keys_new (self));
}
/**
* gtk_multi_sorter_new:
*
* Creates a new multi sorter.
*
* This sorter compares items by trying each of the sorters
* in turn, until one returns non-zero. In particular, if
* no sorter has been added to it, it will always compare
* items as equal.
*
* Returns: a new #GtkMultiSorter
*/
GtkMultiSorter *
gtk_multi_sorter_new (void)
{
return g_object_new (GTK_TYPE_MULTI_SORTER, NULL);
}
/**
* gtk_multi_sorter_append:
* @self: a #GtkMultiSorter
* @sorter: (transfer full): a sorter to add
*
* Add @sorter to @self to use for sorting at the end. @self
* will consult all existing sorters before it will sort with
* the given @sorter.
*/
void
gtk_multi_sorter_append (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_append (&self->sorters, sorter);
gtk_sorter_changed_with_keys (GTK_SORTER (self),
GTK_SORTER_CHANGE_MORE_STRICT,
gtk_multi_sort_keys_new (self));
}
/**
* gtk_multi_sorter_remove:
* @self: a #GtkMultiSorter
* @position: position of sorter to remove
*
* Removes the sorter at the given @position from the list of sorter
* used by @self.
*
* If @position is larger than the number of sorters, nothing happens.
*/
void
gtk_multi_sorter_remove (GtkMultiSorter *self,
guint position)
{
guint length;
GtkSorter *sorter;
g_return_if_fail (GTK_IS_MULTI_SORTER (self));
length = gtk_sorters_get_size (&self->sorters);
if (position >= length)
return;
sorter = gtk_sorters_get (&self->sorters, position);
g_signal_handlers_disconnect_by_func (sorter, gtk_multi_sorter_changed_cb, self);
gtk_sorters_splice (&self->sorters, position, 1, FALSE, NULL, 0);
gtk_sorter_changed_with_keys (GTK_SORTER (self),
GTK_SORTER_CHANGE_LESS_STRICT,
gtk_multi_sort_keys_new (self));
}