mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

Show dive import text updates in the progress bar

Browse source 
Instead of using printf() to print the string updates ("Parsing sample
data" etc), introduce a function to show those strings in the graphical
progress bar itself.

Subsurface hasn't been a text-mode application in a long time ;)

This partially fixes the second todo entry from commit b0ba22a068
("Show dive import error messages in the import dialog") and generally
makes for a more helpful import - at least for the largely error-free
cases.

Sadly, the messages that really come from within libdivecomputer itself
(like "suunto_vyper2.c:193: Failed to receive the answer.") when things
go really wrong are not caught.  libdivecomputer does have a notion of a
logfile (set with "message_set_logfile()"), but that ends up being
really inconvenient.

Maybe we could use some pipe setup or something. Oh well.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds 2012-05-02 17:40:39 -07:00
parent 26b90cbfa8
commit e7a70b6ae8
3 changed files with 36 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
display-gtk.h
View file

@ -57,6 +57,7 @@ extern void import_dialog(GtkWidget *, gpointer);
extern void report_error(GError* error); extern void report_error(GError* error);
extern int process_ui_events(void); extern int process_ui_events(void);
extern void update_progressbar(progressbar_t *progress, double value); extern void update_progressbar(progressbar_t *progress, double value);
extern void update_progressbar_text(progressbar_t *progress, const char *text);
extern GtkWidget *dive_profile_widget(void); extern GtkWidget *dive_profile_widget(void);
extern GtkWidget *dive_info_frame(void); extern GtkWidget *dive_info_frame(void);

4
gtk-gui.c
View file

@ -1113,6 +1113,10 @@ void update_progressbar(progressbar_t *progress, double value)
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress->bar), value); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress->bar), value);
} }
void update_progressbar_text(progressbar_t *progress, const char *text)
{
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress->bar), text);
}
void set_filename(const char *filename) void set_filename(const char *filename)
{ {

50
libdivecomputer.c
View file

@ -104,7 +104,7 @@ static parser_status_t create_parser(device_data_t *devdata, parser_t **parser)
} }
} }
static int parse_gasmixes(struct dive *dive, parser_t *parser, int ngases) static int parse_gasmixes(device_data_t *devdata, struct dive *dive, parser_t *parser, int ngases)
{ {
int i; int i;
@ -225,11 +225,22 @@ sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata
} }
} }
static void dev_info(device_data_t *devdata, const char *fmt, ...)
{
char buffer[32];
va_list ap;
static int parse_samples(struct dive **divep, parser_t *parser) 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(device_data_t *devdata, struct dive **divep, parser_t *parser)
{ {
// Parse the sample data. // Parse the sample data.
printf("Parsing the sample data.\n");
return parser_samples_foreach(parser, sample_cb, divep); return parser_samples_foreach(parser, sample_cb, divep);
} }
@ -263,21 +274,22 @@ static int dive_cb(const unsigned char *data, unsigned int size,
rc = create_parser(devdata, &parser); rc = create_parser(devdata, &parser);
if (rc != PARSER_STATUS_SUCCESS) { if (rc != PARSER_STATUS_SUCCESS) {
fprintf(stderr, "Unable to create parser for %s", devdata->name); dev_info(devdata, "Unable to create parser for %s", devdata->name);
return rc; return rc;
} }
rc = parser_set_data(parser, data, size); rc = parser_set_data(parser, data, size);
if (rc != PARSER_STATUS_SUCCESS) { if (rc != PARSER_STATUS_SUCCESS) {
fprintf(stderr, "Error registering the data."); dev_info(devdata, "Error registering the data");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
import_dive_number++;
dive = alloc_dive(); dive = alloc_dive();
rc = parser_get_datetime(parser, &dt); rc = parser_get_datetime(parser, &dt);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
fprintf(stderr, "Error parsing the datetime."); dev_info(devdata, "Error parsing the datetime");
parser_destroy (parser); parser_destroy (parser);
return rc; return rc;
} }
@ -291,48 +303,46 @@ static int dive_cb(const unsigned char *data, unsigned int size,
dive->when = utc_mktime(&tm); dive->when = utc_mktime(&tm);
// Parse the divetime. // Parse the divetime.
printf("Parsing the divetime.\n"); dev_info(devdata, "Parsing dive %d", import_dive_number);
unsigned int divetime = 0; unsigned int divetime = 0;
rc = parser_get_field (parser, FIELD_TYPE_DIVETIME, 0, &divetime); rc = parser_get_field (parser, FIELD_TYPE_DIVETIME, 0, &divetime);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
fprintf(stderr, "Error parsing the divetime."); dev_info(devdata, "Error parsing the divetime");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
dive->duration.seconds = divetime; dive->duration.seconds = divetime;
// Parse the maxdepth. // Parse the maxdepth.
printf("Parsing the maxdepth.\n");
double maxdepth = 0.0; double maxdepth = 0.0;
rc = parser_get_field(parser, FIELD_TYPE_MAXDEPTH, 0, &maxdepth); rc = parser_get_field(parser, FIELD_TYPE_MAXDEPTH, 0, &maxdepth);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
fprintf(stderr, "Error parsing the maxdepth."); dev_info(devdata, "Error parsing the maxdepth");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
dive->maxdepth.mm = maxdepth * 1000 + 0.5; dive->maxdepth.mm = maxdepth * 1000 + 0.5;
// Parse the gas mixes. // Parse the gas mixes.
printf("Parsing the gas mixes.\n");
unsigned int ngases = 0; unsigned int ngases = 0;
rc = parser_get_field(parser, FIELD_TYPE_GASMIX_COUNT, 0, &ngases); rc = parser_get_field(parser, FIELD_TYPE_GASMIX_COUNT, 0, &ngases);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
fprintf(stderr, "Error parsing the gas mix count."); dev_info(devdata, "Error parsing the gas mix count");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
rc = parse_gasmixes(dive, parser, ngases); rc = parse_gasmixes(devdata, dive, parser, ngases);
if (rc != PARSER_STATUS_SUCCESS) { if (rc != PARSER_STATUS_SUCCESS) {
fprintf(stderr, "Error parsing the gas mix."); dev_info(devdata, "Error parsing the gas mix");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
// Initialize the sample data. // Initialize the sample data.
rc = parse_samples(&dive, parser); rc = parse_samples(devdata, &dive, parser);
if (rc != PARSER_STATUS_SUCCESS) { if (rc != PARSER_STATUS_SUCCESS) {
fprintf(stderr, "Error parsing the samples."); dev_info(devdata, "Error parsing the samples");
parser_destroy(parser); parser_destroy(parser);
return rc; return rc;
} }
@ -429,6 +439,7 @@ static device_status_t device_open(const char *devname,
} }
} }
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 = data; const device_progress_t *progress = data;
@ -438,7 +449,7 @@ static void event_cb(device_t *device, device_event_t event, const void *data, v
switch (event) { switch (event) {
case DEVICE_EVENT_WAITING: case DEVICE_EVENT_WAITING:
printf("Event: waiting for user action\n"); dev_info(devdata, "Event: waiting for user action");
break; break;
case DEVICE_EVENT_PROGRESS: case DEVICE_EVENT_PROGRESS:
update_progressbar(&devdata->progress, update_progressbar(&devdata->progress,
@ -446,14 +457,14 @@ static void event_cb(device_t *device, device_event_t event, const void *data, v
break; break;
case DEVICE_EVENT_DEVINFO: case DEVICE_EVENT_DEVINFO:
devdata->devinfo = *devinfo; devdata->devinfo = *devinfo;
printf("Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)\n", dev_info(devdata, "model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)",
devinfo->model, devinfo->model, devinfo->model, devinfo->model,
devinfo->firmware, devinfo->firmware, devinfo->firmware, devinfo->firmware,
devinfo->serial, devinfo->serial); devinfo->serial, devinfo->serial);
break; break;
case DEVICE_EVENT_CLOCK: case DEVICE_EVENT_CLOCK:
devdata->clock = *clock; devdata->clock = *clock;
printf("Event: systime=%"PRId64", devtime=%u\n", dev_info(devdata, "Event: systime=%"PRId64", devtime=%u\n",
(uint64_t)clock->systime, clock->devtime); (uint64_t)clock->systime, clock->devtime);
break; break;
default: default:
@ -474,6 +485,7 @@ static const char *do_libdivecomputer_import(device_data_t *data)
device_t *device = NULL; device_t *device = NULL;
device_status_t rc; device_status_t rc;
import_dive_number = 0;
rc = device_open(data->devname, data->type, &device); rc = device_open(data->devname, data->type, &device);
if (rc != DEVICE_STATUS_SUCCESS) if (rc != DEVICE_STATUS_SUCCESS)
return "Unable to open %s (%s)"; return "Unable to open %s (%s)";