path: root/widgets/table/e-tree-sorted.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * e-tree-sorted.c: a Tree Model implementation that the programmer builds in sorted.
 *
 * Author:
 *   Chris Toshok (toshok@ximian.com)
 *   Chris Lahey <clahey@ximian.com>
 *
 * Adapted from the gtree code and ETableModel.
 *
 * (C) 2000, 2001 Ximian, Inc.
 */

/* FIXME: Overall e-tree-sorted.c needs to be made more efficient. */


#include <config.h>

#include "e-tree-sorted.h"

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#include <gnome-xml/parser.h>
#include <gnome-xml/xmlmemory.h>

#include <gtk/gtksignal.h>
#include "gal/util/e-util.h"
#include "gal/util/e-xml-utils.h"
#include "e-table-sorting-utils.h"

#define PARENT_TYPE E_TREE_MODEL_TYPE

/* maximum insertions between an idle event that we will do without scheduling an idle sort */
#define ETS_INSERT_MAX (4)

#define TREEPATH_CHUNK_AREA_SIZE (30 * sizeof (ETreeSortedPath))

#define d(x)

static ETreeModel *parent_class;
static GMemChunk  *node_chunk;

typedef struct ETreeSortedPath ETreeSortedPath;

struct ETreeSortedPath {
    ETreePath         corresponding;

    /* parent/child/sibling pointers */
    ETreeSortedPath  *parent;
    gint              num_children;
    ETreeSortedPath **children;
    int               position;
    int               orig_position;

    guint             needs_resort : 1;
    guint             child_needs_resort : 1;
    guint             resort_all_children : 1;
    guint             needs_regen_to_sort : 1;
};

struct ETreeSortedPriv {
    ETreeModel      *source;
    ETreeSortedPath *root;

    ETableSortInfo   *sort_info;
    ETableHeader     *full_header;

    ETreeSortedPath  *last_access;

    int          tree_model_pre_change_id;
    int          tree_model_node_changed_id;
    int          tree_model_node_data_changed_id;
    int          tree_model_node_col_changed_id;
    int          tree_model_node_inserted_id;
    int          tree_model_node_removed_id;

    int          sort_info_changed_id;
    int          sort_idle_id;
    int          insert_idle_id;
    int          insert_count;
};

enum {
    ARG_0,

    ARG_SORT_INFO,
};

static void ets_sort_info_changed (ETableSortInfo *sort_info, ETreeSorted *ets);
static void resort_node (ETreeSorted *ets, ETreeSortedPath *path, gboolean resort_all_children, gboolean needs_regen, gboolean send_signals);
static void mark_path_needs_resort (ETreeSorted *ets, ETreeSortedPath *path, gboolean needs_rebuild, gboolean resort_all_children);
static void schedule_resort (ETreeSorted *ets, ETreeSortedPath *path, gboolean needs_regen, gboolean resort_all_children);
static void free_path (ETreeSortedPath *path);
static void generate_children(ETreeSorted *ets, ETreeSortedPath *path);
static void regenerate_children(ETreeSorted *ets, ETreeSortedPath *path);



/* idle callbacks */

static gboolean
ets_sort_idle(gpointer user_data)
{
    ETreeSorted *ets = user_data;
    ets->priv->sort_idle_id = 0;
    if (ets->priv->root) {
        resort_node (ets, ets->priv->root, FALSE, FALSE, TRUE);
    }
    return FALSE;
}

static gboolean
ets_insert_idle(ETreeSorted *ets)
{
    ets->priv->insert_count = 0;
    ets->priv->insert_idle_id = 0;
    return FALSE;
}



/* Helper functions */

#define CHECK_AROUND_LAST_ACCESS

static inline ETreeSortedPath *
check_last_access (ETreeSorted *ets, ETreePath corresponding)
{
#ifdef CHECK_AROUND_LAST_ACCESS
    ETreeSortedPath *parent;
    int end;
    int start;
    int i;
#endif

    if (ets->priv->last_access == NULL)
        return NULL;

    if (ets->priv->last_access == corresponding) {
        d(g_print("Found last access %p at %p.", ets->priv->last_access, ets->priv->last_access));
        return ets->priv->last_access;
    }

#ifdef CHECK_AROUND_LAST_ACCESS
    parent = ets->priv->last_access->parent;
    if (parent && parent->children) {
        i = ets->priv->last_access->position;
        end = MIN(parent->num_children, i + 10);
        for (; i < end; i++) {
            if (parent->children[i] && parent->children[i]->corresponding == corresponding) {
                d(g_print("Found last access %p at %p.", ets->priv->last_access, parent->children[i]));
                return parent->children[i];
            }
        }

        i = ets->priv->last_access->position - 1;
        start = MAX(0, i - 10);
        for (; i >= start; i--) {
            if (parent->children[i] && parent->children[i]->corresponding == corresponding) {
                d(g_print("Found last access %p at %p.", ets->priv->last_access, parent->children[i]));
                return parent->children[i];
            }
        }
    }
#endif
    return NULL;
}

