#include <stdio.h>
-#include <gtk/gtk.h>
+#include <pthread.h>
#include "dive.h"
#include "divelist.h"
#include "display.h"
+#include "display-gtk.h"
-/* libdivecomputer */
-#include <device.h>
-#include <suunto.h>
-#include <reefnet.h>
-#include <uwatec.h>
-#include <oceanic.h>
-#include <mares.h>
-#include <hw.h>
-#include <cressi.h>
-#include <zeagle.h>
-#include <atomics.h>
-#include <utils.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);
-}
+#include "libdivecomputer.h"
static void error(const char *fmt, ...)
{
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);
}
-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)
{
switch (devdata->type) {
struct tm tm;
struct dive *dive;
- /* Christ, this is hacky */
- run_gtk_mainloop();
-
rc = create_parser(devdata, &parser);
if (rc != PARSER_STATUS_SUCCESS) {
- error("Unable to create parser for %s", devdata->name);
+ fprintf(stderr, "Unable to create parser for %s", devdata->name);
return rc;
}
rc = parser_set_data(parser, data, size);
if (rc != PARSER_STATUS_SUCCESS) {
- error("Error registering the data.");
+ fprintf(stderr, "Error registering the data.");
parser_destroy(parser);
return rc;
}
dive = alloc_dive();
rc = parser_get_datetime(parser, &dt);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
- error("Error parsing the datetime.");
+ fprintf(stderr, "Error parsing the datetime.");
parser_destroy (parser);
return rc;
}
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.");
+ fprintf(stderr, "Error parsing the divetime.");
parser_destroy(parser);
return rc;
}
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.");
+ fprintf(stderr, "Error parsing the maxdepth.");
parser_destroy(parser);
return rc;
}
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.");
+ fprintf(stderr, "Error parsing the gas mix count.");
parser_destroy(parser);
return rc;
}
rc = parse_gasmixes(dive, parser, ngases);
if (rc != PARSER_STATUS_SUCCESS) {
- error("Error parsing the gas mix.");
+ fprintf(stderr, "Error parsing the gas mix.");
parser_destroy(parser);
return rc;
}
// Initialize the sample data.
rc = parse_samples(&dive, parser);
if (rc != PARSER_STATUS_SUCCESS) {
- error("Error parsing the samples.");
+ fprintf(stderr, "Error parsing the samples.");
parser_destroy(parser);
return rc;
}
}
}
-static void
-event_cb(device_t *device, device_event_t event, const void *data, void *userdata)
+static void event_cb(device_t *device, device_event_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();
-
switch (event) {
case DEVICE_EVENT_WAITING:
printf("Event: waiting for user action\n");
break;
case DEVICE_EVENT_PROGRESS:
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(devdata->progressbar),
+ update_progressbar(devdata->progress,
(double) progress->current / (double) progress->maximum);
break;
case DEVICE_EVENT_DEVINFO:
}
}
+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_libdivecomputer_import(device_data_t *data)
{
device_t *device = NULL;
device_status_t rc;
rc = device_open(data->devname, data->type, &device);
- if (rc != DEVICE_STATUS_SUCCESS) {
- error("Unable to open %s (%s)", data->name, data->devname);
- return;
- }
+ if (rc != DEVICE_STATUS_SUCCESS)
+ return "Unable to open %s (%s)";
// 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;
+ 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;
+ 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;
+ return "Dive data import error";
}
device_close(device);
+ return NULL;
+}
+
+static void *pthread_wrapper(void *_data)
+{
+ device_data_t *data = _data;
+ const char *err_string = do_libdivecomputer_import(data);
+ import_thread_done = 1;
+ return (void *)err_string;
+}
+
+void do_import(device_data_t *data)
+{
+ pthread_t pthread;
+ void *retval;
+
+ if (data->type == DEVICE_TYPE_UEMIS)
+ return uemis_import();
+
+ /* 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);
+ }
+ if (pthread_join(pthread, &retval) < 0)
+ retval = "Odd pthread error return";
+ if (retval)
+ error(retval, data->name, data->devname);
}
/*
* 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[] = {
+struct device_list device_list[] = {
{ "Suunto Solution", DEVICE_TYPE_SUUNTO_SOLUTION },
{ "Suunto Eon", DEVICE_TYPE_SUUNTO_EON },
{ "Suunto Vyper", DEVICE_TYPE_SUUNTO_VYPER },
{ "Cressi Edy", DEVICE_TYPE_CRESSI_EDY },
{ "Zeagle N2iTiON 3", DEVICE_TYPE_ZEAGLE_N2ITION3 },
{ "Atomics Cobalt", DEVICE_TYPE_ATOMICS_COBALT },
+ { "Uemis Zurich SDA", DEVICE_TYPE_UEMIS },
{ NULL }
};
-
-static void fill_computer_list(GtkListStore *store)
-{
- 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);
- }
-}
-
-static GtkComboBox *dive_computer_selector(GtkWidget *dialog)
-{
- 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);
-}
-
-void import_dialog(GtkWidget *w, gpointer 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;
- }
- gtk_widget_destroy(dialog);
-
- report_dives();
- dive_list_update_dives(dive_list);
-}
projects / ext / subsurface.git / blobdiff