X-Git-Url: http://git.tdb.fi/?p=ext%2Fsubsurface.git;a=blobdiff_plain;f=libdivecomputer.c;h=d96d2769f7391afb3bccebb64df1de5fd21a33e5;hp=7bea8e3a0ac6ce4b178e39b6358a82bb21ae1bb7;hb=HEAD;hpb=d45db9fac7b3d2ea0426a96158432f54d938f5c7 diff --git a/libdivecomputer.c b/libdivecomputer.c index 7bea8e3..d96d276 100644 --- a/libdivecomputer.c +++ b/libdivecomputer.c @@ -1,184 +1,152 @@ #include -#include +#include +#include +#include #include "dive.h" +#include "divelist.h" #include "display.h" +#include "display-gtk.h" -/* libdivecomputer */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "libdivecomputer.h" -/* - * I'd love to do a while-loop here for pending events, but - * that seems to screw up with the dive computer reading timing. - * - * I may need to spawn a new thread to do the computer - * reading stuff.. - */ -static int run_gtk_mainloop(void) -{ - return gtk_main_iteration_do(0); -} +/* Christ. Libdivecomputer has the worst configuration system ever. */ +#ifdef HW_FROG_H + #define NOT_FROG , 0 + #define LIBDIVECOMPUTER_SUPPORTS_FROG +#else + #define NOT_FROG +#endif -static void error(const char *fmt, ...) +static GError *error(const char *fmt, ...) { va_list args; GError *error; va_start(args, fmt); error = g_error_new_valist( - g_quark_from_string("divelog"), + g_quark_from_string("subsurface"), DIVE_ERROR_PARSE, fmt, args); va_end(args); - report_error(error); - g_error_free(error); + return error; } -typedef struct device_data_t { - device_type_t type; - const char *name, *devname; - GtkWidget *progressbar; - device_devinfo_t devinfo; - device_clock_t clock; -} device_data_t; - -static parser_status_t create_parser(device_data_t *devdata, parser_t **parser) +static dc_status_t create_parser(device_data_t *devdata, dc_parser_t **parser) { - switch (devdata->type) { - case DEVICE_TYPE_SUUNTO_SOLUTION: - return suunto_solution_parser_create(parser); - - case DEVICE_TYPE_SUUNTO_EON: - return suunto_eon_parser_create(parser, 0); - - case DEVICE_TYPE_SUUNTO_VYPER: - if (devdata->devinfo.model == 0x01) - return suunto_eon_parser_create(parser, 1); - return suunto_vyper_parser_create(parser); - - case DEVICE_TYPE_SUUNTO_VYPER2: - case DEVICE_TYPE_SUUNTO_D9: - return suunto_d9_parser_create(parser, devdata->devinfo.model); - - case DEVICE_TYPE_UWATEC_ALADIN: - case DEVICE_TYPE_UWATEC_MEMOMOUSE: - return uwatec_memomouse_parser_create(parser, devdata->clock.devtime, devdata->clock.systime); - - case DEVICE_TYPE_UWATEC_SMART: - return uwatec_smart_parser_create(parser, devdata->devinfo.model, devdata->clock.devtime, devdata->clock.systime); - - case DEVICE_TYPE_REEFNET_SENSUS: - return reefnet_sensus_parser_create(parser, devdata->clock.devtime, devdata->clock.systime); - - case DEVICE_TYPE_REEFNET_SENSUSPRO: - return reefnet_sensuspro_parser_create(parser, devdata->clock.devtime, devdata->clock.systime); - - case DEVICE_TYPE_REEFNET_SENSUSULTRA: - return reefnet_sensusultra_parser_create(parser, devdata->clock.devtime, devdata->clock.systime); - - case DEVICE_TYPE_OCEANIC_VTPRO: - return oceanic_vtpro_parser_create(parser); - - case DEVICE_TYPE_OCEANIC_VEO250: - return oceanic_veo250_parser_create(parser, devdata->devinfo.model); - - case DEVICE_TYPE_OCEANIC_ATOM2: - return oceanic_atom2_parser_create(parser, devdata->devinfo.model); - - case DEVICE_TYPE_MARES_NEMO: - case DEVICE_TYPE_MARES_PUCK: - return mares_nemo_parser_create(parser, devdata->devinfo.model); - - case DEVICE_TYPE_MARES_ICONHD: - return mares_iconhd_parser_create(parser); - - case DEVICE_TYPE_HW_OSTC: - return hw_ostc_parser_create(parser); - - case DEVICE_TYPE_CRESSI_EDY: - case DEVICE_TYPE_ZEAGLE_N2ITION3: - return cressi_edy_parser_create(parser, devdata->devinfo.model); - - case DEVICE_TYPE_ATOMICS_COBALT: - return atomics_cobalt_parser_create(parser); - - default: - return PARSER_STATUS_ERROR; - } + return dc_parser_new(parser, devdata->device); } -static int parse_gasmixes(parser_t *parser, int ngases) +static int parse_gasmixes(device_data_t *devdata, struct dive *dive, dc_parser_t *parser, int ngases) { int i; for (i = 0; i < ngases; i++) { int rc; - gasmix_t gasmix = {0}; + dc_gasmix_t gasmix = {0}; + int o2, he; - rc = parser_get_field(parser, FIELD_TYPE_GASMIX, i, &gasmix); - if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) + rc = dc_parser_get_field(parser, DC_FIELD_GASMIX, i, &gasmix); + if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) return rc; - printf("\n" - " %.1f\n" - " %.1f\n" - " %.1f\n" - "\n", - gasmix.helium * 100.0, - gasmix.oxygen * 100.0, - gasmix.nitrogen * 100.0); + if (i >= MAX_CYLINDERS) + continue; + + o2 = gasmix.oxygen * 1000 + 0.5; + he = gasmix.helium * 1000 + 0.5; + + /* Ignore bogus data - libdivecomputer does some crazy stuff */ + if (o2 <= AIR_PERMILLE || o2 >= 1000) + o2 = 0; + if (he < 0 || he >= 800 || o2+he >= 1000) + he = 0; + + dive->cylinder[i].gasmix.o2.permille = o2; + dive->cylinder[i].gasmix.he.permille = he; } - return PARSER_STATUS_SUCCESS; + return DC_STATUS_SUCCESS; } -void -sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdata) +static void handle_event(struct dive *dive, struct sample *sample, dc_sample_value_t value) { - int i; + int type, time; static const char *events[] = { "none", "deco", "rbt", "ascent", "ceiling", "workload", "transmitter", "violation", "bookmark", "surface", "safety stop", "gaschange", "safety stop (voluntary)", "safety stop (mandatory)", "deepstop", "ceiling (safety stop)", "unknown", "divetime", "maxdepth", - "OLF", "PO2", "airtime", "rgbm", "heading", "tissue level warning"}; + "OLF", "PO2", "airtime", "rgbm", "heading", "tissue level warning" + }; + const int nr_events = sizeof(events) / sizeof(const char *); + const char *name; + + /* + * Just ignore surface events. They are pointless. What "surface" + * means depends on the dive computer (and possibly even settings + * in the dive computer). It does *not* necessarily mean "depth 0", + * so don't even turn it into that. + */ + if (value.event.type == SAMPLE_EVENT_SURFACE) + return; + + /* + * Other evens might be more interesting, but for now we just print them out. + */ + type = value.event.type; + name = "invalid event number"; + if (type < nr_events) + name = events[type]; + + time = value.event.time; + if (sample) + time += sample->time.seconds; + + add_event(dive, time, type, value.event.flags, value.event.value, name); +} + +void +sample_cb(dc_sample_type_t type, dc_sample_value_t value, void *userdata) +{ + int i; + struct dive **divep = userdata; + struct dive *dive = *divep; + struct sample *sample; + + /* + * We fill in the "previous" sample - except for DC_SAMPLE_TIME, + * which creates a new one. + */ + sample = dive->samples ? dive->sample+dive->samples-1 : NULL; switch (type) { - case SAMPLE_TYPE_TIME: - printf("\n"); - printf(" \n", value.time / 60, value.time % 60); + case DC_SAMPLE_TIME: + sample = prepare_sample(divep); + sample->time.seconds = value.time; + finish_sample(*divep); break; - case SAMPLE_TYPE_DEPTH: - printf(" %.2f\n", value.depth); + case DC_SAMPLE_DEPTH: + sample->depth.mm = value.depth * 1000 + 0.5; break; - case SAMPLE_TYPE_PRESSURE: - printf(" %.2f\n", value.pressure.tank, value.pressure.value); + case DC_SAMPLE_PRESSURE: + sample->cylinderindex = value.pressure.tank; + sample->cylinderpressure.mbar = value.pressure.value * 1000 + 0.5; break; - case SAMPLE_TYPE_TEMPERATURE: - printf(" %.2f\n", value.temperature); + case DC_SAMPLE_TEMPERATURE: + sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5; break; - case SAMPLE_TYPE_EVENT: - printf(" %s\n", - value.event.type, value.event.time, value.event.flags, value.event.value, events[value.event.type]); + case DC_SAMPLE_EVENT: + handle_event(dive, sample, value); break; - case SAMPLE_TYPE_RBT: + case DC_SAMPLE_RBT: printf(" %u\n", value.rbt); break; - case SAMPLE_TYPE_HEARTBEAT: + case DC_SAMPLE_HEARTBEAT: printf(" %u\n", value.heartbeat); break; - case SAMPLE_TYPE_BEARING: + case DC_SAMPLE_BEARING: printf(" %u\n", value.bearing); break; - case SAMPLE_TYPE_VENDOR: + case DC_SAMPLE_VENDOR: printf(" ", value.vendor.type, value.vendor.size); for (i = 0; i < value.vendor.size; ++i) printf("%02X", ((unsigned char *) value.vendor.data)[i]); @@ -189,12 +157,49 @@ sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdat } } +static void dev_info(device_data_t *devdata, const char *fmt, ...) +{ + char buffer[32]; + va_list ap; + + va_start(ap, fmt); + vsnprintf(buffer, sizeof(buffer), fmt, ap); + va_end(ap); + update_progressbar_text(&devdata->progress, buffer); +} + +static int import_dive_number = 0; -static int parse_samples(parser_t *parser) +static int parse_samples(device_data_t *devdata, struct dive **divep, dc_parser_t *parser) { // Parse the sample data. - printf("Parsing the sample data.\n"); - return parser_samples_foreach(parser, sample_cb, NULL); + return dc_parser_samples_foreach(parser, sample_cb, divep); +} + +/* + * Check if this dive already existed before the import + */ +static int find_dive(struct dive *dive, device_data_t *devdata) +{ + int i; + + for (i = 0; i < dive_table.preexisting; i++) { + struct dive *old = dive_table.dives[i]; + + if (dive->when != old->when) + continue; + return 1; + } + return 0; +} + +static inline int year(int year) +{ + if (year < 70) + return year + 2000; + if (year < 100) + return year + 1900; + return year; } static int dive_cb(const unsigned char *data, unsigned int size, @@ -202,367 +207,213 @@ static int dive_cb(const unsigned char *data, unsigned int size, void *userdata) { int rc; - parser_t *parser = NULL; + dc_parser_t *parser = NULL; device_data_t *devdata = userdata; dc_datetime_t dt = {0}; - - /* Christ, this is hacky */ - run_gtk_mainloop(); + struct tm tm; + struct dive *dive; rc = create_parser(devdata, &parser); - if (rc != PARSER_STATUS_SUCCESS) { - error("Unable to create parser for %s", devdata->name); + if (rc != DC_STATUS_SUCCESS) { + dev_info(devdata, "Unable to create parser for %s %s", devdata->vendor, devdata->product); return rc; } - rc = parser_set_data(parser, data, size); - if (rc != PARSER_STATUS_SUCCESS) { - error("Error registering the data."); - parser_destroy(parser); + rc = dc_parser_set_data(parser, data, size); + if (rc != DC_STATUS_SUCCESS) { + dev_info(devdata, "Error registering the data"); + dc_parser_destroy(parser); return rc; } - rc = parser_get_datetime(parser, &dt); - if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { - error("Error parsing the datetime."); - parser_destroy (parser); + import_dive_number++; + dive = alloc_dive(); + rc = dc_parser_get_datetime(parser, &dt); + if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) { + dev_info(devdata, "Error parsing the datetime"); + dc_parser_destroy(parser); return rc; } - printf("%04i-%02i-%02i %02i:%02i:%02i\n", - dt.year, dt.month, dt.day, - dt.hour, dt.minute, dt.second); + tm.tm_year = dt.year; + tm.tm_mon = dt.month-1; + tm.tm_mday = dt.day; + tm.tm_hour = dt.hour; + tm.tm_min = dt.minute; + tm.tm_sec = dt.second; + dive->when = utc_mktime(&tm); // Parse the divetime. - printf("Parsing the divetime.\n"); + dev_info(devdata, "Dive %d: %s %d %04d", import_dive_number, + monthname(tm.tm_mon), tm.tm_mday, year(tm.tm_year)); unsigned int divetime = 0; - rc = parser_get_field (parser, FIELD_TYPE_DIVETIME, 0, &divetime); - if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { - error("Error parsing the divetime."); - parser_destroy(parser); + rc = dc_parser_get_field (parser, DC_FIELD_DIVETIME, 0, &divetime); + if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) { + dev_info(devdata, "Error parsing the divetime"); + dc_parser_destroy(parser); return rc; } - - printf("%02u:%02u\n", - divetime / 60, divetime % 60); + dive->duration.seconds = divetime; // Parse the maxdepth. - printf("Parsing the maxdepth.\n"); double maxdepth = 0.0; - rc = parser_get_field(parser, FIELD_TYPE_MAXDEPTH, 0, &maxdepth); - if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { - error("Error parsing the maxdepth."); - parser_destroy(parser); + rc = dc_parser_get_field(parser, DC_FIELD_MAXDEPTH, 0, &maxdepth); + if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) { + dev_info(devdata, "Error parsing the maxdepth"); + dc_parser_destroy(parser); return rc; } - - printf("%.2f\n", maxdepth); + dive->maxdepth.mm = maxdepth * 1000 + 0.5; // Parse the gas mixes. - printf("Parsing the gas mixes.\n"); unsigned int ngases = 0; - rc = parser_get_field(parser, FIELD_TYPE_GASMIX_COUNT, 0, &ngases); - if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { - error("Error parsing the gas mix count."); - parser_destroy(parser); + rc = dc_parser_get_field(parser, DC_FIELD_GASMIX_COUNT, 0, &ngases); + if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) { + dev_info(devdata, "Error parsing the gas mix count"); + dc_parser_destroy(parser); return rc; } - rc = parse_gasmixes(parser, ngases); - if (rc != PARSER_STATUS_SUCCESS) { - error("Error parsing the gas mix."); - parser_destroy(parser); + rc = parse_gasmixes(devdata, dive, parser, ngases); + if (rc != DC_STATUS_SUCCESS) { + dev_info(devdata, "Error parsing the gas mix"); + dc_parser_destroy(parser); return rc; } // Initialize the sample data. - rc = parse_samples(parser); - if (rc != PARSER_STATUS_SUCCESS) { - error("Error parsing the samples."); - parser_destroy(parser); + rc = parse_samples(devdata, &dive, parser); + if (rc != DC_STATUS_SUCCESS) { + dev_info(devdata, "Error parsing the samples"); + dc_parser_destroy(parser); return rc; } - parser_destroy(parser); + dc_parser_destroy(parser); + + /* If we already saw this dive, abort. */ + if (find_dive(dive, devdata)) + return 0; + + record_dive(dive); return 1; } -static device_status_t import_device_data(device_t *device, device_data_t *devicedata) +static dc_status_t import_device_data(dc_device_t *device, device_data_t *devicedata) { - return device_foreach(device, dive_cb, devicedata); + return dc_device_foreach(device, dive_cb, devicedata); } -static device_status_t device_open(const char *devname, - device_type_t type, - device_t **device) -{ - switch (type) { - case DEVICE_TYPE_SUUNTO_SOLUTION: - return suunto_solution_device_open(device, devname); - - case DEVICE_TYPE_SUUNTO_EON: - return suunto_eon_device_open(device, devname); - - case DEVICE_TYPE_SUUNTO_VYPER: - return suunto_vyper_device_open(device, devname); - - case DEVICE_TYPE_SUUNTO_VYPER2: - return suunto_vyper2_device_open(device, devname); - - case DEVICE_TYPE_SUUNTO_D9: - return suunto_d9_device_open(device, devname); - - case DEVICE_TYPE_UWATEC_ALADIN: - return uwatec_aladin_device_open(device, devname); - - case DEVICE_TYPE_UWATEC_MEMOMOUSE: - return uwatec_memomouse_device_open(device, devname); - - case DEVICE_TYPE_UWATEC_SMART: - return uwatec_smart_device_open(device); - - case DEVICE_TYPE_REEFNET_SENSUS: - return reefnet_sensus_device_open(device, devname); - - case DEVICE_TYPE_REEFNET_SENSUSPRO: - return reefnet_sensuspro_device_open(device, devname); - - case DEVICE_TYPE_REEFNET_SENSUSULTRA: - return reefnet_sensusultra_device_open(device, devname); - - case DEVICE_TYPE_OCEANIC_VTPRO: - return oceanic_vtpro_device_open(device, devname); - - case DEVICE_TYPE_OCEANIC_VEO250: - return oceanic_veo250_device_open(device, devname); - - case DEVICE_TYPE_OCEANIC_ATOM2: - return oceanic_atom2_device_open(device, devname); - - case DEVICE_TYPE_MARES_NEMO: - return mares_nemo_device_open(device, devname); - - case DEVICE_TYPE_MARES_PUCK: - return mares_puck_device_open(device, devname); - - case DEVICE_TYPE_MARES_ICONHD: - return mares_iconhd_device_open(device, devname); - - case DEVICE_TYPE_HW_OSTC: - return hw_ostc_device_open(device, devname); - - case DEVICE_TYPE_CRESSI_EDY: - return cressi_edy_device_open(device, devname); - - case DEVICE_TYPE_ZEAGLE_N2ITION3: - return zeagle_n2ition3_device_open(device, devname); - - case DEVICE_TYPE_ATOMICS_COBALT: - return atomics_cobalt_device_open(device); - default: - return DEVICE_STATUS_ERROR; - } -} - -static void -event_cb(device_t *device, device_event_t event, const void *data, void *userdata) +static void event_cb(dc_device_t *device, dc_event_type_t event, const void *data, void *userdata) { - const device_progress_t *progress = (device_progress_t *) data; - const device_devinfo_t *devinfo = (device_devinfo_t *) data; - const device_clock_t *clock = (device_clock_t *) data; - device_data_t *devdata = (device_data_t *) userdata; - - /* Christ, this is hacky */ - run_gtk_mainloop(); + const dc_event_progress_t *progress = data; + const dc_event_devinfo_t *devinfo = data; + const dc_event_clock_t *clock = data; + device_data_t *devdata = userdata; switch (event) { - case DEVICE_EVENT_WAITING: - printf("Event: waiting for user action\n"); + case DC_EVENT_WAITING: + dev_info(devdata, "Event: waiting for user action"); break; - case DEVICE_EVENT_PROGRESS: - gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(devdata->progressbar), + case DC_EVENT_PROGRESS: + update_progressbar(&devdata->progress, (double) progress->current / (double) progress->maximum); break; - case DEVICE_EVENT_DEVINFO: - devdata->devinfo = *devinfo; - printf("Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)\n", + case DC_EVENT_DEVINFO: + dev_info(devdata, "model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)", devinfo->model, devinfo->model, devinfo->firmware, devinfo->firmware, devinfo->serial, devinfo->serial); break; - case DEVICE_EVENT_CLOCK: - devdata->clock = *clock; - printf("Event: systime=%lld, devtime=%u\n", - clock->systime, clock->devtime); + case DC_EVENT_CLOCK: + dev_info(devdata, "Event: systime=%"PRId64", devtime=%u\n", + (uint64_t)clock->systime, clock->devtime); break; default: break; } } +static int import_thread_done = 0, import_thread_cancelled; + static int cancel_cb(void *userdata) { - return run_gtk_mainloop(); + return import_thread_cancelled; } -static void do_import(device_data_t *data) +static const char *do_device_import(device_data_t *data) { - /* FIXME! Needs user input! */ - const char *devname = "/dev/ttyUSB0"; - device_t *device = NULL; - device_status_t rc; - - rc = device_open(devname, data->type, &device); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Unable to open %s (%s)", data->name, data->devname); - return; - } + dc_status_t rc; + dc_device_t *device = data->device; // Register the event handler. - int events = DEVICE_EVENT_WAITING | DEVICE_EVENT_PROGRESS | DEVICE_EVENT_DEVINFO | DEVICE_EVENT_CLOCK; - rc = device_set_events(device, events, event_cb, data); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Error registering the event handler."); - device_close(device); - return; - } + int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK; + rc = dc_device_set_events(device, events, event_cb, data); + if (rc != DC_STATUS_SUCCESS) + return "Error registering the event handler."; // Register the cancellation handler. - rc = device_set_cancel(device, cancel_cb, data); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Error registering the cancellation handler."); - device_close(device); - return; - } + rc = dc_device_set_cancel(device, cancel_cb, data); + if (rc != DC_STATUS_SUCCESS) + return "Error registering the cancellation handler."; rc = import_device_data(device, data); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Dive data import error"); - device_close(device); - return; - } + if (rc != DC_STATUS_SUCCESS) + return "Dive data import error"; - device_close(device); + /* All good */ + return NULL; } -/* - * Taken from 'example.c' in libdivecomputer. - * - * I really wish there was some way to just have - * libdivecomputer tell us what devices it supports, - * rather than have the application have to know.. - */ -struct device_list { - const char *name; - device_type_t type; -} device_list[] = { - { "Suunto Solution", DEVICE_TYPE_SUUNTO_SOLUTION }, - { "Suunto Eon", DEVICE_TYPE_SUUNTO_EON }, - { "Suunto Vyper", DEVICE_TYPE_SUUNTO_VYPER }, - { "Suunto Vyper Air", DEVICE_TYPE_SUUNTO_VYPER2 }, - { "Suunto D9", DEVICE_TYPE_SUUNTO_D9 }, - { "Uwatec Aladin", DEVICE_TYPE_UWATEC_ALADIN }, - { "Uwatec Memo Mouse", DEVICE_TYPE_UWATEC_MEMOMOUSE }, - { "Uwatec Smart", DEVICE_TYPE_UWATEC_SMART }, - { "ReefNet Sensus", DEVICE_TYPE_REEFNET_SENSUS }, - { "ReefNet Sensus Pro", DEVICE_TYPE_REEFNET_SENSUSPRO }, - { "ReefNet Sensus Ultra",DEVICE_TYPE_REEFNET_SENSUSULTRA }, - { "Oceanic VT Pro", DEVICE_TYPE_OCEANIC_VTPRO }, - { "Oceanic Veo250", DEVICE_TYPE_OCEANIC_VEO250 }, - { "Oceanic Atom 2", DEVICE_TYPE_OCEANIC_ATOM2 }, - { "Mares Nemo", DEVICE_TYPE_MARES_NEMO }, - { "Mares Puck", DEVICE_TYPE_MARES_PUCK }, - { "Mares Icon HD", DEVICE_TYPE_MARES_ICONHD }, - { "OSTC", DEVICE_TYPE_HW_OSTC }, - { "Cressi Edy", DEVICE_TYPE_CRESSI_EDY }, - { "Zeagle N2iTiON 3", DEVICE_TYPE_ZEAGLE_N2ITION3 }, - { "Atomics Cobalt", DEVICE_TYPE_ATOMICS_COBALT }, - { NULL } -}; - -static void fill_computer_list(GtkListStore *store) +static const char *do_libdivecomputer_import(device_data_t *data) { - GtkTreeIter iter; - struct device_list *list = device_list; - - for (list = device_list ; list->name ; list++) { - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, - 0, list->name, - 1, list->type, - -1); + dc_status_t rc; + const char *err; + + import_dive_number = 0; + data->device = NULL; + data->context = NULL; + + rc = dc_context_new(&data->context); + if (rc != DC_STATUS_SUCCESS) + return "Unable to create libdivecomputer context"; + + err = "Unable to open %s %s (%s)"; + rc = dc_device_open(&data->device, data->context, data->descriptor, data->devname); + if (rc == DC_STATUS_SUCCESS) { + err = do_device_import(data); + dc_device_close(data->device); } + dc_context_free(data->context); + return err; } -static GtkComboBox *dive_computer_selector(GtkWidget *dialog) +static void *pthread_wrapper(void *_data) { - GtkWidget *hbox, *combo_box; - GtkListStore *model; - GtkCellRenderer *renderer; - - hbox = gtk_hbox_new(FALSE, 6); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 3); - - model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); - fill_computer_list(model); - - combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); - gtk_box_pack_start(GTK_BOX(hbox), combo_box, FALSE, TRUE, 3); - - renderer = gtk_cell_renderer_text_new(); - gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE); - gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "text", 0, NULL); - - return GTK_COMBO_BOX(combo_box); + device_data_t *data = _data; + const char *err_string = do_libdivecomputer_import(data); + import_thread_done = 1; + return (void *)err_string; } -void import_dialog(GtkWidget *w, gpointer data) +GError *do_import(device_data_t *data) { - int result; - GtkWidget *dialog, *hbox; - GtkComboBox *computer; - device_data_t devicedata = { - .devname = "/dev/ttyUSB0", - }; - - dialog = gtk_dialog_new_with_buttons("Import from dive computer", - GTK_WINDOW(main_window), - GTK_DIALOG_DESTROY_WITH_PARENT, - GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, - GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, - NULL); - - computer = dive_computer_selector(dialog); - - hbox = gtk_hbox_new(FALSE, 6); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, TRUE, 3); - devicedata.progressbar = gtk_progress_bar_new(); - gtk_container_add(GTK_CONTAINER(hbox), devicedata.progressbar); - - gtk_widget_show_all(dialog); - result = gtk_dialog_run(GTK_DIALOG(dialog)); - switch (result) { - int type; - GtkTreeIter iter; - GtkTreeModel *model; - const char *comp; - case GTK_RESPONSE_ACCEPT: - if (!gtk_combo_box_get_active_iter(computer, &iter)) - break; - model = gtk_combo_box_get_model(computer); - gtk_tree_model_get(model, &iter, - 0, &comp, - 1, &type, - -1); - devicedata.type = type; - devicedata.name = comp; - do_import(&devicedata); - break; - default: - break; + pthread_t pthread; + void *retval; + + /* I'm sure there is some better interface for waiting on a thread in a UI main loop */ + import_thread_done = 0; + pthread_create(&pthread, NULL, pthread_wrapper, data); + while (!import_thread_done) { + import_thread_cancelled = process_ui_events(); + usleep(100000); } - gtk_widget_destroy(dialog); + if (pthread_join(pthread, &retval) < 0) + retval = "Odd pthread error return"; + if (retval) + return error(retval, data->vendor, data->product, data->devname); + return NULL; }