From f8605636c394f9df19b80a8d7084038566a43cfa Mon Sep 17 00:00:00 2001 From: Matthew Barnes Date: Wed, 26 Jun 2013 21:46:26 -0400 Subject: ETableSortInfo cleanups. --- e-util/e-table-sort-info.c | 341 +++++++++++++++++++++++---------------------- 1 file changed, 174 insertions(+), 167 deletions(-) (limited to 'e-util/e-table-sort-info.c') diff --git a/e-util/e-table-sort-info.c b/e-util/e-table-sort-info.c index 55d746fc28..fc75088d9f 100644 --- a/e-util/e-table-sort-info.c +++ b/e-util/e-table-sort-info.c @@ -1,4 +1,6 @@ /* + * e-table-sort-info.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,72 +14,45 @@ * You should have received a copy of the GNU Lesser General Public * License along with the program; if not, see * - * - * Authors: - * Chris Lahey - * - * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) - * */ -#ifdef HAVE_CONFIG_H -#include -#endif - #include "e-table-sort-info.h" #include #include "e-xml-utils.h" -#define ETM_CLASS(e) (E_TABLE_SORT_INFO_GET_CLASS (e)) - -G_DEFINE_TYPE (ETableSortInfo , e_table_sort_info, G_TYPE_OBJECT) - enum { SORT_INFO_CHANGED, GROUP_INFO_CHANGED, LAST_SIGNAL }; -static guint e_table_sort_info_signals[LAST_SIGNAL] = { 0, }; +static guint signals[LAST_SIGNAL]; + +G_DEFINE_TYPE (ETableSortInfo , e_table_sort_info, G_TYPE_OBJECT) static void -etsi_finalize (GObject *object) +table_sort_info_finalize (GObject *object) { - ETableSortInfo *etsi = E_TABLE_SORT_INFO (object); - - if (etsi->groupings) - g_free (etsi->groupings); - etsi->groupings = NULL; + ETableSortInfo *sort_info = E_TABLE_SORT_INFO (object); - if (etsi->sortings) - g_free (etsi->sortings); - etsi->sortings = NULL; + g_free (sort_info->groupings); + g_free (sort_info->sortings); + /* Chain up to parent's finalize() method. */ G_OBJECT_CLASS (e_table_sort_info_parent_class)->finalize (object); } -static void -e_table_sort_info_init (ETableSortInfo *info) -{ - info->group_count = 0; - info->groupings = NULL; - info->sort_count = 0; - info->sortings = NULL; - info->sort_info_changed = 0; - info->group_info_changed = 0; - info->can_group = 1; -} - static void e_table_sort_info_class_init (ETableSortInfoClass *class) { - GObjectClass * object_class = G_OBJECT_CLASS (class); + GObjectClass * object_class; - object_class->finalize = etsi_finalize; + object_class = G_OBJECT_CLASS (class); + object_class->finalize = table_sort_info_finalize; - e_table_sort_info_signals[SORT_INFO_CHANGED] = g_signal_new ( + signals[SORT_INFO_CHANGED] = g_signal_new ( "sort_info_changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, @@ -86,7 +61,7 @@ e_table_sort_info_class_init (ETableSortInfoClass *class) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - e_table_sort_info_signals[GROUP_INFO_CHANGED] = g_signal_new ( + signals[GROUP_INFO_CHANGED] = g_signal_new ( "group_info_changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, @@ -94,176 +69,212 @@ e_table_sort_info_class_init (ETableSortInfoClass *class) (GSignalAccumulator) NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - - class->sort_info_changed = NULL; - class->group_info_changed = NULL; } static void -e_table_sort_info_sort_info_changed (ETableSortInfo *info) +e_table_sort_info_init (ETableSortInfo *sort_info) +{ + sort_info->can_group = TRUE; +} + +/** + * e_table_sort_info_new: + * + * This creates a new #ETableSortInfo object that contains no + * grouping and no sorting defined as of yet. This object is used + * to keep track of multi-level sorting and multi-level grouping of + * an #ETable. + * + * Returns: A new #ETableSortInfo object + */ +ETableSortInfo * +e_table_sort_info_new (void) +{ + return g_object_new (E_TYPE_TABLE_SORT_INFO, NULL); +} + +gboolean +e_table_sort_info_get_can_group (ETableSortInfo *sort_info) { - g_return_if_fail (info != NULL); - g_return_if_fail (E_IS_TABLE_SORT_INFO (info)); + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), FALSE); - g_signal_emit (info, e_table_sort_info_signals[SORT_INFO_CHANGED], 0); + return sort_info->can_group; } -static void -e_table_sort_info_group_info_changed (ETableSortInfo *info) +void +e_table_sort_info_set_can_group (ETableSortInfo *sort_info, + gboolean can_group) { - g_return_if_fail (info != NULL); - g_return_if_fail (E_IS_TABLE_SORT_INFO (info)); + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); - g_signal_emit (info, e_table_sort_info_signals[GROUP_INFO_CHANGED], 0); + sort_info->can_group = can_group; } /** * e_table_sort_info_grouping_get_count: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * * Returns: the number of grouping criteria in the object. */ guint -e_table_sort_info_grouping_get_count (ETableSortInfo *info) +e_table_sort_info_grouping_get_count (ETableSortInfo *sort_info) { - if (info->can_group) - return info->group_count; - else - return 0; + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), 0); + + return (sort_info->can_group) ? sort_info->group_count : 0; } static void -e_table_sort_info_grouping_real_truncate (ETableSortInfo *info, - gint length) +table_sort_info_grouping_real_truncate (ETableSortInfo *sort_info, + gint length) { - if (length < info->group_count) { - info->group_count = length; - } - if (length > info->group_count) { - info->groupings = g_realloc (info->groupings, length * sizeof (ETableSortColumn)); - info->group_count = length; + if (length < sort_info->group_count) + sort_info->group_count = length; + + if (length > sort_info->group_count) { + sort_info->groupings = g_realloc ( + sort_info->groupings, + length * sizeof (ETableSortColumn)); + sort_info->group_count = length; } } /** * e_table_sort_info_grouping_truncate: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @length: position where the truncation happens. * * This routine can be used to reduce or grow the number of grouping * criteria in the object. */ void -e_table_sort_info_grouping_truncate (ETableSortInfo *info, +e_table_sort_info_grouping_truncate (ETableSortInfo *sort_info, gint length) { - e_table_sort_info_grouping_real_truncate (info, length); - e_table_sort_info_group_info_changed (info); + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); + + table_sort_info_grouping_real_truncate (sort_info, length); + + g_signal_emit (sort_info, signals[GROUP_INFO_CHANGED], 0); } /** * e_table_sort_info_grouping_get_nth: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @n: Item information to fetch. * * Returns: the description of the @n-th grouping criteria in the @info object. */ ETableSortColumn -e_table_sort_info_grouping_get_nth (ETableSortInfo *info, +e_table_sort_info_grouping_get_nth (ETableSortInfo *sort_info, gint n) { - if (info->can_group && n < info->group_count) { - return info->groupings[n]; - } else { - ETableSortColumn fake = {0, 0}; - return fake; - } + ETableSortColumn fake = {0, 0}; + + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), fake); + + if (sort_info->can_group && n < sort_info->group_count) + return sort_info->groupings[n]; + + return fake; } /** * e_table_sort_info_grouping_set_nth: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @n: Item information to fetch. * @column: new values for the grouping * - * Sets the grouping criteria for index @n to be given by @column (a column number and - * whether it is ascending or descending). + * Sets the grouping criteria for index @n to be given by @column + * (a column number and whether it is ascending or descending). */ void -e_table_sort_info_grouping_set_nth (ETableSortInfo *info, +e_table_sort_info_grouping_set_nth (ETableSortInfo *sort_info, gint n, ETableSortColumn column) { - if (n >= info->group_count) { - e_table_sort_info_grouping_real_truncate (info, n + 1); - } - info->groupings[n] = column; - e_table_sort_info_group_info_changed (info); + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); + + if (n >= sort_info->group_count) + table_sort_info_grouping_real_truncate (sort_info, n + 1); + + sort_info->groupings[n] = column; + + g_signal_emit (sort_info, signals[GROUP_INFO_CHANGED], 0); } /** * e_table_sort_info_get_count: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * * Returns: the number of sorting criteria in the object. */ guint -e_table_sort_info_sorting_get_count (ETableSortInfo *info) +e_table_sort_info_sorting_get_count (ETableSortInfo *sort_info) { - return info->sort_count; + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), 0); + + return sort_info->sort_count; } static void -e_table_sort_info_sorting_real_truncate (ETableSortInfo *info, - gint length) +table_sort_info_sorting_real_truncate (ETableSortInfo *sort_info, + gint length) { - if (length < info->sort_count) { - info->sort_count = length; - } - if (length > info->sort_count) { - info->sortings = g_realloc (info->sortings, length * sizeof (ETableSortColumn)); - info->sort_count = length; + if (length < sort_info->sort_count) + sort_info->sort_count = length; + + if (length > sort_info->sort_count) { + sort_info->sortings = g_realloc ( + sort_info->sortings, + length * sizeof (ETableSortColumn)); + sort_info->sort_count = length; } } /** * e_table_sort_info_sorting_truncate: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @length: position where the truncation happens. * * This routine can be used to reduce or grow the number of sort * criteria in the object. */ void -e_table_sort_info_sorting_truncate (ETableSortInfo *info, +e_table_sort_info_sorting_truncate (ETableSortInfo *sort_info, gint length) { - e_table_sort_info_sorting_real_truncate (info, length); - e_table_sort_info_sort_info_changed (info); + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); + + table_sort_info_sorting_real_truncate (sort_info, length); + + g_signal_emit (sort_info, signals[SORT_INFO_CHANGED], 0); } /** * e_table_sort_info_sorting_get_nth: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @n: Item information to fetch. * * Returns: the description of the @n-th grouping criteria in the @info object. */ ETableSortColumn -e_table_sort_info_sorting_get_nth (ETableSortInfo *info, +e_table_sort_info_sorting_get_nth (ETableSortInfo *sort_info, gint n) { - if (n < info->sort_count) { - return info->sortings[n]; - } else { - ETableSortColumn fake = {0, 0}; - return fake; - } + ETableSortColumn fake = {0, 0}; + + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), fake); + + if (n < sort_info->sort_count) + return sort_info->sortings[n]; + + return fake; } /** * e_table_sort_info_sorting_set_nth: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @n: Item information to fetch. * @column: new values for the sorting * @@ -271,64 +282,54 @@ e_table_sort_info_sorting_get_nth (ETableSortInfo *info, * column number and whether it is ascending or descending). */ void -e_table_sort_info_sorting_set_nth (ETableSortInfo *info, +e_table_sort_info_sorting_set_nth (ETableSortInfo *sort_info, gint n, ETableSortColumn column) { - if (n >= info->sort_count) { - e_table_sort_info_sorting_real_truncate (info, n + 1); - } - info->sortings[n] = column; - e_table_sort_info_sort_info_changed (info); -} + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); -/** - * e_table_sort_info_new: - * - * This creates a new e_table_sort_info object that contains no - * grouping and no sorting defined as of yet. This object is used - * to keep track of multi-level sorting and multi-level grouping of - * the ETable. - * - * Returns: A new %ETableSortInfo object - */ -ETableSortInfo * -e_table_sort_info_new (void) -{ - return g_object_new (E_TYPE_TABLE_SORT_INFO, NULL); + if (n >= sort_info->sort_count) + table_sort_info_sorting_real_truncate (sort_info, n + 1); + + sort_info->sortings[n] = column; + + g_signal_emit (sort_info, signals[SORT_INFO_CHANGED], 0); } /** * e_table_sort_info_load_from_node: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @node: pointer to the xmlNode that describes the sorting and grouping information * @state_version: * - * This loads the state for the %ETableSortInfo object @info from the + * This loads the state for the #ETableSortInfo object @info from the * xml node @node. */ void -e_table_sort_info_load_from_node (ETableSortInfo *info, +e_table_sort_info_load_from_node (ETableSortInfo *sort_info, xmlNode *node, gdouble state_version) { gint i; xmlNode *grouping; + g_return_if_fail (E_IS_TABLE_SORT_INFO (sort_info)); + g_return_if_fail (node != NULL); + if (state_version <= 0.05) { i = 0; for (grouping = node->xmlChildrenNode; grouping && !strcmp ((gchar *) grouping->name, "group"); grouping = grouping->xmlChildrenNode) { ETableSortColumn column; column.column = e_xml_get_integer_prop_by_name (grouping, (const guchar *)"column"); column.ascending = e_xml_get_bool_prop_by_name (grouping, (const guchar *)"ascending"); - e_table_sort_info_grouping_set_nth (info, i++, column); + e_table_sort_info_grouping_set_nth (sort_info, i++, column); } i = 0; for (; grouping && !strcmp ((gchar *) grouping->name, "leaf"); grouping = grouping->xmlChildrenNode) { ETableSortColumn column; column.column = e_xml_get_integer_prop_by_name (grouping, (const guchar *)"column"); column.ascending = e_xml_get_bool_prop_by_name (grouping, (const guchar *)"ascending"); - e_table_sort_info_sorting_set_nth (info, i++, column); + e_table_sort_info_sorting_set_nth (sort_info, i++, column); } } else { gint gcnt = 0; @@ -342,20 +343,20 @@ e_table_sort_info_load_from_node (ETableSortInfo *info, if (!strcmp ((gchar *) grouping->name, "group")) { column.column = e_xml_get_integer_prop_by_name (grouping, (const guchar *)"column"); column.ascending = e_xml_get_bool_prop_by_name (grouping, (const guchar *)"ascending"); - e_table_sort_info_grouping_set_nth (info, gcnt++, column); + e_table_sort_info_grouping_set_nth (sort_info, gcnt++, column); } else if (!strcmp ((gchar *) grouping->name, "leaf")) { column.column = e_xml_get_integer_prop_by_name (grouping, (const guchar *)"column"); column.ascending = e_xml_get_bool_prop_by_name (grouping, (const guchar *)"ascending"); - e_table_sort_info_sorting_set_nth (info, scnt++, column); + e_table_sort_info_sorting_set_nth (sort_info, scnt++, column); } } } - g_signal_emit (info, e_table_sort_info_signals[SORT_INFO_CHANGED], 0); + g_signal_emit (sort_info, signals[SORT_INFO_CHANGED], 0); } /** * e_table_sort_info_save_to_node: - * @info: The ETableSortInfo object + * @sort_info: an #ETableSortInfo * @parent: xmlNode that will be hosting the saved state of the @info object. * * This function is used @@ -364,27 +365,38 @@ e_table_sort_info_load_from_node (ETableSortInfo *info, * the sorting and grouping information for this ETableSortInfo object. */ xmlNode * -e_table_sort_info_save_to_node (ETableSortInfo *info, +e_table_sort_info_save_to_node (ETableSortInfo *sort_info, xmlNode *parent) { xmlNode *grouping; + gint sort_count; + gint group_count; gint i; - const gint sort_count = e_table_sort_info_sorting_get_count (info); - const gint group_count = e_table_sort_info_grouping_get_count (info); + + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), NULL); + + sort_count = e_table_sort_info_sorting_get_count (sort_info); + group_count = e_table_sort_info_grouping_get_count (sort_info); grouping = xmlNewChild (parent, NULL, (const guchar *)"grouping", NULL); for (i = 0; i < group_count; i++) { - ETableSortColumn column = e_table_sort_info_grouping_get_nth (info, i); - xmlNode *new_node = xmlNewChild (grouping, NULL, (const guchar *)"group", NULL); + ETableSortColumn column; + xmlNode *new_node; + + column = e_table_sort_info_grouping_get_nth (sort_info, i); + new_node = xmlNewChild (grouping, NULL, (const guchar *)"group", NULL); e_xml_set_integer_prop_by_name (new_node, (const guchar *)"column", column.column); e_xml_set_bool_prop_by_name (new_node, (const guchar *)"ascending", column.ascending); } for (i = 0; i < sort_count; i++) { - ETableSortColumn column = e_table_sort_info_sorting_get_nth (info, i); - xmlNode *new_node = xmlNewChild (grouping, NULL, (const guchar *)"leaf", NULL); + ETableSortColumn column; + xmlNode *new_node; + + column = e_table_sort_info_sorting_get_nth (sort_info, i); + new_node = xmlNewChild (grouping, NULL, (const guchar *)"leaf", NULL); e_xml_set_integer_prop_by_name (new_node, (const guchar *)"column", column.column); e_xml_set_bool_prop_by_name (new_node, (const guchar *)"ascending", column.ascending); @@ -394,35 +406,30 @@ e_table_sort_info_save_to_node (ETableSortInfo *info, } ETableSortInfo * -e_table_sort_info_duplicate (ETableSortInfo *info) +e_table_sort_info_duplicate (ETableSortInfo *sort_info) { ETableSortInfo *new_info; + g_return_val_if_fail (E_IS_TABLE_SORT_INFO (sort_info), NULL); + new_info = e_table_sort_info_new (); - new_info->group_count = info->group_count; + new_info->group_count = sort_info->group_count; new_info->groupings = g_new (ETableSortColumn, new_info->group_count); - memmove (new_info->groupings, info->groupings, sizeof (ETableSortColumn) * new_info->group_count); + memmove ( + new_info->groupings, + sort_info->groupings, + sizeof (ETableSortColumn) * new_info->group_count); - new_info->sort_count = info->sort_count; + new_info->sort_count = sort_info->sort_count; new_info->sortings = g_new (ETableSortColumn, new_info->sort_count); - memmove (new_info->sortings, info->sortings, sizeof (ETableSortColumn) * new_info->sort_count); + memmove ( + new_info->sortings, + sort_info->sortings, + sizeof (ETableSortColumn) * new_info->sort_count); - new_info->can_group = info->can_group; + new_info->can_group = sort_info->can_group; return new_info; } -void -e_table_sort_info_set_can_group (ETableSortInfo *info, - gboolean can_group) -{ - info->can_group = can_group; -} - -gboolean -e_table_sort_info_get_can_group (ETableSortInfo *info) -{ - return info->can_group; -} - -- cgit v1.2.3