void DiveLogExportDialog::exportHTMLstatistics(const QString &filename)
{
QFile file(filename);
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
int i = 0;
out << "divestat=[";
while (stats_yearly != NULL && stats_yearly[i].period) {
out << "{";
out << "\"YEAR\":\"" << stats_yearly[i].period << "\",";
out << "\"DIVES\":\"" << stats_yearly[i].selection_size << "\",";
out << "\"TOTAL_TIME\":\"" << get_time_string(stats_yearly[i].total_time.seconds, 0) << "\",";
out << "\"AVERAGE_TIME\":\"" << get_minutes(stats_yearly[i].total_time.seconds / stats_yearly[i].selection_size) << "\",";
out << "\"SHORTEST_TIME\":\"" << get_minutes(stats_yearly[i].shortest_time.seconds) << "\",";
out << "\"LONGEST_TIME\":\"" << get_minutes(stats_yearly[i].longest_time.seconds) << "\",";
out << "\"AVG_DEPTH\":\"" << get_depth_string(stats_yearly[i].avg_depth) << "\",";
out << "\"MIN_DEPTH\":\"" << get_depth_string(stats_yearly[i].min_depth) << "\",";
out << "\"MAX_DEPTH\":\"" << get_depth_string(stats_yearly[i].max_depth) << "\",";
out << "\"AVG_SAC\":\"" << get_volume_string(stats_yearly[i].avg_sac) << "\",";
out << "\"MIN_SAC\":\"" << get_volume_string(stats_yearly[i].min_sac) << "\",";
out << "\"MAX_SAC\":\"" << get_volume_string(stats_yearly[i].max_sac) << "\",";
out << "\"AVG_TEMP\":\"" << QString::number(stats_yearly[i].combined_temp / stats_yearly[i].combined_count, 'f', 1) << "\",";
out << "\"MIN_TEMP\":\"" << get_temp_units(stats_yearly[i].min_temp, NULL) << "\",";
out << "\"MAX_TEMP\":\"" << get_temp_units(stats_yearly[i].max_temp, NULL) << "\",";
out << "},";
i++;
}
out << "]";
file.close();
}
static void process_interval_stats(stats_t stats_interval, GtkTreeIter *parent, GtkTreeIter *row)
{
double value;
const char *unit;
char value_str[40];
GtkTreeStore *store;
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(yearly_tree)));
/* Year or month */
snprintf(value_str, sizeof(value_str), "%d", stats_interval.period);
add_row_to_tree(store, value_str, 0, row, parent);
/* Dives */
snprintf(value_str, sizeof(value_str), "%d", stats_interval.selection_size);
add_cell_to_tree(store, value_str, 1, row);
/* Total duration */
add_cell_to_tree(store, get_time_string(stats_interval.total_time.seconds, 0), 2, row);
/* Average dive duration */
add_cell_to_tree(store, get_minutes(stats_interval.total_time.seconds / stats_interval.selection_size), 3, row);
/* Shortest duration */
add_cell_to_tree(store, get_minutes(stats_interval.shortest_time.seconds), 4, row);
/* Longest duration */
add_cell_to_tree(store, get_minutes(stats_interval.longest_time.seconds), 5, row);
/* Average depth */
add_cell(store, row, stats_interval.avg_depth.mm, 6, TRUE);
/* Smallest maximum depth */
add_cell(store, row, stats_interval.min_depth.mm, 7, TRUE);
/* Deepest maximum depth */
add_cell(store, row, stats_interval.max_depth.mm, 8, TRUE);
/* Average air consumption */
add_cell(store, row, stats_interval.avg_sac.mliter, 9, FALSE);
/* Smallest average air consumption */
add_cell(store, row, stats_interval.min_sac.mliter, 10, FALSE);
/* Biggest air consumption */
add_cell(store, row, stats_interval.max_sac.mliter, 11, FALSE);
/* Average water temperature */
value = get_temp_units(stats_interval.min_temp, &unit);
if (stats_interval.combined_temp && stats_interval.combined_count) {
snprintf(value_str, sizeof(value_str), "%.1f %s", stats_interval.combined_temp / (stats_interval.combined_count * 1.0), unit);
add_cell_to_tree(store, value_str, 12, row);
} else {
add_cell_to_tree(store, "", 12, row);
}
/* Coldest water temperature */
if (value > -100.0) {
snprintf(value_str, sizeof(value_str), "%.1f %s\t", value, unit);
add_cell_to_tree(store, value_str, 13, row);
} else {
add_cell_to_tree(store, "", 13, row);
}
/* Warmest water temperature */
value = get_temp_units(stats_interval.max_temp, &unit);
if (value > -100.0) {
snprintf(value_str, sizeof(value_str), "%.1f %s", value, unit);
add_cell_to_tree(store, value_str, 14, row);
} else {
add_cell_to_tree(store, "", 14, row);
}
}
QVariant YearStatisticsItem::data(int column, int role) const
{
double value;
QVariant ret;
if (role == Qt::FontRole) {
QFont font = defaultModelFont();
font.setBold(stats_interval.is_year);
return font;
} else if (role != Qt::DisplayRole) {
return ret;
}
switch(column) {
case YEAR:
if (stats_interval.is_trip) {
ret = stats_interval.location;
} else {
ret = stats_interval.period;
}
break;
case DIVES: ret = stats_interval.selection_size; break;
case TOTAL_TIME: ret = get_time_string(stats_interval.total_time.seconds, 0); break;
case AVERAGE_TIME: ret = get_minutes(stats_interval.total_time.seconds / stats_interval.selection_size); break;
case SHORTEST_TIME: ret = get_minutes(stats_interval.shortest_time.seconds); break;
case LONGEST_TIME: ret = get_minutes(stats_interval.longest_time.seconds); break;
case AVG_DEPTH: ret = get_depth_string(stats_interval.avg_depth); break;
case MIN_DEPTH: ret = get_depth_string(stats_interval.min_depth); break;
case MAX_DEPTH: ret = get_depth_string(stats_interval.max_depth); break;
case AVG_SAC: ret = get_volume_string(stats_interval.avg_sac); break;
case MIN_SAC: ret = get_volume_string(stats_interval.min_sac); break;
case MAX_SAC: ret = get_volume_string(stats_interval.max_sac); break;
case AVG_TEMP:
if (stats_interval.combined_temp && stats_interval.combined_count) {
ret = QString::number(stats_interval.combined_temp / stats_interval.combined_count, 'f', 1);
}
break;
case MIN_TEMP:
value = get_temp_units(stats_interval.min_temp, NULL);
if (value > -100.0)
ret = QString::number(value, 'f', 1);
break;
case MAX_TEMP:
value = get_temp_units(stats_interval.max_temp, NULL);
if (value > -100.0)
ret = QString::number(value, 'f', 1);
break;
}
return ret;
}
static void show_total_dive_stats(void)
{
double value;
int decimals, seconds;
const char *unit;
char buffer[60];
stats_t *stats_ptr;
if (!stats_w.framelabel)
return;
stats_ptr = &stats_selection;
get_selected_dives_text(buffer, sizeof(buffer));
set_label(stats_w.framelabel, _("Statistics %s"), buffer);
set_label(stats_w.selection_size, "%d", stats_ptr->selection_size);
if (stats_ptr->selection_size == 0) {
clear_stats_widgets();
return;
}
if (stats_ptr->min_temp) {
value = get_temp_units(stats_ptr->min_temp, &unit);
set_label(stats_w.min_temp, "%.1f %s", value, unit);
}
if (stats_ptr->combined_temp && stats_ptr->combined_count)
set_label(stats_w.avg_temp, "%.1f %s", stats_ptr->combined_temp / stats_ptr->combined_count, unit);
if (stats_ptr->max_temp) {
value = get_temp_units(stats_ptr->max_temp, &unit);
set_label(stats_w.max_temp, "%.1f %s", value, unit);
}
set_label(stats_w.total_time, get_time_string(stats_ptr->total_time.seconds, 0));
seconds = stats_ptr->total_time.seconds;
if (stats_ptr->selection_size)
seconds /= stats_ptr->selection_size;
set_label(stats_w.avg_time, get_time_string(seconds, 0));
set_label(stats_w.longest_time, get_time_string(stats_ptr->longest_time.seconds, 0));
set_label(stats_w.shortest_time, get_time_string(stats_ptr->shortest_time.seconds, 0));
value = get_depth_units(stats_ptr->max_depth.mm, &decimals, &unit);
set_label(stats_w.max_overall_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(stats_ptr->min_depth.mm, &decimals, &unit);
set_label(stats_w.min_overall_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(stats_ptr->avg_depth.mm, &decimals, &unit);
set_label(stats_w.avg_overall_depth, "%.*f %s", decimals, value, unit);
value = get_volume_units(stats_ptr->max_sac.mliter, &decimals, &unit);
set_label(stats_w.max_sac, _("%.*f %s/min"), decimals, value, unit);
value = get_volume_units(stats_ptr->min_sac.mliter, &decimals, &unit);
set_label(stats_w.min_sac, _("%.*f %s/min"), decimals, value, unit);
value = get_volume_units(stats_ptr->avg_sac.mliter, &decimals, &unit);
set_label(stats_w.avg_sac, _("%.*f %s/min"), decimals, value, unit);
}
static void process_temperatures(struct dive *dp, stats_t *stats)
{
int min_temp, mean_temp, max_temp = 0;
if (dp->maxtemp.mkelvin)
max_temp = dp->maxtemp.mkelvin;
else
max_temp = dp->dc.watertemp.mkelvin;
if (max_temp && (!stats->max_temp || max_temp > stats->max_temp))
stats->max_temp = max_temp;
if (dp->mintemp.mkelvin)
min_temp = dp->mintemp.mkelvin;
else
min_temp = dp->dc.watertemp.mkelvin;
if (min_temp && (!stats->min_temp || min_temp < stats->min_temp))
stats->min_temp = min_temp;
if (min_temp || max_temp) {
mean_temp = min_temp;
if (mean_temp)
mean_temp = (mean_temp + max_temp) / 2;
else
mean_temp = max_temp;
stats->combined_temp += get_temp_units(mean_temp, NULL);
stats->combined_count++;
}
}
void ProfileGraphicsView::plot_single_temp_text(int sec, int mkelvin)
{
double deg;
const char *unit;
static text_render_options_t tro = {TEMP_TEXT_SIZE, TEMP_TEXT, LEFT, TOP};
deg = get_temp_units(mkelvin, &unit);
plot_text(&tro, QPointF(sec, mkelvin), QString("%1%2").arg(deg, 0, 'f', 1).arg(unit)); //"%.2g%s"
}
void update_dive_list_units(void)
{
const char *unit;
GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model);
(void) get_depth_units(0, NULL, &unit);
gtk_tree_view_column_set_title(dive_list.depth, unit);
(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);
}
void DiveTemperatureItem::createTextItem(int sec, int mkelvin)
{
double deg;
const char *unit;
deg = get_temp_units(mkelvin, &unit);
DiveTextItem *text = new DiveTextItem(this);
text->setAlignment(Qt::AlignRight | Qt::AlignBottom);
text->setBrush(getColor(TEMP_TEXT));
text->setPos(QPointF(hAxis->posAtValue(sec), vAxis->posAtValue(mkelvin)));
text->setScale(0.8); // need to call this BEFORE setText()
text->setText(QString("%1%2").arg(deg, 0, 'f', 1).arg(unit));
texts.append(text);
}
static void process_dive(struct dive *dp, stats_t *stats)
{
int old_tt, sac_time = 0;
const char *unit;
old_tt = stats->total_time.seconds;
stats->total_time.seconds += dp->duration.seconds;
if (dp->duration.seconds > stats->longest_time.seconds)
stats->longest_time.seconds = dp->duration.seconds;
if (stats->shortest_time.seconds == 0 || dp->duration.seconds < stats->shortest_time.seconds)
stats->shortest_time.seconds = dp->duration.seconds;
if (dp->maxdepth.mm > stats->max_depth.mm)
stats->max_depth.mm = dp->maxdepth.mm;
if (stats->min_depth.mm == 0 || dp->maxdepth.mm < stats->min_depth.mm)
stats->min_depth.mm = dp->maxdepth.mm;
if (dp->watertemp.mkelvin) {
if (stats->min_temp == 0 || dp->watertemp.mkelvin < stats->min_temp)
stats->min_temp = dp->watertemp.mkelvin;
if (dp->watertemp.mkelvin > stats->max_temp)
stats->max_temp = dp->watertemp.mkelvin;
stats->combined_temp += get_temp_units(dp->watertemp.mkelvin, &unit);
stats->combined_count++;
}
/* Maybe we should drop zero-duration dives */
if (!dp->duration.seconds)
return;
stats->avg_depth.mm = (1.0 * old_tt * stats->avg_depth.mm +
dp->duration.seconds * dp->meandepth.mm) / stats->total_time.seconds;
if (dp->sac > 2800) { /* less than .1 cuft/min (2800ml/min) is bogus */
sac_time = stats->total_sac_time + dp->duration.seconds;
stats->avg_sac.mliter = (1.0 * stats->total_sac_time * stats->avg_sac.mliter +
dp->duration.seconds * dp->sac) / sac_time ;
if (dp->sac > stats->max_sac.mliter)
stats->max_sac.mliter = dp->sac;
if (stats->min_sac.mliter == 0 || dp->sac < stats->min_sac.mliter)
stats->min_sac.mliter = dp->sac;
stats->total_sac_time = sac_time;
}
}
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;
struct tm *tm;
process_all_dives(dive, &prev_dive);
tm = gmtime(&dive->when);
snprintf(buf, sizeof(buf),
"%s, %s %d, %d %2d:%02d",
weekday(tm->tm_wday),
monthname(tm->tm_mon),
tm->tm_mday, tm->tm_year + 1900,
tm->tm_hour, tm->tm_min);
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 + prev_dive->duration.seconds), 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);
if (dive->watertemp.mkelvin) {
value = get_temp_units(dive->watertemp.mkelvin, &unit);
set_label(info_stat_w.water_temp, "%.1f %s", value, unit);
} else
set_label(info_stat_w.water_temp, "");
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];
unsigned int start, end;
start = cyl->start.mbar ? : cyl->sample_start.mbar;
end = cyl->end.mbar ? : cyl->sample_end.mbar;
/* 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 || start || end) {
/* 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 && start && end)
gas_used += cyl->type.size.mliter / 1000.0 * (start - end);
}
static void plot_string(struct plot_info *pi, struct plot_data *entry, struct membuffer *b, bool has_ndl)
{
int pressurevalue, mod, ead, end, eadd;
const char *depth_unit, *pressure_unit, *temp_unit, *vertical_speed_unit;
double depthvalue, tempvalue, speedvalue, sacvalue;
int decimals;
const char *unit;
depthvalue = get_depth_units(entry->depth, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "@: %d:%02d\nD: %.1f%s\n"), FRACTION(entry->sec, 60), depthvalue, depth_unit);
if (GET_PRESSURE(entry)) {
pressurevalue = get_pressure_units(GET_PRESSURE(entry), &pressure_unit);
put_format(b, translate("gettextFromC", "P: %d%s\n"), pressurevalue, pressure_unit);
}
if (entry->temperature) {
tempvalue = get_temp_units(entry->temperature, &temp_unit);
put_format(b, translate("gettextFromC", "T: %.1f%s\n"), tempvalue, temp_unit);
}
speedvalue = get_vertical_speed_units(abs(entry->speed), NULL, &vertical_speed_unit);
/* Ascending speeds are positive, descending are negative */
if (entry->speed > 0)
speedvalue *= -1;
put_format(b, translate("gettextFromC", "V: %.1f%s\n"), speedvalue, vertical_speed_unit);
sacvalue = get_volume_units(entry->sac, &decimals, &unit);
if (entry->sac && prefs.show_sac)
put_format(b, translate("gettextFromC", "SAC: %.*f%s/min\n"), decimals, sacvalue, unit);
if (entry->cns)
put_format(b, translate("gettextFromC", "CNS: %u%%\n"), entry->cns);
if (prefs.pp_graphs.po2)
put_format(b, translate("gettextFromC", "pO%s: %.2fbar\n"), UTF8_SUBSCRIPT_2, entry->pressures.o2);
if (prefs.pp_graphs.pn2)
put_format(b, translate("gettextFromC", "pN%s: %.2fbar\n"), UTF8_SUBSCRIPT_2, entry->pressures.n2);
if (prefs.pp_graphs.phe)
put_format(b, translate("gettextFromC", "pHe: %.2fbar\n"), entry->pressures.he);
if (prefs.mod) {
mod = (int)get_depth_units(entry->mod, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "MOD: %d%s\n"), mod, depth_unit);
}
eadd = (int)get_depth_units(entry->eadd, NULL, &depth_unit);
if (prefs.ead) {
switch (pi->dive_type) {
case NITROX:
ead = (int)get_depth_units(entry->ead, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "EAD: %d%s\nEADD: %d%s\n"), ead, depth_unit, eadd, depth_unit);
break;
case TRIMIX:
end = (int)get_depth_units(entry->end, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "END: %d%s\nEADD: %d%s\n"), end, depth_unit, eadd, depth_unit);
break;
case AIR:
case FREEDIVING:
/* nothing */
break;
}
}
if (entry->stopdepth) {
depthvalue = get_depth_units(entry->stopdepth, NULL, &depth_unit);
if (entry->ndl) {
/* this is a safety stop as we still have ndl */
if (entry->stoptime)
put_format(b, translate("gettextFromC", "Safetystop: %umin @ %.0f%s\n"), DIV_UP(entry->stoptime, 60),
depthvalue, depth_unit);
else
put_format(b, translate("gettextFromC", "Safetystop: unkn time @ %.0f%s\n"),
depthvalue, depth_unit);
} else {
/* actual deco stop */
if (entry->stoptime)
put_format(b, translate("gettextFromC", "Deco: %umin @ %.0f%s\n"), DIV_UP(entry->stoptime, 60),
depthvalue, depth_unit);
else
put_format(b, translate("gettextFromC", "Deco: unkn time @ %.0f%s\n"),
depthvalue, depth_unit);
}
} else if (entry->in_deco) {
put_string(b, translate("gettextFromC", "In deco\n"));
} else if (has_ndl) {
put_format(b, translate("gettextFromC", "NDL: %umin\n"), DIV_UP(entry->ndl, 60));
}
if (entry->tts)
put_format(b, translate("gettextFromC", "TTS: %umin\n"), DIV_UP(entry->tts, 60));
if (entry->stopdepth_calc && entry->stoptime_calc) {
depthvalue = get_depth_units(entry->stopdepth_calc, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "Deco: %umin @ %.0f%s (calc)\n"), DIV_UP(entry->stoptime_calc, 60),
depthvalue, depth_unit);
} else if (entry->in_deco_calc) {
/* This means that we have no NDL left,
* and we have no deco stop,
* so if we just accend to the surface slowly
* (ascent_mm_per_step / ascent_s_per_step)
* everything will be ok. */
put_string(b, translate("gettextFromC", "In deco (calc)\n"));
} else if (prefs.calcndltts && entry->ndl_calc != 0) {
if(entry->ndl_calc < MAX_PROFILE_DECO)
put_format(b, translate("gettextFromC", "NDL: %umin (calc)\n"), DIV_UP(entry->ndl_calc, 60));
else
put_format(b, "%s", translate("gettextFromC", "NDL: >2h (calc)\n"));
}
if (entry->tts_calc) {
if (entry->tts_calc < MAX_PROFILE_DECO)
put_format(b, translate("gettextFromC", "TTS: %umin (calc)\n"), DIV_UP(entry->tts_calc, 60));
else
put_format(b, "%s", translate("gettextFromC", "TTS: >2h (calc)\n"));
}
if (entry->rbt)
put_format(b, translate("gettextFromC", "RBT: %umin\n"), DIV_UP(entry->rbt, 60));
if (entry->ceiling) {
depthvalue = get_depth_units(entry->ceiling, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "Calculated ceiling %.0f%s\n"), depthvalue, depth_unit);
if (prefs.calcalltissues) {
int k;
for (k = 0; k < 16; k++) {
if (entry->ceilings[k]) {
depthvalue = get_depth_units(entry->ceilings[k], NULL, &depth_unit);
put_format(b, translate("gettextFromC", "Tissue %.0fmin: %.1f%s\n"), buehlmann_N2_t_halflife[k], depthvalue, depth_unit);
}
}
}
}
if (entry->heartbeat && prefs.hrgraph)
put_format(b, translate("gettextFromC", "heartbeat: %d\n"), entry->heartbeat);
if (entry->bearing)
put_format(b, translate("gettextFromC", "bearing: %d\n"), entry->bearing);
if (entry->running_sum) {
depthvalue = get_depth_units(entry->running_sum / entry->sec, NULL, &depth_unit);
put_format(b, translate("gettextFromC", "mean depth to here %.1f%s\n"), depthvalue, depth_unit);
}
strip_mb(b);
}
static void show_single_dive_stats(struct dive *dive)
{
char buf[80];
double value;
int decimals;
const char *unit;
int idx, offset, gas_used;
struct dive *prev_dive;
struct tm tm;
process_all_dives(dive, &prev_dive);
utc_mkdate(dive->when, &tm);
snprintf(buf, sizeof(buf),
/*++GETTEXT 80 chars: weekday, monthname, day, year, hour, min */
_("%1$s, %2$s %3$d, %4$d %5$2d:%6$02d"),
weekday(tm.tm_wday),
monthname(tm.tm_mon),
tm.tm_mday, tm.tm_year + 1900,
tm.tm_hour, tm.tm_min);
set_label(single_w.date, buf);
set_label(single_w.dive_time, _("%d min"), (dive->duration.seconds + 30) / 60);
if (prev_dive)
set_label(single_w.surf_intv,
get_time_string(dive->when - (prev_dive->when + prev_dive->duration.seconds), 4));
else
set_label(single_w.surf_intv, _("unknown"));
value = get_depth_units(dive->maxdepth.mm, &decimals, &unit);
set_label(single_w.max_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(dive->meandepth.mm, &decimals, &unit);
set_label(single_w.avg_depth, "%.*f %s", decimals, value, unit);
if (dive->watertemp.mkelvin) {
value = get_temp_units(dive->watertemp.mkelvin, &unit);
set_label(single_w.water_temp, "%.1f %s", value, unit);
} else
set_label(single_w.water_temp, "");
value = get_volume_units(dive->sac, &decimals, &unit);
if (value > 0) {
set_label(single_w.sac, _("%.*f %s/min"), decimals, value, unit);
} else
set_label(single_w.sac, "");
set_label(single_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];
unsigned int start, end;
start = cyl->start.mbar ? : cyl->sample_start.mbar;
end = cyl->end.mbar ? : cyl->sample_end.mbar;
if (!cylinder_none(cyl)) {
/* 0% O2 strangely means air, so 21% - I don't like that at all */
int o2 = cyl->gasmix.o2.permille ? : AIR_PERMILLE;
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 && start && end)
gas_used += cyl->type.size.mliter / 1000.0 * (start - end);
}
void TabDiveStatistics::updateData()
{
clear();
ui->depthLimits->setMaximum(get_depth_string(stats_selection.max_depth, true));
if (amount_selected > 1)
ui->depthLimits->setMinimum(get_depth_string(stats_selection.min_depth, true));
else
ui->depthLimits->setMinimum("");
// the overall average depth is really confusing when listed between the
// deepest and shallowest dive - let's just not set it
// ui->depthLimits->setAverage(get_depth_string(stats_selection.avg_depth, true));
// Also hide the avgIco, so its clear that its not there.
ui->depthLimits->overrideAvgToolTipText("");
ui->depthLimits->setAvgVisibility(false);
if (stats_selection.max_sac.mliter && (stats_selection.max_sac.mliter != stats_selection.avg_sac.mliter))
ui->sacLimits->setMaximum(get_volume_string(stats_selection.max_sac, true).append(tr("/min")));
else
ui->sacLimits->setMaximum("");
if (stats_selection.min_sac.mliter && (stats_selection.min_sac.mliter != stats_selection.avg_sac.mliter))
ui->sacLimits->setMinimum(get_volume_string(stats_selection.min_sac, true).append(tr("/min")));
else
ui->sacLimits->setMinimum("");
if (stats_selection.avg_sac.mliter)
ui->sacLimits->setAverage(get_volume_string(stats_selection.avg_sac, true).append(tr("/min")));
else
ui->sacLimits->setAverage("");
temperature_t temp;
temp.mkelvin = stats_selection.max_temp;
ui->tempLimits->setMaximum(get_temperature_string(temp, true));
temp.mkelvin = stats_selection.min_temp;
ui->tempLimits->setMinimum(get_temperature_string(temp, true));
if (stats_selection.combined_temp && stats_selection.combined_count) {
const char *unit;
get_temp_units(0, &unit);
ui->tempLimits->setAverage(QString("%1%2").arg(stats_selection.combined_temp / stats_selection.combined_count, 0, 'f', 1).arg(unit));
}
ui->divesAllText->setText(QString::number(stats_selection.selection_size));
ui->totalTimeAllText->setText(get_dive_duration_string(stats_selection.total_time.seconds, tr("h"), tr("min"), tr("sec"),
" ", displayed_dive.dc.divemode == FREEDIVE));
int seconds = stats_selection.total_time.seconds;
if (stats_selection.selection_size)
seconds /= stats_selection.selection_size;
ui->timeLimits->setAverage(get_dive_duration_string(seconds, tr("h"), tr("min"), tr("sec"),
" ", displayed_dive.dc.divemode == FREEDIVE));
if (amount_selected > 1) {
ui->timeLimits->setMaximum(get_dive_duration_string(stats_selection.longest_time.seconds, tr("h"), tr("min"), tr("sec"),
" ", displayed_dive.dc.divemode == FREEDIVE));
ui->timeLimits->setMinimum(get_dive_duration_string(stats_selection.shortest_time.seconds, tr("h"), tr("min"), tr("sec"),
" ", displayed_dive.dc.divemode == FREEDIVE));
} else {
ui->timeLimits->setMaximum("");
ui->timeLimits->setMinimum("");
}
QVector<QPair<QString, int> > gasUsed;
QString gasUsedString;
volume_t vol;
selectedDivesGasUsed(gasUsed);
for (int j = 0; j < 20; j++) {
if (gasUsed.isEmpty())
break;
QPair<QString, int> gasPair = gasUsed.last();
gasUsed.pop_back();
vol.mliter = gasPair.second;
gasUsedString.append(gasPair.first).append(": ").append(get_volume_string(vol, true)).append("\n");
}
if (!gasUsed.isEmpty())
gasUsedString.append("...");
volume_t o2_tot = {}, he_tot = {};
selected_dives_gas_parts(&o2_tot, &he_tot);
/* No need to show the gas mixing information if diving
* with pure air, and only display the he / O2 part when
* it is used.
*/
if (he_tot.mliter || o2_tot.mliter) {
gasUsedString.append(tr("These gases could be\nmixed from Air and using:\n"));
if (he_tot.mliter) {
gasUsedString.append(tr("He"));
gasUsedString.append(QString(": %1").arg(get_volume_string(he_tot, true)));
}
if (he_tot.mliter && o2_tot.mliter)
gasUsedString.append(" ").append(tr("and")).append(" ");
if (o2_tot.mliter) {
gasUsedString.append(tr("O₂"));
gasUsedString.append(QString(": %2\n").arg(get_volume_string(o2_tot, true)));
}
}
ui->gasConsumption->setText(gasUsedString);
}
/* we try to show the data from the currently selected divecomputer
* right now for some values (e.g., surface pressure) we could fall back
* to dive data, but for consistency we don't. */
static void show_single_dive_stats(struct dive *dive)
{
char buf[256];
double value;
int decimals;
const char *unit;
int idx, offset, gas_used, mbar;
struct dive *prev_dive;
struct tm tm;
struct divecomputer *dc;
process_all_dives(dive, &prev_dive);
if (!dive)
return;
dc = select_dc(&dive->dc);
utc_mkdate(dive->when, &tm);
snprintf(buf, sizeof(buf),
/*++GETTEXT 80 chars: weekday, monthname, day, year, hour, min */
_("%1$s, %2$s %3$d, %4$d %5$2d:%6$02d"),
weekday(tm.tm_wday),
monthname(tm.tm_mon),
tm.tm_mday, tm.tm_year + 1900,
tm.tm_hour, tm.tm_min);
set_label(single_w.date, buf);
set_label(single_w.dive_time, _("%d min"), (dive->duration.seconds + 30) / 60);
if (prev_dive)
set_label(single_w.surf_intv,
get_time_string(dive->when - (prev_dive->when + prev_dive->duration.seconds), 4));
else
set_label(single_w.surf_intv, _("unknown"));
value = get_depth_units(dc->maxdepth.mm, &decimals, &unit);
set_label(single_w.max_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(dc->meandepth.mm, &decimals, &unit);
set_label(single_w.avg_depth, "%.*f %s", decimals, value, unit);
set_label(single_w.viz, star_strings[dive->visibility]);
if (dc->watertemp.mkelvin) {
value = get_temp_units(dc->watertemp.mkelvin, &unit);
set_label(single_w.water_temp, "%.1f %s", value, unit);
} else {
set_label(single_w.water_temp, "");
}
if (dc->airtemp.mkelvin) {
value = get_temp_units(dc->airtemp.mkelvin, &unit);
set_label(single_w.air_temp, "%.1f %s", value, unit);
} else {
if (dive->airtemp.mkelvin) {
value = get_temp_units(dive->airtemp.mkelvin, &unit);
set_label(single_w.air_temp, "%.1f %s", value, unit);
} else {
set_label(single_w.air_temp, "");
}
}
mbar = dc->surface_pressure.mbar;
/* it would be easy to get dive data here:
* if (!mbar)
* mbar = get_surface_pressure_in_mbar(dive, FALSE);
*/
if (mbar) {
set_label(single_w.air_press, "%d mbar", mbar);
} else {
set_label(single_w.air_press, "");
}
value = get_volume_units(dive->sac, &decimals, &unit);
if (value > 0)
set_label(single_w.sac, _("%.*f %s/min"), decimals, value, unit);
else
set_label(single_w.sac, "");
set_label(single_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];
pressure_t start, end;
start = cyl->start.mbar ? cyl->start : cyl->sample_start;
end = cyl->end.mbar ?cyl->sample_end : cyl->sample_end;
if (!cylinder_none(cyl)) {
/* 0% O2 strangely means air, so 21% - I don't like that at all */
int o2 = get_o2(&cyl->gasmix);
int he = get_he(&cyl->gasmix);
if (offset > 0) {
snprintf(buf+offset, 80-offset, ", ");
offset += 2;
}
snprintf(buf+offset, 80-offset, "%d/%d", (o2 + 5) / 10, (he + 5) / 10);
offset = strlen(buf);
}
/* and if we have size, start and end pressure, we can
* calculate the total gas used */
if (start.mbar && end.mbar)
gas_used += gas_volume(cyl, start) - gas_volume(cyl, end);
}
set_label(single_w.o2he, buf);
if (gas_used) {
value = get_volume_units(gas_used, &decimals, &unit);
set_label(single_w.gas_used, "%.*f %s", decimals, value, unit);
} else {
set_label(single_w.gas_used, "");
}
}
