Convert ESorter to an interface.

6 files changed, 230 insertions, 290 deletions

diff --git a/e-util/e-sorter-array.c b/e-util/e-sorter-array.c
index fc411e12ec..f5cd03a3df 100644
--- a/e-util/e-sorter-array.c
+++ b/e-util/e-sorter-array.c
@@ -35,25 +35,19 @@
 
 #define INCREMENT_AMOUNT 100
 
-G_DEFINE_TYPE (
-	ESorterArray,
-	e_sorter_array,
-	E_TYPE_SORTER)
-
 static void	esa_sort			(ESorterArray *esa);
 static void	esa_backsort			(ESorterArray *esa);
 
-static gint	esa_model_to_sorted		(ESorter *sorter, gint row);
-static gint	esa_sorted_to_model		(ESorter *sorter, gint row);
-static void	esa_get_model_to_sorted_array	(ESorter *sorter,
-						 gint **array,
-						 gint *count);
-static void	esa_get_sorted_to_model_array	(ESorter *sorter,
-						 gint **array,
-						 gint *count);
-static gboolean	esa_needs_sorting		(ESorter *esa);
+/* Forward Declarations */
+static void	e_sorter_array_interface_init	(ESorterInterface *interface);
 
-#define ESA_NEEDS_SORTING(esa) (((ESorterArray *) (esa))->compare != NULL)
+G_DEFINE_TYPE_WITH_CODE (
+	ESorterArray,
+	e_sorter_array,
+	G_TYPE_OBJECT,
+	G_IMPLEMENT_INTERFACE (
+		E_TYPE_SORTER,
+		e_sorter_array_interface_init))
 
 static gint
 esort_callback (gconstpointer data1,
@@ -127,81 +121,6 @@ esa_backsort (ESorterArray *esa)
 	}
 }
 
-static gint
-esa_model_to_sorted (ESorter *es,
-                     gint row)
-{
-	ESorterArray *esa = E_SORTER_ARRAY (es);
-
-	g_return_val_if_fail (row >= 0, -1);
-	g_return_val_if_fail (row < esa->rows, -1);
-
-	if (ESA_NEEDS_SORTING (es))
-		esa_backsort (esa);
-
-	if (esa->backsorted)
-		return esa->backsorted[row];
-	else
-		return row;
-}
-
-static gint
-esa_sorted_to_model (ESorter *es,
-                     gint row)
-{
-	ESorterArray *esa = (ESorterArray *) es;
-
-	g_return_val_if_fail (row >= 0, -1);
-	g_return_val_if_fail (row < esa->rows, -1);
-
-	if (ESA_NEEDS_SORTING (es))
-		esa_sort (esa);
-
-	if (esa->sorted)
-		return esa->sorted[row];
-	else
-		return row;
-}
-
-static void
-esa_get_model_to_sorted_array (ESorter *es,
-                               gint **array,
-                               gint *count)
-{
-	ESorterArray *esa = E_SORTER_ARRAY (es);
-	if (array || count) {
-		esa_backsort (esa);
-
-		if (array)
-			*array = esa->backsorted;
-		if (count)
-			*count = esa->rows;
-	}
-}
-
-static void
-esa_get_sorted_to_model_array (ESorter *es,
-                               gint **array,
-                               gint *count)
-{
-	ESorterArray *esa = E_SORTER_ARRAY (es);
-	if (array || count) {
-		esa_sort (esa);
-
-		if (array)
-			*array = esa->sorted;
-		if (count)
-			*count = esa->rows;
-	}
-}
-
-static gboolean
-esa_needs_sorting (ESorter *es)
-{
-	ESorterArray *esa = E_SORTER_ARRAY (es);
-	return esa->compare != NULL;
-}
-
 void
 e_sorter_array_clean (ESorterArray *esa)
 {
@@ -283,19 +202,97 @@ e_sorter_array_new (ECreateCmpCacheFunc create_cmp_cache,
 	return e_sorter_array_construct (esa, create_cmp_cache, compare, closure);
 }
 
+static gint
+sorter_array_model_to_sorted (ESorter *es,
+                              gint row)
+{
+	ESorterArray *esa = E_SORTER_ARRAY (es);
+
+	g_return_val_if_fail (row >= 0, -1);
+	g_return_val_if_fail (row < esa->rows, -1);
+
+	if (e_sorter_needs_sorting (es))
+		esa_backsort (esa);
+
+	if (esa->backsorted)
+		return esa->backsorted[row];
+	else
+		return row;
+}
+
+static gint
+sorter_array_sorted_to_model (ESorter *es,
+                              gint row)
+{
+	ESorterArray *esa = (ESorterArray *) es;
+
+	g_return_val_if_fail (row >= 0, -1);
+	g_return_val_if_fail (row < esa->rows, -1);
+
+	if (e_sorter_needs_sorting (es))
+		esa_sort (esa);
+
+	if (esa->sorted)
+		return esa->sorted[row];
+	else
+		return row;
+}
+
+static void
+sorter_array_get_model_to_sorted_array (ESorter *es,
+                                        gint **array,
+                                        gint *count)
+{
+	ESorterArray *esa = E_SORTER_ARRAY (es);
+	if (array || count) {
+		esa_backsort (esa);
+
+		if (array)
+			*array = esa->backsorted;
+		if (count)
+			*count = esa->rows;
+	}
+}
+
+static void
+sorter_array_get_sorted_to_model_array (ESorter *es,
+                                        gint **array,
+                                        gint *count)
+{
+	ESorterArray *esa = E_SORTER_ARRAY (es);
+	if (array || count) {
+		esa_sort (esa);
+
+		if (array)
+			*array = esa->sorted;
+		if (count)
+			*count = esa->rows;
+	}
+}
+
+static gboolean
+sorter_array_needs_sorting (ESorter *es)
+{
+	ESorterArray *esa = E_SORTER_ARRAY (es);
+	return esa->compare != NULL;
+}
+
 static void
 e_sorter_array_class_init (ESorterArrayClass *class)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (class);
-	ESorterClass *sorter_class = E_SORTER_CLASS (class);
 
 	object_class->finalize = esa_finalize;
+}
 