static ETreeSortedPath *
find_path(ETreeSorted *ets, ETreePath corresponding)
{
    int depth;
    ETreePath *sequence;
    int i;
    ETreeSortedPath *path;
    ETreeSortedPath *check_last;

    if (corresponding == NULL)
        return NULL;

    check_last = check_last_access (ets, corresponding);
    if (check_last) {
        d(g_print(" (find_path)\n"));
        return check_last;
    }

    depth = e_tree_model_node_depth(ets->priv->source, corresponding);

    sequence = g_new(ETreePath, depth + 1);

    sequence[0] = corresponding;

    for (i = 0; i < depth; i++)
        sequence[i + 1] = e_tree_model_node_get_parent(ets->priv->source, sequence[i]);

    path = ets->priv->root;

    for (i = depth - 1; i >= 0 && path != NULL; i --) {
        int j;

        if (path->num_children == -1) {
            path = NULL;
            break;
        }

        for (j = 0; j < path->num_children; j++) {
            if (path->children[j]->corresponding == sequence[i]) {
                break;
            }
        }

        if (j < path->num_children) {
            path = path->children[j];
        } else {
            path = NULL;
        }
    }
    g_free (sequence);

    d(g_print("Didn't find last access %p.  Setting to %p. (find_path)\n", ets->priv->last_access, path));
    ets->priv->last_access = path;

    return path;
}

static ETreeSortedPath *
find_child_path(ETreeSorted *ets, ETreeSortedPath *parent, ETreePath corresponding)
{
    int i;

    if (corresponding == NULL)
        return NULL;

    if (parent->num_children == -1) {
        return NULL;
    }

    for (i = 0; i < parent->num_children; i++)
        if (parent->children[i]->corresponding == corresponding)
            return parent->children[i];

    return NULL;
}

static ETreeSortedPath *
find_or_create_path(ETreeSorted *ets, ETreePath corresponding)
{
    int depth;
    ETreePath *sequence;
    int i;
    ETreeSortedPath *path;
    ETreeSortedPath *check_last;

    if (corresponding == NULL)
        return NULL;

    check_last = check_last_access (ets, corresponding);
    if (check_last) {
        d(g_print(" (find_or_create_path)\n"));
        return check_last;
    }

    depth = e_tree_model_node_depth(ets->priv->source, corresponding);

    sequence = g_new(ETreePath, depth + 1);

    sequence[0] = corresponding;

    for (i = 0; i < depth; i++)
        sequence[i + 1] = e_tree_model_node_get_parent(ets->priv->source, sequence[i]);

    path = ets->priv->root;

    for (i = depth - 1; i >= 0 && path != NULL; i --) {
        int j;

        if (path->num_children == -1) {
            generate_children(ets, path);
        }

        for (j = 0; j < path->num_children; j++) {
            if (path->children[j]->corresponding == sequence[i]) {
                break;
            }
        }

        if (j < path->num_children) {
            path = path->children[j];
        } else {
            path = NULL;
        }
    }
    g_free (sequence);

    d(g_print("Didn't find last access %p.  Setting to %p. (find_or_create_path)\n", ets->priv->last_access, path));
    ets->priv->last_access = path;

    return path;
}

static void
free_children (ETreeSortedPath *path)
{
    int i;

    if (path == NULL)
        return;

    for (i = 0; i < path->num_children; i++) {
        free_path(path->children[i]);
    }

    g_free(path->children);
    path->children = NULL;
    path->num_children = -1;
}

static void
free_path (ETreeSortedPath *path)
{
    free_children(path);
    g_chunk_free(path, node_chunk);
}

static ETreeSortedPath *
new_path (ETreeSortedPath *parent, ETreePath corresponding)
{
    ETreeSortedPath *path;

    path = g_chunk_new0 (ETreeSortedPath, node_chunk);

    path->corresponding = corresponding;
    path->parent = parent;
    path->num_children = -1;
    path->children = NULL;
    path->position = -1;
    path->orig_position = -1;
    path->child_needs_resort = 0;
    path->resort_all_children = 0;
    path->needs_resort = 0;
    path->needs_regen_to_sort = 0;

    return path;
}

