Consolidate base utility libraries into libeutil.

Evolution consists of entirely too many small utility libraries, which
increases linking and loading time, places a burden on higher layers of
the application (e.g. modules) which has to remember to link to all the
small in-tree utility libraries, and makes it difficult to generate API
documentation for these utility libraries in one Gtk-Doc module.

Merge the following utility libraries under the umbrella of libeutil,
and enforce a single-include policy on libeutil so we can reorganize
the files as desired without disrupting its pseudo-public API.

   libemail-utils/libemail-utils.la
   libevolution-utils/libevolution-utils.la
   filter/libfilter.la
   widgets/e-timezone-dialog/libetimezonedialog.la
   widgets/menus/libmenus.la
   widgets/misc/libemiscwidgets.la
   widgets/table/libetable.la
   widgets/text/libetext.la

This also merges libedataserverui from the Evolution-Data-Server module,
since Evolution is its only consumer nowadays, and I'd like to make some
improvements to those APIs without concern for backward-compatibility.

And finally, start a Gtk-Doc module for libeutil.  It's going to be a
project just getting all the symbols _listed_ much less _documented_.
But the skeletal structure is in place and I'm off to a good start.

1 files changed, 412 insertions, 0 deletions

diff --git a/e-util/e-table-without.c b/e-util/e-table-without.c
new file mode 100644
index 0000000000..7139ad15df
--- /dev/null
+++ b/e-util/e-table-without.c
@@ -0,0 +1,412 @@
+/*
+ *
+ * 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
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program 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 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
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "e-table-without.h"
+
+#define E_TABLE_WITHOUT_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_TABLE_WITHOUT, ETableWithoutPrivate))
+
+/* workaround for avoiding API breakage */
+#define etw_get_type e_table_without_get_type
+G_DEFINE_TYPE (ETableWithout, etw, E_TYPE_TABLE_SUBSET)
+
+#define INCREMENT_AMOUNT 10
+
+struct _ETableWithoutPrivate {
+	GHashTable *hash;
+
+	GHashFunc hash_func;
+	GCompareFunc compare_func;
+
+	ETableWithoutGetKeyFunc get_key_func;
+	ETableWithoutDuplicateKeyFunc duplicate_key_func;
+	ETableWithoutFreeKeyFunc free_gotten_key_func;
+	ETableWithoutFreeKeyFunc free_duplicated_key_func;
+
+	gpointer closure;
+};
+
+static gboolean
+check (ETableWithout *etw,
+       gint model_row)
+{
+	gboolean ret_val;
+	gpointer key;
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	if (etw->priv->get_key_func)
+		key = etw->priv->get_key_func (etss->source, model_row, etw->priv->closure);
+	else
+		key = GINT_TO_POINTER (model_row);
+	ret_val = (g_hash_table_lookup (etw->priv->hash, key) != NULL);
+	if (etw->priv->free_gotten_key_func)
+		etw->priv->free_gotten_key_func (key, etw->priv->closure);
+	return ret_val;
+}
+
+static gboolean
+check_with_key (ETableWithout *etw,
+                gpointer key,
+                gint model_row)
+{
+	gboolean ret_val;
+	gpointer key2;
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	if (etw->priv->get_key_func)
+		key2 = etw->priv->get_key_func (etss->source, model_row, etw->priv->closure);
+	else
+		key2 = GINT_TO_POINTER (model_row);
+	if (etw->priv->compare_func)
+		ret_val = (etw->priv->compare_func (key, key2));
+	else
+		ret_val = (key == key2);
+	if (etw->priv->free_gotten_key_func)
+		etw->priv->free_gotten_key_func (key2, etw->priv->closure);
+	return ret_val;
+}
+
+static gint
+etw_view_to_model_row (ETableWithout *etw,
+                       gint view_row)
+{
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+	return etss->map_table[view_row];
+}
+
+static void
+add_row (ETableWithout *etw,
+         gint model_row)
+{
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	e_table_model_pre_change (E_TABLE_MODEL (etw));
+
+	etss->map_table = g_renew (int, etss->map_table, etss->n_map + 1);
+
+	etss->map_table[etss->n_map++] = model_row;
+
+	e_table_model_row_inserted (E_TABLE_MODEL (etw), etss->n_map - 1);
+}
+
+static void
+remove_row (ETableWithout *etw,
+            gint view_row)
+{
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	e_table_model_pre_change (E_TABLE_MODEL (etw));
+	memmove (
+		etss->map_table + view_row,
+		etss->map_table + view_row + 1,
+		(etss->n_map - view_row - 1) * sizeof (gint));
+	etss->n_map--;
+	e_table_model_row_deleted (E_TABLE_MODEL (etw), view_row);
+}
+
+static void
+delete_hash_element (gpointer key,
+                     gpointer value,
+                     gpointer closure)
+{
+	ETableWithout *etw = closure;
+	if (etw->priv->free_duplicated_key_func)
+		etw->priv->free_duplicated_key_func (key, etw->priv->closure);
+}
+
+static void
+etw_dispose (GObject *object)
+{
+	ETableWithoutPrivate *priv;
+
+	priv = E_TABLE_WITHOUT_GET_PRIVATE (object);
+
+	if (priv->hash != NULL) {
+		g_hash_table_foreach (priv->hash, delete_hash_element, object);
+		g_hash_table_destroy (priv->hash);
+		priv->hash = NULL;
+	}
+
+	/* Chain up to parent's dispose() method. */
+	G_OBJECT_CLASS (etw_parent_class)->dispose (object);
+}
+
+static void
+etw_proxy_model_rows_inserted (ETableSubset *etss,
+                               ETableModel *etm,
+                               gint model_row,
+                               gint count)
+{
+	gint i;
+	ETableWithout *etw = E_TABLE_WITHOUT (etss);
+	gboolean shift = FALSE;
+
+	/* i is View row */
+	if (model_row != etss->n_map) {
+		for (i = 0; i < etss->n_map; i++) {
+			if (etss->map_table[i] > model_row)
+				etss->map_table[i] += count;
+		}
+		shift = TRUE;
+	}
+
+	/* i is Model row */
+	for (i = model_row; i < model_row + count; i++) {
+		if (!check (etw, i)) {
+			add_row (etw, i);
+		}
+	}
+	if (shift)
+		e_table_model_changed (E_TABLE_MODEL (etw));
+	else
+		e_table_model_no_change (E_TABLE_MODEL (etw));
+}
+
+static void
+etw_proxy_model_rows_deleted (ETableSubset *etss,
+                              ETableModel *etm,
+                              gint model_row,
+                              gint count)
+{
+	gint i; /* View row */
+	ETableWithout *etw = E_TABLE_WITHOUT (etss);
+	gboolean shift = FALSE;
+
+	for (i = 0; i < etss->n_map; i++) {
+		if (etss->map_table[i] >= model_row &&
+		    etss->map_table[i] < model_row + count) {
+			remove_row (etw, i);
+			i--;
+		} else if (etss->map_table[i] >= model_row + count) {
+			etss->map_table[i] -= count;
+			shift = TRUE;
+		}
+	}
+	if (shift)
+		e_table_model_changed (E_TABLE_MODEL (etw));
+	else
+		e_table_model_no_change (E_TABLE_MODEL (etw));
+}
+
+static void
+etw_proxy_model_changed (ETableSubset *etss,
+                         ETableModel *etm)
+{
+	gint i; /* Model row */
+	gint j; /* View row */
+	gint row_count;
+	ETableWithout *etw = E_TABLE_WITHOUT (etss);
+
+	g_free (etss->map_table);
+	row_count = e_table_model_row_count (etm);
+	etss->map_table = g_new (int, row_count);
+
+	for (i = 0, j = 0; i < row_count; i++) {
+		if (!check (etw, i)) {
+			etss->map_table[j++] = i;
+		}
+	}
+	etss->n_map = j;
+
+	if (E_TABLE_SUBSET_CLASS (etw_parent_class)->proxy_model_changed)
+		E_TABLE_SUBSET_CLASS (etw_parent_class)->proxy_model_changed (etss, etm);
+}
+
+static void
+etw_class_init (ETableWithoutClass *class)
+{
+	GObjectClass *object_class;
+	ETableSubsetClass *etss_class;
+
+	g_type_class_add_private (class, sizeof (ETableWithoutPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->dispose = etw_dispose;
+
+	etss_class = E_TABLE_SUBSET_CLASS (class);
+	etss_class->proxy_model_rows_inserted = etw_proxy_model_rows_inserted;
+	etss_class->proxy_model_rows_deleted  = etw_proxy_model_rows_deleted;
+	etss_class->proxy_model_changed = etw_proxy_model_changed;
+}
+
+static void
+etw_init (ETableWithout *etw)
+{
+	etw->priv = E_TABLE_WITHOUT_GET_PRIVATE (etw);
+}
+
+ETableModel *
+e_table_without_construct (ETableWithout *etw,
+                           ETableModel *source,
+                           GHashFunc hash_func,
+                           GCompareFunc compare_func,
+                           ETableWithoutGetKeyFunc get_key_func,
+                           ETableWithoutDuplicateKeyFunc duplicate_key_func,
+                           ETableWithoutFreeKeyFunc free_gotten_key_func,
+                           ETableWithoutFreeKeyFunc free_duplicated_key_func,
+                           gpointer closure)
+{
+	if (e_table_subset_construct (E_TABLE_SUBSET (etw), source, 1) == NULL)
+		return NULL;
+	E_TABLE_SUBSET (etw)->n_map = 0;
+
+	etw->priv->hash_func                = hash_func;
+	etw->priv->compare_func	    = compare_func;
+	etw->priv->get_key_func	    = get_key_func;
+	etw->priv->duplicate_key_func	    = duplicate_key_func;
+	etw->priv->free_gotten_key_func     = free_gotten_key_func;
+	etw->priv->free_duplicated_key_func = free_duplicated_key_func;
+	etw->priv->closure                  = closure;
+
+	etw->priv->hash = g_hash_table_new (
+		etw->priv->hash_func, etw->priv->compare_func);
+
+	return E_TABLE_MODEL (etw);
+}
+
+ETableModel *
+e_table_without_new (ETableModel *source,
+                     GHashFunc hash_func,
+                     GCompareFunc compare_func,
+                     ETableWithoutGetKeyFunc get_key_func,
+                     ETableWithoutDuplicateKeyFunc duplicate_key_func,
+                     ETableWithoutFreeKeyFunc free_gotten_key_func,
+                     ETableWithoutFreeKeyFunc free_duplicated_key_func,
+                     gpointer closure)
+{
+	ETableWithout *etw = g_object_new (E_TYPE_TABLE_WITHOUT, NULL);
+
+	if (e_table_without_construct (etw,
+				       source,
+				       hash_func,
+				       compare_func,
+				       get_key_func,
+				       duplicate_key_func,
+				       free_gotten_key_func,
+				       free_duplicated_key_func,
+				       closure)
+	    == NULL) {
+		g_object_unref (etw);
+		return NULL;
+	}
+
+	return (ETableModel *) etw;
+}
+
+void
+e_table_without_hide (ETableWithout *etw,
+                      gpointer key)
+{
+	gint i; /* View row */
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	if (etw->priv->duplicate_key_func)
+		key = etw->priv->duplicate_key_func (key, etw->priv->closure);
+
+	g_hash_table_insert (etw->priv->hash, key, key);
+	for (i = 0; i < etss->n_map; i++) {
+		if (check_with_key (etw, key, etw_view_to_model_row (etw, i))) {
+			remove_row (etw, i);
+			i--;
+		}
+	}
+}
+
+/* An adopted key will later be freed using the free_duplicated_key function. */
+void
+e_table_without_hide_adopt (ETableWithout *etw,
+                            gpointer key)
+{
+	gint i; /* View row */
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	g_hash_table_insert (etw->priv->hash, key, key);
+	for (i = 0; i < etss->n_map; i++) {
+		if (check_with_key (etw, key, etw_view_to_model_row (etw, i))) {
+			remove_row (etw, i);
+			i--;
+		}
+	}
+}
+
+void
+e_table_without_show (ETableWithout *etw,
+                      gpointer key)
+{
+	gint i; /* Model row */
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+	gint count;
+	gpointer old_key;
+
+	count = e_table_model_row_count (etss->source);
+
+	for (i = 0; i < count; i++) {
+		if (check_with_key (etw, key, i)) {
+			add_row (etw, i);
+		}
+	}
+	if (g_hash_table_lookup_extended (etw->priv->hash, key, &old_key, NULL)) {
+#if 0
+		if (etw->priv->free_duplicated_key_func)
+			etw->priv->free_duplicated_key_func (key, etw->priv->closure);
+#endif
+		g_hash_table_remove (etw->priv->hash, key);
+	}
+}
+
+void
+e_table_without_show_all (ETableWithout *etw)
+{
+	gint i; /* Model row */
+	gint row_count;
+	ETableSubset *etss = E_TABLE_SUBSET (etw);
+
+	e_table_model_pre_change (E_TABLE_MODEL (etw));
+
+	if (etw->priv->hash) {
+		g_hash_table_foreach (etw->priv->hash, delete_hash_element, etw);
+		g_hash_table_destroy (etw->priv->hash);
+		etw->priv->hash = NULL;
+	}
+	etw->priv->hash = g_hash_table_new (
+		etw->priv->hash_func, etw->priv->compare_func);
+
+	row_count = e_table_model_row_count (E_TABLE_MODEL (etss->source));
+	g_free (etss->map_table);
+	etss->map_table = g_new (int, row_count);
+
+	for (i = 0; i < row_count; i++) {
+		etss->map_table[i] = i;
+	}
+	etss->n_map = row_count;
+
+	e_table_model_changed (E_TABLE_MODEL (etw));
+}