-	sorter_class->model_to_sorted           = esa_model_to_sorted;
-	sorter_class->sorted_to_model           = esa_sorted_to_model;
-	sorter_class->get_model_to_sorted_array = esa_get_model_to_sorted_array;
-	sorter_class->get_sorted_to_model_array = esa_get_sorted_to_model_array;
-	sorter_class->needs_sorting             = esa_needs_sorting;
+static void
+e_sorter_array_interface_init (ESorterInterface *interface)
+{
+	interface->model_to_sorted = sorter_array_model_to_sorted;
+	interface->sorted_to_model = sorter_array_sorted_to_model;
+	interface->get_model_to_sorted_array = sorter_array_get_model_to_sorted_array;
+	interface->get_sorted_to_model_array = sorter_array_get_sorted_to_model_array;
+	interface->needs_sorting = sorter_array_needs_sorting;
 }
 
 static void
diff --git a/e-util/e-sorter-array.h b/e-util/e-sorter-array.h
index 04899d21b6..468c320e8f 100644
--- a/e-util/e-sorter-array.h
+++ b/e-util/e-sorter-array.h
@@ -61,7 +61,7 @@ typedef gint (*ECompareRowsFunc) (gint row1,
 typedef GHashTable * (*ECreateCmpCacheFunc) (gpointer closure);
 
 struct _ESorterArray {
-	ESorter parent;
+	GObject parent;
 
 	GHashTable *cmp_cache;
 	ECreateCmpCacheFunc create_cmp_cache;
@@ -77,7 +77,7 @@ struct _ESorterArray {
 };
 
 struct _ESorterArrayClass {
-	ESorterClass parent_class;
+	GObjectClass parent_class;
 };
 
 GType		e_sorter_array_get_type	(void) G_GNUC_CONST;
diff --git a/e-util/e-sorter.c b/e-util/e-sorter.c
index f2023d7ddf..0534f21d02 100644
--- a/e-util/e-sorter.c
+++ b/e-util/e-sorter.c
@@ -1,4 +1,6 @@
 /*
+ * e-sorter.h
+ *
  * This program 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
@@ -12,64 +14,14 @@
  * You should have received a copy of the GNU Lesser General Public
  * License along with the program; if not, see <http://www.gnu.org/licenses/>
  *
- *
- * Authors:
- *		Chris Lahey <clahey@ximian.com>
- *
- * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
- *
  */
 
 #include "e-sorter.h"
 
-G_DEFINE_TYPE (ESorter, e_sorter, G_TYPE_OBJECT)
-
-static gint
-sorter_model_to_sorted (ESorter *sorter,
-                        gint row)
-{
-	return row;
-}
-
-static gint
-sorter_sorted_to_model (ESorter *sorter,
-                        gint row)
-{
-	return row;
-}
-
-static void
-sorter_get_model_to_sorted_array (ESorter *sorter,
-                                  gint **array,
-                                  gint *count)
-{
-}
-
-static void
-sorter_get_sorted_to_model_array (ESorter *sorter,
-                                  gint **array,
-                                  gint *count)
-{
-}
-
-static gboolean
-sorter_needs_sorting (ESorter *sorter)
-{
-	return FALSE;
-}
-
-static void
-e_sorter_class_init (ESorterClass *class)
-{
-	class->model_to_sorted = sorter_model_to_sorted;
-	class->sorted_to_model = sorter_sorted_to_model;
-	class->get_model_to_sorted_array = sorter_get_model_to_sorted_array;
-	class->get_sorted_to_model_array = sorter_get_sorted_to_model_array;
-	class->needs_sorting = sorter_needs_sorting;
-}
+G_DEFINE_INTERFACE (ESorter, e_sorter, G_TYPE_OBJECT)
 
 static void
-e_sorter_init (ESorter *sorter)
+e_sorter_default_init (ESorterInterface *interface)
 {
 }
 
@@ -77,30 +29,30 @@ gint
 e_sorter_model_to_sorted (ESorter *sorter,
                           gint row)
 {
-	ESorterClass *class;
+	ESorterInterface *interface;
 
 	g_return_val_if_fail (E_IS_SORTER (sorter), -1);
 	g_return_val_if_fail (row >= 0, -1);
 
-	class = E_SORTER_GET_CLASS (sorter);
-	g_return_val_if_fail (class->model_to_sorted != NULL, -1);
+	interface = E_SORTER_GET_INTERFACE (sorter);
+	g_return_val_if_fail (interface->model_to_sorted != NULL, -1);
 
-	return class->model_to_sorted (sorter, row);
+	return interface->model_to_sorted (sorter, row);
 }
 
 gint
 e_sorter_sorted_to_model (ESorter *sorter,
                           gint row)
 {
-	ESorterClass *class;
+	ESorterInterface *interface;
 
 	g_return_val_if_fail (E_IS_SORTER (sorter), -1);
 	g_return_val_if_fail (row >= 0, -1);
 
-	class = E_SORTER_GET_CLASS (sorter);
-	g_return_val_if_fail (class->sorted_to_model != NULL, -1);
+	interface = E_SORTER_GET_INTERFACE (sorter);
+	g_return_val_if_fail (interface->sorted_to_model != NULL, -1);
 
-	return class->sorted_to_model (sorter, row);
+	return interface->sorted_to_model (sorter, row);
 }
 
 void
@@ -108,14 +60,14 @@ e_sorter_get_model_to_sorted_array (ESorter *sorter,
                                     gint **array,
                                     gint *count)
 {
-	ESorterClass *class;
+	ESorterInterface *interface;
 
 	g_return_if_fail (E_IS_SORTER (sorter));
 
-	class = E_SORTER_GET_CLASS (sorter);
-	g_return_if_fail (class->get_model_to_sorted_array != NULL);
+	interface = E_SORTER_GET_INTERFACE (sorter);
+	g_return_if_fail (interface->get_model_to_sorted_array != NULL);
 
-	class->get_model_to_sorted_array (sorter, array, count);
+	interface->get_model_to_sorted_array (sorter, array, count);
 }
 
 void
@@ -123,26 +75,26 @@ e_sorter_get_sorted_to_model_array (ESorter *sorter,
                                     gint **array,
                                     gint *count)
 {
-	ESorterClass *class;
+	ESorterInterface *interface;
 
 	g_return_if_fail (E_IS_SORTER (sorter));
 
-	class = E_SORTER_GET_CLASS (sorter);
-	g_return_if_fail (class->get_sorted_to_model_array != NULL);
+	interface = E_SORTER_GET_INTERFACE (sorter);
+	g_return_if_fail (interface->get_sorted_to_model_array != NULL);
 
-	class->get_sorted_to_model_array (sorter, array, count);
+	interface->get_sorted_to_model_array (sorter, array, count);
 }
 
 gboolean
 e_sorter_needs_sorting (ESorter *sorter)
 {
-	ESorterClass *class;
+	ESorterInterface *interface;
 
 	g_return_val_if_fail (E_IS_SORTER (sorter), FALSE);
 
-	class = E_SORTER_GET_CLASS (sorter);
-	g_return_val_if_fail (class->needs_sorting != NULL, FALSE);
+	interface = E_SORTER_GET_INTERFACE (sorter);
+	g_return_val_if_fail (interface->needs_sorting != NULL, FALSE);
 
-	return class->needs_sorting (sorter);
+	return interface->needs_sorting (sorter);
 }
 
diff --git a/e-util/e-sorter.h b/e-util/e-sorter.h
index 4ab5e8420a..70060302be 100644
--- a/e-util/e-sorter.h
+++ b/e-util/e-sorter.h
@@ -1,4 +1,5 @@
 /*
+ * e-sorter.h
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -13,12 +14,6 @@
  * You should have received a copy of the GNU Lesser General Public
  * License along with the program; if not, see <http://www.gnu.org/licenses/>
  *
- *
- * Authors:
- *		Chris Lahey <clahey@ximian.com>
- *
- * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
- *
  */
 
 #if !defined (__E_UTIL_H_INSIDE__) && !defined (LIBEUTIL_COMPILATION)
@@ -36,30 +31,20 @@
 #define E_SORTER(obj) \
 	(G_TYPE_CHECK_INSTANCE_CAST \
 	((obj), E_TYPE_SORTER, ESorter))
-#define E_SORTER_CLASS(cls) \
-	(G_TYPE_CHECK_CLASS_CAST \
-	((cls), E_TYPE_SORTER, ESorterClass))
 #define E_IS_SORTER(obj) \
 	(G_TYPE_CHECK_INSTANCE_TYPE \
 	((obj), E_TYPE_SORTER))
-#define E_IS_SORTER_CLASS(cls) \
-	(G_TYPE_CHECK_CLASS_TYPE \
-	((cls), E_TYPE_SORTER))
-#define E_SORTER_GET_CLASS(obj) \
-	(G_TYPE_INSTANCE_GET_CLASS \
-	((obj), E_TYPE_SORTER, ESorterClass))
+#define E_SORTER_GET_INTERFACE(obj) \
+	(G_TYPE_INSTANCE_GET_INTERFACE \
+	((obj), E_TYPE_SORTER, ESorterInterface))
 
 G_BEGIN_DECLS
 
 typedef struct _ESorter ESorter;
-typedef struct _ESorterClass ESorterClass;
-
-struct _ESorter {
-	GObject parent;
-};
+typedef struct _ESorterInterface ESorterInterface;
 
-struct _ESorterClass {
-	GObjectClass parent_class;
+struct _ESorterInterface {
+	GTypeInterface parent_interface;
 
 	gint		(*model_to_sorted)	(ESorter *sorter,
 						 gint row);
diff --git a/e-util/e-table-sorter.c b/e-util/e-table-sorter.c
index 0ff30db68b..a74bc3626c 100644
--- a/e-util/e-table-sorter.c
+++ b/e-util/e-table-sorter.c
@@ -39,8 +39,6 @@ enum {
 	PROP_SORT_INFO
 };
 
-G_DEFINE_TYPE (ETableSorter, e_table_sorter, E_TYPE_SORTER)
-
 #define INCREMENT_AMOUNT 100
 
 static void	ets_model_changed      (ETableModel *etm, ETableSorter *ets);
@@ -53,11 +51,16 @@ static void	ets_clean              (ETableSorter *ets);
 static void	ets_sort               (ETableSorter *ets);
 static void	ets_backsort           (ETableSorter *ets);
 
-static gint	ets_model_to_sorted           (ESorter *sorter, gint row);
-static gint	ets_sorted_to_model           (ESorter *sorter, gint row);
-static void	ets_get_model_to_sorted_array (ESorter *sorter, gint **array, gint *count);
-static void	ets_get_sorted_to_model_array (ESorter *sorter, gint **array, gint *count);
-static gboolean ets_needs_sorting             (ESorter *ets);
+/* Forward Declarations */
+static void	e_table_sorter_interface_init	(ESorterInterface *interface);
+
+G_DEFINE_TYPE_WITH_CODE (
+	ETableSorter,
+	e_table_sorter,
+	G_TYPE_OBJECT,
+	G_IMPLEMENT_INTERFACE (
+		E_TYPE_SORTER,
+		e_table_sorter_interface_init))
 
 static void
 ets_dispose (GObject *object)
@@ -165,22 +168,97 @@ ets_get_property (GObject *object,
 	}
 }
 
+static gint
+table_sorter_model_to_sorted (ESorter *es,
+                              gint row)
+{
+	ETableSorter *ets = E_TABLE_SORTER (es);
+	gint rows = e_table_model_row_count (ets->source);
+
+	g_return_val_if_fail (row >= 0, -1);
+	g_return_val_if_fail (row < rows, -1);
+
+	if (e_sorter_needs_sorting (es))
+		ets_backsort (ets);
+
+	if (ets->backsorted)
+		return ets->backsorted[row];
+	else
+		return row;
+}
+
+static gint
+table_sorter_sorted_to_model (ESorter *es,
+                              gint row)
+{
+	ETableSorter *ets = E_TABLE_SORTER (es);
+	gint rows = e_table_model_row_count (ets->source);
+
+	g_return_val_if_fail (row >= 0, -1);
+	g_return_val_if_fail (row < rows, -1);
+
+	if (e_sorter_needs_sorting (es))
+		ets_sort (ets);
+
+	if (ets->sorted)
+		return ets->sorted[row];
+	else
+		return row;
+}
+
+static void
+table_sorter_get_model_to_sorted_array (ESorter *es,
+                                        gint **array,
+                                        gint *count)
+{
+	ETableSorter *ets = E_TABLE_SORTER (es);
+	if (array || count) {
+		ets_backsort (ets);
+
+		if (array)
+			*array = ets->backsorted;
+		if (count)
+			*count = e_table_model_row_count(ets->source);
+	}
+}
+
+static void
+table_sorter_get_sorted_to_model_array (ESorter *es,
+                                        gint **array,
+                                        gint *count)
+{
+	ETableSorter *ets = E_TABLE_SORTER (es);
+	if (array || count) {
+		ets_sort (ets);
+
+		if (array)
+			*array = ets->sorted;
+		if (count)
+			*count = e_table_model_row_count(ets->source);
+	}
+}
+
+static gboolean
+table_sorter_needs_sorting (ESorter *es)
+{
+	ETableSorter *ets = E_TABLE_SORTER (es);
+	if (ets->needs_sorting < 0) {
+		if (e_table_sort_info_sorting_get_count (ets->sort_info) + e_table_sort_info_grouping_get_count (ets->sort_info))
+			ets->needs_sorting = 1;
+		else
+			ets->needs_sorting = 0;
+	}
+	return ets->needs_sorting;
+}
 static void
 e_table_sorter_class_init (ETableSorterClass *class)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (class);
-	ESorterClass *sorter_class = E_SORTER_CLASS (class);
 
 	object_class->dispose                   = ets_dispose;
 	object_class->set_property              = ets_set_property;
 	object_class->get_property              = ets_get_property;
 
-	sorter_class->model_to_sorted           = ets_model_to_sorted;
-	sorter_class->sorted_to_model           = ets_sorted_to_model;
-	sorter_class->get_model_to_sorted_array = ets_get_model_to_sorted_array;
-	sorter_class->get_sorted_to_model_array = ets_get_sorted_to_model_array;
-	sorter_class->needs_sorting             = ets_needs_sorting;
-
 	g_object_class_install_property (
 		object_class,
 		PROP_SORT_INFO,
@@ -193,6 +271,16 @@ e_table_sorter_class_init (ETableSorterClass *class)
 }
 
 static void
+e_table_sorter_interface_init (ESorterInterface *interface)
+{
+	interface->model_to_sorted = table_sorter_model_to_sorted;
+	interface->sorted_to_model = table_sorter_sorted_to_model;
+	interface->get_model_to_sorted_array = table_sorter_get_model_to_sorted_array;
+	interface->get_sorted_to_model_array = table_sorter_get_sorted_to_model_array;
+	interface->needs_sorting = table_sorter_needs_sorting;
+}
+
+static void
 e_table_sorter_init (ETableSorter *ets)
 {
 	ets->full_header = NULL;
@@ -433,85 +521,3 @@ ets_backsort (ETableSorter *ets)
 	}
 }
 
-static gint
-ets_model_to_sorted (ESorter *es,
-                     gint row)
-{
-	ETableSorter *ets = E_TABLE_SORTER (es);
-	gint rows = e_table_model_row_count (ets->source);
-
-	g_return_val_if_fail (row >= 0, -1);
-	g_return_val_if_fail (row < rows, -1);
-
-	if (ets_needs_sorting (es))
-		ets_backsort (ets);
-
-	if (ets->backsorted)
-		return ets->backsorted[row];
-	else
-		return row;
-}
-
-static gint
-ets_sorted_to_model (ESorter *es,
-                     gint row)
-{
-	ETableSorter *ets = E_TABLE_SORTER (es);
-	gint rows = e_table_model_row_count (ets->source);
-
-	g_return_val_if_fail (row >= 0, -1);
-	g_return_val_if_fail (row < rows, -1);
-
-	if (ets_needs_sorting (es))
-		ets_sort (ets);
-
-	if (ets->sorted)
-		return ets->sorted[row];
-	else
-		return row;
-}
-
-static void
-ets_get_model_to_sorted_array (ESorter *es,
-                               gint **array,
-                               gint *count)
-{
-	ETableSorter *ets = E_TABLE_SORTER (es);
-	if (array || count) {
-		ets_backsort (ets);
-
-		if (array)
-			*array = ets->backsorted;
-		if (count)
-			*count = e_table_model_row_count(ets->source);
-	}
-}
-
-static void
-ets_get_sorted_to_model_array (ESorter *es,
-                               gint **array,
-                               gint *count)
-{
-	ETableSorter *ets = E_TABLE_SORTER (es);
-	if (array || count) {
-		ets_sort (ets);
-
-		if (array)
-			*array = ets->sorted;
-		if (count)
-			*count = e_table_model_row_count(ets->source);
-	}
-}
-
-static gboolean
-ets_needs_sorting (ESorter *es)
-{
-	ETableSorter *ets = E_TABLE_SORTER (es);
-	if (ets->needs_sorting < 0) {
-		if (e_table_sort_info_sorting_get_count (ets->sort_info) + e_table_sort_info_grouping_get_count (ets->sort_info))
-			ets->needs_sorting = 1;
-		else
-			ets->needs_sorting = 0;
-	}
-	return ets->needs_sorting;
-}
diff --git a/e-util/e-table-sorter.h b/e-util/e-table-sorter.h
index 9615a9b17f..a32116edf7 100644
--- a/e-util/e-table-sorter.h
+++ b/e-util/e-table-sorter.h
@@ -58,7 +58,7 @@ typedef struct _ETableSorter ETableSorter;
 typedef struct _ETableSorterClass ETableSorterClass;
 
 struct _ETableSorter {
-	ESorter parent;
+	GObject parent;
 
 	ETableModel *source;
 	ETableHeader *full_header;
@@ -81,7 +81,7 @@ struct _ETableSorter {
 };
 
 struct _ETableSorterClass {
-	ESorterClass parent_class;
+	GObjectClass parent_class;
 };
 
 GType		e_table_sorter_get_type		(void) G_GNUC_CONST;