static void
reposition_path (ETreeSorted *ets, ETreeSortedPath *path)
{
    int new_index;
    int old_index = path->position;
    ETreeSortedPath *parent = path->parent;
    if (parent) {
        if (ets->priv->sort_idle_id == 0) {
            if (ets->priv->insert_count > ETS_INSERT_MAX) {
                /* schedule a sort, and append instead */
                schedule_resort(ets, parent, TRUE, FALSE);
            } else {
                /* make sure we have an idle handler to reset the count every now and then */
                if (ets->priv->insert_idle_id == 0) {
                    ets->priv->insert_idle_id = g_idle_add_full(40, (GSourceFunc) ets_insert_idle, ets, NULL);
                }

                new_index = e_table_sorting_utils_tree_check_position
                    (E_TREE_MODEL(ets),
                     ets->priv->sort_info,
                     ets->priv->full_header,
                     (ETreePath *) parent->children,
                     parent->num_children,
                     old_index);

                if (new_index > old_index) {
                    int i;
                    ets->priv->insert_count++;
                    memmove(parent->children + old_index, parent->children + old_index + 1, sizeof (ETreePath) * (new_index - old_index));
                    parent->children[new_index] = path;
                    for (i = old_index; i <= new_index; i++)
                        parent->children[i]->position = i;
                    e_tree_model_node_changed(E_TREE_MODEL(ets), parent);
                    e_tree_model_pre_change(E_TREE_MODEL(ets));
                } else if (new_index < old_index) {
                    int i;
                    ets->priv->insert_count++;
                    memmove(parent->children + new_index + 1, parent->children + new_index, sizeof (ETreePath) * (old_index - new_index));
                    parent->children[new_index] = path;
                    for (i = new_index; i <= old_index; i++)
                        parent->children[i]->position = i;
                    e_tree_model_node_changed(E_TREE_MODEL(ets), parent);
                    e_tree_model_pre_change(E_TREE_MODEL(ets));
                }
            }
        } else
            mark_path_needs_resort(ets, parent, TRUE, FALSE);
    }
}

static void
regenerate_children(ETreeSorted *ets, ETreeSortedPath *path)
{
    ETreeSortedPath **children;
    int i;

    children = g_new(ETreeSortedPath *, path->num_children);
    for (i = 0; i < path->num_children; i++)
        children[path->children[i]->orig_position] = path->children[i];
    g_free(path->children);
    path->children = children;
}

static void
generate_children(ETreeSorted *ets, ETreeSortedPath *path)
{
    ETreePath child;
    int i;
    int count;

    free_children(path);

    count = 0;
    for (child = e_tree_model_node_get_first_child(ets->priv->source, path->corresponding);
         child;
         child = e_tree_model_node_get_next(ets->priv->source, child)) {
        count ++;
    }

    path->num_children = count;
    path->children = g_new(ETreeSortedPath *, count);
    for (child = e_tree_model_node_get_first_child(ets->priv->source, path->corresponding), i = 0;
         child;
         child = e_tree_model_node_get_next(ets->priv->source, child), i++) {
        path->children[i] = new_path(path, child);
        path->children[i]->position = i;
        path->children[i]->orig_position = i;
    }
    if (path->num_children > 0)
        schedule_resort (ets, path, FALSE, TRUE);
}

static void
resort_node (ETreeSorted *ets, ETreeSortedPath *path, gboolean resort_all_children, gboolean needs_regen, gboolean send_signals)
{
    gboolean needs_resort;
    if (path) {
        needs_resort = path->needs_resort || resort_all_children;
        needs_regen = path->needs_regen_to_sort || needs_regen;
        if (path->num_children > 0) {
            if (needs_resort && send_signals)
                e_tree_model_pre_change(E_TREE_MODEL(ets));
            if (needs_resort) {
                int i;
                d(g_print("Start sort of node %p\n", path));
                if (needs_regen)
                    regenerate_children(ets, path);
                d(g_print("Regened sort of node %p\n", path));
                e_table_sorting_utils_tree_sort (E_TREE_MODEL(ets),
                                 ets->priv->sort_info,
                                 ets->priv->full_header,
                                 (ETreePath *) path->children,
                                 path->num_children);
                d(g_print("Renumbering sort of node %p\n", path));
                for (i = 0; i < path->num_children; i++) {
                    path->children[i]->position = i;
                }
                d(g_print("End sort of node %p\n", path));
            }
            if (path->resort_all_children)
                resort_all_children = TRUE;
            if ((resort_all_children || path->child_needs_resort) && path->num_children >= 0) {
                int i;
                for (i = 0; i < path->num_children; i++) {
                    resort_node(ets, path->children[i], resort_all_children, needs_regen, send_signals && !needs_resort);
                }
                path->child_needs_resort = 0;
            }
        }
        path->needs_resort = 0; 
        path->child_needs_resort = 0;
        path->needs_regen_to_sort = 0;
        path->resort_all_children = 0;
        if (needs_resort && send_signals && path->num_children > 0)
            e_tree_model_node_changed(E_TREE_MODEL(ets), path);
    }
}

