/* -*- 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 * * 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 #include "e-tree-sorted.h" #include #include #include #include #include #include #include #include #include #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; }