From 162b36f4a5007d9c267743bb2f09ac5adc8da408 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Wed, 27 Jun 2012 18:09:26 -0700 Subject: Make it possible to do "Add Dive" from just the main dive menu No need for right-clicks. It's inconvenient on lots of laptops etc, so allow just using the Dive menu as an alternative. Signed-off-by: Linus Torvalds --- display-gtk.h | 1 + 1 file changed, 1 insertion(+) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index efbf3fd87..4ce05468c 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -54,6 +54,7 @@ extern const char *divelist_font; extern void set_divelist_font(const char *); extern void import_dialog(GtkWidget *, gpointer); +extern void add_dive_cb(GtkWidget *, gpointer); extern void report_error(GError* error); extern int process_ui_events(void); extern void update_progressbar(progressbar_t *progress, double value); -- cgit v1.2.3-70-g09d2 From 19621bf481c68955184c11dd407c59af4a05130e Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 7 Aug 2012 11:24:40 -0700 Subject: Add total weight column to divelist This adds the total weight carried on the dive in different weight systems to the divelist. The column is by default not shown, which can be changed in the preferences. The column is sortable. Signed-off-by: Dirk Hohndel --- display-gtk.h | 1 + dive.c | 22 ++++++++++++++++++++++ dive.h | 5 +++-- divelist.c | 41 ++++++++++++++++++++++++++++++++++++++++- gtk-gui.c | 8 ++++++++ 5 files changed, 74 insertions(+), 3 deletions(-) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 4ce05468c..9f1b51771 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -14,6 +14,7 @@ typedef struct { typedef struct { gboolean cylinder; gboolean temperature; + gboolean totalweight; gboolean nitrox; gboolean sac; gboolean otu; diff --git a/dive.c b/dive.c index 57a735c8e..a420a3ef6 100644 --- a/dive.c +++ b/dive.c @@ -120,6 +120,28 @@ double get_depth_units(unsigned int mm, int *frac, const char **units) return d; } +double get_weight_units(unsigned int grams, int *frac, const char **units) +{ + int decimals; + double value; + const char* unit; + + if (output_units.weight == LBS) { + value = grams_to_lbs(grams); + unit = "lbs"; + decimals = 0; + } else { + value = grams / 1000.0; + unit = "kg"; + decimals = 1; + } + if (frac) + *frac = decimals; + if (units) + *units = unit; + return value; +} + struct dive *alloc_dive(void) { const int initial_samples = 5; diff --git a/dive.h b/dive.h index 30894e506..8a867ad0d 100644 --- a/dive.h +++ b/dive.h @@ -97,8 +97,9 @@ extern int weightsystem_none(void *_data); extern int get_pressure_units(unsigned int mb, const char **units); extern double get_depth_units(unsigned int mm, int *frac, const char **units); -extern double get_volume_units(unsigned int mm, int *frac, const char **units); -extern double get_temp_units(unsigned int mm, const char **units); +extern double get_volume_units(unsigned int ml, int *frac, const char **units); +extern double get_temp_units(unsigned int mk, const char **units); +extern double get_weight_units(unsigned int grams, int *frac, const char **units); static inline double grams_to_lbs(int grams) { diff --git a/divelist.c b/divelist.c index 21f343f7f..ce61d20d1 100644 --- a/divelist.c +++ b/divelist.c @@ -26,7 +26,7 @@ struct DiveList { GtkWidget *container_widget; GtkListStore *model; GtkTreeViewColumn *nr, *date, *stars, *depth, *duration, *location; - GtkTreeViewColumn *temperature, *cylinder, *nitrox, *sac, *otu; + GtkTreeViewColumn *temperature, *cylinder, *totalweight, *nitrox, *sac, *otu; int changed; }; @@ -44,6 +44,7 @@ enum { DIVE_DEPTH, /* int: dive->maxdepth in mm */ DIVE_DURATION, /* int: in seconds */ DIVE_TEMPERATURE, /* int: in mkelvin */ + DIVE_TOTALWEIGHT, /* int: in grams */ DIVE_CYLINDER, DIVE_NITROX, /* int: dummy */ DIVE_SAC, /* int: in ml/min */ @@ -269,6 +270,35 @@ newmax: *o2low_p = mino2; } +static int total_weight(struct dive *dive) +{ + int i, total_grams = 0; + + if (dive) + for (i=0; i< MAX_WEIGHTSYSTEMS; i++) + total_grams += dive->weightsystem[i].weight.grams; + return total_grams; +} + +static void weight_data_func(GtkTreeViewColumn *col, + GtkCellRenderer *renderer, + GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + int indx, decimals; + double value; + char buffer[80]; + struct dive *dive; + + gtk_tree_model_get(model, iter, DIVE_INDEX, &indx, -1); + dive = get_dive(indx); + value = get_weight_units(total_weight(dive), &decimals, NULL); + snprintf(buffer, sizeof(buffer), "%.*f", decimals, value); + + g_object_set(renderer, "text", buffer, NULL); +} + static gint nitrox_sort_func(GtkTreeModel *model, GtkTreeIter *iter_a, GtkTreeIter *iter_b, @@ -521,6 +551,7 @@ static void fill_one_dive(struct dive *dive, DIVE_RATING, dive->rating, DIVE_SAC, dive->sac, DIVE_OTU, dive->otu, + DIVE_TOTALWEIGHT, total_weight(dive), -1); } @@ -569,6 +600,9 @@ void update_dive_list_units(void) (void) get_temp_units(0, &unit); gtk_tree_view_column_set_title(dive_list.temperature, unit); + (void) get_weight_units(0, NULL, &unit); + gtk_tree_view_column_set_title(dive_list.totalweight, unit); + gtk_tree_model_foreach(model, set_one_dive, NULL); } @@ -576,6 +610,7 @@ void update_dive_list_col_visibility(void) { gtk_tree_view_column_set_visible(dive_list.cylinder, visible_cols.cylinder); gtk_tree_view_column_set_visible(dive_list.temperature, visible_cols.temperature); + gtk_tree_view_column_set_visible(dive_list.totalweight, visible_cols.totalweight); gtk_tree_view_column_set_visible(dive_list.nitrox, visible_cols.nitrox); gtk_tree_view_column_set_visible(dive_list.sac, visible_cols.sac); gtk_tree_view_column_set_visible(dive_list.otu, visible_cols.otu); @@ -604,6 +639,7 @@ static void fill_dive_list(void) DIVE_DURATION, dive->duration.seconds, DIVE_LOCATION, "location", DIVE_TEMPERATURE, dive->watertemp.mkelvin, + DIVE_TOTALWEIGHT, 0, DIVE_SAC, 0, -1); } @@ -636,6 +672,7 @@ static struct divelist_column { [DIVE_DEPTH] = { "ft", depth_data_func, NULL, ALIGN_RIGHT }, [DIVE_DURATION] = { "min", duration_data_func, NULL, ALIGN_RIGHT }, [DIVE_TEMPERATURE] = { UTF8_DEGREE "F", temperature_data_func, NULL, ALIGN_RIGHT, &visible_cols.temperature }, + [DIVE_TOTALWEIGHT] = { "lbs", weight_data_func, NULL, ALIGN_RIGHT, &visible_cols.totalweight }, [DIVE_CYLINDER] = { "Cyl", NULL, NULL, 0, &visible_cols.cylinder }, [DIVE_NITROX] = { "O" UTF8_SUBSCRIPT_2 "%", nitrox_data_func, nitrox_sort_func, 0, &visible_cols.nitrox }, [DIVE_SAC] = { "SAC", sac_data_func, NULL, 0, &visible_cols.sac }, @@ -742,6 +779,7 @@ GtkWidget *dive_list_create(void) G_TYPE_INT, /* Depth */ G_TYPE_INT, /* Duration */ G_TYPE_INT, /* Temperature */ + G_TYPE_INT, /* Total weight */ G_TYPE_STRING, /* Cylinder */ G_TYPE_INT, /* Nitrox */ G_TYPE_INT, /* SAC */ @@ -762,6 +800,7 @@ GtkWidget *dive_list_create(void) dive_list.depth = divelist_column(&dive_list, dl_column + DIVE_DEPTH); dive_list.duration = divelist_column(&dive_list, dl_column + DIVE_DURATION); dive_list.temperature = divelist_column(&dive_list, dl_column + DIVE_TEMPERATURE); + dive_list.totalweight = divelist_column(&dive_list, dl_column + DIVE_TOTALWEIGHT); dive_list.cylinder = divelist_column(&dive_list, dl_column + DIVE_CYLINDER); dive_list.nitrox = divelist_column(&dive_list, dl_column + DIVE_NITROX); dive_list.sac = divelist_column(&dive_list, dl_column + DIVE_SAC); diff --git a/gtk-gui.c b/gtk-gui.c index 45aa21263..0dc2f9734 100644 --- a/gtk-gui.c +++ b/gtk-gui.c @@ -348,6 +348,7 @@ OPTIONCALLBACK(otu_toggle, visible_cols.otu) OPTIONCALLBACK(sac_toggle, visible_cols.sac) OPTIONCALLBACK(nitrox_toggle, visible_cols.nitrox) OPTIONCALLBACK(temperature_toggle, visible_cols.temperature) +OPTIONCALLBACK(totalweight_toggle, visible_cols.totalweight) OPTIONCALLBACK(cylinder_toggle, visible_cols.cylinder) static void event_toggle(GtkWidget *w, gpointer _data) @@ -434,6 +435,11 @@ static void preferences_dialog(GtkWidget *w, gpointer data) gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(otu_toggle), NULL); + button = gtk_check_button_new_with_label("Show Weight"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.totalweight); + gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6); + g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(totalweight_toggle), NULL); + font = gtk_font_button_new_with_font(divelist_font); gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5); @@ -457,6 +463,7 @@ static void preferences_dialog(GtkWidget *w, gpointer data) subsurface_set_conf("fahrenheit", PREF_BOOL, BOOL_TO_PTR(output_units.temperature == FAHRENHEIT)); subsurface_set_conf("lbs", PREF_BOOL, BOOL_TO_PTR(output_units.weight == LBS)); subsurface_set_conf("TEMPERATURE", PREF_BOOL, BOOL_TO_PTR(visible_cols.temperature)); + subsurface_set_conf("TOTALWEIGHT", PREF_BOOL, BOOL_TO_PTR(visible_cols.totalweight)); subsurface_set_conf("CYLINDER", PREF_BOOL, BOOL_TO_PTR(visible_cols.cylinder)); subsurface_set_conf("NITROX", PREF_BOOL, BOOL_TO_PTR(visible_cols.nitrox)); subsurface_set_conf("SAC", PREF_BOOL, BOOL_TO_PTR(visible_cols.sac)); @@ -726,6 +733,7 @@ void init_ui(int *argcp, char ***argvp) /* an unset key is FALSE - all these are hidden by default */ visible_cols.cylinder = PTR_TO_BOOL(subsurface_get_conf("CYLINDER", PREF_BOOL)); visible_cols.temperature = PTR_TO_BOOL(subsurface_get_conf("TEMPERATURE", PREF_BOOL)); + visible_cols.totalweight = PTR_TO_BOOL(subsurface_get_conf("TOTALWEIGHT", PREF_BOOL)); visible_cols.nitrox = PTR_TO_BOOL(subsurface_get_conf("NITROX", PREF_BOOL)); visible_cols.otu = PTR_TO_BOOL(subsurface_get_conf("OTU", PREF_BOOL)); visible_cols.sac = PTR_TO_BOOL(subsurface_get_conf("SAC", PREF_BOOL)); -- cgit v1.2.3-70-g09d2 From dc9d0e23e5d158ea4775021b2f629e7f90b5377c Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Mon, 13 Aug 2012 14:53:07 -0700 Subject: Maintain selected rows when switching between list model and tree model We keep track of the DIVE_INDEX of all selected dives and simply re-select those dives after changing model (date based sort or sort by other column). There are a few TODOs left. We lose the sort direction (ascending / descending) when switching models. We also don't correctly deal with the user selecting summary rows in the tree model. Signed-off-by: Dirk Hohndel --- display-gtk.h | 2 +- divelist.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- statistics.c | 11 ++++++++--- 3 files changed, 62 insertions(+), 6 deletions(-) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 4ce05468c..3043c873b 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -72,7 +72,7 @@ extern GtkWidget *dive_list_create(void); unsigned int amount_selected; -extern void process_selected_dives(GList *, GtkTreeModel *); +extern void process_selected_dives(GList *, int *, GtkTreeModel *); typedef void (*data_func_t)(GtkTreeViewColumn *col, GtkCellRenderer *renderer, diff --git a/divelist.c b/divelist.c index b70b415ca..4260651b7 100644 --- a/divelist.c +++ b/divelist.c @@ -79,6 +79,7 @@ static void dump_model(GtkListStore *store) #endif static GList *selected_dives; +static int *selectiontracker; static void selection_cb(GtkTreeSelection *selection, gpointer userdata) { @@ -92,6 +93,7 @@ static void selection_cb(GtkTreeSelection *selection, gpointer userdata) g_list_free (selected_dives); } selected_dives = gtk_tree_selection_get_selected_rows(selection, NULL); + selectiontracker = realloc(selectiontracker, nr_selected * sizeof(int)); switch (nr_selected) { case 0: /* keep showing the last selected dive */ @@ -118,6 +120,7 @@ static void selection_cb(GtkTreeSelection *selection, gpointer userdata) gtk_tree_view_expand_row(GTK_TREE_VIEW(dive_list.tree_view), tpath, FALSE); gtk_tree_model_get(GTK_TREE_MODEL(dive_list.model), &iter, DIVE_INDEX, &selected_dive, -1); } + selectiontracker[0] = selected_dive; repaint_dive(); } return; @@ -127,8 +130,11 @@ static void selection_cb(GtkTreeSelection *selection, gpointer userdata) * is the most intuitive solution. * I do however want to keep around which dives have * been selected */ + /* TODO: + this also does not handle the case if a summary row is selected; + We should iterate and select all dives under that row */ amount_selected = g_list_length(selected_dives); - process_selected_dives(selected_dives, GTK_TREE_MODEL(dive_list.model)); + process_selected_dives(selected_dives, selectiontracker, GTK_TREE_MODEL(dive_list.model)); repaint_dive(); return; } @@ -777,6 +783,8 @@ static void fill_dive_list(void) GtkTreeSelection *selection; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view)); gtk_tree_selection_select_iter(selection, &iter); + selectiontracker = realloc(selectiontracker, sizeof(int)); + gtk_tree_model_get(GTK_TREE_MODEL(dive_list.model), &iter, DIVE_INDEX, selectiontracker, -1); } } @@ -896,9 +904,37 @@ static gboolean button_press_cb(GtkWidget *treeview, GdkEventButton *event, gpoi return FALSE; } +/* we need to have a temporary copy of the selected dives while + switching model as the selection_cb function keeps getting called + by when gtk_tree_selection_select_path is called. */ +static int *oldselection; +static int old_nr_selected; + +/* 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, + GtkTreeIter *iter, gpointer data) +{ + int i, idx; + GtkTreeSelection *selection = GTK_TREE_SELECTION(data); + + 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; + } + return FALSE; + +} + /* If the sort column is date (default), show the tree model. For every other sort column only show the list model. - If the model changed, inform the new model of the chosen sort column. */ + If the model changed, inform the new model of the chosen sort column and make + sure the same dives are still selected. */ static void sort_column_change_cb(GtkTreeSortable *treeview, gpointer data) { int colid; @@ -911,8 +947,23 @@ static void sort_column_change_cb(GtkTreeSortable *treeview, gpointer data) else dive_list.model = dive_list.listmodel; if (dive_list.model != currentmodel) { + /* TODO + we should remember the sort order we had for each column */ + 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)); + 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)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dive_list.model), colid, order); + + 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); + } } } diff --git a/statistics.c b/statistics.c index 19105653c..adfc9c77a 100644 --- a/statistics.c +++ b/statistics.c @@ -142,10 +142,11 @@ static void process_all_dives(struct dive *dive, struct dive **prev_dive) } } -void process_selected_dives(GList *selected_dives, GtkTreeModel *model) +void process_selected_dives(GList *selected_dives, int *selectiontracker, GtkTreeModel *model) { struct dive *dp; unsigned int i; + int idx; GtkTreeIter iter; GtkTreePath *path; @@ -157,9 +158,13 @@ void process_selected_dives(GList *selected_dives, GtkTreeModel *model) path = g_list_nth_data(selected_dives, i); if (gtk_tree_model_get_iter(model, &iter, path)) { gtk_tree_model_get_value(model, &iter, 0, &value); - dp = get_dive(g_value_get_int(&value)); + idx = g_value_get_int(&value); + dp = get_dive(idx); + if (dp) { + selectiontracker[i] = idx; + process_dive(dp, &stats_selection); + } } - process_dive(dp, &stats_selection); } } -- cgit v1.2.3-70-g09d2 From e8ec3df371f0496a52ebdc463245d7b9df3be6ff Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 14 Aug 2012 16:07:25 -0700 Subject: Add exposure protection tracking For simplicity and shortness, throughout subsurface exposure protection is simply referred to as "suit". Add the fields to the data structures, add the column to the dive_list and the preferences dialog (once again with it being turned invisible by default). Support loading and saving of the suit information. Display the suit information in the Dive Info pane (this may be a bit controversial as people could argue this should be in the Equipment pane) and allow editing of the suit info, with our usual support for completion and drop down lists to pick from. Signed-off-by: Dirk Hohndel --- display-gtk.h | 1 + dive.c | 2 ++ dive.h | 2 ++ divelist.c | 20 ++++++++++++++++++-- gtk-gui.c | 8 ++++++++ info.c | 21 ++++++++++++++++++--- parse-xml.c | 2 ++ save-xml.c | 1 + 8 files changed, 52 insertions(+), 5 deletions(-) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 9f1b51771..37326d590 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -15,6 +15,7 @@ typedef struct { gboolean cylinder; gboolean temperature; gboolean totalweight; + gboolean suit; gboolean nitrox; gboolean sac; gboolean otu; diff --git a/dive.c b/dive.c index a420a3ef6..f5d082801 100644 --- a/dive.c +++ b/dive.c @@ -486,6 +486,7 @@ struct dive *fixup_dive(struct dive *dive) add_people(dive->buddy); add_people(dive->divemaster); add_location(dive->location); + add_suit(dive->suit); for (i = 0; i < MAX_CYLINDERS; i++) { cylinder_t *cyl = dive->cylinder + i; add_cylinder_description(&cyl->type); @@ -703,6 +704,7 @@ struct dive *try_to_merge(struct dive *a, struct dive *b) MERGE_TXT(res, a, b, buddy); MERGE_TXT(res, a, b, divemaster); MERGE_MAX(res, a, b, rating); + MERGE_TXT(res, a, b, suit); MERGE_MAX(res, a, b, number); MERGE_MAX(res, a, b, maxdepth.mm); res->meandepth.mm = 0; diff --git a/dive.h b/dive.h index 8a867ad0d..faed89ac9 100644 --- a/dive.h +++ b/dive.h @@ -243,6 +243,7 @@ struct dive { temperature_t airtemp, watertemp; cylinder_t cylinder[MAX_CYLINDERS]; weightsystem_t weightsystem[MAX_WEIGHTSYSTEMS]; + char *suit; int sac, otu; struct event *events; int samples, alloc_samples; @@ -342,6 +343,7 @@ extern void add_cylinder_description(cylinder_type_t *); extern void add_weightsystem_description(weightsystem_t *); extern void add_people(const char *string); extern void add_location(const char *string); +extern void add_suit(const char *string); extern void remember_event(const char *eventname); extern void evn_foreach(void (*callback)(const char *, int *, void *), void *data); diff --git a/divelist.c b/divelist.c index 1d31da567..8cf079391 100644 --- a/divelist.c +++ b/divelist.c @@ -26,7 +26,7 @@ struct DiveList { GtkWidget *container_widget; GtkListStore *model; GtkTreeViewColumn *nr, *date, *stars, *depth, *duration, *location; - GtkTreeViewColumn *temperature, *cylinder, *totalweight, *nitrox, *sac, *otu; + GtkTreeViewColumn *temperature, *cylinder, *totalweight, *suit, *nitrox, *sac, *otu; int changed; }; @@ -45,6 +45,7 @@ enum { DIVE_DURATION, /* int: in seconds */ DIVE_TEMPERATURE, /* int: in mkelvin */ DIVE_TOTALWEIGHT, /* int: in grams */ + DIVE_SUIT, /* "wet, 3mm" */ DIVE_CYLINDER, DIVE_NITROX, /* int: dummy */ DIVE_SAC, /* int: in ml/min */ @@ -534,6 +535,11 @@ static void get_cylinder(struct dive *dive, char **str) get_string(str, dive->cylinder[0].type.description); } +static void get_suit(struct dive *dive, char **str) +{ + get_string(str, dive->suit); +} + /* * Set up anything that could have changed due to editing * of dive information @@ -542,10 +548,11 @@ static void fill_one_dive(struct dive *dive, GtkTreeModel *model, GtkTreeIter *iter) { - char *location, *cylinder; + char *location, *cylinder, *suit; get_cylinder(dive, &cylinder); get_location(dive, &location); + get_suit(dive, &suit); gtk_list_store_set(GTK_LIST_STORE(model), iter, DIVE_NR, dive->number, @@ -555,7 +562,11 @@ static void fill_one_dive(struct dive *dive, DIVE_SAC, dive->sac, DIVE_OTU, dive->otu, DIVE_TOTALWEIGHT, total_weight(dive), + DIVE_SUIT, suit, -1); + + /* this will create a merge conflict with the memory leak patches */ + free(suit); } static gboolean set_one_dive(GtkTreeModel *model, @@ -614,6 +625,7 @@ void update_dive_list_col_visibility(void) gtk_tree_view_column_set_visible(dive_list.cylinder, visible_cols.cylinder); gtk_tree_view_column_set_visible(dive_list.temperature, visible_cols.temperature); gtk_tree_view_column_set_visible(dive_list.totalweight, visible_cols.totalweight); + gtk_tree_view_column_set_visible(dive_list.suit, visible_cols.suit); gtk_tree_view_column_set_visible(dive_list.nitrox, visible_cols.nitrox); gtk_tree_view_column_set_visible(dive_list.sac, visible_cols.sac); gtk_tree_view_column_set_visible(dive_list.otu, visible_cols.otu); @@ -643,6 +655,7 @@ static void fill_dive_list(void) DIVE_LOCATION, "location", DIVE_TEMPERATURE, dive->watertemp.mkelvin, DIVE_TOTALWEIGHT, 0, + DIVE_SUIT, dive->suit, DIVE_SAC, 0, -1); } @@ -676,6 +689,7 @@ static struct divelist_column { [DIVE_DURATION] = { "min", duration_data_func, NULL, ALIGN_RIGHT }, [DIVE_TEMPERATURE] = { UTF8_DEGREE "F", temperature_data_func, NULL, ALIGN_RIGHT, &visible_cols.temperature }, [DIVE_TOTALWEIGHT] = { "lbs", weight_data_func, NULL, ALIGN_RIGHT, &visible_cols.totalweight }, + [DIVE_SUIT] = { "Suit", NULL, NULL, ALIGN_LEFT, &visible_cols.suit }, [DIVE_CYLINDER] = { "Cyl", NULL, NULL, 0, &visible_cols.cylinder }, [DIVE_NITROX] = { "O" UTF8_SUBSCRIPT_2 "%", nitrox_data_func, nitrox_sort_func, 0, &visible_cols.nitrox }, [DIVE_SAC] = { "SAC", sac_data_func, NULL, 0, &visible_cols.sac }, @@ -783,6 +797,7 @@ GtkWidget *dive_list_create(void) G_TYPE_INT, /* Duration */ G_TYPE_INT, /* Temperature */ G_TYPE_INT, /* Total weight */ + G_TYPE_STRING, /* Suit */ G_TYPE_STRING, /* Cylinder */ G_TYPE_INT, /* Nitrox */ G_TYPE_INT, /* SAC */ @@ -804,6 +819,7 @@ GtkWidget *dive_list_create(void) dive_list.duration = divelist_column(&dive_list, dl_column + DIVE_DURATION); dive_list.temperature = divelist_column(&dive_list, dl_column + DIVE_TEMPERATURE); dive_list.totalweight = divelist_column(&dive_list, dl_column + DIVE_TOTALWEIGHT); + dive_list.suit = divelist_column(&dive_list, dl_column + DIVE_SUIT); dive_list.cylinder = divelist_column(&dive_list, dl_column + DIVE_CYLINDER); dive_list.nitrox = divelist_column(&dive_list, dl_column + DIVE_NITROX); dive_list.sac = divelist_column(&dive_list, dl_column + DIVE_SAC); diff --git a/gtk-gui.c b/gtk-gui.c index 0dc2f9734..9f37c1a0b 100644 --- a/gtk-gui.c +++ b/gtk-gui.c @@ -349,6 +349,7 @@ OPTIONCALLBACK(sac_toggle, visible_cols.sac) OPTIONCALLBACK(nitrox_toggle, visible_cols.nitrox) OPTIONCALLBACK(temperature_toggle, visible_cols.temperature) OPTIONCALLBACK(totalweight_toggle, visible_cols.totalweight) +OPTIONCALLBACK(suit_toggle, visible_cols.suit) OPTIONCALLBACK(cylinder_toggle, visible_cols.cylinder) static void event_toggle(GtkWidget *w, gpointer _data) @@ -440,6 +441,11 @@ static void preferences_dialog(GtkWidget *w, gpointer data) gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(totalweight_toggle), NULL); + button = gtk_check_button_new_with_label("Show Suit"); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.suit); + gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6); + g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(suit_toggle), NULL); + font = gtk_font_button_new_with_font(divelist_font); gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5); @@ -464,6 +470,7 @@ static void preferences_dialog(GtkWidget *w, gpointer data) subsurface_set_conf("lbs", PREF_BOOL, BOOL_TO_PTR(output_units.weight == LBS)); subsurface_set_conf("TEMPERATURE", PREF_BOOL, BOOL_TO_PTR(visible_cols.temperature)); subsurface_set_conf("TOTALWEIGHT", PREF_BOOL, BOOL_TO_PTR(visible_cols.totalweight)); + subsurface_set_conf("SUIT", PREF_BOOL, BOOL_TO_PTR(visible_cols.suit)); subsurface_set_conf("CYLINDER", PREF_BOOL, BOOL_TO_PTR(visible_cols.cylinder)); subsurface_set_conf("NITROX", PREF_BOOL, BOOL_TO_PTR(visible_cols.nitrox)); subsurface_set_conf("SAC", PREF_BOOL, BOOL_TO_PTR(visible_cols.sac)); @@ -734,6 +741,7 @@ void init_ui(int *argcp, char ***argvp) visible_cols.cylinder = PTR_TO_BOOL(subsurface_get_conf("CYLINDER", PREF_BOOL)); visible_cols.temperature = PTR_TO_BOOL(subsurface_get_conf("TEMPERATURE", PREF_BOOL)); visible_cols.totalweight = PTR_TO_BOOL(subsurface_get_conf("TOTALWEIGHT", PREF_BOOL)); + visible_cols.suit = PTR_TO_BOOL(subsurface_get_conf("SUIT", PREF_BOOL)); visible_cols.nitrox = PTR_TO_BOOL(subsurface_get_conf("NITROX", PREF_BOOL)); visible_cols.otu = PTR_TO_BOOL(subsurface_get_conf("OTU", PREF_BOOL)); visible_cols.sac = PTR_TO_BOOL(subsurface_get_conf("SAC", PREF_BOOL)); diff --git a/info.c b/info.c index 1847a49bf..09d61c835 100644 --- a/info.c +++ b/info.c @@ -19,9 +19,9 @@ #include "display-gtk.h" #include "divelist.h" -static GtkEntry *location, *buddy, *divemaster, *rating; +static GtkEntry *location, *buddy, *divemaster, *rating, *suit; static GtkTextView *notes; -static GtkListStore *location_list, *people_list, *star_list; +static GtkListStore *location_list, *people_list, *star_list, *suit_list; static char *get_text(GtkTextView *view) { @@ -96,6 +96,7 @@ void show_dive_info(struct dive *dive) SET_TEXT_VALUE(divemaster); SET_TEXT_VALUE(buddy); SET_TEXT_VALUE(location); + SET_TEXT_VALUE(suit); gtk_entry_set_text(rating, star_strings[dive->rating]); gtk_text_buffer_set_text(gtk_text_view_get_buffer(notes), dive && dive->notes ? dive->notes : "", -1); @@ -296,6 +297,11 @@ void add_location(const char *string) add_string_list_entry(string, location_list); } +void add_suit(const char *string) +{ + add_string_list_entry(string, suit_list); +} + static int get_rating(const char *string) { int rating_val = 0; @@ -308,7 +314,7 @@ static int get_rating(const char *string) } struct dive_info { - GtkComboBoxEntry *location, *divemaster, *buddy, *rating; + GtkComboBoxEntry *location, *divemaster, *buddy, *rating, *suit; GtkTextView *notes; }; @@ -336,6 +342,12 @@ static void save_dive_info_changes(struct dive *dive, struct dive_info *info) changed = 1; } + new_text = get_combo_box_entry_text(info->suit, &dive->suit); + if (new_text) { + add_suit(new_text); + changed = 1; + } + rating_string = strdup(star_strings[dive->rating]); new_text = get_combo_box_entry_text(info->rating, &rating_string); if (new_text) { @@ -378,6 +390,7 @@ static void dive_info_widget(GtkWidget *box, struct dive *dive, struct dive_info gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, TRUE, 0); info->rating = text_entry(hbox, "Rating", star_list, star_strings[dive->rating]); + info->suit = text_entry(hbox, "Suit", suit_list, dive->suit); info->notes = text_view(box, "Notes", READ_WRITE); if (dive->notes && *dive->notes) @@ -562,6 +575,7 @@ GtkWidget *extended_dive_info_widget(void) add_string_list_entry(THREE_STARS, star_list); add_string_list_entry(FOUR_STARS, star_list); add_string_list_entry(FIVE_STARS, star_list); + suit_list = gtk_list_store_new(1, G_TYPE_STRING); gtk_container_set_border_width(GTK_CONTAINER(vbox), 6); location = text_value(vbox, "Location"); @@ -576,6 +590,7 @@ GtkWidget *extended_dive_info_widget(void) gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); rating = text_value(hbox, "Rating"); + suit = text_value(hbox, "Suit"); notes = text_view(vbox, "Notes", READ_ONLY); return vbox; diff --git a/parse-xml.c b/parse-xml.c index d6fc953a7..a36758ca0 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -1100,6 +1100,8 @@ static void try_to_fill_dive(struct dive **divep, const char *name, char *buf) return; if (MATCH(".location", utf8_string, &dive->location)) return; + if (MATCH(".suit", utf8_string, &dive->suit)) + return; if (MATCH(".notes", utf8_string, &dive->notes)) return; if (MATCH(".divemaster", utf8_string, &dive->divemaster)) diff --git a/save-xml.c b/save-xml.c index ed55c022d..37d6d062e 100644 --- a/save-xml.c +++ b/save-xml.c @@ -183,6 +183,7 @@ static void save_overview(FILE *f, struct dive *dive) show_utf8(f, dive->divemaster, " ","\n"); show_utf8(f, dive->buddy, " ","\n"); show_utf8(f, dive->notes, " ","\n"); + show_utf8(f, dive->suit, " ","\n"); } static void save_cylinder_info(FILE *f, struct dive *dive) -- cgit v1.2.3-70-g09d2 From 621761233b2e1b139c07987b562ef2aa299ff35e Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Wed, 15 Aug 2012 15:21:34 -0700 Subject: Redo dive editing This commit addresses two issues: We now can add / edit / delete equipment from the edit dive dialog We now can edit multiple dives at once The latter feature has some interesting design constraints: It picks the 'selected_dive' as the one to start the edit from - so if this dive already has some information filled in, that information needs to be overwritten before it is stored in all of the dives. Similarly, only changes to the cylinders or weightsystems are recorded. Also, the notes field is not editable in the multi dive edit mode (as that didn't seem useful). The workflow seems to work best if using the multi-edit right after importing new dives from a dive computer. The user then can select all the new dives and only needs to edit things like location, divemaster, buddy, weights, etc. once. This commit will create some obvious conflicts with the commit that adds exposure protection tracking. It was implemented on top of the tree_view changes as it reuses some of the infrastructure for tracking the selected dives. Signed-off-by: Dirk Hohndel --- display-gtk.h | 5 +- dive.h | 7 ++- divelist.c | 13 +++++ equipment.c | 158 +++++++++++++++++++++++++++++++--------------------------- gtk-gui.c | 2 +- info.c | 109 ++++++++++++++++++++++++++++++---------- main.c | 2 +- 7 files changed, 191 insertions(+), 105 deletions(-) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 3043c873b..1cf150bb6 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -63,10 +63,11 @@ extern void update_progressbar_text(progressbar_t *progress, const char *text); extern GtkWidget *dive_profile_widget(void); extern GtkWidget *dive_info_frame(void); extern GtkWidget *extended_dive_info_widget(void); -extern GtkWidget *equipment_widget(void); +extern GtkWidget *equipment_widget(int w_idx); extern GtkWidget *single_stats_widget(void); extern GtkWidget *total_stats_widget(void); -extern GtkWidget *cylinder_list_widget(void); +extern GtkWidget *cylinder_list_widget(int w_idx); +extern GtkWidget *weightsystem_list_widget(int w_idx); extern GtkWidget *dive_list_create(void); diff --git a/dive.h b/dive.h index a25fafb39..de95d5e66 100644 --- a/dive.h +++ b/dive.h @@ -227,6 +227,8 @@ struct event { #define MAX_CYLINDERS (8) #define MAX_WEIGHTSYSTEMS (4) +#define W_IDX_PRIMARY 0 +#define W_IDX_SECONDARY 1 struct dive { int number; @@ -282,7 +284,7 @@ extern int selected_dive; static inline struct dive *get_dive(unsigned int nr) { - if (nr >= dive_table.nr) + if (nr >= dive_table.nr || nr < 0) return NULL; return dive_table.dives[nr]; } @@ -299,7 +301,7 @@ extern xmlDoc *test_xslt_transforms(xmlDoc *doc); extern void show_dive_info(struct dive *); -extern void show_dive_equipment(struct dive *); +extern void show_dive_equipment(struct dive *, int w_idx); extern void show_dive_stats(struct dive *); @@ -345,6 +347,7 @@ extern void evn_foreach(void (*callback)(const char *, int *, void *), void *dat extern int add_new_dive(struct dive *dive); extern int edit_dive_info(struct dive *dive); +extern int edit_multi_dive_info(int nr, int *indices); extern void dive_list_update_dives(void); extern void flush_divelist(struct dive *dive); diff --git a/divelist.c b/divelist.c index 112307a1c..a4221f7b9 100644 --- a/divelist.c +++ b/divelist.c @@ -938,14 +938,27 @@ void add_dive_cb(GtkWidget *menuitem, gpointer data) free(dive); } +void edit_dive_cb(GtkWidget *menuitem, gpointer data) +{ + edit_multi_dive_info(amount_selected, selectiontracker); +} + static void popup_divelist_menu(GtkTreeView *tree_view, GtkTreeModel *model, int button) { GtkWidget *menu, *menuitem; + char editlabel[] = "Edit dives"; menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_label("Add dive"); g_signal_connect(menuitem, "activate", G_CALLBACK(add_dive_cb), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + if (amount_selected) { + if (amount_selected == 1) + editlabel[strlen(editlabel) - 1] = '\0'; + menuitem = gtk_menu_item_new_with_label(editlabel); + g_signal_connect(menuitem, "activate", G_CALLBACK(edit_dive_cb), model); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + } gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, diff --git a/equipment.c b/equipment.c index b74d85b7b..ccfeb1270 100644 --- a/equipment.c +++ b/equipment.c @@ -2,10 +2,10 @@ /* creates the UI for the equipment page - * controlled through the following interfaces: * - * void show_dive_equipment(struct dive *dive) + * void show_dive_equipment(struct dive *dive, int w_idx) * * called from gtk-ui: - * GtkWidget *equipment_widget(void) + * GtkWidget *equipment_widget(int w_idx) */ #include #include @@ -40,10 +40,11 @@ enum { struct equipment_list { int max_index; GtkListStore *model; + GtkTreeView *tree_view; GtkWidget *edit, *add, *del; }; -static struct equipment_list cylinder_list, weightsystem_list; +static struct equipment_list cylinder_list[2], weightsystem_list[2]; struct cylinder_widget { @@ -519,11 +520,11 @@ static void show_equipment(struct dive *dive, int max, } } -void show_dive_equipment(struct dive *dive) +void show_dive_equipment(struct dive *dive, int w_idx) { - show_equipment(dive, MAX_CYLINDERS, &cylinder_list, + show_equipment(dive, MAX_CYLINDERS, &cylinder_list[w_idx], &cyl_ptr, &cylinder_none, &set_one_cylinder); - show_equipment(dive, MAX_WEIGHTSYSTEMS, &weightsystem_list, + show_equipment(dive, MAX_WEIGHTSYSTEMS, &weightsystem_list[w_idx], &ws_ptr, &weightsystem_none, &set_one_weightsystem); } @@ -1061,11 +1062,12 @@ static int get_model_index(GtkListStore *model, GtkTreeIter *iter) return index; } -static void edit_cb(GtkButton *button, GtkTreeView *tree_view) +static void edit_cb(GtkButton *button, int w_idx) { int index; GtkTreeIter iter; - GtkListStore *model = cylinder_list.model; + GtkListStore *model = cylinder_list[w_idx].model; + GtkTreeView *tree_view = cylinder_list[w_idx].tree_view; GtkTreeSelection *selection; cylinder_t cyl; @@ -1083,11 +1085,12 @@ static void edit_cb(GtkButton *button, GtkTreeView *tree_view) repaint_dive(); } -static void add_cb(GtkButton *button, GtkTreeView *tree_view) +static void add_cb(GtkButton *button, int w_idx) { - int index = cylinder_list.max_index; + int index = cylinder_list[w_idx].max_index; GtkTreeIter iter; - GtkListStore *model = cylinder_list.model; + GtkListStore *model = cylinder_list[w_idx].model; + GtkTreeView *tree_view = cylinder_list[w_idx].tree_view; GtkTreeSelection *selection; cylinder_t cyl; @@ -1100,15 +1103,16 @@ static void add_cb(GtkButton *button, GtkTreeView *tree_view) selection = gtk_tree_view_get_selection(tree_view); gtk_tree_selection_select_iter(selection, &iter); - cylinder_list.max_index++; - gtk_widget_set_sensitive(cylinder_list.add, cylinder_list.max_index < MAX_CYLINDERS); + cylinder_list[w_idx].max_index++; + gtk_widget_set_sensitive(cylinder_list[w_idx].add, cylinder_list[w_idx].max_index < MAX_CYLINDERS); } -static void del_cb(GtkButton *button, GtkTreeView *tree_view) +static void del_cb(GtkButton *button, int w_idx) { int index, nr; GtkTreeIter iter; - GtkListStore *model = cylinder_list.model; + GtkListStore *model = cylinder_list[w_idx].model; + GtkTreeView *tree_view = cylinder_list[w_idx].tree_view; GtkTreeSelection *selection; struct dive *dive; cylinder_t *cyl; @@ -1125,27 +1129,28 @@ static void del_cb(GtkButton *button, GtkTreeView *tree_view) if (!dive) return; cyl = dive->cylinder + index; - nr = cylinder_list.max_index - index - 1; + nr = cylinder_list[w_idx].max_index - index - 1; gtk_list_store_remove(model, &iter); - cylinder_list.max_index--; + cylinder_list[w_idx].max_index--; memmove(cyl, cyl+1, nr*sizeof(*cyl)); memset(cyl+nr, 0, sizeof(*cyl)); mark_divelist_changed(TRUE); flush_divelist(dive); - gtk_widget_set_sensitive(cylinder_list.edit, 0); - gtk_widget_set_sensitive(cylinder_list.del, 0); - gtk_widget_set_sensitive(cylinder_list.add, 1); + gtk_widget_set_sensitive(cylinder_list[w_idx].edit, 0); + gtk_widget_set_sensitive(cylinder_list[w_idx].del, 0); + gtk_widget_set_sensitive(cylinder_list[w_idx].add, 1); } -static void ws_edit_cb(GtkButton *button, GtkTreeView *tree_view) +static void ws_edit_cb(GtkButton *button, int w_idx) { int index; GtkTreeIter iter; - GtkListStore *model = weightsystem_list.model; + GtkListStore *model = weightsystem_list[w_idx].model; + GtkTreeView *tree_view = weightsystem_list[w_idx].tree_view; GtkTreeSelection *selection; weightsystem_t ws; @@ -1163,11 +1168,12 @@ static void ws_edit_cb(GtkButton *button, GtkTreeView *tree_view) repaint_dive(); } -static void ws_add_cb(GtkButton *button, GtkTreeView *tree_view) +static void ws_add_cb(GtkButton *button, int w_idx) { - int index = weightsystem_list.max_index; + int index = weightsystem_list[w_idx].max_index; GtkTreeIter iter; - GtkListStore *model = weightsystem_list.model; + GtkListStore *model = weightsystem_list[w_idx].model; + GtkTreeView *tree_view = weightsystem_list[w_idx].tree_view; GtkTreeSelection *selection; weightsystem_t ws; @@ -1180,15 +1186,16 @@ static void ws_add_cb(GtkButton *button, GtkTreeView *tree_view) selection = gtk_tree_view_get_selection(tree_view); gtk_tree_selection_select_iter(selection, &iter); - weightsystem_list.max_index++; - gtk_widget_set_sensitive(weightsystem_list.add, weightsystem_list.max_index < MAX_WEIGHTSYSTEMS); + weightsystem_list[w_idx].max_index++; + gtk_widget_set_sensitive(weightsystem_list[w_idx].add, weightsystem_list[w_idx].max_index < MAX_WEIGHTSYSTEMS); } -static void ws_del_cb(GtkButton *button, GtkTreeView *tree_view) +static void ws_del_cb(GtkButton *button, int w_idx) { int index, nr; GtkTreeIter iter; - GtkListStore *model = weightsystem_list.model; + GtkListStore *model = weightsystem_list[w_idx].model; + GtkTreeView *tree_view = weightsystem_list[w_idx].tree_view; GtkTreeSelection *selection; struct dive *dive; weightsystem_t *ws; @@ -1205,20 +1212,20 @@ static void ws_del_cb(GtkButton *button, GtkTreeView *tree_view) if (!dive) return; ws = dive->weightsystem + index; - nr = weightsystem_list.max_index - index - 1; + nr = weightsystem_list[w_idx].max_index - index - 1; gtk_list_store_remove(model, &iter); - weightsystem_list.max_index--; + weightsystem_list[w_idx].max_index--; memmove(ws, ws+1, nr*sizeof(*ws)); memset(ws+nr, 0, sizeof(*ws)); mark_divelist_changed(TRUE); flush_divelist(dive); - gtk_widget_set_sensitive(weightsystem_list.edit, 0); - gtk_widget_set_sensitive(weightsystem_list.del, 0); - gtk_widget_set_sensitive(weightsystem_list.add, 1); + gtk_widget_set_sensitive(weightsystem_list[w_idx].edit, 0); + gtk_widget_set_sensitive(weightsystem_list[w_idx].del, 0); + gtk_widget_set_sensitive(weightsystem_list[w_idx].add, 1); } static GtkListStore *create_tank_size_model(void) @@ -1338,33 +1345,33 @@ static void selection_cb(GtkTreeSelection *selection, struct equipment_list *lis static void row_activated_cb(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, - GtkTreeModel *model) + int w_idx) { - edit_cb(NULL, tree_view); + edit_cb(NULL, w_idx); } static void ws_row_activated_cb(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, - GtkTreeModel *model) + int w_idx) { - ws_edit_cb(NULL, tree_view); + ws_edit_cb(NULL, w_idx); } -GtkWidget *cylinder_list_widget(void) +GtkWidget *cylinder_list_widget(int w_idx) { - GtkListStore *model = cylinder_list.model; + GtkListStore *model = cylinder_list[w_idx].model; GtkWidget *tree_view; GtkTreeSelection *selection; tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); gtk_widget_set_can_focus(tree_view, FALSE); - g_signal_connect(tree_view, "row-activated", G_CALLBACK(row_activated_cb), model); + g_signal_connect(tree_view, "row-activated", G_CALLBACK(row_activated_cb), GINT_TO_POINTER(w_idx)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); - g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), &cylinder_list); + g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), &cylinder_list[w_idx]); g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, @@ -1380,9 +1387,9 @@ GtkWidget *cylinder_list_widget(void) return tree_view; } -GtkWidget *weightsystem_list_widget(void) +GtkWidget *weightsystem_list_widget(int w_idx) { - GtkListStore *model = weightsystem_list.model; + GtkListStore *model = weightsystem_list[w_idx].model; GtkWidget *tree_view; GtkTreeSelection *selection; @@ -1392,7 +1399,7 @@ GtkWidget *weightsystem_list_widget(void) selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); - g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), &weightsystem_list); + g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), &weightsystem_list[w_idx]); g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, @@ -1405,7 +1412,7 @@ GtkWidget *weightsystem_list_widget(void) return tree_view; } -static GtkWidget *cylinder_list_create(void) +static GtkWidget *cylinder_list_create(int w_idx) { GtkListStore *model; @@ -1418,11 +1425,11 @@ static GtkWidget *cylinder_list_create(void) G_TYPE_INT, /* CYL_O2: permille */ G_TYPE_INT /* CYL_HE: permille */ ); - cylinder_list.model = model; - return cylinder_list_widget(); + cylinder_list[w_idx].model = model; + return cylinder_list_widget(w_idx); } -static GtkWidget *weightsystem_list_create(void) +static GtkWidget *weightsystem_list_create(int w_idx) { GtkListStore *model; @@ -1430,11 +1437,11 @@ static GtkWidget *weightsystem_list_create(void) G_TYPE_STRING, /* WS_DESC: utf8 */ G_TYPE_INT /* WS_WEIGHT: grams */ ); - weightsystem_list.model = model; - return weightsystem_list_widget(); + weightsystem_list[w_idx].model = model; + return weightsystem_list_widget(w_idx); } -GtkWidget *equipment_widget(void) +GtkWidget *equipment_widget(int w_idx) { GtkWidget *vbox, *hbox, *frame, *framebox, *tree_view; GtkWidget *add, *del, *edit; @@ -1442,14 +1449,17 @@ GtkWidget *equipment_widget(void) vbox = gtk_vbox_new(FALSE, 3); /* - * We create the cylinder size model at startup, since - * we're going to share it across all cylinders and all - * dives. So if you add a new cylinder type in one dive, - * it will show up when you edit the cylinder types for - * another dive. + * We create the cylinder size (and weightsystem) models + * at startup for the primary cylinder / weightsystem widget, + * since we're going to share it across all cylinders and all + * dives. So if you add a new cylinder type or weightsystem in + * one dive, it will show up when you edit the cylinder types + * or weightsystems for another dive. */ - cylinder_model = create_tank_size_model(); - tree_view = cylinder_list_create(); + if (w_idx == W_IDX_PRIMARY) + cylinder_model = create_tank_size_model(); + tree_view = cylinder_list_create(w_idx); + cylinder_list[w_idx].tree_view = GTK_TREE_VIEW(tree_view); hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); @@ -1475,19 +1485,21 @@ GtkWidget *equipment_widget(void) gtk_box_pack_start(GTK_BOX(hbox), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), del, FALSE, FALSE, 0); - cylinder_list.edit = edit; - cylinder_list.add = add; - cylinder_list.del = del; + cylinder_list[w_idx].edit = edit; + cylinder_list[w_idx].add = add; + cylinder_list[w_idx].del = del; - g_signal_connect(edit, "clicked", G_CALLBACK(edit_cb), tree_view); - g_signal_connect(add, "clicked", G_CALLBACK(add_cb), tree_view); - g_signal_connect(del, "clicked", G_CALLBACK(del_cb), tree_view); + g_signal_connect(edit, "clicked", G_CALLBACK(edit_cb), GINT_TO_POINTER(w_idx)); + g_signal_connect(add, "clicked", G_CALLBACK(add_cb), GINT_TO_POINTER(w_idx)); + g_signal_connect(del, "clicked", G_CALLBACK(del_cb), GINT_TO_POINTER(w_idx)); hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); - weightsystem_model = create_weightsystem_model(); - tree_view = weightsystem_list_create(); + if (w_idx == W_IDX_PRIMARY) + weightsystem_model = create_weightsystem_model(); + tree_view = weightsystem_list_create(w_idx); + weightsystem_list[w_idx].tree_view = GTK_TREE_VIEW(tree_view); frame = gtk_frame_new("Weight"); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, FALSE, 3); @@ -1510,13 +1522,13 @@ GtkWidget *equipment_widget(void) gtk_box_pack_start(GTK_BOX(hbox), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), del, FALSE, FALSE, 0); - weightsystem_list.edit = edit; - weightsystem_list.add = add; - weightsystem_list.del = del; + weightsystem_list[w_idx].edit = edit; + weightsystem_list[w_idx].add = add; + weightsystem_list[w_idx].del = del; - g_signal_connect(edit, "clicked", G_CALLBACK(ws_edit_cb), tree_view); - g_signal_connect(add, "clicked", G_CALLBACK(ws_add_cb), tree_view); - g_signal_connect(del, "clicked", G_CALLBACK(ws_del_cb), tree_view); + g_signal_connect(edit, "clicked", G_CALLBACK(ws_edit_cb), GINT_TO_POINTER(w_idx)); + g_signal_connect(add, "clicked", G_CALLBACK(ws_add_cb), GINT_TO_POINTER(w_idx)); + g_signal_connect(del, "clicked", G_CALLBACK(ws_del_cb), GINT_TO_POINTER(w_idx)); return vbox; } diff --git a/gtk-gui.c b/gtk-gui.c index 45aa21263..f7d3c5008 100644 --- a/gtk-gui.c +++ b/gtk-gui.c @@ -794,7 +794,7 @@ void init_ui(int *argcp, char ***argvp) gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Dive Notes")); /* Frame for dive equipment */ - nb_page = equipment_widget(); + nb_page = equipment_widget(W_IDX_PRIMARY); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Equipment")); /* Frame for single dive statistics */ diff --git a/info.c b/info.c index 1847a49bf..842a15001 100644 --- a/info.c +++ b/info.c @@ -344,25 +344,27 @@ static void save_dive_info_changes(struct dive *dive, struct dive_info *info) changed =1; } - old_text = dive->notes; - dive->notes = get_text(info->notes); - if (text_changed(old_text,dive->notes)) - changed = 1; - if (old_text) - g_free(old_text); - + if (info->notes) { + old_text = dive->notes; + dive->notes = get_text(info->notes); + if (text_changed(old_text,dive->notes)) + changed = 1; + if (old_text) + g_free(old_text); + } if (changed) { mark_divelist_changed(TRUE); update_dive(dive); } } -static void dive_info_widget(GtkWidget *box, struct dive *dive, struct dive_info *info) +static void dive_info_widget(GtkWidget *box, struct dive *dive, struct dive_info *info, gboolean multi) { - GtkWidget *hbox, *label, *cylinder, *frame; - char buffer[80]; + GtkWidget *hbox, *label, *frame, *equipment; + char buffer[80] = "Edit multiple dives"; - divename(buffer, sizeof(buffer), dive); + if (!multi) + divename(buffer, sizeof(buffer), dive); label = gtk_label_new(buffer); gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0); @@ -379,28 +381,57 @@ static void dive_info_widget(GtkWidget *box, struct dive *dive, struct dive_info info->rating = text_entry(hbox, "Rating", star_list, star_strings[dive->rating]); - info->notes = text_view(box, "Notes", READ_WRITE); - if (dive->notes && *dive->notes) - gtk_text_buffer_set_text(gtk_text_view_get_buffer(info->notes), dive->notes, -1); - + /* only show notes if editing a single dive */ + if (multi) { + info->notes = NULL; + } else { + info->notes = text_view(box, "Notes", READ_WRITE); + if (dive->notes && *dive->notes) + gtk_text_buffer_set_text(gtk_text_view_get_buffer(info->notes), dive->notes, -1); + } hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, TRUE, 0); - frame = gtk_frame_new("Cylinder"); - cylinder = cylinder_list_widget(); - gtk_container_add(GTK_CONTAINER(frame), cylinder); + /* create a secondary Equipment widget */ + frame = gtk_frame_new("Equipment"); + equipment = equipment_widget(W_IDX_SECONDARY); + gtk_container_add(GTK_CONTAINER(frame), equipment); gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 0); } -int edit_dive_info(struct dive *dive) +/* we use these to find out if we edited the cylinder or weightsystem entries */ +static cylinder_t remember_cyl[MAX_CYLINDERS]; +static weightsystem_t remember_ws[MAX_WEIGHTSYSTEMS]; + +void save_equipment_data(struct dive *dive) { - int success; + if (dive) { + memcpy(remember_cyl, dive->cylinder, sizeof(cylinder_t) * MAX_CYLINDERS); + memcpy(remember_ws, dive->weightsystem, sizeof(weightsystem_t) * MAX_WEIGHTSYSTEMS); + } +} + +void update_equipment_data(struct dive *dive, struct dive *master) +{ + if (dive == master) + return; + if (memcmp(remember_cyl, master->cylinder, sizeof(cylinder_t) * MAX_CYLINDERS)) { + memcpy(dive->cylinder, master->cylinder, sizeof(cylinder_t) * MAX_CYLINDERS); + } + if (memcmp(remember_ws, master->weightsystem, sizeof(weightsystem_t) * MAX_WEIGHTSYSTEMS)) { + memcpy(dive->weightsystem, master->weightsystem, sizeof(weightsystem_t) * MAX_WEIGHTSYSTEMS); + } +} + +int edit_multi_dive_info(int nr, int *indices) +{ + int success, i; GtkWidget *dialog, *vbox; struct dive_info info; + struct dive *dive; - if (!dive) + if (!nr) return 0; - dialog = gtk_dialog_new_with_buttons("Dive Info", GTK_WINDOW(main_window), GTK_DIALOG_DESTROY_WITH_PARENT, @@ -409,18 +440,44 @@ int edit_dive_info(struct dive *dive) NULL); vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); - dive_info_widget(vbox, dive, &info); - + /* SCARY STUFF - IS THIS THE BEST WAY TO DO THIS??? + * + * current_dive is one of our selected dives - and that is + * the one that is used to pre-fill the edit widget. Its + * data is used as the starting point for all selected dives + * I think it would be better to somehow collect and combine + * info from all the selected dives */ + dive = current_dive; + dive_info_widget(vbox, dive, &info, (nr > 1)); + show_dive_equipment(dive, W_IDX_SECONDARY); + save_equipment_data(dive); gtk_widget_show_all(dialog); success = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT; if (success) - save_dive_info_changes(dive, &info); - + for (i = 0; i < nr; i++) { + /* copy all "info" fields */ + save_dive_info_changes(get_dive(indices[i]), &info); + /* copy the cylinders / weightsystems */ + update_equipment_data(get_dive(indices[i]), dive); + /* this is extremely inefficient... it loops through all + dives to find the right one - but we KNOW the index already */ + flush_divelist(get_dive(indices[i])); + } gtk_widget_destroy(dialog); return success; } +int edit_dive_info(struct dive *dive) +{ + int idx; + + if (!dive) + return 0; + idx = dive->number; + return edit_multi_dive_info(1, &idx); +} + static GtkWidget *frame_box(GtkWidget *vbox, const char *fmt, ...) { va_list ap; diff --git a/main.c b/main.c index 60f2902e6..8e579f88c 100644 --- a/main.c +++ b/main.c @@ -190,7 +190,7 @@ void update_dive(struct dive *new_dive) } if (new_dive) { show_dive_info(new_dive); - show_dive_equipment(new_dive); + show_dive_equipment(new_dive, W_IDX_PRIMARY); show_dive_stats(new_dive); } buffered_dive = new_dive; -- cgit v1.2.3-70-g09d2 From 9cb36850303f8ce6c031926512aad3fc2d800889 Mon Sep 17 00:00:00 2001 From: Pierre-Yves Chibon Date: Tue, 17 Jul 2012 16:49:27 +0200 Subject: Add a 'Save As' entry in the menu. Add a "Save As" entry in the "File" menu allowing the user to specify the file in which to save the data. This is useful as we no longer offer this option through the "Save" entry while the data had been opened from an existing file. Signed-off-by: Pierre-Yves Chibon --- display-gtk.h | 2 ++ gtk-gui.c | 26 ++++++++++++++++++++++++++ 2 files changed, 28 insertions(+) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 059c6aa23..1f143077e 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -31,9 +31,11 @@ typedef enum { #if defined __APPLE__ #define CTRLCHAR "" +#define SHIFTCHAR "" #define PREFERENCE_ACCEL "comma" #else #define CTRLCHAR "" +#define SHIFTCHAR "" #define PREFERENCE_ACCEL NULL #endif diff --git a/gtk-gui.c b/gtk-gui.c index a969e9552..02463d91e 100644 --- a/gtk-gui.c +++ b/gtk-gui.c @@ -197,6 +197,30 @@ static void file_save(GtkWidget *w, gpointer data) } } +static void file_save_as(GtkWidget *w, gpointer data) +{ + GtkWidget *dialog; + char *filename; + dialog = gtk_file_chooser_dialog_new("Save File As", + GTK_WINDOW(main_window), + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); + + gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), existing_filename); + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + } + gtk_widget_destroy(dialog); + + if (filename){ + save_dives(filename); + mark_divelist_changed(FALSE); + } +} + static gboolean ask_save_changes() { GtkWidget *dialog, *label, *content; @@ -666,6 +690,7 @@ static GtkActionEntry menu_items[] = { { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL}, { "OpenFile", GTK_STOCK_OPEN, NULL, CTRLCHAR "O", NULL, G_CALLBACK(file_open) }, { "SaveFile", GTK_STOCK_SAVE, NULL, CTRLCHAR "S", NULL, G_CALLBACK(file_save) }, + { "SaveAsFile", GTK_STOCK_SAVE_AS, NULL, SHIFTCHAR CTRLCHAR "S", NULL, G_CALLBACK(file_save_as) }, { "Print", GTK_STOCK_PRINT, NULL, CTRLCHAR "P", NULL, G_CALLBACK(do_print) }, { "Import", NULL, "Import", NULL, NULL, G_CALLBACK(import_dialog) }, { "AddDive", NULL, "Add Dive", NULL, NULL, G_CALLBACK(add_dive_cb) }, @@ -687,6 +712,7 @@ static const gchar* ui_string = " \ \ \ \ + \ \ \ \ -- cgit v1.2.3-70-g09d2 From 972669d6363c163ed6d3b737cbd6b1bd534f3d7b Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Mon, 20 Aug 2012 05:48:07 -0700 Subject: Rework dive selection logic This completely changes how we keep track of selected dives: instead of having an array listing the selection ("selectiontracker") or trusting the gtk selection information, just save the information about whether a dive is selected in the dive itself. That makes it trivial to keep track of the state of selection across group collapse/expand events, or when changing the tree view model. It also ends up simplifying the code and logic in other ways. HOWEVER, it does currently (re-)introduce an annoying oddity with gtk: if you collapse a dive trip that has individual selections, gtk will forget those selections ("out of sight, out of mind"), and when you do *new* selections, the old hidden ones remain. So there's some games required to make gtk do sane things. We may need to either explicitly drop selections when collapsing trips, or make sure the group entry gets selected when collapsing a group that has selections in it. Or something. There may be other issues introduced by this too. Signed-off-by: Linus Torvalds --- display-gtk.h | 2 +- dive.h | 4 +- divelist.c | 306 ++++++++++++++++++++++++++-------------------------------- info.c | 54 +++++------ profile.c | 1 - statistics.c | 21 ++-- 6 files changed, 175 insertions(+), 213 deletions(-) (limited to 'display-gtk.h') diff --git a/display-gtk.h b/display-gtk.h index 1f143077e..dd7e2c4a0 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -77,7 +77,7 @@ extern GtkWidget *dive_list_create(void); unsigned int amount_selected; -extern void process_selected_dives(GList *, int *, GtkTreeModel *); +extern void process_selected_dives(void); typedef void (*data_func_t)(GtkTreeViewColumn *col, GtkCellRenderer *renderer, diff --git a/dive.h b/dive.h index 41f427a2c..cc27ab861 100644 --- a/dive.h +++ b/dive.h @@ -236,6 +236,7 @@ struct event { struct dive { int number; + int selected; time_t when; char *location; char *notes; @@ -284,7 +285,6 @@ struct dive_table { extern struct dive_table dive_table; -extern int *selectiontracker; extern int selected_dive; #define current_dive (get_dive(selected_dive)) @@ -355,7 +355,7 @@ extern void evn_foreach(void (*callback)(const char *, int *, void *), void *dat extern int add_new_dive(struct dive *dive); extern int edit_dive_info(struct dive *dive); -extern int edit_multi_dive_info(int nr, int *indices); +extern int edit_multi_dive_info(int idx); extern void dive_list_update_dives(void); extern void flush_divelist(struct dive *dive); diff --git a/divelist.c b/divelist.c index 0cb03f326..1c475afea 100644 --- a/divelist.c +++ b/divelist.c @@ -78,85 +78,21 @@ 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("currently selected are %d dives:", amount_selected); + for (i = 0; (dive = get_dive(i)) != NULL; i++) { + if (dive->selected) + printf(" %d", 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; - } - 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 -} - -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 DIVE_INDEX) */ @@ -177,97 +113,137 @@ 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) -{ - int i, nr_children; - gboolean expanded = FALSE; - GtkTreeIter parent; - GtkTreePath *tpath; - - 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); - } - } -} - /* 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) { + GtkTreeIter child; + 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 (!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)); } -/* 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 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(); + if (!gtk_tree_model_get_iter(model, &iter, path)) + 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 */ + /* 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 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); - } +static void select_dive(struct dive *dive, int selected) +{ + if (dive->selected != selected) { + amount_selected += selected ? 1 : -1; + dive->selected = selected; } - /* allow this selection to proceed */ - return TRUE; +} + +/* + * 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 (!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) + break; + + 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; + } + 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(); } @@ -1098,7 +1074,7 @@ 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(-1); } static void expand_all_cb(GtkWidget *menuitem, GtkTreeView *tree_view) @@ -1161,8 +1137,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; @@ -1170,20 +1144,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; } @@ -1236,20 +1217,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); @@ -1328,7 +1298,7 @@ GtkWidget *dive_list_create(void) g_signal_connect(dive_list.tree_view, "row-expanded", G_CALLBACK(row_expanded_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); diff --git a/info.c b/info.c index adc6c5902..468f35772 100644 --- a/info.c +++ b/info.c @@ -166,7 +166,7 @@ static int delete_dive_info(struct dive *dive) static void info_menu_edit_cb(GtkMenuItem *menuitem, gpointer user_data) { - edit_multi_dive_info(amount_selected, selectiontracker); + edit_multi_dive_info(-1); } static void info_menu_delete_cb(GtkMenuItem *menuitem, gpointer user_data) @@ -489,15 +489,14 @@ void update_equipment_data(struct dive *dive, struct dive *master) memcpy(dive->weightsystem, master->weightsystem, WS_BYTES); } -int edit_multi_dive_info(int nr, int *indices) +/* A negative index means "all selected" */ +int edit_multi_dive_info(int index) { - int success, i; + int success; GtkWidget *dialog, *vbox; struct dive_info info; struct dive *master; - if (!nr) - return 0; dialog = gtk_dialog_new_with_buttons("Dive Info", GTK_WINDOW(main_window), GTK_DIALOG_DESTROY_WITH_PARENT, @@ -506,34 +505,31 @@ int edit_multi_dive_info(int nr, int *indices) NULL); vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); - /* SCARY STUFF - IS THIS THE BEST WAY TO DO THIS??? - * - * current_dive is one of our selected dives - and that is - * the one that is used to pre-fill the edit widget. Its - * data is used as the starting point for all selected dives - * I think it would be better to somehow collect and combine - * info from all the selected dives */ - master = current_dive; - dive_info_widget(vbox, master, &info, (nr > 1)); + master = get_dive(index); + if (!master) + master = current_dive; + dive_info_widget(vbox, master, &info, index < 0); show_dive_equipment(master, W_IDX_SECONDARY); save_equipment_data(master); gtk_widget_show_all(dialog); success = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT; if (success) { - /* Update the other non-current dives first */ - for (i = 0; i < nr; i++) { - int idx = indices[i]; - struct dive *dive = get_dive(idx); - - if (!dive || dive == master) - continue; - /* copy all "info" fields */ - save_dive_info_changes(dive, master, &info); - /* copy the cylinders / weightsystems */ - update_equipment_data(dive, master); - /* this is extremely inefficient... it loops through all - dives to find the right one - but we KNOW the index already */ - flush_divelist(dive); + /* Update the non-current selected dives first */ + if (index < 0) { + int i; + struct dive *dive; + + for (i = 0; (dive = get_dive(i)) != NULL; i++) { + if (dive == master || !dive->selected) + continue; + /* copy all "info" fields */ + save_dive_info_changes(dive, master, &info); + /* copy the cylinders / weightsystems */ + update_equipment_data(dive, master); + /* this is extremely inefficient... it loops through all + dives to find the right one - but we KNOW the index already */ + flush_divelist(dive); + } } /* Update the master dive last! */ @@ -553,7 +549,7 @@ int edit_dive_info(struct dive *dive) if (!dive) return 0; idx = dive->number; - return edit_multi_dive_info(1, &idx); + return edit_multi_dive_info(idx); } static GtkWidget *frame_box(GtkWidget *vbox, const char *fmt, ...) diff --git a/profile.c b/profile.c index d3362432e..9618c4680 100644 --- a/profile.c +++ b/profile.c @@ -14,7 +14,6 @@ #include "color.h" int selected_dive = 0; -int *selectiontracker; typedef enum { STABLE, SLOW, MODERATE, FAST, CRAZY } velocity_t; diff --git a/statistics.c b/statistics.c index 0f6fbe047..0a23f9022 100644 --- a/statistics.c +++ b/statistics.c @@ -143,24 +143,21 @@ static void process_all_dives(struct dive *dive, struct dive **prev_dive) } /* make sure we skip the selected summary entries */ -void process_selected_dives(GList *selected_dives, int *selectiontracker, GtkTreeModel *model) +void process_selected_dives(void) { - struct dive *dp; - unsigned int i; - int idx; + struct dive *dive; + unsigned int i, nr; memset(&stats_selection, 0, sizeof(stats_selection)); - for (i = 0; i < amount_selected; ++i) { - idx = selectiontracker[i]; - if (idx > 0) { - dp = get_dive(idx); - if (dp) { - process_dive(dp, &stats_selection); - } + nr = 0; + for (i = 0; (dive = get_dive(i)) != NULL; ++i) { + if (dive->selected) { + process_dive(dive, &stats_selection); + nr++; } } - stats_selection.selection_size = amount_selected; + stats_selection.selection_size = nr; } static void set_label(GtkWidget *w, const char *fmt, ...) -- cgit v1.2.3-70-g09d2