static void
mark_path_child_needs_resort (ETreeSorted *ets, ETreeSortedPath *path)
{
    if (path == NULL)
        return;
    if (!path->child_needs_resort) {
        path->child_needs_resort = 1;
        mark_path_child_needs_resort (ets, path->parent);
    }
}

static void
mark_path_needs_resort (ETreeSorted *ets, ETreeSortedPath *path, gboolean needs_regen, gboolean resort_all_children)
{
    if (path == NULL)
        return;
    if (path->num_children == 0)
        return;
    path->needs_resort = 1;
    path->needs_regen_to_sort = needs_regen;
    path->resort_all_children = resort_all_children;
    mark_path_child_needs_resort(ets, path->parent);
}

static void
schedule_resort (ETreeSorted *ets, ETreeSortedPath *path, gboolean needs_regen, gboolean resort_all_children)
{
    ets->priv->insert_count = 0;
    if (ets->priv->insert_idle_id != 0) {
        g_source_remove(ets->priv->insert_idle_id);
        ets->priv->insert_idle_id = 0;
    }

    if (path == NULL)
        return;
    if (path->num_children == 0)
        return;

    mark_path_needs_resort(ets, path, needs_regen, resort_all_children);
    if (ets->priv->sort_idle_id == 0) {
        ets->priv->sort_idle_id = g_idle_add_full(50, (GSourceFunc) ets_sort_idle, ets, NULL);
    }
}



/* virtual methods */

static void
ets_destroy (GtkObject *object)
{
    ETreeSorted *ets = E_TREE_SORTED (object);
    ETreeSortedPriv *priv = ets->priv;

    /* FIXME lots of stuff to free here */

    free_path(priv->root);

    if (priv->source) {
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_pre_change_id);
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_node_changed_id);
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_node_data_changed_id);
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_node_col_changed_id);
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_node_inserted_id);
        gtk_signal_disconnect (GTK_OBJECT (priv->source),
                       priv->tree_model_node_removed_id);

        gtk_object_unref (GTK_OBJECT (priv->source));
        priv->source = NULL;

        priv->tree_model_pre_change_id = 0;
        priv->tree_model_node_changed_id = 0;
        priv->tree_model_node_data_changed_id = 0;
        priv->tree_model_node_col_changed_id = 0;
        priv->tree_model_node_inserted_id = 0;
        priv->tree_model_node_removed_id = 0;
    }

    if (priv->sort_info) {
        gtk_signal_disconnect (GTK_OBJECT (priv->sort_info),
                       priv->sort_info_changed_id);

        gtk_object_unref (GTK_OBJECT (priv->sort_info));
        priv->sort_info = NULL;

        priv->sort_info_changed_id = 0;
    }

    if (ets->priv->sort_idle_id) {
        g_source_remove(ets->priv->sort_idle_id);
        ets->priv->sort_idle_id = 0;
    }
    if (ets->priv->insert_idle_id) {
        g_source_remove(ets->priv->insert_idle_id);
        ets->priv->insert_idle_id = 0;
    }

    if (priv->full_header)
        gtk_object_unref(GTK_OBJECT(priv->full_header));

    g_free (priv);

    GTK_OBJECT_CLASS (parent_class)->destroy (object);
}

/* Set_arg handler for the text item */
static void
ets_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
    ETreeSorted *ets;

    ets = E_TREE_SORTED (object);

    switch (arg_id) {
    case ARG_SORT_INFO:
        if (ets->priv->sort_info) {
            gtk_signal_disconnect (GTK_OBJECT (ets->priv->sort_info),
                           ets->priv->sort_info_changed_id);

            gtk_object_unref (GTK_OBJECT (ets->priv->sort_info));
            ets->priv->sort_info_changed_id = 0;
        }
        if (GTK_VALUE_OBJECT (*arg))
            ets->priv->sort_info = E_TABLE_SORT_INFO(GTK_VALUE_OBJECT (*arg));
        else
            ets->priv->sort_info = NULL;
        if (ets->priv->sort_info) {
            gtk_object_ref(GTK_OBJECT(ets->priv->sort_info));

            ets->priv->sort_info_changed_id = gtk_signal_connect (GTK_OBJECT (ets->priv->sort_info), "sort_info_changed",
                                          GTK_SIGNAL_FUNC (ets_sort_info_changed), ets);
        }
        if (ets->priv->root)
            schedule_resort (ets, ets->priv->root, TRUE, TRUE);
        break;

    default:
        return;
    }
}

