[evolution] ETableSorter: Further cleanups.
- From: Matthew Barnes <mbarnes src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [evolution] ETableSorter: Further cleanups.
- Date: Thu, 20 Jun 2013 21:00:50 +0000 (UTC)
commit 9f9d4803090b84a6b7c1851a716229455692992e
Author: Matthew Barnes <mbarnes redhat com>
Date: Thu Jun 20 16:44:24 2013 -0400
ETableSorter: Further cleanups.
e-util/e-table-sorter.c | 678 +++++++++++++++++++++++------------------------
e-util/e-table-sorter.h | 28 +--
2 files changed, 347 insertions(+), 359 deletions(-)
---
diff --git a/e-util/e-table-sorter.c b/e-util/e-table-sorter.c
index a74bc36..e570042 100644
--- a/e-util/e-table-sorter.c
+++ b/e-util/e-table-sorter.c
@@ -1,4 +1,6 @@
/*
+ * e-table-sorter.c
+ *
* 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,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)
- *
*/
#ifdef HAVE_CONFIG_H
@@ -39,18 +35,6 @@ enum {
PROP_SORT_INFO
};
-#define INCREMENT_AMOUNT 100
-
-static void ets_model_changed (ETableModel *etm, ETableSorter *ets);
-static void ets_model_row_changed (ETableModel *etm, gint row, ETableSorter *ets);
-static void ets_model_cell_changed (ETableModel *etm, gint col, gint row, ETableSorter *ets);
-static void ets_model_rows_inserted (ETableModel *etm, gint row, gint count, ETableSorter *ets);
-static void ets_model_rows_deleted (ETableModel *etm, gint row, gint count, ETableSorter *ets);
-static void ets_sort_info_changed (ETableSortInfo *info, ETableSorter *ets);
-static void ets_clean (ETableSorter *ets);
-static void ets_sort (ETableSorter *ets);
-static void ets_backsort (ETableSorter *ets);
-
/* Forward Declarations */
static void e_table_sorter_interface_init (ESorterInterface *interface);
@@ -62,92 +46,225 @@ G_DEFINE_TYPE_WITH_CODE (
E_TYPE_SORTER,
e_table_sorter_interface_init))
+struct qsort_data {
+ ETableSorter *table_sorter;
+ gpointer *vals;
+ gint cols;
+ gint *ascending;
+ GCompareDataFunc *compare;
+ gpointer cmp_cache;
+};
+
+/* FIXME: Make it not cache the second and later columns (as if anyone cares.) */
+
+static gint
+qsort_callback (gconstpointer data1,
+ gconstpointer data2,
+ gpointer user_data)
+{
+ struct qsort_data *qd = (struct qsort_data *) user_data;
+ gint row1 = *(gint *) data1;
+ gint row2 = *(gint *) data2;
+ gint j;
+ gint sort_count;
+ gint comp_val = 0;
+ gint ascending = 1;
+
+ sort_count =
+ e_table_sort_info_sorting_get_count (
+ qd->table_sorter->sort_info) +
+ e_table_sort_info_grouping_get_count (
+ qd->table_sorter->sort_info);
+
+ for (j = 0; j < sort_count; j++) {
+ comp_val = (*(qd->compare[j]))(qd->vals[qd->cols * row1 + j], qd->vals[qd->cols * row2 + j],
qd->cmp_cache);
+ ascending = qd->ascending[j];
+ if (comp_val != 0)
+ break;
+ }
+ if (comp_val == 0) {
+ if (row1 < row2)
+ comp_val = -1;
+ if (row1 > row2)
+ comp_val = 1;
+ }
+ if (!ascending)
+ comp_val = -comp_val;
+
+ return comp_val;
+}
+
+static void
+table_sorter_clean (ETableSorter *table_sorter)
+{
+ g_free (table_sorter->sorted);
+ table_sorter->sorted = NULL;
+
+ g_free (table_sorter->backsorted);
+ table_sorter->backsorted = NULL;
+
+ table_sorter->needs_sorting = -1;
+}
+
+static void
+table_sorter_sort (ETableSorter *table_sorter)
+{
+ gint rows;
+ gint i;
+ gint j;
+ gint cols;
+ gint group_cols;
+ struct qsort_data qd;
+
+ if (table_sorter->sorted)
+ return;
+
+ rows = e_table_model_row_count (table_sorter->source);
+ group_cols = e_table_sort_info_grouping_get_count (table_sorter->sort_info);
+ cols = e_table_sort_info_sorting_get_count (table_sorter->sort_info) + group_cols;
+
+ table_sorter->sorted = g_new (int, rows);
+ for (i = 0; i < rows; i++)
+ table_sorter->sorted[i] = i;
+
+ qd.cols = cols;
+ qd.table_sorter = table_sorter;
+
+ qd.vals = g_new (gpointer , rows * cols);
+ qd.ascending = g_new (int, cols);
+ qd.compare = g_new (GCompareDataFunc, cols);
+ qd.cmp_cache = e_table_sorting_utils_create_cmp_cache ();
+
+ for (j = 0; j < cols; j++) {
+ ETableSortColumn column;
+ ETableCol *col;
+
+ if (j < group_cols)
+ column = e_table_sort_info_grouping_get_nth (table_sorter->sort_info, j);
+ else
+ column = e_table_sort_info_sorting_get_nth (table_sorter->sort_info, j - group_cols);
+
+ col = e_table_header_get_column_by_col_idx (table_sorter->full_header, column.column);
+ if (col == NULL)
+ col = e_table_header_get_column (table_sorter->full_header, e_table_header_count
(table_sorter->full_header) - 1);
+
+ for (i = 0; i < rows; i++) {
+ qd.vals[i * cols + j] = e_table_model_value_at (table_sorter->source, col->col_idx,
i);
+ }
+
+ qd.compare[j] = col->compare;
+ qd.ascending[j] = column.ascending;
+ }
+
+ g_qsort_with_data (table_sorter->sorted, rows, sizeof (gint), qsort_callback, &qd);
+
+ g_free (qd.vals);
+ g_free (qd.ascending);
+ g_free (qd.compare);
+ e_table_sorting_utils_free_cmp_cache (qd.cmp_cache);
+}
+
static void
-ets_dispose (GObject *object)
+table_sorter_backsort (ETableSorter *table_sorter)
{
- ETableSorter *ets = E_TABLE_SORTER (object);
-
- if (ets->sort_info) {
- if (ets->table_model_changed_id)
- g_signal_handler_disconnect (
- ets->source,
- ets->table_model_changed_id);
- if (ets->table_model_row_changed_id)
- g_signal_handler_disconnect (
- ets->source,
- ets->table_model_row_changed_id);
- if (ets->table_model_cell_changed_id)
- g_signal_handler_disconnect (
- ets->source,
- ets->table_model_cell_changed_id);
- if (ets->table_model_rows_inserted_id)
- g_signal_handler_disconnect (
- ets->source,
- ets->table_model_rows_inserted_id);
- if (ets->table_model_rows_deleted_id)
- g_signal_handler_disconnect (
- ets->source,
- ets->table_model_rows_deleted_id);
- if (ets->sort_info_changed_id)
- g_signal_handler_disconnect (
- ets->sort_info,
- ets->sort_info_changed_id);
- if (ets->group_info_changed_id)
- g_signal_handler_disconnect (
- ets->sort_info,
- ets->group_info_changed_id);
-
- ets->table_model_changed_id = 0;
- ets->table_model_row_changed_id = 0;
- ets->table_model_cell_changed_id = 0;
- ets->table_model_rows_inserted_id = 0;
- ets->table_model_rows_deleted_id = 0;
- ets->sort_info_changed_id = 0;
- ets->group_info_changed_id = 0;
-
- g_object_unref (ets->sort_info);
- ets->sort_info = NULL;
+ gint i, rows;
+
+ if (table_sorter->backsorted)
+ return;
+
+ table_sorter_sort (table_sorter);
+
+ rows = e_table_model_row_count (table_sorter->source);
+ table_sorter->backsorted = g_new0 (int, rows);
+
+ for (i = 0; i < rows; i++) {
+ table_sorter->backsorted[table_sorter->sorted[i]] = i;
}
+}
- if (ets->full_header)
- g_object_unref (ets->full_header);
- ets->full_header = NULL;
+static void
+table_sorter_model_changed_cb (ETableModel *table_model,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
+}
- if (ets->source)
- g_object_unref (ets->source);
- ets->source = NULL;
+static void
+table_sorter_model_row_changed_cb (ETableModel *table_model,
+ gint row,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
+}
- G_OBJECT_CLASS (e_table_sorter_parent_class)->dispose (object);
+static void
+table_sorter_model_cell_changed_cb (ETableModel *table_model,
+ gint col,
+ gint row,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
+}
+
+static void
+table_sorter_model_rows_inserted_cb (ETableModel *table_model,
+ gint row,
+ gint count,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
+}
+
+static void
+table_sorter_model_rows_deleted_cb (ETableModel *table_model,
+ gint row,
+ gint count,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
+}
+
+static void
+table_sorter_sort_info_changed_cb (ETableSortInfo *sort_info,
+ ETableSorter *table_sorter)
+{
+ table_sorter_clean (table_sorter);
}
static void
-ets_set_property (GObject *object,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec)
+table_sorter_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- ETableSorter *ets = E_TABLE_SORTER (object);
+ ETableSorter *table_sorter = E_TABLE_SORTER (object);
switch (property_id) {
case PROP_SORT_INFO:
- if (ets->sort_info) {
- if (ets->sort_info_changed_id)
- g_signal_handler_disconnect (ets->sort_info, ets->sort_info_changed_id);
- if (ets->group_info_changed_id)
- g_signal_handler_disconnect (ets->sort_info, ets->group_info_changed_id);
- g_object_unref (ets->sort_info);
+ if (table_sorter->sort_info) {
+ if (table_sorter->sort_info_changed_id)
+ g_signal_handler_disconnect (
+ table_sorter->sort_info,
+ table_sorter->sort_info_changed_id);
+ if (table_sorter->group_info_changed_id)
+ g_signal_handler_disconnect (
+ table_sorter->sort_info,
+ table_sorter->group_info_changed_id);
+ g_object_unref (table_sorter->sort_info);
}
- ets->sort_info = E_TABLE_SORT_INFO (g_value_get_object (value));
- g_object_ref (ets->sort_info);
- ets->sort_info_changed_id = g_signal_connect (
- ets->sort_info, "sort_info_changed",
- G_CALLBACK (ets_sort_info_changed), ets);
- ets->group_info_changed_id = g_signal_connect (
- ets->sort_info, "group_info_changed",
- G_CALLBACK (ets_sort_info_changed), ets);
+ table_sorter->sort_info = g_value_dup_object (value);
- ets_clean (ets);
+ table_sorter->sort_info_changed_id = g_signal_connect (
+ table_sorter->sort_info, "sort_info_changed",
+ G_CALLBACK (table_sorter_sort_info_changed_cb),
+ table_sorter);
+ table_sorter->group_info_changed_id = g_signal_connect (
+ table_sorter->sort_info, "group_info_changed",
+ G_CALLBACK (table_sorter_sort_info_changed_cb),
+ table_sorter);
+
+ table_sorter_clean (table_sorter);
break;
default:
break;
@@ -155,109 +272,176 @@ ets_set_property (GObject *object,
}
static void
-ets_get_property (GObject *object,
- guint property_id,
- GValue *value,
- GParamSpec *pspec)
+table_sorter_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- ETableSorter *ets = E_TABLE_SORTER (object);
+ ETableSorter *table_sorter = E_TABLE_SORTER (object);
switch (property_id) {
case PROP_SORT_INFO:
- g_value_set_object (value, ets->sort_info);
+ g_value_set_object (value, table_sorter->sort_info);
break;
}
}
+static void
+table_sorter_dispose (GObject *object)
+{
+ ETableSorter *table_sorter = E_TABLE_SORTER (object);
+
+ if (table_sorter->table_model_changed_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->source,
+ table_sorter->table_model_changed_id);
+ table_sorter->table_model_changed_id = 0;
+ }
+
+ if (table_sorter->table_model_row_changed_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->source,
+ table_sorter->table_model_row_changed_id);
+ table_sorter->table_model_row_changed_id = 0;
+ }
+
+ if (table_sorter->table_model_cell_changed_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->source,
+ table_sorter->table_model_cell_changed_id);
+ table_sorter->table_model_cell_changed_id = 0;
+ }
+
+ if (table_sorter->table_model_rows_inserted_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->source,
+ table_sorter->table_model_rows_inserted_id);
+ table_sorter->table_model_rows_inserted_id = 0;
+ }
+
+ if (table_sorter->table_model_rows_deleted_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->source,
+ table_sorter->table_model_rows_deleted_id);
+ table_sorter->table_model_rows_deleted_id = 0;
+ }
+
+ if (table_sorter->sort_info_changed_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->sort_info,
+ table_sorter->sort_info_changed_id);
+ table_sorter->sort_info_changed_id = 0;
+ }
+
+ if (table_sorter->group_info_changed_id > 0) {
+ g_signal_handler_disconnect (
+ table_sorter->sort_info,
+ table_sorter->group_info_changed_id);
+ table_sorter->group_info_changed_id = 0;
+ }
+
+ g_clear_object (&table_sorter->sort_info);
+ g_clear_object (&table_sorter->full_header);
+ g_clear_object (&table_sorter->source);
+
+ /* Chain up to parent's dispose() method. */
+ G_OBJECT_CLASS (e_table_sorter_parent_class)->dispose (object);
+}
+
static gint
-table_sorter_model_to_sorted (ESorter *es,
+table_sorter_model_to_sorted (ESorter *sorter,
gint row)
{
- ETableSorter *ets = E_TABLE_SORTER (es);
- gint rows = e_table_model_row_count (ets->source);
+ ETableSorter *table_sorter = E_TABLE_SORTER (sorter);
+ gint rows = e_table_model_row_count (table_sorter->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 (e_sorter_needs_sorting (sorter))
+ table_sorter_backsort (table_sorter);
- if (ets->backsorted)
- return ets->backsorted[row];
+ if (table_sorter->backsorted)
+ return table_sorter->backsorted[row];
else
return row;
}
static gint
-table_sorter_sorted_to_model (ESorter *es,
+table_sorter_sorted_to_model (ESorter *sorter,
gint row)
{
- ETableSorter *ets = E_TABLE_SORTER (es);
- gint rows = e_table_model_row_count (ets->source);
+ ETableSorter *table_sorter = E_TABLE_SORTER (sorter);
+ gint rows = e_table_model_row_count (table_sorter->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 (e_sorter_needs_sorting (sorter))
+ table_sorter_sort (table_sorter);
- if (ets->sorted)
- return ets->sorted[row];
+ if (table_sorter->sorted)
+ return table_sorter->sorted[row];
else
return row;
}
static void
-table_sorter_get_model_to_sorted_array (ESorter *es,
+table_sorter_get_model_to_sorted_array (ESorter *sorter,
gint **array,
gint *count)
{
- ETableSorter *ets = E_TABLE_SORTER (es);
+ ETableSorter *table_sorter = E_TABLE_SORTER (sorter);
+
if (array || count) {
- ets_backsort (ets);
+ table_sorter_backsort (table_sorter);
if (array)
- *array = ets->backsorted;
+ *array = table_sorter->backsorted;
if (count)
- *count = e_table_model_row_count(ets->source);
+ *count = e_table_model_row_count(table_sorter->source);
}
}
static void
-table_sorter_get_sorted_to_model_array (ESorter *es,
+table_sorter_get_sorted_to_model_array (ESorter *sorter,
gint **array,
gint *count)
{
- ETableSorter *ets = E_TABLE_SORTER (es);
+ ETableSorter *table_sorter = E_TABLE_SORTER (sorter);
+
if (array || count) {
- ets_sort (ets);
+ table_sorter_sort (table_sorter);
if (array)
- *array = ets->sorted;
+ *array = table_sorter->sorted;
if (count)
- *count = e_table_model_row_count(ets->source);
+ *count = e_table_model_row_count(table_sorter->source);
}
}
static gboolean
-table_sorter_needs_sorting (ESorter *es)
+table_sorter_needs_sorting (ESorter *sorter)
{
- 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;
+ ETableSorter *table_sorter = E_TABLE_SORTER (sorter);
+
+ if (table_sorter->needs_sorting < 0) {
+ if (e_table_sort_info_sorting_get_count (table_sorter->sort_info) +
e_table_sort_info_grouping_get_count (table_sorter->sort_info))
+ table_sorter->needs_sorting = 1;
else
- ets->needs_sorting = 0;
+ table_sorter->needs_sorting = 0;
}
- return ets->needs_sorting;
+ return table_sorter->needs_sorting;
}
+
static void
e_table_sorter_class_init (ETableSorterClass *class)
{
- GObjectClass *object_class = G_OBJECT_CLASS (class);
+ GObjectClass *object_class;
- object_class->dispose = ets_dispose;
- object_class->set_property = ets_set_property;
- object_class->get_property = ets_get_property;
+ object_class = G_OBJECT_CLASS (class);
+ object_class->set_property = table_sorter_set_property;
+ object_class->get_property = table_sorter_get_property;
+ object_class->dispose = table_sorter_dispose;
g_object_class_install_property (
object_class,
@@ -281,21 +465,9 @@ e_table_sorter_interface_init (ESorterInterface *interface)
}
static void
-e_table_sorter_init (ETableSorter *ets)
+e_table_sorter_init (ETableSorter *table_sorter)
{
- ets->full_header = NULL;
- ets->sort_info = NULL;
- ets->source = NULL;
-
- ets->needs_sorting = -1;
-
- ets->table_model_changed_id = 0;
- ets->table_model_row_changed_id = 0;
- ets->table_model_cell_changed_id = 0;
- ets->table_model_rows_inserted_id = 0;
- ets->table_model_rows_deleted_id = 0;
- ets->sort_info_changed_id = 0;
- ets->group_info_changed_id = 0;
+ table_sorter->needs_sorting = -1;
}
ETableSorter *
@@ -303,221 +475,41 @@ e_table_sorter_new (ETableModel *source,
ETableHeader *full_header,
ETableSortInfo *sort_info)
{
- ETableSorter *ets = g_object_new (E_TYPE_TABLE_SORTER, NULL);
+ ETableSorter *table_sorter;
- ets->sort_info = sort_info;
- g_object_ref (ets->sort_info);
- ets->full_header = full_header;
- g_object_ref (ets->full_header);
- ets->source = source;
- g_object_ref (ets->source);
+ table_sorter = g_object_new (E_TYPE_TABLE_SORTER, NULL);
+ table_sorter->sort_info = g_object_ref (sort_info);
+ table_sorter->full_header = g_object_ref (full_header);
+ table_sorter->source = g_object_ref (source);
- ets->table_model_changed_id = g_signal_connect (
+ table_sorter->table_model_changed_id = g_signal_connect (
source, "model_changed",
- G_CALLBACK (ets_model_changed), ets);
+ G_CALLBACK (table_sorter_model_changed_cb), table_sorter);
- ets->table_model_row_changed_id = g_signal_connect (
+ table_sorter->table_model_row_changed_id = g_signal_connect (
source, "model_row_changed",
- G_CALLBACK (ets_model_row_changed), ets);
+ G_CALLBACK (table_sorter_model_row_changed_cb), table_sorter);
- ets->table_model_cell_changed_id = g_signal_connect (
+ table_sorter->table_model_cell_changed_id = g_signal_connect (
source, "model_cell_changed",
- G_CALLBACK (ets_model_cell_changed), ets);
+ G_CALLBACK (table_sorter_model_cell_changed_cb), table_sorter);
- ets->table_model_rows_inserted_id = g_signal_connect (
+ table_sorter->table_model_rows_inserted_id = g_signal_connect (
source, "model_rows_inserted",
- G_CALLBACK (ets_model_rows_inserted), ets);
+ G_CALLBACK (table_sorter_model_rows_inserted_cb), table_sorter);
- ets->table_model_rows_deleted_id = g_signal_connect (
+ table_sorter->table_model_rows_deleted_id = g_signal_connect (
source, "model_rows_deleted",
- G_CALLBACK (ets_model_rows_deleted), ets);
+ G_CALLBACK (table_sorter_model_rows_deleted_cb), table_sorter);
- ets->sort_info_changed_id = g_signal_connect (
+ table_sorter->sort_info_changed_id = g_signal_connect (
sort_info, "sort_info_changed",
- G_CALLBACK (ets_sort_info_changed), ets);
+ G_CALLBACK (table_sorter_sort_info_changed_cb), table_sorter);
- ets->group_info_changed_id = g_signal_connect (
+ table_sorter->group_info_changed_id = g_signal_connect (
sort_info, "group_info_changed",
- G_CALLBACK (ets_sort_info_changed), ets);
-
- return ets;
-}
-
-static void
-ets_model_changed (ETableModel *etm,
- ETableSorter *ets)
-{
- ets_clean (ets);
-}
-
-static void
-ets_model_row_changed (ETableModel *etm,
- gint row,
- ETableSorter *ets)
-{
- ets_clean (ets);
-}
-
-static void
-ets_model_cell_changed (ETableModel *etm,
- gint col,
- gint row,
- ETableSorter *ets)
-{
- ets_clean (ets);
-}
-
-static void
-ets_model_rows_inserted (ETableModel *etm,
- gint row,
- gint count,
- ETableSorter *ets)
-{
- ets_clean (ets);
-}
-
-static void
-ets_model_rows_deleted (ETableModel *etm,
- gint row,
- gint count,
- ETableSorter *ets)
-{
- ets_clean (ets);
-}
-
-static void
-ets_sort_info_changed (ETableSortInfo *info,
- ETableSorter *ets)
-{
- d (g_print ("sort info changed\n"));
- ets_clean (ets);
-}
-
-struct qsort_data {
- ETableSorter *ets;
- gpointer *vals;
- gint cols;
- gint *ascending;
- GCompareDataFunc *compare;
- gpointer cmp_cache;
-};
-
-/* FIXME: Make it not cache the second and later columns (as if anyone cares.) */
-
-static gint
-qsort_callback (gconstpointer data1,
- gconstpointer data2,
- gpointer user_data)
-{
- struct qsort_data *qd = (struct qsort_data *) user_data;
- gint row1 = *(gint *) data1;
- gint row2 = *(gint *) data2;
- gint j;
- gint sort_count = e_table_sort_info_sorting_get_count (qd->ets->sort_info) +
e_table_sort_info_grouping_get_count (qd->ets->sort_info);
- gint comp_val = 0;
- gint ascending = 1;
- for (j = 0; j < sort_count; j++) {
- comp_val = (*(qd->compare[j]))(qd->vals[qd->cols * row1 + j], qd->vals[qd->cols * row2 + j],
qd->cmp_cache);
- ascending = qd->ascending[j];
- if (comp_val != 0)
- break;
- }
- if (comp_val == 0) {
- if (row1 < row2)
- comp_val = -1;
- if (row1 > row2)
- comp_val = 1;
- }
- if (!ascending)
- comp_val = -comp_val;
- return comp_val;
-}
+ G_CALLBACK (table_sorter_sort_info_changed_cb), table_sorter);
-static void
-ets_clean (ETableSorter *ets)
-{
- g_free (ets->sorted);
- ets->sorted = NULL;
-
- g_free (ets->backsorted);
- ets->backsorted = NULL;
-
- ets->needs_sorting = -1;
-}
-
-static void
-ets_sort (ETableSorter *ets)
-{
- gint rows;
- gint i;
- gint j;
- gint cols;
- gint group_cols;
- struct qsort_data qd;
-
- if (ets->sorted)
- return;
-
- rows = e_table_model_row_count (ets->source);
- group_cols = e_table_sort_info_grouping_get_count (ets->sort_info);
- cols = e_table_sort_info_sorting_get_count (ets->sort_info) + group_cols;
-
- ets->sorted = g_new (int, rows);
- for (i = 0; i < rows; i++)
- ets->sorted[i] = i;
-
- qd.cols = cols;
- qd.ets = ets;
-
- qd.vals = g_new (gpointer , rows * cols);
- qd.ascending = g_new (int, cols);
- qd.compare = g_new (GCompareDataFunc, cols);
- qd.cmp_cache = e_table_sorting_utils_create_cmp_cache ();
-
- for (j = 0; j < cols; j++) {
- ETableSortColumn column;
- ETableCol *col;
-
- if (j < group_cols)
- column = e_table_sort_info_grouping_get_nth (ets->sort_info, j);
- else
- column = e_table_sort_info_sorting_get_nth (ets->sort_info, j - group_cols);
-
- col = e_table_header_get_column_by_col_idx (ets->full_header, column.column);
- if (col == NULL)
- col = e_table_header_get_column (ets->full_header, e_table_header_count
(ets->full_header) - 1);
-
- for (i = 0; i < rows; i++) {
- qd.vals[i * cols + j] = e_table_model_value_at (ets->source, col->col_idx, i);
- }
-
- qd.compare[j] = col->compare;
- qd.ascending[j] = column.ascending;
- }
-
- g_qsort_with_data (ets->sorted, rows, sizeof (gint), qsort_callback, &qd);
-
- g_free (qd.vals);
- g_free (qd.ascending);
- g_free (qd.compare);
- e_table_sorting_utils_free_cmp_cache (qd.cmp_cache);
-}
-
-static void
-ets_backsort (ETableSorter *ets)
-{
- gint i, rows;
-
- if (ets->backsorted)
- return;
-
- ets_sort (ets);
-
- rows = e_table_model_row_count (ets->source);
- ets->backsorted = g_new0 (int, rows);
-
- for (i = 0; i < rows; i++) {
- ets->backsorted[ets->sorted[i]] = i;
- }
+ return table_sorter;
}
diff --git a/e-util/e-table-sorter.h b/e-util/e-table-sorter.h
index a32116e..7dbba44 100644
--- a/e-util/e-table-sorter.h
+++ b/e-util/e-table-sorter.h
@@ -1,4 +1,6 @@
/*
+ * e-table-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,20 +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)
- *
*/
#if !defined (__E_UTIL_H_INSIDE__) && !defined (LIBEUTIL_COMPILATION)
#error "Only <e-util/e-util.h> should be included directly."
#endif
-#ifndef _E_TABLE_SORTER_H_
-#define _E_TABLE_SORTER_H_
+#ifndef E_TABLE_SORTER_H
+#define E_TABLE_SORTER_H
#include <e-util/e-sorter.h>
#include <e-util/e-table-header.h>
@@ -71,13 +67,13 @@ struct _ETableSorter {
gint *sorted;
gint *backsorted;
- gint table_model_changed_id;
- gint table_model_row_changed_id;
- gint table_model_cell_changed_id;
- gint table_model_rows_inserted_id;
- gint table_model_rows_deleted_id;
- gint sort_info_changed_id;
- gint group_info_changed_id;
+ gulong table_model_changed_id;
+ gulong table_model_row_changed_id;
+ gulong table_model_cell_changed_id;
+ gulong table_model_rows_inserted_id;
+ gulong table_model_rows_deleted_id;
+ gulong sort_info_changed_id;
+ gulong group_info_changed_id;
};
struct _ETableSorterClass {
@@ -91,4 +87,4 @@ ETableSorter * e_table_sorter_new (ETableModel *etm,
G_END_DECLS
-#endif /* _E_TABLE_SORTER_H_ */
+#endif /* E_TABLE_SORTER_H */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
