From e315abf645bbca8eb3cee7d6688db8b088c14cba Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 21 Aug 2012 22:04:24 -0700 Subject: First cut of explicit trip tracking This code establishes the explicit trip data structures and loads and saves them in the XML data. No attempts are made to edit / modify the trips, yet. Loading XML files without trip data creates the trips based on timing as before. Saving out the same, unmodified data will create 'trip' entries in the XML file with a 'number' that reflects the number of dives in that trip. The trip tag also stores the beginning time of the first dive in the trip and the location of the trip (which we display in the summary entries in the UI). The logic allows for dives that aren't part of a dive trip. All other dives simply belong to the "previous" dive trip - i.e. the dive trip with the latest start time that is earlier or equal to the start time of this dive. This logic significantly simplifies the tracking of trips compared to other approaches that I have tried. The automatic grouping into trips now is an option that defaults to off (as it makes changes to the XML file - and people who don't want this feature shouldn't have trips added to their XML files that they then need to manually remove). For now you have to select this option, then exit the program and start it again. Still to do is to trigger the trip generation at run time. We also need a way to mark dives as not part of trips and to allow options to combine trips, split trips, edit trip location data, etc. The code has only had some limited testing when opening multiple files. The code is known to fail if a location name contains unquoted special characters like an "'". This commit also fixes a visual inconsistency in the preferences dialog where the font selector button didn't have a frame around it that told you what this option was about. Inspired-by: Linus Torvalds Signed-off-by: Dirk Hohndel --- parse-xml.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 61 insertions(+), 1 deletion(-) (limited to 'parse-xml.c') diff --git a/parse-xml.c b/parse-xml.c index 173314dd4..00538dad9 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -39,6 +39,11 @@ void record_dive(struct dive *dive) dive_table.nr = nr+1; } +void record_trip(struct dive *trip) +{ + dive_trip_list = INSERT_TRIP(trip, dive_trip_list); +} + static void delete_dive_renumber(struct dive **dives, int i, int nr) { struct dive *dive = dives[i]; @@ -156,7 +161,7 @@ const struct units IMPERIAL_units = { /* * Dive info as it is being built up.. */ -static struct dive *cur_dive; +static struct dive *cur_dive, *cur_trip = NULL; static struct sample *cur_sample; static struct { int active; @@ -535,6 +540,17 @@ static void get_index(char *buffer, void *_i) free(buffer); } +static void get_tripflag(char *buffer, void *_tf) +{ + tripflag_t *tf = _tf; + tripflag_t i; + + *tf = TF_NONE; + for (i = NO_TRIP; i < NUM_TRIPFLAGS; i++) + if(! strcmp(buffer, tripflag_names[i])) + *tf = i; +} + static void centibar(char *buffer, void *_pressure) { pressure_t *pressure = _pressure; @@ -1062,6 +1078,8 @@ static void try_to_fill_dive(struct dive **divep, const char *name, char *buf) if (MATCH(".number", get_index, &dive->number)) return; + if (MATCH(".tripflag", get_tripflag, &dive->tripflag)) + return; if (MATCH(".date", divedate, &dive->when)) return; if (MATCH(".time", divetime, &dive->when)) @@ -1138,6 +1156,27 @@ static void try_to_fill_dive(struct dive **divep, const char *name, char *buf) nonmatch("dive", name, buf); } +/* We're in the top-level trip xml. Try to convert whatever value to a trip value */ +static void try_to_fill_trip(struct dive **divep, const char *name, char *buf) +{ + int len = strlen(name); + + start_match("trip", name, buf); + + struct dive *dive = *divep; + + if (MATCH(".date", divedate, &dive->when)) { + dive->when = utc_mktime(&cur_tm); + return; + } + if (MATCH(".location", utf8_string, &dive->location)) + return; + if (MATCH(".notes", utf8_string, &dive->notes)) + return; + + nonmatch("trip", name, buf); +} + /* * File boundaries are dive boundaries. But sometimes there are * multiple dives per file, so there can be other events too that @@ -1162,6 +1201,22 @@ static void dive_end(void) cur_ws_index = 0; } +static void trip_start(void) +{ + if (cur_trip) + return; + cur_trip = alloc_dive(); + memset(&cur_tm, 0, sizeof(cur_tm)); +} + +static void trip_end(void) +{ + if (!cur_trip) + return; + record_trip(cur_trip); + cur_trip = NULL; +} + static void event_start(void) { memset(&cur_event, 0, sizeof(cur_event)); @@ -1225,6 +1280,10 @@ static void entry(const char *name, int size, const char *raw) try_to_fill_sample(cur_sample, name, buf); return; } + if (cur_trip) { + try_to_fill_trip(&cur_trip, name, buf); + return; + } if (cur_dive) { try_to_fill_dive(&cur_dive, name, buf); return; @@ -1350,6 +1409,7 @@ static struct nesting { } nesting[] = { { "dive", dive_start, dive_end }, { "Dive", dive_start, dive_end }, + { "trip", trip_start, trip_end }, { "sample", sample_start, sample_end }, { "waypoint", sample_start, sample_end }, { "SAMPLE", sample_start, sample_end }, -- cgit v1.2.3-70-g09d2 From 9cf961249e197d6d8a3656968ce15dfd19e3ef3b Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Mon, 27 Aug 2012 15:29:40 -0700 Subject: Fix an issue with trips that have dives from multiple input files The existing code didn't handle the case of different trips for the same date coming from different sources. It also got confused if the first dive processed (which is, chronologically, the last dive) happened to be a "NOTRIP" dive. This commit adds a bit of debugging infrastructure for the trip handling, too. Signed-off-by: Dirk Hohndel --- dive.h | 33 ++++++++++++++++++++++++++++++++- divelist.c | 9 +++++---- parse-xml.c | 2 +- 3 files changed, 38 insertions(+), 6 deletions(-) (limited to 'parse-xml.c') diff --git a/dive.h b/dive.h index 65b812b06..a715ea249 100644 --- a/dive.h +++ b/dive.h @@ -278,9 +278,40 @@ static inline int dive_date_cmp(gconstpointer _a, gconstpointer _b) { return ((struct dive *)(_a))->when - ((struct dive *)(_b))->when; } -#define INSERT_TRIP(_trip, _list) g_list_insert_sorted((_list), (_trip), dive_date_cmp) #define FIND_TRIP(_trip, _list) g_list_find_custom((_list), (_trip), dive_date_cmp) +#ifdef DEBUG_TRIP +static void dump_trip_list(void) +{ + GList *p = NULL; + int i=0; + while ((p = NEXT_TRIP(p, dive_trip_list))) { + struct tm *tm = gmtime(&DIVE_TRIP(p)->when); + printf("trip %d to \"%s\" on %04u-%02u-%02u\n", ++i, DIVE_TRIP(p)->location, + tm->tm_year + 1900, tm->tm_mon+1, tm->tm_mday); + } + printf("-----\n"); +} +#endif + +/* insert the trip into the list - but ensure you don't have two trips + * for the same date; but if you have, make sure you don't keep the + * one with less information */ +static inline GList *insert_trip(struct dive *_trip, GList *_list) +{ + GList *result = FIND_TRIP(_trip, _list); + if (result) { + if (! DIVE_TRIP(result)->location) + DIVE_TRIP(result)->location = _trip->location; + } else { + result = g_list_insert_sorted((_list), (_trip), dive_date_cmp); + } +#ifdef DEBUG_TRIP + dump_trip_list(); +#endif + return result; +} + /* * We keep our internal data in well-specified units, but * the input and output may come in some random format. This diff --git a/divelist.c b/divelist.c index a3bb1fb5e..83161b8c5 100644 --- a/divelist.c +++ b/divelist.c @@ -893,8 +893,6 @@ static void fill_dive_list(void) /* if we have pre-existing trips, start on the last one */ trip = g_list_last(dive_trip_list); - if (trip) - dive_trip = DIVE_TRIP(trip); treestore = GTK_TREE_STORE(dive_list.treemodel); liststore = GTK_TREE_STORE(dive_list.listmodel); @@ -911,6 +909,9 @@ static void fill_dive_list(void) DIVE_LOCATION, dive_trip->location, -1); } + /* the dive_trip info might have been killed by a previous UNGROUPED dive */ + if (trip) + dive_trip = DIVE_TRIP(trip); /* tripflag defines how dives are handled; * TF_NONE "not handled yet" - create time based group if autogroup == TRUE * NO_TRIP "set as no group" - simply leave at top level @@ -925,7 +926,7 @@ static void fill_dive_list(void) /* allocate new trip - all fields default to 0 and get filled in further down */ dive_trip = alloc_dive(); - dive_trip_list = INSERT_TRIP(dive_trip, dive_trip_list); + dive_trip_list = insert_trip(dive_trip, dive_trip_list); trip = FIND_TRIP(dive_trip, dive_trip_list); } } else { /* either the dive has a trip or we aren't creating trips */ @@ -938,7 +939,7 @@ static void fill_dive_list(void) * Otherwise we need to create a new trip */ if (autogroup) { dive_trip = alloc_dive(); - dive_trip_list = INSERT_TRIP(dive_trip, dive_trip_list); + dive_trip_list = insert_trip(dive_trip, dive_trip_list); trip = FIND_TRIP(dive_trip, dive_trip_list); } else { /* let's go back to the last valid trip */ diff --git a/parse-xml.c b/parse-xml.c index 00538dad9..b70f15444 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -41,7 +41,7 @@ void record_dive(struct dive *dive) void record_trip(struct dive *trip) { - dive_trip_list = INSERT_TRIP(trip, dive_trip_list); + dive_trip_list = insert_trip(trip, dive_trip_list); } static void delete_dive_renumber(struct dive **dives, int i, int nr) -- cgit v1.2.3-70-g09d2