/* Get_arg handler for the text item */
static void
ets_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
    ETreeSorted *ets;

    ets = E_TREE_SORTED (object);

    switch (arg_id) {
    case ARG_SORT_INFO:
        if (ets->priv->sort_info)
            GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(ets->priv->sort_info);
        else
            GTK_VALUE_OBJECT (*arg) = NULL;
        break;

    default:
        arg->type = GTK_TYPE_INVALID;
        break;
    }
}

static ETreePath
ets_get_root (ETreeModel *etm)
{
    ETreeSortedPriv *priv = E_TREE_SORTED(etm)->priv;
    if (priv->root == NULL) {
        ETreeSorted *ets = E_TREE_SORTED(etm);
        ETreePath corresponding = e_tree_model_get_root(ets->priv->source);

        if (corresponding) {
            priv->root = new_path(NULL, corresponding);
        }
    }
    if (priv->root && priv->root->num_children == -1) {
        generate_children(E_TREE_SORTED(etm), priv->root);
    }

    return priv->root;
}

static ETreePath
ets_get_parent (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    return path->parent;
}

static ETreePath
ets_get_first_child (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);

    if (path->num_children == -1)
        generate_children(ets, path);

    if (path->num_children > 0)
        return path->children[0];
    else
        return NULL;
}

static ETreePath
ets_get_last_child (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);

    if (path->num_children == -1)
        generate_children(ets, path);

    if (path->num_children > 0)
        return path->children[path->num_children - 1];
    else
        return NULL;
}

static ETreePath
ets_get_next (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSortedPath *parent = path->parent;
    if (parent) {
        if (parent->num_children > path->position + 1)
            return parent->children[path->position + 1];
        else
            return NULL;
    } else
          return NULL;
}

static ETreePath
ets_get_prev (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSortedPath *parent = path->parent;
    if (parent) {
        if (path->position - 1 >= 0)
            return parent->children[path->position - 1];
        else
            return NULL;
    } else
          return NULL;
}

static gboolean
ets_is_root (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_node_is_root (ets->priv->source, path->corresponding);
}

static gboolean
ets_is_expandable (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);
    gboolean expandable = e_tree_model_node_is_expandable (ets->priv->source, path->corresponding);

    if (path->num_children == -1) {
        generate_children(ets, node);
    }

    return expandable;
}

static guint
ets_get_children (ETreeModel *etm, ETreePath node, ETreePath **nodes)
{
    ETreeSortedPath *path = node;
    guint n_children;

    if (path->num_children == -1) {
        generate_children(E_TREE_SORTED(etm), node);
    }

    n_children = path->num_children;

    if (nodes) {
        int i;

        (*nodes) = g_malloc (sizeof (ETreePath) * n_children);
        for (i = 0; i < n_children; i ++) {
            (*nodes)[i] = path->children[i];
        }
    }

    return n_children;
}

static guint
ets_depth (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_node_depth(ets->priv->source, path->corresponding);
}

static GdkPixbuf *
ets_icon_at (ETreeModel *etm, ETreePath node)
{
    ETreeSortedPath *path = node;
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_icon_at(ets->priv->source, path->corresponding);
}

static gboolean
ets_get_expanded_default (ETreeModel *etm)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_get_expanded_default(ets->priv->source);
}

static gint
ets_column_count (ETreeModel *etm)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_column_count(ets->priv->source);
}


static gboolean
ets_has_save_id (ETreeModel *etm)
{
    return TRUE;
}

static gchar *
ets_get_save_id (ETreeModel *etm, ETreePath node)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    ETreeSortedPath *path = node;

    if (e_tree_model_has_save_id(ets->priv->source))
        return e_tree_model_get_save_id(ets->priv->source, path->corresponding);
    else
        return g_strdup_printf("%p", path->corresponding);
}

static gboolean
ets_has_get_node_by_id (ETreeModel *etm)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    return e_tree_model_has_get_node_by_id(ets->priv->source);
}

static ETreePath
ets_get_node_by_id (ETreeModel *etm, gchar *save_id)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    ETreePath node;

    node = e_tree_model_get_node_by_id (ets->priv->source, save_id);

    return find_path(ets, node);
}

static gboolean
ets_has_change_pending (ETreeModel *etm)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return ets->priv->sort_idle_id != 0;
}


static void *
ets_value_at (ETreeModel *etm, ETreePath node, int col)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    ETreeSortedPath *path = node;

    return e_tree_model_value_at(ets->priv->source, path->corresponding, col);
}

static void
ets_set_value_at (ETreeModel *etm, ETreePath node, int col, const void *val)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    ETreeSortedPath *path = node;

    e_tree_model_set_value_at (ets->priv->source, path->corresponding, col, val);
}

