mirror of
https://github.com/subsurface/subsurface.git
synced 2024-11-28 21:20:19 +00:00
935af9e8af
When diving in areas where there are risk of boats passing above you,
its common practise to do the last stop at 6m to better stay out of
harms way. When doing o2-deco, it doesn't matter for the deco time if
you are doing all the time at 6m, due to that you don't have any inert
gas in your breathing gas.
This code is a reintroduction of 0b8462bd lost somehow between
a70a8898..8fae0031
Signed-off-by: Anton Lundin <glance@acc.umu.se>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
456 lines
16 KiB
C
456 lines
16 KiB
C
/* planner.c
|
|
*
|
|
* code that allows us to plan future dives
|
|
*
|
|
* (c) Dirk Hohndel 2013
|
|
*/
|
|
#include <libintl.h>
|
|
#include <glib/gi18n.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include "dive.h"
|
|
#include "divelist.h"
|
|
#include "display-gtk.h"
|
|
#include "planner.h"
|
|
|
|
GtkWidget *planner, *planner_error_bar, *error_label;
|
|
|
|
static void on_error_bar_response(GtkWidget *widget, gint response, gpointer data)
|
|
{
|
|
if (response == GTK_RESPONSE_OK)
|
|
{
|
|
gtk_widget_destroy(widget);
|
|
planner_error_bar = NULL;
|
|
error_label = NULL;
|
|
}
|
|
}
|
|
|
|
static void show_error(const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
GError *error;
|
|
GtkWidget *box, *container;
|
|
gboolean bar_is_visible = TRUE;
|
|
|
|
va_start(args, fmt);
|
|
error = g_error_new_valist(g_quark_from_string("subsurface"), DIVE_ERROR_PLAN, fmt, args);
|
|
va_end(args);
|
|
if (!planner_error_bar) {
|
|
planner_error_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
|
|
g_signal_connect(planner_error_bar, "response", G_CALLBACK(on_error_bar_response), NULL);
|
|
gtk_info_bar_set_message_type(GTK_INFO_BAR(planner_error_bar), GTK_MESSAGE_ERROR);
|
|
bar_is_visible = FALSE;
|
|
}
|
|
container = gtk_info_bar_get_content_area(GTK_INFO_BAR(planner_error_bar));
|
|
if (error_label)
|
|
gtk_container_remove(GTK_CONTAINER(container), error_label);
|
|
error_label = gtk_label_new(error->message);
|
|
gtk_container_add(GTK_CONTAINER(container), error_label);
|
|
box = gtk_dialog_get_content_area(GTK_DIALOG(planner));
|
|
if (!bar_is_visible)
|
|
gtk_box_pack_start(GTK_BOX(box), planner_error_bar, FALSE, FALSE, 0);
|
|
gtk_widget_show_all(box);
|
|
/* make sure this actually gets shown BEFORE the calculations run */
|
|
while (gtk_events_pending())
|
|
gtk_main_iteration_do(FALSE);
|
|
}
|
|
|
|
|
|
static GtkWidget *add_entry_to_box(GtkWidget *box, const char *label)
|
|
{
|
|
GtkWidget *entry, *frame;
|
|
|
|
entry = gtk_entry_new();
|
|
gtk_entry_set_max_length(GTK_ENTRY(entry), 16);
|
|
if (label) {
|
|
frame = gtk_frame_new(label);
|
|
gtk_container_add(GTK_CONTAINER(frame), entry);
|
|
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
|
|
} else {
|
|
gtk_box_pack_start(GTK_BOX(box), entry, FALSE, FALSE, 2);
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
#define MAX_WAYPOINTS 12
|
|
GtkWidget *entry_depth[MAX_WAYPOINTS], *entry_duration[MAX_WAYPOINTS], *entry_gas[MAX_WAYPOINTS], *entry_po2[MAX_WAYPOINTS];
|
|
int nr_waypoints = 0;
|
|
static GtkListStore *gas_model = NULL;
|
|
|
|
static gboolean gas_focus_out_cb(GtkWidget *entry, GdkEvent *event, gpointer data)
|
|
{
|
|
const char *gastext;
|
|
int o2, he;
|
|
int idx = data - NULL;
|
|
char *error_string = NULL;
|
|
|
|
gastext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
o2 = he = 0;
|
|
if (validate_gas(gastext, &o2, &he))
|
|
add_string_list_entry(gastext, gas_model);
|
|
add_gas_to_nth_dp(&diveplan, idx, o2, he);
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
return FALSE;
|
|
}
|
|
|
|
static void gas_changed_cb(GtkWidget *combo, gpointer data)
|
|
{
|
|
const char *gastext;
|
|
int o2, he;
|
|
int idx = data - NULL;
|
|
char *error_string = NULL;
|
|
|
|
gastext = get_active_text(GTK_COMBO_BOX(combo));
|
|
/* stupidly this gets called for two reasons:
|
|
* a) any keystroke into the entry field
|
|
* b) mouse selection of a dropdown
|
|
* we only care about b) (a) is handled much better with the focus-out event)
|
|
* so let's check that the text returned is actually in our model before going on
|
|
*/
|
|
if (match_list(gas_model, gastext) != MATCH_EXACT)
|
|
return;
|
|
o2 = he = 0;
|
|
if (!validate_gas(gastext, &o2, &he)) {
|
|
/* this should never happen as only validated texts should be
|
|
* in the dropdown */
|
|
show_error(_("Invalid gas for row %d"),idx);
|
|
}
|
|
add_gas_to_nth_dp(&diveplan, idx, o2, he);
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
}
|
|
|
|
static gboolean depth_focus_out_cb(GtkWidget *entry, GdkEvent *event, gpointer data)
|
|
{
|
|
const char *depthtext;
|
|
int depth = -1;
|
|
int idx = data - NULL;
|
|
char *error_string = NULL;
|
|
|
|
depthtext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
|
|
if (validate_depth(depthtext, &depth)) {
|
|
if (depth > 150000)
|
|
show_error(_("Warning - planning very deep dives can take excessive amounts of time"));
|
|
add_depth_to_nth_dp(&diveplan, idx, depth);
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
} else {
|
|
/* it might be better to instead change the color of the input field or something */
|
|
if (depth == -1)
|
|
show_error(_("Invalid depth - could not parse \"%s\""), depthtext);
|
|
else
|
|
show_error(_("Invalid depth - values deeper than 400m not supported"));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean duration_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *durationtext;
|
|
int duration, is_rel;
|
|
int idx = data - NULL;
|
|
char *error_string = NULL;
|
|
|
|
durationtext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
if (validate_time(durationtext, &duration, &is_rel))
|
|
if (add_duration_to_nth_dp(&diveplan, idx, duration, is_rel) < 0)
|
|
show_error(_("Warning - extremely long dives can cause long calculation time"));
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean po2_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *po2text;
|
|
int po2;
|
|
int idx = data - NULL;
|
|
char *error_string = NULL;
|
|
|
|
po2text = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
if (validate_po2(po2text, &po2))
|
|
add_po2_to_nth_dp(&diveplan, idx, po2);
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean starttime_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *starttimetext;
|
|
int starttime, is_rel;
|
|
char *error_string = NULL;
|
|
|
|
starttimetext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
if (validate_time(starttimetext, &starttime, &is_rel)) {
|
|
/* we alway make this relative - either from the current time or from the
|
|
* end of the last dive, whichever is later */
|
|
timestamp_t cur = current_time_notz();
|
|
if (diveplan.lastdive_nr >= 0) {
|
|
struct dive *last_dive = get_dive(diveplan.lastdive_nr);
|
|
if (last_dive && last_dive->when + last_dive->dc.duration.seconds > cur)
|
|
cur = last_dive->when + last_dive->dc.duration.seconds;
|
|
}
|
|
diveplan.when = cur + starttime;
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
} else {
|
|
/* it might be better to instead change the color of the input field or something */
|
|
show_error(_("Invalid starttime"));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean surfpres_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *surfprestext;
|
|
char *error_string = NULL;
|
|
|
|
surfprestext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
diveplan.surface_pressure = atoi(surfprestext);
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean sac_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *sactext;
|
|
char *error_string = NULL;
|
|
|
|
sactext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
if (validate_volume(sactext, data)) {
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean gf_focus_out_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
const char *gftext;
|
|
int gf;
|
|
double *gfp = data;
|
|
char *error_string = NULL;
|
|
|
|
gftext = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
if (sscanf(gftext, "%d", &gf) == 1) {
|
|
*gfp = gf / 100.0;
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean last_stop_toggled_cb(GtkWidget *entry, GdkEvent * event, gpointer data)
|
|
{
|
|
char *error_string = NULL;
|
|
set_last_stop(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(entry)));
|
|
show_planned_dive(&error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
return FALSE;
|
|
}
|
|
|
|
static GtkWidget *add_gas_combobox_to_box(GtkWidget *box, const char *label, int idx)
|
|
{
|
|
GtkWidget *frame, *combo;
|
|
|
|
if (!gas_model) {
|
|
gas_model = gtk_list_store_new(1, G_TYPE_STRING);
|
|
add_string_list_entry(_("AIR"), gas_model);
|
|
add_string_list_entry(_("EAN32"), gas_model);
|
|
add_string_list_entry(_("EAN36"), gas_model);
|
|
}
|
|
combo = combo_box_with_model_and_entry(gas_model);
|
|
gtk_widget_add_events(combo, GDK_FOCUS_CHANGE_MASK);
|
|
g_signal_connect(gtk_bin_get_child(GTK_BIN(combo)), "focus-out-event", G_CALLBACK(gas_focus_out_cb), NULL + idx);
|
|
g_signal_connect(combo, "changed", G_CALLBACK(gas_changed_cb), NULL + idx);
|
|
if (label) {
|
|
frame = gtk_frame_new(label);
|
|
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
|
|
gtk_container_add(GTK_CONTAINER(frame), combo);
|
|
} else {
|
|
gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 2);
|
|
}
|
|
|
|
return combo;
|
|
}
|
|
|
|
static void add_waypoint_widgets(GtkWidget *box, int idx)
|
|
{
|
|
GtkWidget *hbox;
|
|
|
|
hbox = gtk_hbox_new(FALSE, 0);
|
|
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
|
|
if (idx == 0) {
|
|
entry_depth[idx] = add_entry_to_box(hbox, _("Ending Depth"));
|
|
entry_duration[idx] = add_entry_to_box(hbox, _("Segment Time"));
|
|
entry_gas[idx] = add_gas_combobox_to_box(hbox, C_("Type of","Gas Used"), idx);
|
|
entry_po2[idx] = add_entry_to_box(hbox, _("CC SetPoint"));
|
|
} else {
|
|
entry_depth[idx] = add_entry_to_box(hbox, NULL);
|
|
entry_duration[idx] = add_entry_to_box(hbox, NULL);
|
|
entry_gas[idx] = add_gas_combobox_to_box(hbox, NULL, idx);
|
|
entry_po2[idx] = add_entry_to_box(hbox, NULL);
|
|
}
|
|
gtk_widget_add_events(entry_depth[idx], GDK_FOCUS_CHANGE_MASK);
|
|
g_signal_connect(entry_depth[idx], "focus-out-event", G_CALLBACK(depth_focus_out_cb), NULL + idx);
|
|
gtk_widget_add_events(entry_duration[idx], GDK_FOCUS_CHANGE_MASK);
|
|
g_signal_connect(entry_duration[idx], "focus-out-event", G_CALLBACK(duration_focus_out_cb), NULL + idx);
|
|
gtk_widget_add_events(entry_po2[idx], GDK_FOCUS_CHANGE_MASK);
|
|
g_signal_connect(entry_po2[idx], "focus-out-event", G_CALLBACK(po2_focus_out_cb), NULL + idx);
|
|
}
|
|
|
|
static void add_waypoint_cb(GtkButton *button, gpointer _data)
|
|
{
|
|
GtkWidget *vbox = _data;
|
|
if (nr_waypoints < MAX_WAYPOINTS) {
|
|
GtkWidget *ovbox, *dialog;
|
|
add_waypoint_widgets(vbox, nr_waypoints);
|
|
nr_waypoints++;
|
|
ovbox = gtk_widget_get_parent(GTK_WIDGET(button));
|
|
dialog = gtk_widget_get_parent(ovbox);
|
|
gtk_widget_show_all(dialog);
|
|
} else {
|
|
show_error(_("Too many waypoints"));
|
|
}
|
|
}
|
|
|
|
static void add_entry_with_callback(GtkWidget *box, int length, char *label, char *initialtext,
|
|
gboolean (*callback)(GtkWidget *, GdkEvent *, gpointer), gpointer data)
|
|
{
|
|
GtkWidget *entry = add_entry_to_box(box, label);
|
|
gtk_entry_set_max_length(GTK_ENTRY(entry), length);
|
|
gtk_entry_set_text(GTK_ENTRY(entry), initialtext);
|
|
gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK);
|
|
g_signal_connect(entry, "focus-out-event", G_CALLBACK(callback), data);
|
|
}
|
|
|
|
/* set up the dialog where the user can input their dive plan */
|
|
void input_plan()
|
|
{
|
|
GtkWidget *content, *vbox, *hbox, *outervbox, *add_row, *label;
|
|
char *bottom_sac, *deco_sac, gflowstring[4], gfhighstring[4];
|
|
char *explanationtext = _("<small>Add segments below.\nEach line describes part of the planned dive.\n"
|
|
"An entry with depth, time and gas describes a segment that ends "
|
|
"at the given depth, takes the given time (if relative, e.g. '+3:30') "
|
|
"or ends at the given time (if absolute e.g '@5:00', 'runtime'), and uses the given gas.\n"
|
|
"An empty gas means 'use previous gas' (or AIR if no gas was specified).\n"
|
|
"An entry that has a depth and a gas given but no time is special; it "
|
|
"informs the planner that the gas specified is available for the ascent "
|
|
"once the depth given has been reached.\n"
|
|
"CC SetPoint specifies CC (rebreather) dives, leave empty for OC.</small>\n");
|
|
char *labeltext;
|
|
char *error_string = NULL;
|
|
int len;
|
|
|
|
disclaimer = _("DISCLAIMER / WARNING: THIS IS A NEW IMPLEMENTATION OF THE BUHLMANN "
|
|
"ALGORITHM AND A DIVE PLANNER IMPLEMENTION BASED ON THAT WHICH HAS "
|
|
"RECEIVED ONLY A LIMITED AMOUNT OF TESTING. WE STRONGLY RECOMMEND NOT TO "
|
|
"PLAN DIVES SIMPLY BASED ON THE RESULTS GIVEN HERE.");
|
|
if (diveplan.dp)
|
|
free_dps(diveplan.dp);
|
|
memset(&diveplan, 0, sizeof(diveplan));
|
|
diveplan.lastdive_nr = dive_table.nr - 1;
|
|
free(cache_data);
|
|
cache_data = NULL;
|
|
planned_dive = NULL;
|
|
planner = gtk_dialog_new_with_buttons(_("Dive Plan - THIS IS JUST A SIMULATION; DO NOT USE FOR DIVING"),
|
|
GTK_WINDOW(main_window),
|
|
GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
NULL);
|
|
content = gtk_dialog_get_content_area (GTK_DIALOG (planner));
|
|
outervbox = gtk_vbox_new(FALSE, 2);
|
|
gtk_container_add (GTK_CONTAINER (content), outervbox);
|
|
|
|
len = strlen(explanationtext) + strlen(disclaimer) + sizeof("<span foreground='red'></span>");
|
|
labeltext = malloc(len);
|
|
snprintf(labeltext, len, "%s<span foreground='red'>%s</span>", explanationtext, disclaimer);
|
|
label = gtk_label_new(labeltext);
|
|
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
|
|
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
|
|
gtk_label_set_width_chars(GTK_LABEL(label), 60);
|
|
gtk_box_pack_start(GTK_BOX(outervbox), label, TRUE, TRUE, 0);
|
|
vbox = gtk_vbox_new(FALSE, 0);
|
|
gtk_box_pack_start(GTK_BOX(outervbox), vbox, TRUE, TRUE, 0);
|
|
hbox = gtk_hbox_new(FALSE, 0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
|
|
add_entry_with_callback(hbox, 12, _("Dive starts when?"), "+60:00", starttime_focus_out_cb, NULL);
|
|
add_entry_with_callback(hbox, 12, _("Surface Pressure (mbar)"), SURFACE_PRESSURE_STRING, surfpres_focus_out_cb, NULL);
|
|
|
|
if (get_units()->length == METERS)
|
|
labeltext = _("Last stop at 6 Meters");
|
|
else
|
|
labeltext = _("Last stop at 20 Feet");
|
|
|
|
set_last_stop(FALSE);
|
|
content = gtk_check_button_new_with_label(labeltext);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(content), 0);
|
|
gtk_box_pack_start(GTK_BOX(hbox), content, FALSE, FALSE, 6);
|
|
g_signal_connect(G_OBJECT(content), "toggled", G_CALLBACK(last_stop_toggled_cb), NULL);
|
|
|
|
hbox = gtk_hbox_new(FALSE, 0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
|
|
if (get_units()->volume == CUFT) {
|
|
bottom_sac = _("0.7 cuft/min");
|
|
deco_sac = _("0.6 cuft/min");
|
|
diveplan.bottomsac = 1000 * cuft_to_l(0.7);
|
|
diveplan.decosac = 1000 * cuft_to_l(0.6);
|
|
} else {
|
|
bottom_sac = _("20 l/min");
|
|
deco_sac = _("17 l/min");
|
|
diveplan.bottomsac = 20000;
|
|
diveplan.decosac = 17000;
|
|
}
|
|
add_entry_with_callback(hbox, 12, _("SAC during dive"), bottom_sac, sac_focus_out_cb, &diveplan.bottomsac);
|
|
add_entry_with_callback(hbox, 12, _("SAC during decostop"), deco_sac, sac_focus_out_cb, &diveplan.decosac);
|
|
plangflow = prefs.gflow;
|
|
plangfhigh = prefs.gfhigh;
|
|
snprintf(gflowstring, sizeof(gflowstring), "%3.0f", 100 * plangflow);
|
|
snprintf(gfhighstring, sizeof(gflowstring), "%3.0f", 100 * plangfhigh);
|
|
add_entry_with_callback(hbox, 5, _("GFlow for plan"), gflowstring, gf_focus_out_cb, &plangflow);
|
|
add_entry_with_callback(hbox, 5, _("GFhigh for plan"), gfhighstring, gf_focus_out_cb, &plangfhigh);
|
|
diveplan.when = current_time_notz() + 3600;
|
|
diveplan.surface_pressure = SURFACE_PRESSURE;
|
|
nr_waypoints = 4;
|
|
add_waypoint_widgets(vbox, 0);
|
|
add_waypoint_widgets(vbox, 1);
|
|
add_waypoint_widgets(vbox, 2);
|
|
add_waypoint_widgets(vbox, 3);
|
|
add_row = gtk_button_new_with_label(_("Add waypoint"));
|
|
g_signal_connect(G_OBJECT(add_row), "clicked", G_CALLBACK(add_waypoint_cb), vbox);
|
|
gtk_box_pack_start(GTK_BOX(outervbox), add_row, FALSE, FALSE, 0);
|
|
gtk_widget_show_all(planner);
|
|
if (gtk_dialog_run(GTK_DIALOG(planner)) == GTK_RESPONSE_ACCEPT) {
|
|
plan(&diveplan, &cache_data, &planned_dive, &error_string);
|
|
if (error_string)
|
|
show_error(error_string);
|
|
mark_divelist_changed(TRUE);
|
|
} else {
|
|
if (planned_dive) {
|
|
/* we have added a dive during the dynamic construction
|
|
* in the dialog; get rid of it */
|
|
delete_single_dive(dive_table.nr - 1);
|
|
report_dives(FALSE, FALSE);
|
|
planned_dive = NULL;
|
|
}
|
|
}
|
|
gtk_widget_destroy(planner);
|
|
planner_error_bar = NULL;
|
|
error_label = NULL;
|
|
set_gf(prefs.gflow, prefs.gfhigh);
|
|
}
|