From 18b8247cb357a9a716846854e451e306b752e542 Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 1 Nov 2011 11:39:52 -0700 Subject: [PATCH 1/6] Add new helper function to get temperature and unit Designed along the lines of get_depth_units - except we don't define a specific number of digits to show. Use this in the one spot we need it right now in profile.c Signed-off-by: Dirk Hohndel --- dive.c | 17 +++++++++++++++++ dive.h | 1 + profile.c | 14 ++++---------- 3 files changed, 22 insertions(+), 10 deletions(-) diff --git a/dive.c b/dive.c index ed3908928..c913e9476 100644 --- a/dive.c +++ b/dive.c @@ -29,6 +29,23 @@ void add_event(struct dive *dive, int time, int type, int flags, int value, cons remember_event(name); } +double get_temp_units(unsigned int mk, const char **units) +{ + double deg; + const char *unit; + + if (output_units.temperature == FAHRENHEIT) { + deg = mkelvin_to_F(mk); + unit = UTF8_DEGREE "F"; + } else { + deg = mkelvin_to_C(mk); + unit = UTF8_DEGREE "C"; + } + if (units) + *units = unit; + return deg; +} + double get_depth_units(unsigned int mm, int *frac, const char **units) { int decimals; diff --git a/dive.h b/dive.h index 58b6611f8..97654dc52 100644 --- a/dive.h +++ b/dive.h @@ -87,6 +87,7 @@ typedef struct { } cylinder_t; extern double get_depth_units(unsigned int mm, int *frac, const char **units); +extern double get_temp_units(unsigned int mm, const char **units); static inline double mm_to_feet(int mm) { diff --git a/profile.c b/profile.c index a7ea885a1..f81ae7138 100644 --- a/profile.c +++ b/profile.c @@ -485,19 +485,13 @@ static int setup_temperature_limits(struct graphics_context *gc, struct plot_inf static void plot_single_temp_text(struct graphics_context *gc, int sec, int mkelvin) { - int deg; + double deg; const char *unit; static const text_render_options_t tro = {12, 0.2, 0.2, 1.0, LEFT, TOP}; - temperature_t temperature = { mkelvin }; - if (output_units.temperature == FAHRENHEIT) { - deg = to_F(temperature); - unit = UTF8_DEGREE "F"; - } else { - deg = to_C(temperature); - unit = UTF8_DEGREE "C"; - } - plot_text(gc, &tro, sec, temperature.mkelvin, "%d%s", deg, unit); + deg = get_temp_units(mkelvin, &unit); + + plot_text(gc, &tro, sec, mkelvin, "%d%s", (int)(deg + 0.5), unit); } static void plot_temperature_text(struct graphics_context *gc, struct plot_info *pi) From a487f6c9314f0fe5e4173b670d9653067285da21 Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 1 Nov 2011 19:56:14 -0700 Subject: [PATCH 2/6] More consistency improvements Treat SAC and OTU consistently: - SAC is now a member of struct dive - it's calculated / populated at the same time with a helper function with consistent API Create get_volume_units function that returns volumes (e.g. used in SAC rates) based on preferred units - make sure we have these conversions just once in the code. Signed-off-by: Dirk Hohndel --- dive.c | 25 +++++++++++++++++++++++++ dive.h | 8 +++++++- divelist.c | 14 ++++++-------- 3 files changed, 38 insertions(+), 9 deletions(-) diff --git a/dive.c b/dive.c index c913e9476..53a874b9b 100644 --- a/dive.c +++ b/dive.c @@ -46,6 +46,31 @@ double get_temp_units(unsigned int mk, const char **units) return deg; } +double get_volume_units(unsigned int ml, int *frac, const char **units) +{ + int decimals; + double vol; + const char *unit; + + switch (output_units.volume) { + case LITER: + vol = ml / 1000.0; + unit = "l"; + decimals = 1; + break; + case CUFT: + vol = ml_to_cuft(ml); + unit = "cuft"; + decimals = 2; + break; + } + if (frac) + *frac = decimals; + if (units) + *units = unit; + return vol; +} + double get_depth_units(unsigned int mm, int *frac, const char **units) { int decimals; diff --git a/dive.h b/dive.h index 97654dc52..5eec6f170 100644 --- a/dive.h +++ b/dive.h @@ -87,8 +87,14 @@ typedef struct { } cylinder_t; 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); +static inline double ml_to_cuft(int ml) +{ + return ml / 28317.0; +} + static inline double mm_to_feet(int mm) { return mm * 0.00328084; @@ -177,7 +183,7 @@ struct dive { depth_t visibility; temperature_t airtemp, watertemp; cylinder_t cylinder[MAX_CYLINDERS]; - int otu; + int sac, otu; struct event *events; int samples, alloc_samples; struct sample sample[]; diff --git a/divelist.c b/divelist.c index 3ddfb6582..ca984b4eb 100644 --- a/divelist.c +++ b/divelist.c @@ -315,23 +315,22 @@ static double calculate_airuse(struct dive *dive) return airuse; } -static void get_sac(struct dive *dive, int *val) +static int calculate_sac(struct dive *dive) { double airuse, pressure, sac; - *val = 0; airuse = calculate_airuse(dive); if (!airuse) - return; + return 0; if (!dive->duration.seconds) - return; + return 0; /* Mean pressure in atm: 1 atm per 10m */ pressure = 1 + (dive->meandepth.mm / 10000.0); sac = airuse / pressure * 60 / dive->duration.seconds; /* milliliters per minute.. */ - *val = sac * 1000; + return sac * 1000; } static void get_string(char **str, const char *s) @@ -364,12 +363,10 @@ static void fill_one_dive(struct dive *dive, GtkTreeModel *model, GtkTreeIter *iter) { - int sac; char *location, *cylinder; get_cylinder(dive, &cylinder); get_location(dive, &location); - get_sac(dive, &sac); /* * We only set the fields that changed: the strings. @@ -379,7 +376,7 @@ static void fill_one_dive(struct dive *dive, DIVE_NR, dive->number, DIVE_LOCATION, location, DIVE_CYLINDER, cylinder, - DIVE_SAC, sac, + DIVE_SAC, dive->sac, DIVE_OTU, dive->otu, -1); } @@ -471,6 +468,7 @@ static void fill_dive_list(void) struct dive *dive = dive_table.dives[i]; dive->otu = calculate_otu(dive); + dive->sac = calculate_sac(dive); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, DIVE_INDEX, i, From b26ca781b87371e77b851298093b0a7136be64fa Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 1 Nov 2011 20:13:14 -0700 Subject: [PATCH 3/6] Use unit functions to get column headers, add unit function for pressure Finally getting more consistent overall in how we convert between the different units and how we decide which units to display. Signed-off-by: Dirk Hohndel --- dive.c | 24 ++++++++++++++++++++++++ dive.h | 7 +++++++ divelist.c | 21 ++------------------- profile.c | 21 +-------------------- 4 files changed, 34 insertions(+), 39 deletions(-) diff --git a/dive.c b/dive.c index 53a874b9b..cb94e7925 100644 --- a/dive.c +++ b/dive.c @@ -29,6 +29,30 @@ void add_event(struct dive *dive, int time, int type, int flags, int value, cons remember_event(name); } +int get_pressure_units(unsigned int mb, const char **units) +{ + int pressure; + const char* unit; + + switch (output_units.pressure) { + case PASCAL: + pressure = mb * 100; + unit = "pascal"; + break; + case BAR: + pressure = (mb + 500) / 1000; + unit = "bar"; + break; + case PSI: + pressure = mbar_to_PSI(mb); + unit = "psi"; + break; + } + if (units) + *units = unit; + return pressure; +} + double get_temp_units(unsigned int mk, const char **units) { double deg; diff --git a/dive.h b/dive.h index 5eec6f170..fe4515ee6 100644 --- a/dive.h +++ b/dive.h @@ -86,6 +86,7 @@ typedef struct { pressure_t start, end; } cylinder_t; +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); @@ -146,6 +147,12 @@ static inline double to_ATM(pressure_t pressure) return pressure.mbar / 1013.25; } +static inline int mbar_to_PSI(int mbar) +{ + pressure_t p = {mbar}; + return to_PSI(p); +} + struct sample { duration_t time; depth_t depth; diff --git a/divelist.c b/divelist.c index ca984b4eb..acaf08d38 100644 --- a/divelist.c +++ b/divelist.c @@ -420,27 +420,10 @@ void update_dive_list_units(void) const char *unit; GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model); - switch (output_units.length) { - case METERS: - unit = "m"; - break; - case FEET: - unit = "ft"; - break; - } + (void) get_depth_units(0, NULL, &unit); gtk_tree_view_column_set_title(dive_list.depth, unit); - switch (output_units.temperature) { - case CELSIUS: - unit = UTF8_DEGREE "C"; - break; - case FAHRENHEIT: - unit = UTF8_DEGREE "F"; - break; - case KELVIN: - unit = "Kelvin"; - break; - } + (void) get_temp_units(0, &unit); gtk_tree_view_column_set_title(dive_list.temperature, unit); gtk_tree_model_foreach(model, set_one_dive, NULL); diff --git a/profile.c b/profile.c index f81ae7138..7caa5da9f 100644 --- a/profile.c +++ b/profile.c @@ -611,32 +611,13 @@ static void plot_cylinder_pressure(struct graphics_context *gc, struct plot_info plot_pressure_helper(gc, pi, INTERPOLATED_PR); } -static int mbar_to_PSI(int mbar) -{ - pressure_t p = {mbar}; - return to_PSI(p); -} - static void plot_pressure_value(struct graphics_context *gc, int mbar, int sec, int xalign, int yalign) { int pressure; const char *unit; - switch (output_units.pressure) { - case PASCAL: - pressure = mbar * 100; - unit = "pascal"; - break; - case BAR: - pressure = (mbar + 500) / 1000; - unit = "bar"; - break; - case PSI: - pressure = mbar_to_PSI(mbar); - unit = "psi"; - break; - } + pressure = get_pressure_units(mbar, &unit); text_render_options_t tro = {10, 0.2, 1.0, 0.2, xalign, yalign}; plot_text(gc, &tro, sec, mbar, "%d %s", pressure, unit); } From 56980579514f2900e43441b483e435b3e3235266 Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 1 Nov 2011 21:00:46 -0700 Subject: [PATCH 4/6] Further cleanup of pressure and volume conversions I'm amazed at how many spots we were doing conversions - some of them subtly different than others. Signed-off-by: Dirk Hohndel --- dive.h | 16 +++++++++++++++- equipment.c | 44 +++++++++++++++++++++++--------------------- 2 files changed, 38 insertions(+), 22 deletions(-) diff --git a/dive.h b/dive.h index fe4515ee6..783d640a0 100644 --- a/dive.h +++ b/dive.h @@ -91,9 +91,19 @@ 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); +static inline double bar_to_atm(double bar) +{ + return bar / 1.01325; +} + static inline double ml_to_cuft(int ml) { - return ml / 28317.0; + return ml / 28316.8466; +} + +static inline double cuft_to_ml(double cuft) +{ + return cuft * 28.3168466; } static inline double mm_to_feet(int mm) @@ -137,6 +147,10 @@ static inline int to_K(temperature_t temp) return (temp.mkelvin + 499)/1000; } +static inline double psi_to_bar(double psi) +{ + return psi / 14.5037738; +} static inline int to_PSI(pressure_t pressure) { return pressure.mbar * 0.0145037738 + 0.5; diff --git a/equipment.c b/equipment.c index 12f39ae3f..64a05d5b0 100644 --- a/equipment.c +++ b/equipment.c @@ -49,18 +49,19 @@ struct cylinder_widget { GtkWidget *o2, *gasmix_button; }; +/* we want bar - so let's not use our unit functions */ static int convert_pressure(int mbar, double *p) { int decimals = 1; double pressure; - pressure = mbar / 1000.0; - if (mbar) { - if (output_units.pressure == PSI) { - pressure *= 14.5037738; /* Bar to PSI */ - decimals = 0; - } + if (output_units.pressure == PSI) { + pressure = mbar_to_PSI(mbar); + decimals = 0; + } else { + pressure = mbar / 1000.0; } + *p = pressure; return decimals; } @@ -70,17 +71,18 @@ static int convert_volume_pressure(int ml, int mbar, double *v, double *p) int decimals = 1; double volume, pressure; - volume = ml / 1000.0; - pressure = mbar / 1000.0; if (mbar) { if (output_units.volume == CUFT) { - volume /= 28.3168466; /* Liters to cuft */ - volume *= pressure / 1.01325; - } + volume = ml_to_cuft(ml); + volume *= bar_to_atm(mbar / 1000.0); + } else + volume = ml / 1000.0; + if (output_units.pressure == PSI) { - pressure *= 14.5037738; /* Bar to PSI */ + pressure = mbar_to_PSI(mbar); decimals = 0; - } + } else + pressure = mbar / 1000.0; } *v = volume; *p = pressure; @@ -352,14 +354,14 @@ static void fill_cylinder_info(struct cylinder_widget *cylinder, cylinder_t *cyl int mbar, ml; if (output_units.pressure == PSI) { - pressure /= 14.5037738; - start /= 14.5037738; - end /= 14.5037738; + pressure = psi_to_bar(pressure); + start = psi_to_bar(start); + end = psi_to_bar(end); } if (pressure && output_units.volume == CUFT) { - volume *= 28.3168466; /* CUFT to liter */ - volume /= pressure / 1.01325; + volume = cuft_to_ml(volume); + volume /= bar_to_atm(pressure); } ml = volume * 1000 + 0.5; @@ -461,9 +463,9 @@ static void fill_tank_list(GtkListStore *store) /* Is it in cuft and psi? */ if (psi) { - double bar = 0.0689475729 * psi; - double airvolume = 28316.8466 * size; - double atm = bar / 1.01325; + double bar = psi_to_bar(psi); + double airvolume = cuft_to_ml(size); + double atm = bar_to_atm(bar); ml = airvolume / atm + 0.5; mbar = bar*1000 + 0.5; From 485b02937d8ca1f9a9043c89e74a3d2f15d6426b Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Tue, 1 Nov 2011 21:12:21 -0700 Subject: [PATCH 5/6] Even more places with pressure and volume conversions Amazing at how many spots we are re-implementing the wheel. Signed-off-by: Dirk Hohndel --- dive.h | 12 ++++++------ divelist.c | 5 ++--- equipment.c | 4 ++-- parse-xml.c | 9 +++++---- uemis.c | 2 +- 5 files changed, 16 insertions(+), 16 deletions(-) diff --git a/dive.h b/dive.h index 783d640a0..b5a42d3e2 100644 --- a/dive.h +++ b/dive.h @@ -91,17 +91,12 @@ 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); -static inline double bar_to_atm(double bar) -{ - return bar / 1.01325; -} - static inline double ml_to_cuft(int ml) { return ml / 28316.8466; } -static inline double cuft_to_ml(double cuft) +static inline double cuft_to_l(double cuft) { return cuft * 28.3168466; } @@ -156,6 +151,11 @@ static inline int to_PSI(pressure_t pressure) return pressure.mbar * 0.0145037738 + 0.5; } +static inline double bar_to_atm(double bar) +{ + return bar / 1.01325; +} + static inline double to_ATM(pressure_t pressure) { return pressure.mbar / 1013.25; diff --git a/divelist.c b/divelist.c index acaf08d38..2d04eb5b0 100644 --- a/divelist.c +++ b/divelist.c @@ -223,7 +223,6 @@ static void sac_data_func(GtkTreeViewColumn *col, gpointer data) { int value; - const double liters_per_cuft = 28.317; const char *fmt; char buffer[16]; double sac; @@ -242,7 +241,7 @@ static void sac_data_func(GtkTreeViewColumn *col, break; case CUFT: fmt = "%4.2f"; - sac /= liters_per_cuft; + sac = ml_to_cuft(sac * 1000); break; } snprintf(buffer, sizeof(buffer), fmt, sac); @@ -307,7 +306,7 @@ static double calculate_airuse(struct dive *dive) if (!size) continue; - kilo_atm = (cyl->start.mbar - cyl->end.mbar) / 1013250.0; + kilo_atm = (to_ATM(cyl->start) - to_ATM(cyl->end)) / 1000.0; /* Liters of air at 1 atm == milliliters at 1k atm*/ airuse += kilo_atm * size; diff --git a/equipment.c b/equipment.c index 64a05d5b0..c7a683b89 100644 --- a/equipment.c +++ b/equipment.c @@ -360,7 +360,7 @@ static void fill_cylinder_info(struct cylinder_widget *cylinder, cylinder_t *cyl } if (pressure && output_units.volume == CUFT) { - volume = cuft_to_ml(volume); + volume = cuft_to_l(volume); volume /= bar_to_atm(pressure); } @@ -464,7 +464,7 @@ static void fill_tank_list(GtkListStore *store) /* Is it in cuft and psi? */ if (psi) { double bar = psi_to_bar(psi); - double airvolume = cuft_to_ml(size); + double airvolume = cuft_to_l(size) * 1000.0; double atm = bar_to_atm(bar); ml = airvolume / atm + 0.5; diff --git a/parse-xml.c b/parse-xml.c index c44b6f6ae..5eabc353c 100644 --- a/parse-xml.c +++ b/parse-xml.c @@ -425,7 +425,7 @@ static void water_pressure(char *buffer, void *_depth) if (!val.fp) break; /* cbar to atm */ - atm = (val.fp / 100) / 1.01325; + atm = bar_to_atm(val.fp * 10); /* * atm to cm. Why not mm? The precision just isn't * there. @@ -1122,9 +1122,9 @@ static void match_standard_cylinder(cylinder_type_t *type) if (type->description) return; - cuft = type->size.mliter / 28317.0; + cuft = ml_to_cuft(type->size.mliter); cuft *= to_ATM(type->workingpressure); - psi = type->workingpressure.mbar / 68.95; + psi = to_PSI(type->workingpressure); switch (psi) { case 2300 ... 2500: /* 2400 psi: LP tank */ @@ -1177,7 +1177,8 @@ static void sanitize_cylinder_type(cylinder_type_t *type) return; if (input_units.volume == CUFT || import_source == SUUNTO) { - volume_of_air = type->size.mliter * 28.317; /* milli-cu ft to milliliter */ + /* confusing - we don't really start from ml but millicuft !*/ + volume_of_air = cuft_to_l(type->size.mliter); atm = to_ATM(type->workingpressure); /* working pressure in atm */ volume = volume_of_air / atm; /* milliliters at 1 atm: "true size" */ type->size.mliter = volume + 0.5; diff --git a/uemis.c b/uemis.c index f55407b4b..86b186043 100644 --- a/uemis.c +++ b/uemis.c @@ -86,7 +86,7 @@ static int pressure_to_depth(uint16_t value) { double atm, cm; - atm = (value / 100.0) / 1.01325; + atm = bar_to_atm(value / 100.0); cm = 100 * atm + 0.5; return( (cm > 0) ? 10 * (long)cm : 0); } From 619ab9e828d4db7b0c4089018b09892c9d04ece9 Mon Sep 17 00:00:00 2001 From: Dirk Hohndel Date: Wed, 2 Nov 2011 09:10:57 -0700 Subject: [PATCH 6/6] Add Info & Stats page to the notebook This provides the relevant information for the currently selected dive plus a bunch of statistics over all dives in the dive_table. The visual design has lots of room for improvement - right now the different fields change size - it might be nice to have a more modern look for the entries - the O2/He field is odd - for most divers the He value will always be 0, so maybe we should only show He if there's at least one dive that uses He? Also, we simply do a comma separated list of gases for all the tanks used Signed-off-by: Dirk Hohndel --- Makefile | 5 +- display-gtk.h | 1 + dive.h | 2 + gtk-gui.c | 5 + main.c | 1 + statistics.c | 277 ++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 290 insertions(+), 1 deletion(-) create mode 100644 statistics.c diff --git a/Makefile b/Makefile index ab7df0003..20cbf8a57 100644 --- a/Makefile +++ b/Makefile @@ -81,7 +81,7 @@ LIBS = $(LIBXML2) $(LIBGTK) $(LIBDIVECOMPUTER) -lpthread OBJS = main.o dive.o profile.o info.o equipment.o divelist.o \ parse-xml.o save-xml.o libdivecomputer.o print.o uemis.o \ - gtk-gui.o $(RESFILE) + gtk-gui.o statistics.o $(RESFILE) $(NAME): $(OBJS) $(CC) $(LDFLAGS) -o $(NAME) $(OBJS) $(LIBS) @@ -136,6 +136,9 @@ info.o: info.c dive.h display.h display-gtk.h divelist.h equipment.o: equipment.c dive.h display.h divelist.h $(CC) $(CFLAGS) $(GTK2CFLAGS) $(GLIB2CFLAGS) -c equipment.c +statistics.o: statistics.c dive.h display.h divelist.h + $(CC) $(CFLAGS) $(GTK2CFLAGS) $(GLIB2CFLAGS) -c statistics.c + divelist.o: divelist.c dive.h display.h divelist.h $(CC) $(CFLAGS) $(GTK2CFLAGS) $(GLIB2CFLAGS) -c divelist.c diff --git a/display-gtk.h b/display-gtk.h index fb2b9af5b..3f1ff0dd6 100644 --- a/display-gtk.h +++ b/display-gtk.h @@ -33,6 +33,7 @@ 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 *stats_widget(void); extern GtkWidget *dive_list_create(void); diff --git a/dive.h b/dive.h index b5a42d3e2..2fae0c92e 100644 --- a/dive.h +++ b/dive.h @@ -259,6 +259,8 @@ extern void flush_dive_info_changes(struct dive *); extern void show_dive_equipment(struct dive *); extern void flush_dive_equipment_changes(struct dive *); +extern void show_dive_stats(struct dive *); + extern void update_dive(struct dive *new_dive); extern void save_dives(const char *filename); diff --git a/gtk-gui.c b/gtk-gui.c index b16050838..dd79f7311 100644 --- a/gtk-gui.c +++ b/gtk-gui.c @@ -746,6 +746,7 @@ void init_ui(int argc, char **argv) GtkWidget *dive_info; GtkWidget *dive_list; GtkWidget *equipment; + GtkWidget *stats; GtkWidget *menubar; GtkWidget *vbox; GdkScreen *screen; @@ -875,6 +876,10 @@ void init_ui(int argc, char **argv) equipment = equipment_widget(); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), equipment, gtk_label_new("Equipment")); + /* Frame for dive statistics */ + stats = stats_widget(); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), stats, gtk_label_new("Info & Stats")); + gtk_widget_set_app_paintable(win, TRUE); gtk_widget_show_all(win); diff --git a/main.c b/main.c index 5fed4cd6e..680bf2171 100644 --- a/main.c +++ b/main.c @@ -193,6 +193,7 @@ void update_dive(struct dive *new_dive) if (new_dive) { show_dive_info(new_dive); show_dive_equipment(new_dive); + show_dive_stats(new_dive); } buffered_dive = new_dive; } diff --git a/statistics.c b/statistics.c new file mode 100644 index 000000000..845bc2a03 --- /dev/null +++ b/statistics.c @@ -0,0 +1,277 @@ +/* statistics.c */ +/* creates the UI for the Info & Stats page - + * controlled through the following interfaces: + * + * void show_dive_stats(struct dive *dive) + * void flush_dive_stats_changes(struct dive *dive) + * + * called from gtk-ui: + * GtkWidget *stats_widget(void) + */ +#include +#include +#include +#include +#include + +#include "dive.h" +#include "display.h" +#include "display-gtk.h" +#include "divelist.h" + +typedef struct { + GtkWidget *date, + *dive_time, + *surf_intv, + *max_depth, + *avg_depth, + *water_temp, + *sac, + *otu, + *o2he, + *gas_used, + *total_time, + *avg_time, + *max_overall_depth, + *avg_overall_depth, + *min_sac, + *avg_sac, + *max_sac; +} info_stat_widget_t; + +static info_stat_widget_t info_stat_w; + +typedef struct { + duration_t total_time; + /* avg_time is simply total_time / nr -- let's not keep this */ + depth_t max_depth; + depth_t avg_depth; + volume_t max_sac; + volume_t min_sac; + volume_t avg_sac; +} info_stat_t; + +static info_stat_t info_stat; + +static void process_all_dives(struct dive *dive, struct dive **prev_dive) +{ + int idx; + struct dive *dp; + int old_tt, sac_time = 0; + + *prev_dive = NULL; + memset(&info_stat, 0, sizeof(info_stat)); + /* this relies on the fact that the dives in the dive_table + * are in chronological order */ + for (idx = 0; idx < dive_table.nr; idx++) { + dp = dive_table.dives[idx]; + if (dp->when == dive->when) { + /* that's the one we are showing */ + if (idx > 0) + *prev_dive = dive_table.dives[idx-1]; + } + old_tt = info_stat.total_time.seconds; + info_stat.total_time.seconds += dp->duration.seconds; + if (dp->maxdepth.mm > info_stat.max_depth.mm) + info_stat.max_depth.mm = dp->maxdepth.mm; + info_stat.avg_depth.mm = (1.0 * old_tt * info_stat.avg_depth.mm + + dp->duration.seconds * dp->meandepth.mm) / info_stat.total_time.seconds; + if (dp->sac > 0) { + int old_sac_time = sac_time; + sac_time += dp->duration.seconds; + info_stat.avg_sac.mliter = (1.0 * old_sac_time * info_stat.avg_sac.mliter + + dp->duration.seconds * dp->sac) / sac_time ; + if (dp->sac > info_stat.max_sac.mliter) + info_stat.max_sac.mliter = dp->sac; + if (info_stat.min_sac.mliter == 0 || dp->sac < info_stat.max_sac.mliter) + info_stat.min_sac.mliter = dp->sac; + } + } +} + +static void set_label(GtkWidget *w, const char *fmt, ...) +{ + char buf[80]; + va_list args; + + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + gtk_label_set_text(GTK_LABEL(w), buf); +} + +static char * get_time_string(int seconds, int maxdays) +{ + static char buf[80]; + if (maxdays && seconds > 3600 * 24 * maxdays) + snprintf(buf, sizeof(buf), "more than %d days", maxdays); + else { + int days = seconds / 3600 / 24; + int hours = (seconds - days * 3600 * 24) / 3600; + int minutes = (seconds - days * 3600 * 24 - hours * 3600) / 60; + if (days > 0) + snprintf(buf, sizeof(buf), "%dd %dh %dmin", days, hours, minutes); + else + snprintf(buf, sizeof(buf), "%dh %dmin", hours, minutes); + } + return buf; +} + +void show_dive_stats(struct dive *dive) +{ + char buf[80]; + double value; + int decimals; + const char *unit; + int idx, offset, gas_used; + struct dive *prev_dive; + + process_all_dives(dive, &prev_dive); + + strftime(buf, 80, "%a, %b %d, %Y, %k:%M", gmtime(&dive->when)); + set_label(info_stat_w.date, buf); + set_label(info_stat_w.dive_time, "%d min", (dive->duration.seconds + 30) / 60); + if (prev_dive) + set_label(info_stat_w.surf_intv, get_time_string(dive->when - prev_dive->when, 4)); + else + set_label(info_stat_w.surf_intv, "unknown"); + value = get_depth_units(dive->maxdepth.mm, &decimals, &unit); + set_label(info_stat_w.max_depth, "%.*f %s", decimals, value, unit); + value = get_depth_units(dive->meandepth.mm, &decimals, &unit); + set_label(info_stat_w.avg_depth, "%.*f %s", decimals, value, unit); + value = get_temp_units(dive->watertemp.mkelvin, &unit); + set_label(info_stat_w.water_temp, "%.1f %s", value, unit); + value = get_volume_units(dive->sac, &decimals, &unit); + if (value > 0) { + set_label(info_stat_w.sac, "%.*f %s/min", decimals, value, unit); + } else + set_label(info_stat_w.sac, ""); + set_label(info_stat_w.otu, "%d", dive->otu); + offset = 0; + gas_used = 0; + buf[0] = '\0'; + /* for the O2/He readings just create a list of them */ + for (idx = 0; idx < MAX_CYLINDERS; idx++) { + cylinder_t *cyl = &dive->cylinder[idx]; + /* we assume that every valid cylinder has either a working pressure + * or a size; but for good measure let's also accept cylinders with + * a starting or ending pressure*/ + if (cyl->type.workingpressure.mbar || cyl->type.size.mliter || + cyl->start.mbar || cyl->end.mbar) { + /* 0% O2 strangely means air, so 21% - I don't like that at all */ + int o2 = cyl->gasmix.o2.permille ? : 209; + if (offset > 0) { + snprintf(buf+offset, 80-offset, ", "); + offset += 2; + } + snprintf(buf+offset, 80-offset, "%d/%d", (o2 + 5) / 10, + (cyl->gasmix.he.permille + 5) / 10); + offset = strlen(buf); + } + /* and if we have size, start and end pressure, we can + * calculate the total gas used */ + if (cyl->type.size.mliter && cyl->start.mbar && cyl->end.mbar) + gas_used += cyl->type.size.mliter / 1000.0 * + (cyl->start.mbar - cyl->end.mbar); + } + if (offset) + set_label(info_stat_w.o2he, buf); + if (gas_used) { + value = get_volume_units(gas_used, &decimals, &unit); + set_label(info_stat_w.gas_used, "%.*f %s", decimals, value, unit); + } else + set_label(info_stat_w.gas_used, ""); + /* and now do the statistics */ + set_label(info_stat_w.total_time, get_time_string(info_stat.total_time.seconds, 0)); + set_label(info_stat_w.avg_time, get_time_string(info_stat.total_time.seconds / dive_table.nr, 0)); + value = get_depth_units(info_stat.max_depth.mm, &decimals, &unit); + set_label(info_stat_w.max_overall_depth, "%.*f %s", decimals, value, unit); + value = get_depth_units(info_stat.avg_depth.mm, &decimals, &unit); + set_label(info_stat_w.avg_overall_depth, "%.*f %s", decimals, value, unit); + value = get_volume_units(info_stat.max_sac.mliter, &decimals, &unit); + set_label(info_stat_w.max_sac, "%.*f %s/min", decimals, value, unit); + value = get_volume_units(info_stat.min_sac.mliter, &decimals, &unit); + set_label(info_stat_w.min_sac, "%.*f %s/min", decimals, value, unit); + value = get_volume_units(info_stat.avg_sac.mliter, &decimals, &unit); + set_label(info_stat_w.avg_sac, "%.*f %s/min", decimals, value, unit); +} + +void flush_dive_stats_changes(struct dive *dive) +{ + /* We do nothing: we require the "Ok" button press */ +} + +static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label) +{ + GtkWidget *label_widget; + GtkWidget *frame; + + frame = gtk_frame_new(label); + label_widget = gtk_label_new(NULL); + gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3); + gtk_container_add(GTK_CONTAINER(frame), label_widget); + + return label_widget; +} + +GtkWidget *stats_widget(void) +{ + + GtkWidget *vbox, *hbox, *infoframe, *statsframe, *framebox; + + vbox = gtk_vbox_new(FALSE, 3); + + infoframe = gtk_frame_new("Dive Info"); + gtk_box_pack_start(GTK_BOX(vbox), infoframe, TRUE, FALSE, 3); + framebox = gtk_vbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(infoframe), framebox); + + /* first row */ + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3); + + info_stat_w.date = new_info_label_in_frame(hbox, "Date"); + info_stat_w.dive_time = new_info_label_in_frame(hbox, "Dive Time"); + info_stat_w.surf_intv = new_info_label_in_frame(hbox, "Surf Intv"); + + /* second row */ + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3); + + info_stat_w.max_depth = new_info_label_in_frame(hbox, "Max Depth"); + info_stat_w.avg_depth = new_info_label_in_frame(hbox, "Avg Depth"); + info_stat_w.water_temp = new_info_label_in_frame(hbox, "Water Temp"); + + /* third row */ + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3); + + info_stat_w.sac = new_info_label_in_frame(hbox, "SAC"); + info_stat_w.otu = new_info_label_in_frame(hbox, "OTU"); + info_stat_w.o2he = new_info_label_in_frame(hbox, "O" UTF8_SUBSCRIPT_2 " / He"); + info_stat_w.gas_used = new_info_label_in_frame(hbox, "Gas Used"); + + statsframe = gtk_frame_new("Statistics"); + gtk_box_pack_start(GTK_BOX(vbox), statsframe, TRUE, FALSE, 3); + framebox = gtk_vbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(statsframe), framebox); + + /* first row */ + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3); + + info_stat_w.total_time = new_info_label_in_frame(hbox, "Total Time"); + info_stat_w.avg_time = new_info_label_in_frame(hbox, "Avg Time"); + info_stat_w.max_overall_depth = new_info_label_in_frame(hbox, "Max Depth"); + info_stat_w.avg_overall_depth = new_info_label_in_frame(hbox, "Avg Depth"); + + /* second row */ + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3); + + info_stat_w.max_sac = new_info_label_in_frame(hbox, "Max SAC"); + info_stat_w.min_sac = new_info_label_in_frame(hbox, "Min SAC"); + info_stat_w.avg_sac = new_info_label_in_frame(hbox, "Avg SAC"); + + return vbox; +}