static gboolean
ets_is_editable (ETreeModel *etm, ETreePath node, int col)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    ETreeSortedPath *path = node;

    return e_tree_model_node_is_editable (ets->priv->source, path->corresponding, col);
}


/* The default for ets_duplicate_value is to return the raw value. */
static void *
ets_duplicate_value (ETreeModel *etm, int col, const void *value)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);

    return e_tree_model_duplicate_value (ets->priv->source, col, value);
}

static void
ets_free_value (ETreeModel *etm, int col, void *value)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);

    e_tree_model_free_value (ets->priv->source, col, value);
}

static void *
ets_initialize_value (ETreeModel *etm, int col)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    
    return e_tree_model_initialize_value (ets->priv->source, col);
}

static gboolean
ets_value_is_empty (ETreeModel *etm, int col, const void *value)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    
    return e_tree_model_value_is_empty (ets->priv->source, col, value);
}

static char *
ets_value_to_string (ETreeModel *etm, int col, const void *value)
{
    ETreeSorted *ets = E_TREE_SORTED(etm);
    
    return e_tree_model_value_to_string (ets->priv->source, col, value);
}



/* Proxy functions */

static void
ets_proxy_pre_change (ETreeModel *etm, ETreeSorted *ets)
{
    e_tree_model_pre_change(E_TREE_MODEL(ets));
}

static void
ets_proxy_node_changed (ETreeModel *etm, ETreePath node, ETreeSorted *ets)
{
    ets->priv->last_access = NULL;
    d(g_print("Setting last access %p. (ets_proxy_node_changed)\n", ets->priv->last_access));

    if (e_tree_model_node_is_root(ets->priv->source, node)) {
        if (ets->priv->root) {
            free_path(ets->priv->root);
        }
        ets->priv->root = new_path(NULL, node);
        e_tree_model_node_changed(E_TREE_MODEL(ets), ets->priv->root);
    } else {
        ETreeSortedPath *path = find_path(ets, node);

        if (path) {
            free_children(path);
            reposition_path(ets, path);
            e_tree_model_node_changed(E_TREE_MODEL(ets), path);
        }
    }
}

static void
ets_proxy_node_data_changed (ETreeModel *etm, ETreePath node, ETreeSorted *ets)
{
    ETreeSortedPath *path = find_path(ets, node);

    if (path) {
        reposition_path(ets, path);
        e_tree_model_node_data_changed(E_TREE_MODEL(ets), path);
    }
}

static void
ets_proxy_node_col_changed (ETreeModel *etm, ETreePath node, int col, ETreeSorted *ets)
{
    ETreeSortedPath *path = find_path(ets, node);

    if (path) {
        if (e_table_sorting_utils_affects_sort(ets->priv->sort_info, ets->priv->full_header, col))
            reposition_path(ets, path);
        e_tree_model_node_col_changed(E_TREE_MODEL(ets), path, col);
    }
}

static void
ets_proxy_node_inserted (ETreeModel *etm, ETreePath parent, ETreePath child, ETreeSorted *ets)
{
    ETreeSortedPath *parent_path = find_path(ets, parent);

    if (parent_path && parent_path->num_children != -1) {
        int i;
        int j;
        ETreeSortedPath *path;
        int position = parent_path->num_children;
        ETreePath counter;

        for (counter = e_tree_model_node_get_next(etm, child);
             counter;
             counter = e_tree_model_node_get_next(etm, counter))
            position --;

        if (position != parent_path->num_children) {
            for (i = 0; i < parent_path->num_children; i++) {
                if (parent_path->children[i]->orig_position >= position)
                    parent_path->children[i]->orig_position++;
            }
        }

        i = parent_path->num_children;
        path = new_path(parent_path, child);
        path->orig_position = position;
        if (ets->priv->sort_idle_id == 0) {
            ets->priv->insert_count++;
            if (ets->priv->insert_count > ETS_INSERT_MAX) {
                /* schedule a sort, and append instead */
                schedule_resort(ets, parent_path, TRUE, FALSE);
            } else {
                /* make sure we have an idle handler to reset the count every now and then */
                if (ets->priv->insert_idle_id == 0) {
                    ets->priv->insert_idle_id = g_idle_add_full(40, (GSourceFunc) ets_insert_idle, ets, NULL);
                }
                i = e_table_sorting_utils_tree_insert
                    (ets->priv->source,
                     ets->priv->sort_info,
                     ets->priv->full_header,
                     (ETreePath *) parent_path->children,
                     parent_path->num_children,
                     path);
            }
        } else {
            mark_path_needs_resort(ets, parent_path, TRUE, FALSE);
        }
        parent_path->num_children ++;
        parent_path->children = g_renew(ETreeSortedPath *, parent_path->children, parent_path->num_children);
        memmove(parent_path->children + i + 1, parent_path->children + i, (parent_path->num_children - 1 - i) * sizeof(int));
        parent_path->children[i] = path;
        for (j = i; j < parent_path->num_children; j++) {
            parent_path->children[j]->position = j;
        }
        e_tree_model_node_inserted(E_TREE_MODEL(ets), parent_path, parent_path->children[i]);
    } else if (ets->priv->root == NULL && parent == NULL) {
        if (child) {
            ets->priv->root = new_path(NULL, child);
            e_tree_model_node_inserted(E_TREE_MODEL(ets), NULL, ets->priv->root);
        }
    }
}

