X-Git-Url: http://git.tdb.fi/?p=ext%2Fsubsurface.git;a=blobdiff_plain;f=divelist.c;h=30bd2d8e97b9024383e3e961457bae46ae06d356;hp=90b7684faf877d0bef9c0bd8083cbe96c2a97108;hb=b693bb3fb962c54767f8430058575441df243b13;hpb=d2d4364afcc3fb310ea43573f0d455f90c9212ce diff --git a/divelist.c b/divelist.c index 90b7684..30bd2d8 100644 --- a/divelist.c +++ b/divelist.c @@ -78,84 +78,20 @@ static void dump_model(GtkListStore *store) } #endif -static GList *selected_dives; -static int st_size = 0; - -gboolean is_in_st(int idx, int *atpos) -{ - int i; - - for (i = 0; i < amount_selected; i++) - if (selectiontracker[i] == idx) { - if (atpos) - *atpos = i; - return TRUE; - } - return FALSE; -} - #if DEBUG_SELECTION_TRACKING void dump_selection(void) { int i; + struct dive *dive; - printf("currently selected are "); - for (i = 0; i < amount_selected; i++) - printf("%d ", selectiontracker[i]); - printf("\n"); -} -#endif - -void track_select(int idx) -{ - if (idx < 0) - return; - -#if DEBUG_SELECTION_TRACKING - printf("add %d to selection of %d entries\n", idx, amount_selected); -#endif - if (is_in_st(idx, NULL)) - return; - if (amount_selected >= st_size) { - selectiontracker = realloc(selectiontracker, dive_table.nr * sizeof(int)); - st_size = dive_table.nr; + printf("currently selected are %d dives:", amount_selected); + for_each_dive(i, dive) { + if (dive->selected) + printf(" %d", i); } - selectiontracker[amount_selected] = idx; - amount_selected++; - if (amount_selected == 1) - selected_dive = idx; -#if DEBUG_SELECTION_TRACKING - printf("increased amount_selected to %d\n", amount_selected); - dump_selection(); -#endif + printf("\n"); } - -void track_unselect(int idx) -{ - if (idx < 0) - return; - -#if DEBUG_SELECTION_TRACKING - printf("remove %d from selection of %d entries\n", idx, amount_selected); #endif - int atpos; - - if (! is_in_st(idx, &atpos)) - return; - memmove(selectiontracker + atpos, - selectiontracker + atpos + 1, - (amount_selected - atpos - 1) * sizeof(int)); - amount_selected--; -#if DEBUG_SELECTION_TRACKING - printf("removed %d at pos %d and decreased amount_selected to %d\n", idx, atpos, amount_selected); - dump_selection(); -#endif -} - -void clear_tracker(void) -{ - amount_selected = 0; -} /* when subsurface starts we want to have the last dive selected. So we simply walk to the first leaf (and skip the summary entries - which have negative @@ -177,97 +113,171 @@ static void first_leaf(GtkTreeModel *model, GtkTreeIter *iter, int *diveidx) } } -/* if we click on a summary dive, we actually want to select / unselect - all the dives "below" it */ -static void select_children(GtkTreeModel *model, GtkTreeSelection * selection, - GtkTreeIter *iter, gboolean was_selected) +/* make sure that if we expand a summary row that is selected, the children show + up as selected, too */ +void row_expanded_cb(GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer data) { - int i, nr_children; - gboolean expanded = FALSE; - GtkTreeIter parent; - GtkTreePath *tpath; + GtkTreeIter child; + GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model); + GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view)); - memcpy(&parent, iter, sizeof(parent)); - - tpath = gtk_tree_model_get_path(model, &parent); - expanded = gtk_tree_view_row_expanded(GTK_TREE_VIEW(dive_list.tree_view), tpath); - nr_children = gtk_tree_model_iter_n_children(model, &parent); - for (i = 0; i < nr_children; i++) { - gtk_tree_model_iter_nth_child(model, iter, &parent, i); - - /* if the parent is expanded, just (un)select the children and we'll - track their selection status in the callback - otherwise just change the selection status directly without - bothering gtk */ - if (expanded) { - if (was_selected) - gtk_tree_selection_unselect_iter(selection, iter); - else - gtk_tree_selection_select_iter(selection, iter); - } else { - int idx; - gtk_tree_model_get(model, iter, DIVE_INDEX, &idx, -1); - if (was_selected) - track_unselect(idx); - else - track_select(idx); - } - } + if (!gtk_tree_model_iter_children(model, &child, iter)) + return; + + do { + int idx; + struct dive *dive; + + gtk_tree_model_get(model, &child, DIVE_INDEX, &idx, -1); + dive = get_dive(idx); + + if (dive->selected) + gtk_tree_selection_select_iter(selection, &child); + else + gtk_tree_selection_unselect_iter(selection, &child); + } while (gtk_tree_model_iter_next(model, &child)); } -/* make sure that if we expand a summary row that is selected, the children show - up as selected, too */ -void row_expanded_cb(GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer data) +static int selected_children(GtkTreeModel *model, GtkTreeIter *iter) { + GtkTreeIter child; + + if (!gtk_tree_model_iter_children(model, &child, iter)) + return FALSE; + + do { + int idx; + struct dive *dive; + + gtk_tree_model_get(model, &child, DIVE_INDEX, &idx, -1); + dive = get_dive(idx); + + if (dive->selected) + return TRUE; + } while (gtk_tree_model_iter_next(model, &child)); + return FALSE; +} + +/* Make sure that if we collapse a summary row with any selected children, the row + shows up as selected too */ +void row_collapsed_cb(GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer data) +{ + GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view)); - if (gtk_tree_selection_path_is_selected(selection, path)) - select_children(GTK_TREE_MODEL(dive_list.model), selection, iter, FALSE); + if (selected_children(model, iter)) + gtk_tree_selection_select_iter(selection, iter); } -/* this is called _before_ the selection is changed, for every single entry; - * we simply have it call down the tree to make sure that summary items toggle - * their children */ +static GList *selection_changed = NULL; + +/* + * This is called _before_ the selection is changed, for every single entry; + * + * We simply create a list of all changed entries, and make sure that the + * group entries go at the end of the list. + */ gboolean modify_selection_cb(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean was_selected, gpointer userdata) { - GtkTreeIter iter; - int dive_idx; + GtkTreeIter iter, *p; + + if (!gtk_tree_model_get_iter(model, &iter, path)) + return TRUE; - /* if gtk thinks nothing is selected we should clear out our - tracker as well - otherwise hidden selected rows can stay - "stuck". The down side is that we now have a different bug: - If you select a dive, collapse the dive trip and ctrl-click - another dive trip, the initial dive is no longer selected. - Just don't do that, ok? */ - if (gtk_tree_selection_count_selected_rows(selection) == 0) - clear_tracker(); + /* Add the group entries to the end */ + p = gtk_tree_iter_copy(&iter); + if (gtk_tree_model_iter_has_child(model, p)) + selection_changed = g_list_append(selection_changed, p); + else + selection_changed = g_list_prepend(selection_changed, p); + return TRUE; +} - if (gtk_tree_model_get_iter(model, &iter, path)) { - gtk_tree_model_get(model, &iter, DIVE_INDEX, &dive_idx, -1); - /* turns out we need to move the selectiontracker here */ +static void select_dive(struct dive *dive, int selected) +{ + if (dive->selected != selected) { + amount_selected += selected ? 1 : -1; + dive->selected = selected; + } +} -#if DEBUG_SELECTION_TRACKING - printf("modify_selection_cb with idx %d (according to gtk was %sselected)\n", - dive_idx, was_selected ? "" : "un"); -#endif - if (dive_idx >= 0) { - if (was_selected) - track_unselect(dive_idx); - else - track_select(dive_idx); - } else { - select_children(model, selection, &iter, was_selected); - } +/* + * This gets called when a dive group has changed selection. + */ +static void select_dive_group(GtkTreeModel *model, GtkTreeSelection *selection, GtkTreeIter *iter, int selected) +{ + int first = 1; + GtkTreeIter child; + + if (selected == selected_children(model, iter)) + return; + + if (!gtk_tree_model_iter_children(model, &child, iter)) + return; + + do { + int idx; + struct dive *dive; + + gtk_tree_model_get(model, &child, DIVE_INDEX, &idx, -1); + if (first && selected) + selected_dive = idx; + first = 0; + dive = get_dive(idx); + if (dive->selected == selected) + continue; + + select_dive(dive, selected); + if (selected) + gtk_tree_selection_select_iter(selection, &child); + else + gtk_tree_selection_unselect_iter(selection, &child); + } while (gtk_tree_model_iter_next(model, &child)); +} + +/* + * This gets called _after_ the selections have changed, for each entry that + * may have changed. Check if the gtk selection state matches our internal + * selection state to verify. + * + * The group entries are at the end, this guarantees that we have handled + * all the dives before we handle groups. + */ +static void check_selection_cb(GtkTreeIter *iter, GtkTreeSelection *selection) +{ + GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model); + struct dive *dive; + int idx, gtk_selected; + + gtk_tree_model_get(model, iter, + DIVE_INDEX, &idx, + -1); + dive = get_dive(idx); + gtk_selected = gtk_tree_selection_iter_is_selected(selection, iter); + if (idx < 0) + select_dive_group(model, selection, iter, gtk_selected); + else { + select_dive(dive, gtk_selected); + if (gtk_selected) + selected_dive = idx; } - /* allow this selection to proceed */ - return TRUE; + gtk_tree_iter_free(iter); } /* this is called when gtk thinks that the selection has changed */ -static void selection_cb(GtkTreeSelection *selection, gpointer userdata) +static void selection_cb(GtkTreeSelection *selection, GtkTreeModel *model) { - process_selected_dives(selected_dives, selectiontracker, GTK_TREE_MODEL(dive_list.model)); + GList *changed = selection_changed; + + selection_changed = NULL; + g_list_foreach(changed, (GFunc) check_selection_cb, selection); + g_list_free(changed); +#if DEBUG_SELECTION_TRACKING + dump_selection(); +#endif + + process_selected_dives(); repaint_dive(); } @@ -306,12 +316,12 @@ static void date_data_func(GtkTreeViewColumn *col, GtkTreeIter *iter, gpointer data) { - int val, idx; + int val, idx, nr; struct tm *tm; time_t when; char buffer[40]; - gtk_tree_model_get(model, iter, DIVE_INDEX, &idx, DIVE_DATE, &val, -1); + gtk_tree_model_get(model, iter, DIVE_INDEX, &idx, DIVE_DATE, &val, DIVE_NR, &nr, -1); /* 2038 problem */ when = val; @@ -320,10 +330,11 @@ static void date_data_func(GtkTreeViewColumn *col, switch(idx) { case -NEW_TRIP: snprintf(buffer, sizeof(buffer), - "Trip %s, %s %d, %d", + "Trip %s, %s %d, %d (%d dive%s)", weekday(tm->tm_wday), monthname(tm->tm_mon), - tm->tm_mday, tm->tm_year + 1900); + tm->tm_mday, tm->tm_year + 1900, + nr, nr > 1 ? "s" : ""); break; default: snprintf(buffer, sizeof(buffer), @@ -892,12 +903,12 @@ static int new_group(struct dive *dive, struct dive **last_dive, time_t *tm_date static void fill_dive_list(void) { - int i; + int i, group_size; GtkTreeIter iter, parent_iter; GtkTreeStore *liststore, *treestore; struct dive *last_dive = NULL; - struct dive *first_trip_dive = NULL; struct dive *last_trip_dive = NULL; + const char *last_location = NULL; time_t dive_date; treestore = GTK_TREE_STORE(dive_list.treemodel); @@ -910,24 +921,29 @@ static void fill_dive_list(void) if (new_group(dive, &last_dive, &dive_date)) { /* make sure we display the first date of the trip in previous summary */ - if (first_trip_dive && last_trip_dive && last_trip_dive->when < first_trip_dive->when) + if (last_trip_dive) gtk_tree_store_set(treestore, &parent_iter, - DIVE_DATE, last_trip_dive->when, - DIVE_LOCATION, last_trip_dive->location, - -1); - first_trip_dive = dive; + DIVE_NR, group_size, + DIVE_DATE, last_trip_dive->when, + DIVE_LOCATION, last_location, + -1); gtk_tree_store_append(treestore, &parent_iter, NULL); gtk_tree_store_set(treestore, &parent_iter, DIVE_INDEX, -NEW_TRIP, - DIVE_NR, -NEW_TRIP, - DIVE_DATE, dive_date, - DIVE_LOCATION, dive->location, + DIVE_NR, 1, DIVE_TEMPERATURE, 0, DIVE_SAC, 0, -1); + + group_size = 0; + /* This might be NULL */ + last_location = dive->location; } + group_size++; last_trip_dive = dive; + if (dive->location) + last_location = dive->location; update_cylinder_related_info(dive); gtk_tree_store_append(treestore, &iter, &parent_iter); gtk_tree_store_set(treestore, &iter, @@ -957,6 +973,14 @@ static void fill_dive_list(void) -1); } + /* make sure we display the first date of the trip in previous summary */ + if (last_trip_dive) + gtk_tree_store_set(treestore, &parent_iter, + DIVE_NR, group_size, + DIVE_DATE, last_trip_dive->when, + DIVE_LOCATION, last_location, + -1); + update_dive_list_units(); if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dive_list.model), &iter)) { GtkTreeSelection *selection; @@ -1035,6 +1059,20 @@ static void realize_cb(GtkWidget *tree_view, gpointer userdata) gtk_widget_grab_focus(tree_view); } +/* + * Double-clicking on a group entry will expand a collapsed group + * and vice versa. + */ +static void collapse_expand(GtkTreeView *tree_view, GtkTreePath *path) +{ + if (!gtk_tree_view_row_expanded(tree_view, path)) + gtk_tree_view_expand_row(tree_view, path, FALSE); + else + gtk_tree_view_collapse_row(tree_view, path); + +} + +/* Double-click on a dive list */ static void row_activated_cb(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, @@ -1045,10 +1083,14 @@ static void row_activated_cb(GtkTreeView *tree_view, if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(dive_list.model), &iter, path)) return; + gtk_tree_model_get(GTK_TREE_MODEL(dive_list.model), &iter, DIVE_INDEX, &index, -1); /* a negative index is special for the "group by date" entries */ - if (index >= 0) - edit_dive_info(get_dive(index)); + if (index < 0) { + collapse_expand(tree_view, path); + return; + } + edit_dive_info(get_dive(index)); } void add_dive_cb(GtkWidget *menuitem, gpointer data) @@ -1066,7 +1108,17 @@ void add_dive_cb(GtkWidget *menuitem, gpointer data) void edit_dive_cb(GtkWidget *menuitem, gpointer data) { - edit_multi_dive_info(amount_selected, selectiontracker); + edit_multi_dive_info(NULL); +} + +static void expand_all_cb(GtkWidget *menuitem, GtkTreeView *tree_view) +{ + gtk_tree_view_expand_all(tree_view); +} + +static void collapse_all_cb(GtkWidget *menuitem, GtkTreeView *tree_view) +{ + gtk_tree_view_collapse_all(tree_view); } static void popup_divelist_menu(GtkTreeView *tree_view, GtkTreeModel *model, int button) @@ -1087,6 +1139,12 @@ static void popup_divelist_menu(GtkTreeView *tree_view, GtkTreeModel *model, int g_signal_connect(menuitem, "activate", G_CALLBACK(edit_dive_cb), model); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); } + menuitem = gtk_menu_item_new_with_label("Expand all"); + g_signal_connect(menuitem, "activate", G_CALLBACK(expand_all_cb), tree_view); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + menuitem = gtk_menu_item_new_with_label("Collapse all"); + g_signal_connect(menuitem, "activate", G_CALLBACK(collapse_all_cb), tree_view); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, @@ -1113,8 +1171,6 @@ static gboolean button_press_cb(GtkWidget *treeview, GdkEventButton *event, gpoi when gtk_tree_selection_select_path is called. We also need to keep copies of the sort order so we can restore that as well after switching models. */ -static int *oldselection; -static int old_nr_selected; static gboolean second_call = FALSE; static GtkSortType sortorder[] = { [0 ... DIVELIST_COLUMNS - 1] = GTK_SORT_DESCENDING, }; static int lastcol = DIVE_DATE; @@ -1122,20 +1178,27 @@ static int lastcol = DIVE_DATE; /* Check if this dive was selected previously and select it again in the new model; * This is used after we switch models to maintain consistent selections. * We always return FALSE to iterate through all dives */ -static gboolean select_selected(GtkTreeModel *model, GtkTreePath *path, +static gboolean set_selected(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { - int i, idx; GtkTreeSelection *selection = GTK_TREE_SELECTION(data); + int idx, selected; + struct dive *dive; - gtk_tree_model_get(model, iter, DIVE_INDEX, &idx, -1); - for (i = 0; i < old_nr_selected; i++) - if (oldselection[i] == idx) { - gtk_tree_view_expand_to_path(GTK_TREE_VIEW(dive_list.tree_view), path); - gtk_tree_selection_select_path(selection, path); - - return FALSE; - } + gtk_tree_model_get(model, iter, + DIVE_INDEX, &idx, + -1); + if (idx < 0) { + GtkTreeIter child; + if (gtk_tree_model_iter_children(model, &child, iter)) + gtk_tree_model_get(model, &child, DIVE_INDEX, &idx, -1); + } + dive = get_dive(idx); + selected = dive && dive->selected; + if (selected) { + gtk_tree_view_expand_to_path(GTK_TREE_VIEW(dive_list.tree_view), path); + gtk_tree_selection_select_path(selection, path); + } return FALSE; } @@ -1188,20 +1251,9 @@ static void sort_column_change_cb(GtkTreeSortable *treeview, gpointer data) if (dive_list.model != currentmodel) { GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view)); - /* remember what is currently selected, switch models and reselect the selected rows */ - old_nr_selected = amount_selected; - oldselection = malloc(old_nr_selected * sizeof(int)); - if (amount_selected) - memcpy(oldselection, selectiontracker, amount_selected * sizeof(int)); gtk_tree_view_set_model(GTK_TREE_VIEW(dive_list.tree_view), GTK_TREE_MODEL(dive_list.model)); - update_column_and_order(colid); - - if (old_nr_selected) { - /* we need to select all the dives that were selected */ - /* this is fundamentally an n^2 algorithm as implemented - YUCK */ - gtk_tree_model_foreach(GTK_TREE_MODEL(dive_list.model), select_selected, selection); - } + gtk_tree_model_foreach(GTK_TREE_MODEL(dive_list.model), set_selected, selection); } else { if (order != sortorder[colid]) { update_column_and_order(colid); @@ -1278,9 +1330,10 @@ GtkWidget *dive_list_create(void) g_signal_connect_after(dive_list.tree_view, "realize", G_CALLBACK(realize_cb), NULL); g_signal_connect(dive_list.tree_view, "row-activated", G_CALLBACK(row_activated_cb), NULL); g_signal_connect(dive_list.tree_view, "row-expanded", G_CALLBACK(row_expanded_cb), NULL); + g_signal_connect(dive_list.tree_view, "row-collapsed", G_CALLBACK(row_collapsed_cb), NULL); g_signal_connect(dive_list.tree_view, "button-press-event", G_CALLBACK(button_press_cb), NULL); g_signal_connect(dive_list.tree_view, "popup-menu", G_CALLBACK(popup_menu_cb), NULL); - g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), NULL); + g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), dive_list.model); g_signal_connect(dive_list.listmodel, "sort-column-changed", G_CALLBACK(sort_column_change_cb), NULL); g_signal_connect(dive_list.treemodel, "sort-column-changed", G_CALLBACK(sort_column_change_cb), NULL);