From aac3f2c8b69f579e04314b21a13d752afe4bd317 Mon Sep 17 00:00:00 2001 From: Chris Toshok Date: Sun, 11 Jun 2000 04:20:56 +0000 Subject: change things so we focus the cell and select the row, and also dispatch 2000-06-10 Chris Toshok * e-table-item.c (eti_event): change things so we focus the cell and select the row, and also dispatch the event to that row/cell. This fixes the problem with the tree where you had to click twice to activate the tree controls. * Makefile.am (libetable_a_SOURCES): remove e-tree-gnode.* and add e-tree-simple.* (icons): add tree-expanded.xpm and tree-unexpanded.xpm * e-cell-tree.c (ect_enter_edit): defer to subcell's view. (ect_leave_edit): defer to subcell's view. (visible_depth_of_node): visual depth, taking into account that the root node of the model might not be displayed. (offset_of_node): return the offset used to shift the subcell over. (ect_draw): don't draw vertical lines if we're the leftmode node (a visual root node). also, don't shift x2 by the subcell offset, so we get ellipses like we're supposed to. (ect_event): remove GDK_BUTTON_RELEASE from the list of events that we care about. * e-tree-example-1.c: lots of changes, a more dynamic UI so we can test tree model api stuff. * e-tree-gnode.c, e-tree-gnode.c: removed files, since their guts have been rolled into e-tree-model.c * e-tree-model.c, e-tree-model.h: substantially changed. too much to really describe here. this should really be considered the first revision of these files :) * e-tree-simple.c, e-tree-simple.h: analogous to e-table-simple, a subclass that allows the use of function pointers. svn path=/trunk/; revision=3519 --- widgets/table/e-tree-model.c | 549 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 459 insertions(+), 90 deletions(-) (limited to 'widgets/table/e-tree-model.c') diff --git a/widgets/table/e-tree-model.c b/widgets/table/e-tree-model.c index d67e59f3f5..c11cb58831 100644 --- a/widgets/table/e-tree-model.c +++ b/widgets/table/e-tree-model.c @@ -20,98 +20,222 @@ static ETableModel *e_tree_model_parent_class; +typedef struct { + gboolean expanded; + guint visible_descendents; + gpointer node_data; +} ENode; + +enum { + NODE_CHANGED, + NODE_INSERTED, + NODE_REMOVED, + LAST_SIGNAL +}; + +static guint e_tree_model_signals [LAST_SIGNAL] = {0, }; + +static void add_visible_descendents_to_array (ETreeModel *etm, GNode *gnode, int *row, int *count); + + /* virtual methods */ -static ETreePath* -etree_get_root (ETreeModel *etm) +static void +etree_destroy (GtkObject *object) { - /* shouldn't be called */ - g_assert(0); - return NULL; + /* XXX lots of stuff to free here */ } -static void* -etree_value_at (ETreeModel *etm, ETreePath* node, int col) +static ETreePath* +etree_get_root (ETreeModel *etm) { - /* shouldn't be called */ - g_assert(0); - return NULL; + return etm->root; } -static void -etree_set_value_at (ETreeModel *etm, ETreePath* node, int col, const void *val) +static ETreePath* +etree_get_parent (ETreeModel *etm, ETreePath *path) { - /* shouldn't be called */ - g_assert(0); + g_return_val_if_fail (path, NULL); + + return path->parent; } -static gboolean -etree_is_editable (ETreeModel *etm, ETreePath* node, int col) +static ETreePath* +etree_get_next (ETreeModel *etm, ETreePath *node) { - /* shouldn't be called */ - g_assert(0); - return FALSE; + g_return_val_if_fail (node, NULL); + + return g_node_next_sibling(node); } -static gboolean -etree_is_expanded (ETreeModel *etm, ETreePath* node) +static ETreePath* +etree_get_prev (ETreeModel *etm, ETreePath *node) { - /* shouldn't be called */ - g_assert(0); - return FALSE; + g_return_val_if_fail (node, NULL); + + return g_node_prev_sibling (node); } static guint etree_get_children (ETreeModel *etm, ETreePath* node, ETreePath ***paths) { - /* shouldn't be called */ - g_assert(0); - return 0; + guint n_children; + + g_return_val_if_fail (node, 0); + + n_children = g_node_n_children (node); + + if (paths) { + int i; + (*paths) = g_malloc (sizeof (ETreePath*) * n_children); + for (i = 0; i < n_children; i ++) { + (*paths)[i] = g_node_nth_child (node, i); + } + } + + return n_children; } -static void -etree_release_paths (ETreeModel *etm, ETreePath **paths, guint num_paths) +static gboolean +etree_is_expanded (ETreeModel *etm, ETreePath* node) { - /* shouldn't be called */ - g_assert(0); + g_return_val_if_fail (node && node->data, FALSE); + + return ((ENode*)node->data)->expanded; +} + +static gboolean +etree_is_visible (ETreeModel *etm, ETreePath* node) +{ + g_return_val_if_fail (node, FALSE); + + for (node = node->parent; node; node = node->parent) { + if (!((ENode*)node->data)->expanded) + return FALSE; + } + + return TRUE; } static void etree_set_expanded (ETreeModel *etm, ETreePath* node, gboolean expanded) { - /* shouldn't be called */ - g_assert(0); + GNode *child; + ENode *enode; + int row; + + g_return_if_fail (node && node->data); + + enode = ((ENode*)node->data); + + if (enode->expanded == expanded) + return; + + enode->expanded = expanded; + + row = e_tree_model_row_of_node (etm, node) + 1; + + if (expanded) { + GNode *parent; + + if (e_tree_model_node_is_visible (etm, node)) { + enode->visible_descendents = 0; + for (child = g_node_first_child (node); child; + child = g_node_next_sibling (child)) { + add_visible_descendents_to_array (etm, child, &row, &enode->visible_descendents); + } + } + /* now iterate back up the tree, adding to our + ancestors' visible descendents */ + + for (parent = node->parent; parent; parent = parent->parent) { + ENode *parent_enode = (ENode*)parent->data; + parent_enode->visible_descendents += enode->visible_descendents; + } + } + else { + int i; + GNode *parent; + + if (e_tree_model_node_is_visible (etm, node)) { + for (i = 0; i < enode->visible_descendents; i ++) { + etm->row_array = g_array_remove_index (etm->row_array, row); + e_table_model_row_deleted (E_TABLE_MODEL (etm), row); + } + } + /* now iterate back up the tree, subtracting from our + ancestors' visible descendents */ + + for (parent = node->parent; parent; parent = parent->parent) { + ENode *parent_enode = (ENode*)parent->data; + + parent_enode->visible_descendents -= enode->visible_descendents; + } + + enode->visible_descendents = 0; + } } +/* fairly naive implementation */ static void -etree_destroy (GtkObject *object) +etree_set_expanded_recurse (ETreeModel *etm, ETreePath* node, gboolean expanded) { + ETreePath **paths; + guint num_children; + int i; + + e_tree_model_node_set_expanded (etm, node, expanded); + + num_children = e_tree_model_node_get_children (etm, node, &paths); + if (num_children) { + for (i = 0; i < num_children; i ++) { + e_tree_model_node_set_expanded_recurse (etm, paths[i], expanded); + } + + g_free (paths); + } } -guint -e_tree_model_node_num_visible_descendents (ETreeModel *etm, ETreePath *node) +static ETreePath * +etree_node_at_row (ETreeModel *etree, int row) { - int count = 1; - if (e_tree_model_node_is_expanded (etm, node)) { - ETreePath **paths; - int i; - int num_paths; + GNode *node = g_array_index (etree->row_array, GNode*, row); - num_paths = e_tree_model_node_get_children (etm, node, &paths); + return node; +} - for (i = 0; i < num_paths; i ++) - count += e_tree_model_node_num_visible_descendents(etm, paths[i]); + +/* ETable analogs */ +static void* +etree_value_at (ETreeModel *etm, ETreePath* node, int col) +{ + /* shouldn't be called */ + g_assert (0); + return NULL; +} - e_tree_model_release_paths (etm, paths, num_paths); - } +static void +etree_set_value_at (ETreeModel *etm, ETreePath* node, int col, const void *val) +{ + /* shouldn't be called */ + g_assert (0); +} - return count; +static gboolean +etree_is_editable (ETreeModel *etm, ETreePath* node, int col) +{ + /* shouldn't be called */ + g_assert(0); + return FALSE; } + +/* ETable virtual functions we map */ static int etable_row_count (ETableModel *etm) { - return e_tree_model_node_num_visible_descendents (E_TREE_MODEL (etm), e_tree_model_get_root (E_TREE_MODEL (etm))); + ETreeModel *tree = E_TREE_MODEL (etm); + return tree->row_array->len; } static void * @@ -155,6 +279,7 @@ etable_is_cell_editable (ETableModel *etm, int col, int row) return et_class->is_editable (etree, node, col); } + static void e_tree_model_class_init (GtkObjectClass *klass) { @@ -165,11 +290,38 @@ e_tree_model_class_init (GtkObjectClass *klass) klass->destroy = etree_destroy; + e_tree_model_signals [NODE_CHANGED] = + gtk_signal_new ("node_changed", + GTK_RUN_LAST, + klass->type, + GTK_SIGNAL_OFFSET (ETreeModelClass, node_changed), + gtk_marshal_NONE__POINTER, + GTK_TYPE_NONE, 1, GTK_TYPE_POINTER); + + e_tree_model_signals [NODE_INSERTED] = + gtk_signal_new ("node_inserted", + GTK_RUN_LAST, + klass->type, + GTK_SIGNAL_OFFSET (ETreeModelClass, node_inserted), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER); + + e_tree_model_signals [NODE_REMOVED] = + gtk_signal_new ("node_removed", + GTK_RUN_LAST, + klass->type, + GTK_SIGNAL_OFFSET (ETreeModelClass, node_removed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER); + + gtk_object_class_add_signals (klass, e_tree_model_signals, LAST_SIGNAL); + table_class->row_count = etable_row_count; table_class->value_at = etable_value_at; table_class->set_value_at = etable_set_value_at; table_class->is_cell_editable = etable_is_cell_editable; #if 0 + /* XX need to pass these through */ table_class->duplicate_value = etable_duplicate_value; table_class->free_value = etable_free_value; table_class->initialize_value = etable_initialize_value; @@ -178,19 +330,68 @@ e_tree_model_class_init (GtkObjectClass *klass) #endif tree_class->get_root = etree_get_root; + tree_class->get_prev = etree_get_prev; + tree_class->get_next = etree_get_next; + tree_class->get_parent = etree_get_parent; + tree_class->value_at = etree_value_at; tree_class->set_value_at = etree_set_value_at; tree_class->is_editable = etree_is_editable; tree_class->get_children = etree_get_children; - tree_class->release_paths = etree_release_paths; tree_class->is_expanded = etree_is_expanded; + tree_class->is_visible = etree_is_visible; tree_class->set_expanded = etree_set_expanded; + tree_class->set_expanded_recurse = etree_set_expanded_recurse; + tree_class->node_at_row = etree_node_at_row; } E_MAKE_TYPE(e_tree_model, "ETreeModel", ETreeModel, e_tree_model_class_init, NULL, PARENT_TYPE) + /* signals */ +void +e_tree_model_node_changed (ETreeModel *tree_model, ETreePath *node) +{ + g_return_if_fail (tree_model != NULL); + g_return_if_fail (E_IS_TREE_MODEL (tree_model)); + + gtk_signal_emit (GTK_OBJECT (tree_model), + e_tree_model_signals [NODE_CHANGED]); +} + +void +e_tree_model_node_inserted (ETreeModel *tree_model, + ETreePath *parent_node, + ETreePath *inserted_node) +{ + g_return_if_fail (tree_model != NULL); + g_return_if_fail (E_IS_TREE_MODEL (tree_model)); + + gtk_signal_emit (GTK_OBJECT (tree_model), + e_tree_model_signals [NODE_INSERTED], + parent_node, inserted_node); +} + +void +e_tree_model_node_removed (ETreeModel *tree_model, ETreePath *parent_node, ETreePath *removed_node) +{ + g_return_if_fail (tree_model != NULL); + g_return_if_fail (E_IS_TREE_MODEL (tree_model)); + + gtk_signal_emit (GTK_OBJECT (tree_model), + e_tree_model_signals [NODE_REMOVED], + parent_node, removed_node); +} + + +void +e_tree_model_construct (ETreeModel *etree) +{ + etree->root = NULL; + etree->root_visible = TRUE; + etree->row_array = g_array_new (FALSE, FALSE, sizeof(GNode*)); +} ETreeModel * e_tree_model_new () @@ -202,52 +403,56 @@ e_tree_model_new () return et; } -static ETreePath * -e_tree_model_node_at_row_1 (ETreeModel *etree, int *row, ETreePath *node) +ETreePath * +e_tree_model_get_root (ETreeModel *etree) { - ETreePath *ret = NULL; - - if (*row == 0) - ret = node; - else if (e_tree_model_node_is_expanded (etree, node)) { - int num_children; - int i; - ETreePath **paths; + return ETM_CLASS(etree)->get_root(etree); +} - num_children = e_tree_model_node_get_children (etree, node, &paths); +ETreePath * +e_tree_model_node_at_row (ETreeModel *etree, int row) +{ + return ETM_CLASS(etree)->node_at_row (etree, row); +} - for (i = 0; i < num_children; i ++) { - ETreePath *p; +int +e_tree_model_row_of_node (ETreeModel *etree, ETreePath *node) +{ + int i; - (*row) --; + for (i = 0; i < etree->row_array->len; i ++) + if (g_array_index (etree->row_array, GNode*, i) == node) + return i; - p = e_tree_model_node_at_row_1 (etree, row, paths[i]); + return -1; +} - if (p) { - ret = p; - break; +void +e_tree_model_root_node_set_visible (ETreeModel *etm, gboolean visible) +{ + if (visible != etm->root_visible) { + etm->root_visible = visible; + if (etm->root) { + if (visible) { + etm->row_array = g_array_insert_val (etm->row_array, 0, etm->root); } + else { + ETreePath *root_path = e_tree_model_get_root (etm); + etm->row_array = g_array_remove_index (etm->row_array, 0); + e_tree_model_node_set_expanded (etm, root_path, TRUE); + } + + e_table_model_changed (E_TABLE_MODEL (etm)); } - - /* XXX need to find why this release is causing problems */ - /* e_tree_model_release_paths (etree, paths, num_children); */ } - - return ret; } -ETreePath * -e_tree_model_get_root (ETreeModel *etree) +gboolean +e_tree_model_root_node_is_visible (ETreeModel *etm) { - return ETM_CLASS(etree)->get_root(etree); + return etm->root_visible; } -ETreePath * -e_tree_model_node_at_row (ETreeModel *etree, int row) -{ - /* XXX icky, perform a depth first search of the tree. we need this optimized sorely */ - return e_tree_model_node_at_row_1 (etree, &row, ETM_CLASS(etree)->get_root(etree)); -} ETreePath * e_tree_model_node_get_next (ETreeModel *etree, ETreePath *node) @@ -264,18 +469,13 @@ e_tree_model_node_get_prev (ETreeModel *etree, ETreePath *node) guint e_tree_model_node_depth (ETreeModel *etree, ETreePath *path) { - return g_list_length (path) - 1; + return g_node_depth (path) - 1; } ETreePath * e_tree_model_node_get_parent (ETreeModel *etree, ETreePath *path) { - g_return_val_if_fail (path, NULL); - - if (path->next == NULL) - return NULL; - else - return g_list_copy (path->next); + return ETM_CLASS(etree)->get_parent(etree, path); } gboolean @@ -296,21 +496,190 @@ e_tree_model_node_is_expanded (ETreeModel *etree, ETreePath *path) return ETM_CLASS(etree)->is_expanded (etree, path); } +gboolean +e_tree_model_node_is_visible (ETreeModel *etree, ETreePath *path) +{ + return ETM_CLASS(etree)->is_visible (etree, path); +} + void e_tree_model_node_set_expanded (ETreeModel *etree, ETreePath *path, gboolean expanded) { ETM_CLASS(etree)->set_expanded (etree, path, expanded); } +void +e_tree_model_node_set_expanded_recurse (ETreeModel *etree, ETreePath *path, gboolean expanded) +{ + ETM_CLASS(etree)->set_expanded_recurse (etree, path, expanded); +} + guint e_tree_model_node_get_children (ETreeModel *etree, ETreePath *path, ETreePath ***paths) { return ETM_CLASS(etree)->get_children (etree, path, paths); } +guint +e_tree_model_node_num_visible_descendents (ETreeModel *etm, ETreePath *node) +{ + ENode *enode = (ENode*)node->data; + + return enode->visible_descendents; +} + +gpointer +e_tree_model_node_get_data (ETreeModel *etm, ETreePath *node) +{ + ENode *enode; + + g_return_val_if_fail (node && node->data, NULL); + + enode = (ENode*)node->data; + + return enode->node_data; +} + void -e_tree_model_release_paths (ETreeModel *etree, ETreePath **paths, guint num_paths) +e_tree_model_node_set_data (ETreeModel *etm, ETreePath *node, gpointer node_data) { - ETM_CLASS(etree)->release_paths (etree, paths, num_paths); + ENode *enode; + + g_return_if_fail (node && node->data); + + enode = (ENode*)node->data; + + enode->node_data = node_data; } +ETreePath* +e_tree_model_node_insert (ETreeModel *tree_model, + ETreePath *parent_path, + int position, + gpointer node_data) +{ + ENode *node; + ETreePath *new_path; + + g_return_val_if_fail (parent_path != NULL || tree_model->root == NULL, NULL); + + node = g_new0 (ENode, 1); + + node->expanded = FALSE; + node->node_data = node_data; + + if (parent_path != NULL) { + + new_path = g_node_new (node); + + g_node_insert (parent_path, position, new_path); + + if (e_tree_model_node_is_visible (tree_model, new_path)) { + int parent_row; + GNode *node; + + /* we need to iterate back up to the root, incrementing the number of visible + descendents */ + for (node = parent_path; node; node = node->parent) { + ENode *parent_enode = (ENode*)node->data; + + parent_enode->visible_descendents ++; + } + + /* finally, insert a row into the table */ + parent_row = e_tree_model_row_of_node (tree_model, parent_path); + + tree_model->row_array = g_array_insert_val (tree_model->row_array, + parent_row + position + 1, new_path); + } + } + else { + tree_model->root = g_node_new (node); + if (tree_model->root_visible) + tree_model->row_array = g_array_insert_val (tree_model->row_array, 0, tree_model->root); + new_path = tree_model->root; + } + + /* FIXME: find out the number of descendents that will be visible, + and call insert_row that many times. */ + e_table_model_changed (E_TABLE_MODEL(tree_model)); + + return new_path; +} + +ETreePath * +e_tree_model_node_insert_before (ETreeModel *etree, ETreePath *parent, + ETreePath *sibling, gpointer node_data) +{ + return e_tree_model_node_insert (etree, parent, + g_node_child_position (parent, sibling), + node_data); +} + +gpointer +e_tree_model_node_remove (ETreeModel *etree, ETreePath *path) +{ + GNode *parent = path->parent; + ENode *enode = (ENode*)path->data; + gpointer ret = enode->node_data; + + g_return_val_if_fail (!g_node_first_child(path), NULL); + + /* clean up the display */ + if (parent) { + if (e_tree_model_node_is_visible (etree, path)) { + int row = e_tree_model_row_of_node (etree, path); + etree->row_array = g_array_remove_index (etree->row_array, row); + e_table_model_row_deleted (E_TABLE_MODEL (etree), row); + + /* we need to iterate back up to the root, incrementing the number of visible + descendents */ + for (; parent; parent = parent->parent) { + ENode *parent_enode = (ENode*)parent->data; + + parent_enode->visible_descendents --; + } + } + } + else if (path == etree->root) { + etree->root = NULL; + if (etree->root_visible) { + etree->row_array = g_array_remove_index (etree->row_array, 0); + e_table_model_row_deleted (E_TABLE_MODEL (etree), 0); + } + } + else { + /* XXX invalid path */ + return NULL; + } + + + /* now free up the storage from that path */ + g_node_destroy (path); + g_free (enode); + + return ret; +} + + +static void +add_visible_descendents_to_array (ETreeModel *etm, GNode *gnode, int *row, int *count) +{ + GNode *child; + ENode *enode; + + /* add a row for this node */ + etm->row_array = g_array_insert_val (etm->row_array, (*row), gnode); + e_table_model_row_inserted (E_TABLE_MODEL (etm), (*row)++); + (*count) ++; + + /* then loop over its children, calling this routine for each + of them */ + enode = (ENode*)gnode->data; + if (enode->expanded) { + for (child = g_node_first_child (gnode); child; + child = g_node_next_sibling (child)) { + add_visible_descendents_to_array (etm, child, row, count); + } + } +} -- cgit v1.2.3