static void
ets_proxy_node_removed (ETreeModel *etm, ETreePath parent, ETreePath child, int old_position, ETreeSorted *ets)
{
    ETreeSortedPath *parent_path = find_path(ets, parent);
    ETreeSortedPath *path;

    if (parent_path)
        path = find_child_path(ets, parent_path, child);
    else
        path = find_path(ets, child);

    d(g_print("Setting last access %p. (ets_proxy_node_removed)\n ", ets->priv->last_access));
    ets->priv->last_access = NULL;

    if (path && parent_path && parent_path->num_children != -1) {
        int i;
        for (i = 0; i < parent_path->num_children; i++) {
            if (parent_path->children[i]->orig_position > old_position)
                parent_path->children[i]->orig_position --;
        }

        i = path->position;

        parent_path->num_children --;
        memmove(parent_path->children + i, parent_path->children + i + 1, sizeof(ETreeSortedPath *) * (parent_path->num_children - i));
        for (; i < parent_path->num_children; i++) {
            parent_path->children[i]->position = i;
        }
        e_tree_model_node_removed(E_TREE_MODEL(ets), parent_path, path, path->position);
        free_path(path);
    } else if (path && path == ets->priv->root) {
        ets->priv->root = NULL;
        e_tree_model_node_removed(E_TREE_MODEL(ets), NULL, path, -1);
        free_path(path);
    }
}

static void
ets_sort_info_changed (ETableSortInfo *sort_info, ETreeSorted *ets)
{
    schedule_resort(ets, ets->priv->root, TRUE, TRUE);
}



/* Initialization and creation */

static void
e_tree_sorted_class_init (GtkObjectClass *klass)
{
    ETreeModelClass *tree_class      = (ETreeModelClass *) klass;

    parent_class                     = gtk_type_class (PARENT_TYPE);

    node_chunk                       = g_mem_chunk_create (ETreeSortedPath, TREEPATH_CHUNK_AREA_SIZE, G_ALLOC_AND_FREE);
    
    klass->destroy                   = ets_destroy;
    klass->set_arg                   = ets_set_arg;
    klass->get_arg                   = ets_get_arg;

    tree_class->get_root             = ets_get_root;
    tree_class->get_parent           = ets_get_parent;
    tree_class->get_first_child      = ets_get_first_child;
    tree_class->get_last_child       = ets_get_last_child;
    tree_class->get_prev             = ets_get_prev;
    tree_class->get_next             = ets_get_next;

    tree_class->is_root              = ets_is_root;
    tree_class->is_expandable        = ets_is_expandable;
    tree_class->get_children         = ets_get_children;
    tree_class->depth                = ets_depth;

    tree_class->icon_at              = ets_icon_at;

    tree_class->get_expanded_default = ets_get_expanded_default;
    tree_class->column_count         = ets_column_count;

    tree_class->has_save_id          = ets_has_save_id;
    tree_class->get_save_id          = ets_get_save_id;

    tree_class->has_get_node_by_id   = ets_has_get_node_by_id;
    tree_class->get_node_by_id       = ets_get_node_by_id;

    tree_class->has_change_pending   = ets_has_change_pending;




    tree_class->value_at             = ets_value_at;
    tree_class->set_value_at         = ets_set_value_at;
    tree_class->is_editable          = ets_is_editable;

    tree_class->duplicate_value      = ets_duplicate_value;
    tree_class->free_value           = ets_free_value;
    tree_class->initialize_value     = ets_initialize_value;
    tree_class->value_is_empty       = ets_value_is_empty;
    tree_class->value_to_string      = ets_value_to_string;

    gtk_object_add_arg_type ("ETreeSorted::sort_info", E_TABLE_SORT_INFO_TYPE,
                 GTK_ARG_READWRITE, ARG_SORT_INFO);
}

static void
e_tree_sorted_init (GtkObject *object)
{
    ETreeSorted *ets = (ETreeSorted *)object;

    ETreeSortedPriv *priv;

    priv                                  = g_new0 (ETreeSortedPriv, 1);
    ets->priv                             = priv;

    priv->root                            = NULL;
    priv->source                          = NULL;

    priv->sort_info                       = NULL;
    priv->full_header                     = NULL;

    priv->last_access                     = NULL;

    priv->tree_model_pre_change_id        = 0;
    priv->tree_model_node_changed_id      = 0;
    priv->tree_model_node_data_changed_id = 0;
    priv->tree_model_node_col_changed_id  = 0;
    priv->tree_model_node_inserted_id     = 0;
    priv->tree_model_node_removed_id      = 0;

    priv->sort_info_changed_id            = 0;
    priv->sort_idle_id                    = 0;
    priv->insert_idle_id                  = 0;
    priv->insert_count                    = 0;
}

E_MAKE_TYPE(e_tree_sorted, "ETreeSorted", ETreeSorted, e_tree_sorted_class_init, e_tree_sorted_init, PARENT_TYPE)

/**
 * e_tree_sorted_construct:
 * @etree: 
 * 
 * 
 **/
void
e_tree_sorted_construct (ETreeSorted *ets, ETreeModel *source, ETableHeader *full_header, ETableSortInfo *sort_info)
{
    ets->priv->source      = source;
    if (source)      gtk_object_ref(GTK_OBJECT(source));

    ets->priv->full_header = full_header;
    if (full_header) gtk_object_ref(GTK_OBJECT(full_header));

    ets->priv->sort_info   = sort_info;
    if (sort_info)   gtk_object_ref(GTK_OBJECT(sort_info));

    ets->priv->tree_model_pre_change_id      = gtk_signal_connect (GTK_OBJECT (source), "pre_change",
                                       GTK_SIGNAL_FUNC (ets_proxy_pre_change), ets);
    ets->priv->tree_model_node_changed_id      = gtk_signal_connect (GTK_OBJECT (source), "node_changed",
                                     GTK_SIGNAL_FUNC (ets_proxy_node_changed), ets);
    ets->priv->tree_model_node_data_changed_id = gtk_signal_connect (GTK_OBJECT (source), "node_data_changed",
                                     GTK_SIGNAL_FUNC (ets_proxy_node_data_changed), ets);
    ets->priv->tree_model_node_col_changed_id  = gtk_signal_connect (GTK_OBJECT (source), "node_col_changed",
                                     GTK_SIGNAL_FUNC (ets_proxy_node_col_changed), ets);
    ets->priv->tree_model_node_inserted_id     = gtk_signal_connect (GTK_OBJECT (source), "node_inserted",
                                     GTK_SIGNAL_FUNC (ets_proxy_node_inserted), ets);
    ets->priv->tree_model_node_removed_id      = gtk_signal_connect (GTK_OBJECT (source), "node_removed",
                                     GTK_SIGNAL_FUNC (ets_proxy_node_removed), ets);

    ets->priv->sort_info_changed_id            = gtk_signal_connect (GTK_OBJECT (sort_info), "sort_info_changed",
                                     GTK_SIGNAL_FUNC (ets_sort_info_changed), ets);
}

/**
 * e_tree_sorted_new
 *
 * FIXME docs here.
 *
 * return values: a newly constructed ETreeSorted.
 */
ETreeSorted *
e_tree_sorted_new (ETreeModel *source, ETableHeader *full_header, ETableSortInfo *sort_info)
{
    ETreeSorted *ets;

    ets = gtk_type_new (e_tree_sorted_get_type ());

    e_tree_sorted_construct(ets, source, full_header, sort_info);

    return ets;
}

ETreePath
e_tree_sorted_view_to_model_path  (ETreeSorted    *ets,
                   ETreePath       view_path)
{
    ETreeSortedPath *path = view_path;
    if (path) {
        ets->priv->last_access = path;
        d(g_print("Setting last access %p. (e_tree_sorted_view_to_model_path)\n", ets->priv->last_access));
        return path->corresponding;
    } else
        return NULL;
}

ETreePath
e_tree_sorted_model_to_view_path  (ETreeSorted    *ets,
                   ETreePath       model_path)
{
    return find_or_create_path(ets, model_path);
}

int
e_tree_sorted_orig_position       (ETreeSorted    *ets,
                   ETreePath       path)
{
    ETreeSortedPath *sorted_path = path;
    return sorted_path->orig_position;
}

int
e_tree_sorted_node_num_children   (ETreeSorted    *ets,
                   ETreePath       path)
{
    ETreeSortedPath *sorted_path = path;
    return sorted_path->num_children;
}