gtk-gui.c

   1 /* gtk-gui.c */
   2 /* gtk UI implementation */
   3 /* creates the window and overall layout
   4  * divelist, dive info, equipment and printing are handled in their own source files
   5  */
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #include <time.h>
  10 #include <unistd.h>
  11
  12 #include "dive.h"
  13 #include "divelist.h"
  14 #include "display.h"
  15 #include "display-gtk.h"
  16
  17 #include "libdivecomputer.h"
  18
  19 GtkWidget *main_window;
  20 GtkWidget *main_vbox;
  21 GtkWidget *error_info_bar;
  22 GtkWidget *error_label;
  23 GtkWidget *vpane, *hpane;
  24 GtkWidget *notebook;
  25
  26 int        error_count;
  27
  28 const char *divelist_font;
  29
  30 struct units output_units;
  31
  32 static GtkWidget *dive_profile;
  33
  34 visible_cols_t visible_cols = {TRUE, FALSE};
  35
  36 static const char *default_dive_computer_vendor;
  37 static const char *default_dive_computer_product;
  38 static const char *default_dive_computer_device;
  39
  40 static int is_default_dive_computer(const char *vendor, const char *product)
  41 {
  42         return default_dive_computer_vendor && !strcmp(vendor, default_dive_computer_vendor) &&
  43                 default_dive_computer_product && !strcmp(product, default_dive_computer_product);
  44 }
  45
  46 static int is_default_dive_computer_device(const char *name)
  47 {
  48         return default_dive_computer_device && !strcmp(name, default_dive_computer_device);
  49 }
  50
  51 static void set_default_dive_computer(const char *vendor, const char *product)
  52 {
  53         if (!vendor || !*vendor)
  54                 return;
  55         if (!product || !*product)
  56                 return;
  57         if (is_default_dive_computer(vendor, product))
  58                 return;
  59         default_dive_computer_vendor = vendor;
  60         default_dive_computer_product = product;
  61         subsurface_set_conf("dive_computer_vendor", PREF_STRING, vendor);
  62         subsurface_set_conf("dive_computer_product", PREF_STRING, product);
  63 }
  64
  65 static void set_default_dive_computer_device(const char *name)
  66 {
  67         if (!name || !*name)
  68                 return;
  69         if (is_default_dive_computer_device(name))
  70                 return;
  71         default_dive_computer_device = name;
  72         subsurface_set_conf("dive_computer_device", PREF_STRING, name);
  73 }
  74
  75 void repaint_dive(void)
  76 {
  77         update_dive(current_dive);
  78         if (dive_profile)
  79                 gtk_widget_queue_draw(dive_profile);
  80 }
  81
  82 static char *existing_filename;
  83 static gboolean need_icon = TRUE;
  84
  85 static void on_info_bar_response(GtkWidget *widget, gint response,
  86                                  gpointer data)
  87 {
  88         if (response == GTK_RESPONSE_OK)
  89         {
  90                 gtk_widget_destroy(widget);
  91                 error_info_bar = NULL;
  92         }
  93 }
  94
  95 void report_error(GError* error)
  96 {
  97         if (error == NULL)
  98         {
  99                 return;
 100         }
 101
 102         if (error_info_bar == NULL)
 103         {
 104                 error_count = 1;
 105                 error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
 106                                                                GTK_RESPONSE_OK,
 107                                                                NULL);
 108                 g_signal_connect(error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
 109                 gtk_info_bar_set_message_type(GTK_INFO_BAR(error_info_bar),
 110                                               GTK_MESSAGE_ERROR);
 111
 112                 error_label = gtk_label_new(error->message);
 113                 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(error_info_bar));
 114                 gtk_container_add(GTK_CONTAINER(container), error_label);
 115
 116                 gtk_box_pack_start(GTK_BOX(main_vbox), error_info_bar, FALSE, FALSE, 0);
 117                 gtk_widget_show_all(main_vbox);
 118         }
 119         else
 120         {
 121                 error_count++;
 122                 char buffer[256];
 123                 snprintf(buffer, sizeof(buffer), "Failed to open %i files.", error_count);
 124                 gtk_label_set(GTK_LABEL(error_label), buffer);
 125         }
 126 }
 127
 128 static void file_open(GtkWidget *w, gpointer data)
 129 {
 130         GtkWidget *dialog;
 131         GtkFileFilter *filter;
 132
 133         dialog = gtk_file_chooser_dialog_new("Open File",
 134                 GTK_WINDOW(main_window),
 135                 GTK_FILE_CHOOSER_ACTION_OPEN,
 136                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 137                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 138                 NULL);
 139         gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
 140
 141         filter = gtk_file_filter_new();
 142         gtk_file_filter_add_pattern(filter, "*.xml");
 143         gtk_file_filter_add_pattern(filter, "*.XML");
 144         gtk_file_filter_add_pattern(filter, "*.sda");
 145         gtk_file_filter_add_pattern(filter, "*.SDA");
 146         gtk_file_filter_add_mime_type(filter, "text/xml");
 147         gtk_file_filter_set_name(filter, "XML file");
 148         gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
 149
 150         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 151                 GSList *filenames, *fn_glist;
 152                 char *filename;
 153                 filenames = fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
 154
 155                 GError *error = NULL;
 156                 while(filenames != NULL) {
 157                         filename = filenames->data;
 158                         parse_file(filename, &error);
 159                         if (error != NULL)
 160                         {
 161                                 report_error(error);
 162                                 g_error_free(error);
 163                                 error = NULL;
 164                         }
 165
 166                         g_free(filename);
 167                         filenames = g_slist_next(filenames);
 168                 }
 169                 g_slist_free(fn_glist);
 170                 report_dives(FALSE);
 171         }
 172         gtk_widget_destroy(dialog);
 173 }
 174
 175 /* return the path and the file component contained in the full path */
 176 static char *path_and_file(char *pathin, char **fileout) {
 177         char *slash = pathin, *next;
 178
 179         if (! pathin) {
 180                 *fileout = strdup("");
 181                 return strdup("");
 182         }
 183         while ((next = strpbrk(slash + 1, "\\/")))
 184                 slash = next;
 185         if (pathin != slash)
 186                 slash++;
 187         *fileout = strdup(slash);
 188         return strndup(pathin, slash - pathin);
 189 }
 190
 191 static void file_save_as(GtkWidget *w, gpointer data)
 192 {
 193         GtkWidget *dialog;
 194         char *filename = NULL;
 195         char *current_file;
 196         char *current_dir;
 197
 198         dialog = gtk_file_chooser_dialog_new("Save File As",
 199                 GTK_WINDOW(main_window),
 200                 GTK_FILE_CHOOSER_ACTION_SAVE,
 201                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 202                 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 203                 NULL);
 204         gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
 205
 206         current_dir = path_and_file(existing_filename, &current_file);
 207         gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), current_dir);
 208         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), current_file);
 209         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 210                 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 211         }
 212         gtk_widget_destroy(dialog);
 213
 214         if (filename){
 215                 save_dives(filename);
 216                 set_filename(filename);
 217                 g_free(filename);
 218                 mark_divelist_changed(FALSE);
 219         }
 220 }
 221
 222 static void file_save(GtkWidget *w, gpointer data)
 223 {
 224         if (!existing_filename)
 225                 return file_save_as(w, data);
 226
 227         save_dives(existing_filename);
 228         mark_divelist_changed(FALSE);
 229 }
 230
 231 static gboolean ask_save_changes()
 232 {
 233         GtkWidget *dialog, *label, *content;
 234         gboolean quit = TRUE;
 235         dialog = gtk_dialog_new_with_buttons("Save Changes?",
 236                 GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 237                 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 238                 GTK_STOCK_NO, GTK_RESPONSE_NO,
 239                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 240                 NULL);
 241         content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 242
 243         if (!existing_filename){
 244                 label = gtk_label_new (
 245                         "You have unsaved changes\nWould you like to save those before exiting the program?");
 246         } else {
 247                 char *label_text = (char*) malloc(sizeof(char) * (92 + strlen(existing_filename)));
 248                 sprintf(label_text,
 249                         "You have unsaved changes to file: %s \nWould you like to save those before exiting the program?",
 250                         existing_filename);
 251                 label = gtk_label_new (label_text);
 252                 g_free(label_text);
 253         }
 254         gtk_container_add (GTK_CONTAINER (content), label);
 255         gtk_widget_show_all (dialog);
 256         gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
 257         gint outcode = gtk_dialog_run(GTK_DIALOG(dialog));
 258         if (outcode == GTK_RESPONSE_ACCEPT) {
 259                 file_save(NULL,NULL);
 260         } else if (outcode == GTK_RESPONSE_CANCEL) {
 261                 quit = FALSE;
 262         }
 263         gtk_widget_destroy(dialog);
 264         return quit;
 265 }
 266
 267 static gboolean on_delete(GtkWidget* w, gpointer data)
 268 {
 269         /* Make sure to flush any modified dive data */
 270         update_dive(NULL);
 271
 272         gboolean quit = TRUE;
 273         if (unsaved_changes())
 274                 quit = ask_save_changes();
 275
 276         if (quit){
 277                 return FALSE; /* go ahead, kill the program, we're good now */
 278         } else {
 279                 return TRUE; /* We are not leaving */
 280         }
 281 }
 282
 283 static void on_destroy(GtkWidget* w, gpointer data)
 284 {
 285         gtk_main_quit();
 286 }
 287
 288 static void quit(GtkWidget *w, gpointer data)
 289 {
 290         /* Make sure to flush any modified dive data */
 291         update_dive(NULL);
 292
 293         gboolean quit = TRUE;
 294         if (unsaved_changes())
 295                 quit = ask_save_changes();
 296
 297         if (quit){
 298                 gtk_main_quit();
 299         }
 300 }
 301
 302 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title,
 303                                 data_func_t data_func, unsigned int flags)
 304 {
 305         GtkCellRenderer *renderer;
 306         GtkTreeViewColumn *col;
 307         double xalign = 0.0; /* left as default */
 308         PangoAlignment align;
 309         gboolean visible;
 310
 311         align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
 312                 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
 313                 PANGO_ALIGN_CENTER;
 314         visible = !(flags & INVISIBLE);
 315
 316         renderer = gtk_cell_renderer_text_new();
 317         col = gtk_tree_view_column_new();
 318
 319         gtk_tree_view_column_set_title(col, title);
 320         if (!(flags & UNSORTABLE))
 321                 gtk_tree_view_column_set_sort_column_id(col, index);
 322         gtk_tree_view_column_set_resizable(col, TRUE);
 323         gtk_tree_view_column_pack_start(col, renderer, TRUE);
 324         if (data_func)
 325                 gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL);
 326         else
 327                 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
 328         gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
 329         switch (align) {
 330         case PANGO_ALIGN_LEFT:
 331                 xalign = 0.0;
 332                 break;
 333         case PANGO_ALIGN_CENTER:
 334                 xalign = 0.5;
 335                 break;
 336         case PANGO_ALIGN_RIGHT:
 337                 xalign = 1.0;
 338                 break;
 339         }
 340         gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
 341         gtk_tree_view_column_set_visible(col, visible);
 342         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
 343         return col;
 344 }
 345
 346 static void create_radio(GtkWidget *vbox, const char *w_name, ...)
 347 {
 348         va_list args;
 349         GtkRadioButton *group = NULL;
 350         GtkWidget *box, *label;
 351
 352         box = gtk_hbox_new(TRUE, 10);
 353         gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 0);
 354
 355         label = gtk_label_new(w_name);
 356         gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
 357
 358         va_start(args, w_name);
 359         for (;;) {
 360                 int enabled;
 361                 const char *name;
 362                 GtkWidget *button;
 363                 void *callback_fn;
 364
 365                 name = va_arg(args, char *);
 366                 if (!name)
 367                         break;
 368                 callback_fn = va_arg(args, void *);
 369                 enabled = va_arg(args, int);
 370
 371                 button = gtk_radio_button_new_with_label_from_widget(group, name);
 372                 group = GTK_RADIO_BUTTON(button);
 373                 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
 374                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), enabled);
 375                 g_signal_connect(button, "toggled", G_CALLBACK(callback_fn), NULL);
 376         }
 377         va_end(args);
 378 }
 379
 380 #define UNITCALLBACK(name, type, value)                         \
 381 static void name(GtkWidget *w, gpointer data)                   \
 382 {                                                               \
 383         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) \
 384                 menu_units.type = value;                        \
 385 }
 386
 387 static struct units menu_units;
 388
 389 UNITCALLBACK(set_meter, length, METERS)
 390 UNITCALLBACK(set_feet, length, FEET)
 391 UNITCALLBACK(set_bar, pressure, BAR)
 392 UNITCALLBACK(set_psi, pressure, PSI)
 393 UNITCALLBACK(set_liter, volume, LITER)
 394 UNITCALLBACK(set_cuft, volume, CUFT)
 395 UNITCALLBACK(set_celsius, temperature, CELSIUS)
 396 UNITCALLBACK(set_fahrenheit, temperature, FAHRENHEIT)
 397 UNITCALLBACK(set_kg, weight, KG)
 398 UNITCALLBACK(set_lbs, weight, LBS)
 399
 400 #define OPTIONCALLBACK(name, option) \
 401 static void name(GtkWidget *w, gpointer data) \
 402 { \
 403         option = GTK_TOGGLE_BUTTON(w)->active; \
 404 }
 405
 406 OPTIONCALLBACK(otu_toggle, visible_cols.otu)
 407 OPTIONCALLBACK(sac_toggle, visible_cols.sac)
 408 OPTIONCALLBACK(nitrox_toggle, visible_cols.nitrox)
 409 OPTIONCALLBACK(temperature_toggle, visible_cols.temperature)
 410 OPTIONCALLBACK(totalweight_toggle, visible_cols.totalweight)
 411 OPTIONCALLBACK(suit_toggle, visible_cols.suit)
 412 OPTIONCALLBACK(cylinder_toggle, visible_cols.cylinder)
 413
 414 static void event_toggle(GtkWidget *w, gpointer _data)
 415 {
 416         gboolean *plot_ev = _data;
 417
 418         *plot_ev = GTK_TOGGLE_BUTTON(w)->active;
 419 }
 420
 421 static void preferences_dialog(GtkWidget *w, gpointer data)
 422 {
 423         int result;
 424         GtkWidget *dialog, *font, *frame, *box, *vbox, *button;
 425
 426         menu_units = output_units;
 427
 428         dialog = gtk_dialog_new_with_buttons("Preferences",
 429                 GTK_WINDOW(main_window),
 430                 GTK_DIALOG_DESTROY_WITH_PARENT,
 431                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 432                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 433                 NULL);
 434
 435         frame = gtk_frame_new("Units");
 436         vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
 437         gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
 438
 439         box = gtk_vbox_new(FALSE, 6);
 440         gtk_container_add(GTK_CONTAINER(frame), box);
 441
 442         create_radio(box, "Depth:",
 443                 "Meter", set_meter, (output_units.length == METERS),
 444                 "Feet",  set_feet, (output_units.length == FEET),
 445                 NULL);
 446
 447         create_radio(box, "Pressure:",
 448                 "Bar", set_bar, (output_units.pressure == BAR),
 449                 "PSI",  set_psi, (output_units.pressure == PSI),
 450                 NULL);
 451
 452         create_radio(box, "Volume:",
 453                 "Liter",  set_liter, (output_units.volume == LITER),
 454                 "CuFt", set_cuft, (output_units.volume == CUFT),
 455                 NULL);
 456
 457         create_radio(box, "Temperature:",
 458                 "Celsius", set_celsius, (output_units.temperature == CELSIUS),
 459                 "Fahrenheit",  set_fahrenheit, (output_units.temperature == FAHRENHEIT),
 460                 NULL);
 461
 462         create_radio(box, "Weight:",
 463                 "kg", set_kg, (output_units.weight == KG),
 464                 "lbs",  set_lbs, (output_units.weight == LBS),
 465                 NULL);
 466
 467         frame = gtk_frame_new("Show Columns");
 468         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
 469
 470         box = gtk_hbox_new(FALSE, 6);
 471         gtk_container_add(GTK_CONTAINER(frame), box);
 472
 473         button = gtk_check_button_new_with_label("Temp");
 474         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.temperature);
 475         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 476         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(temperature_toggle), NULL);
 477
 478         button = gtk_check_button_new_with_label("Cyl");
 479         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.cylinder);
 480         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 481         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(cylinder_toggle), NULL);
 482
 483         button = gtk_check_button_new_with_label("O" UTF8_SUBSCRIPT_2 "%");
 484         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.nitrox);
 485         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 486         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(nitrox_toggle), NULL);
 487
 488         button = gtk_check_button_new_with_label("SAC");
 489         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.sac);
 490         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 491         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(sac_toggle), NULL);
 492
 493         button = gtk_check_button_new_with_label("OTU");
 494         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.otu);
 495         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 496         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(otu_toggle), NULL);
 497
 498         button = gtk_check_button_new_with_label("Weight");
 499         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.totalweight);
 500         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 501         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(totalweight_toggle), NULL);
 502
 503         button = gtk_check_button_new_with_label("Suit");
 504         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.suit);
 505         gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
 506         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(suit_toggle), NULL);
 507
 508         font = gtk_font_button_new_with_font(divelist_font);
 509         gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5);
 510
 511         gtk_widget_show_all(dialog);
 512         result = gtk_dialog_run(GTK_DIALOG(dialog));
 513         if (result == GTK_RESPONSE_ACCEPT) {
 514                 /* Make sure to flush any modified old dive data with old units */
 515                 update_dive(NULL);
 516
 517                 divelist_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
 518                 set_divelist_font(divelist_font);
 519
 520                 output_units = menu_units;
 521                 update_dive_list_units();
 522                 repaint_dive();
 523                 update_dive_list_col_visibility();
 524
 525                 subsurface_set_conf("feet", PREF_BOOL, BOOL_TO_PTR(output_units.length == FEET));
 526                 subsurface_set_conf("psi", PREF_BOOL, BOOL_TO_PTR(output_units.pressure == PSI));
 527                 subsurface_set_conf("cuft", PREF_BOOL, BOOL_TO_PTR(output_units.volume == CUFT));
 528                 subsurface_set_conf("fahrenheit", PREF_BOOL, BOOL_TO_PTR(output_units.temperature == FAHRENHEIT));
 529                 subsurface_set_conf("lbs", PREF_BOOL, BOOL_TO_PTR(output_units.weight == LBS));
 530                 subsurface_set_conf("TEMPERATURE", PREF_BOOL, BOOL_TO_PTR(visible_cols.temperature));
 531                 subsurface_set_conf("TOTALWEIGHT", PREF_BOOL, BOOL_TO_PTR(visible_cols.totalweight));
 532                 subsurface_set_conf("SUIT", PREF_BOOL, BOOL_TO_PTR(visible_cols.suit));
 533                 subsurface_set_conf("CYLINDER", PREF_BOOL, BOOL_TO_PTR(visible_cols.cylinder));
 534                 subsurface_set_conf("NITROX", PREF_BOOL, BOOL_TO_PTR(visible_cols.nitrox));
 535                 subsurface_set_conf("SAC", PREF_BOOL, BOOL_TO_PTR(visible_cols.sac));
 536                 subsurface_set_conf("OTU", PREF_BOOL, BOOL_TO_PTR(visible_cols.otu));
 537                 subsurface_set_conf("divelist_font", PREF_STRING, divelist_font);
 538
 539                 /* Flush the changes out to the system */
 540                 subsurface_flush_conf();
 541         }
 542         gtk_widget_destroy(dialog);
 543 }
 544
 545 static void create_toggle(const char* label, int *on, void *_data)
 546 {
 547         GtkWidget *button, *table = _data;
 548         int rows, cols, x, y;
 549         static int count;
 550
 551         if (table == NULL) {
 552                 /* magic way to reset the number of toggle buttons
 553                  * that we have already added - call this before you
 554                  * create the dialog */
 555                 count = 0;
 556                 return;
 557         }
 558         g_object_get(G_OBJECT(table), "n-columns", &cols, "n-rows", &rows, NULL);
 559         if (count > rows * cols) {
 560                 gtk_table_resize(GTK_TABLE(table),rows+1,cols);
 561                 rows++;
 562         }
 563         x = count % cols;
 564         y = count / cols;
 565         button = gtk_check_button_new_with_label(label);
 566         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), *on);
 567         gtk_table_attach_defaults(GTK_TABLE(table), button, x, x+1, y, y+1);
 568         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(event_toggle), on);
 569         count++;
 570 }
 571
 572 static void selectevents_dialog(GtkWidget *w, gpointer data)
 573 {
 574         int result;
 575         GtkWidget *dialog, *frame, *vbox, *table;
 576
 577         dialog = gtk_dialog_new_with_buttons("SelectEvents",
 578                 GTK_WINDOW(main_window),
 579                 GTK_DIALOG_DESTROY_WITH_PARENT,
 580                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 581                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 582                 NULL);
 583         /* initialize the function that fills the table */
 584         create_toggle(NULL, NULL, NULL);
 585
 586         frame = gtk_frame_new("Enable / Disable Events");
 587         vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
 588         gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
 589
 590         table = gtk_table_new(1, 4, TRUE);
 591         gtk_container_add(GTK_CONTAINER(frame), table);
 592
 593         evn_foreach(&create_toggle, table);
 594
 595         gtk_widget_show_all(dialog);
 596         result = gtk_dialog_run(GTK_DIALOG(dialog));
 597         if (result == GTK_RESPONSE_ACCEPT) {
 598                 repaint_dive();
 599         }
 600         gtk_widget_destroy(dialog);
 601 }
 602
 603 static void renumber_dialog(GtkWidget *w, gpointer data)
 604 {
 605         int result;
 606         struct dive *dive;
 607         GtkWidget *dialog, *frame, *button, *vbox;
 608
 609         dialog = gtk_dialog_new_with_buttons("Renumber",
 610                 GTK_WINDOW(main_window),
 611                 GTK_DIALOG_DESTROY_WITH_PARENT,
 612                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 613                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 614                 NULL);
 615
 616         vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
 617
 618         frame = gtk_frame_new("New starting number");
 619         gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
 620
 621         button = gtk_spin_button_new_with_range(1, 50000, 1);
 622         gtk_container_add(GTK_CONTAINER(frame), button);
 623
 624         /*
 625          * Do we have a number for the first dive already? Use that
 626          * as the default.
 627          */
 628         dive = get_dive(0);
 629         if (dive && dive->number)
 630                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), dive->number);
 631
 632         gtk_widget_show_all(dialog);
 633         result = gtk_dialog_run(GTK_DIALOG(dialog));
 634         if (result == GTK_RESPONSE_ACCEPT) {
 635                 int nr = gtk_spin_button_get_value(GTK_SPIN_BUTTON(button));
 636                 renumber_dives(nr);
 637                 repaint_dive();
 638         }
 639         gtk_widget_destroy(dialog);
 640 }
 641
 642 static void about_dialog(GtkWidget *w, gpointer data)
 643 {
 644         const char *logo_property = NULL;
 645         GdkPixbuf *logo = NULL;
 646
 647         if (need_icon) {
 648                 GtkWidget *image = gtk_image_new_from_file(subsurface_icon_name());
 649
 650                 if (image) {
 651                         logo = gtk_image_get_pixbuf(GTK_IMAGE(image));
 652                         logo_property = "logo";
 653                 }
 654         }
 655
 656         gtk_show_about_dialog(NULL,
 657                 "program-name", "SubSurface",
 658                 "comments", "Half-arsed divelog software in C",
 659                 "license", "GPLv2",
 660                 "version", VERSION_STRING,
 661                 "copyright", "Linus Torvalds 2011",
 662                 "logo-icon-name", "subsurface",
 663                 /* Must be last: */
 664                 logo_property, logo,
 665                 NULL);
 666 }
 667
 668 static void view_list(GtkWidget *w, gpointer data)
 669 {
 670         gtk_paned_set_position(GTK_PANED(vpane), 0);
 671 }
 672
 673 static void view_profile(GtkWidget *w, gpointer data)
 674 {
 675         gtk_paned_set_position(GTK_PANED(hpane), 0);
 676         gtk_paned_set_position(GTK_PANED(vpane), 65535);
 677 }
 678
 679 static void view_info(GtkWidget *w, gpointer data)
 680 {
 681         gtk_paned_set_position(GTK_PANED(vpane), 65535);
 682         gtk_paned_set_position(GTK_PANED(hpane), 65535);
 683 }
 684
 685 static void view_three(GtkWidget *w, gpointer data)
 686 {
 687         GtkAllocation alloc;
 688         GtkRequisition requisition;
 689
 690         gtk_widget_get_allocation(hpane, &alloc);
 691         gtk_paned_set_position(GTK_PANED(hpane), alloc.width/2);
 692         gtk_widget_get_allocation(vpane, &alloc);
 693         gtk_widget_size_request(notebook, &requisition);
 694         /* pick the requested size for the notebook plus 6 pixels for frame */
 695         gtk_paned_set_position(GTK_PANED(vpane), requisition.height + 6);
 696 }
 697
 698 static GtkActionEntry menu_items[] = {
 699         { "FileMenuAction", NULL, "File", NULL, NULL, NULL},
 700         { "LogMenuAction",  NULL, "Log", NULL, NULL, NULL},
 701         { "ViewMenuAction",  NULL, "View", NULL, NULL, NULL},
 702         { "FilterMenuAction",  NULL, "Filter", NULL, NULL, NULL},
 703         { "HelpMenuAction", NULL, "Help", NULL, NULL, NULL},
 704         { "OpenFile",       GTK_STOCK_OPEN, NULL,   CTRLCHAR "O", NULL, G_CALLBACK(file_open) },
 705         { "SaveFile",       GTK_STOCK_SAVE, NULL,   CTRLCHAR "S", NULL, G_CALLBACK(file_save) },
 706         { "SaveAsFile",     GTK_STOCK_SAVE_AS, NULL,   SHIFTCHAR CTRLCHAR "S", NULL, G_CALLBACK(file_save_as) },
 707         { "Print",          GTK_STOCK_PRINT, NULL,  CTRLCHAR "P", NULL, G_CALLBACK(do_print) },
 708         { "Import",         NULL, "Import", NULL, NULL, G_CALLBACK(import_dialog) },
 709         { "AddDive",        GTK_STOCK_ADD, "Add Dive", NULL, NULL, G_CALLBACK(add_dive_cb) },
 710         { "Preferences",    GTK_STOCK_PREFERENCES, "Preferences", PREFERENCE_ACCEL, NULL, G_CALLBACK(preferences_dialog) },
 711         { "Renumber",       NULL, "Renumber", NULL, NULL, G_CALLBACK(renumber_dialog) },
 712         { "SelectEvents",   NULL, "SelectEvents", NULL, NULL, G_CALLBACK(selectevents_dialog) },
 713         { "Quit",           GTK_STOCK_QUIT, NULL,   CTRLCHAR "Q", NULL, G_CALLBACK(quit) },
 714         { "About",          GTK_STOCK_ABOUT, NULL,  NULL, NULL, G_CALLBACK(about_dialog) },
 715         { "ViewList",       NULL, "List",  CTRLCHAR "1", NULL, G_CALLBACK(view_list) },
 716         { "ViewProfile",    NULL, "Profile", CTRLCHAR "2", NULL, G_CALLBACK(view_profile) },
 717         { "ViewInfo",       NULL, "Info", CTRLCHAR "3", NULL, G_CALLBACK(view_info) },
 718         { "ViewThree",       NULL, "Three", CTRLCHAR "4", NULL, G_CALLBACK(view_three) },
 719 };
 720 static gint nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
 721
 722 static const gchar* ui_string = " \
 723         <ui> \
 724                 <menubar name=\"MainMenu\"> \
 725                         <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
 726                                 <menuitem name=\"Open\" action=\"OpenFile\" /> \
 727                                 <menuitem name=\"Save\" action=\"SaveFile\" /> \
 728                                 <menuitem name=\"Save As\" action=\"SaveAsFile\" /> \
 729                                 <menuitem name=\"Print\" action=\"Print\" /> \
 730                                 <separator name=\"Separator1\"/> \
 731                                 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
 732                                 <separator name=\"Separator2\"/> \
 733                                 <menuitem name=\"Quit\" action=\"Quit\" /> \
 734                         </menu> \
 735                         <menu name=\"LogMenu\" action=\"LogMenuAction\"> \
 736                                 <menuitem name=\"Import\" action=\"Import\" /> \
 737                                 <menuitem name=\"Add Dive\" action=\"AddDive\" /> \
 738                                 <separator name=\"Separator\"/> \
 739                                 <menuitem name=\"Renumber\" action=\"Renumber\" /> \
 740                                 <menu name=\"View\" action=\"ViewMenuAction\"> \
 741                                         <menuitem name=\"List\" action=\"ViewList\" /> \
 742                                         <menuitem name=\"Profile\" action=\"ViewProfile\" /> \
 743                                         <menuitem name=\"Info\" action=\"ViewInfo\" /> \
 744                                         <menuitem name=\"Paned\" action=\"ViewThree\" /> \
 745                                 </menu> \
 746                         </menu> \
 747                         <menu name=\"FilterMenu\" action=\"FilterMenuAction\"> \
 748                                 <menuitem name=\"SelectEvents\" action=\"SelectEvents\" /> \
 749                         </menu> \
 750                         <menu name=\"Help\" action=\"HelpMenuAction\"> \
 751                                 <menuitem name=\"About\" action=\"About\" /> \
 752                         </menu> \
 753                 </menubar> \
 754         </ui> \
 755 ";
 756
 757 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager)
 758 {
 759         GtkActionGroup *action_group = gtk_action_group_new("Menu");
 760         gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
 761
 762         gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
 763         GError* error = 0;
 764         gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
 765
 766         gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
 767         GtkWidget* menu = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
 768
 769         return menu;
 770 }
 771
 772 static void switch_page(GtkNotebook *notebook, gint arg1, gpointer user_data)
 773 {
 774         repaint_dive();
 775 }
 776
 777 void init_ui(int *argcp, char ***argvp)
 778 {
 779         GtkWidget *win;
 780         GtkWidget *nb_page;
 781         GtkWidget *dive_list;
 782         GtkWidget *menubar;
 783         GtkWidget *vbox;
 784         GtkWidget *scrolled;
 785         GdkScreen *screen;
 786         GtkIconTheme *icon_theme=NULL;
 787         GtkSettings *settings;
 788         GtkUIManager *ui_manager;
 789
 790         gtk_init(argcp, argvp);
 791         settings = gtk_settings_get_default();
 792         gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "subsurface setting");
 793
 794         g_type_init();
 795
 796         subsurface_open_conf();
 797         if (subsurface_get_conf("feet", PREF_BOOL))
 798                 output_units.length = FEET;
 799         if (subsurface_get_conf("psi", PREF_BOOL))
 800                 output_units.pressure = PSI;
 801         if (subsurface_get_conf("cuft", PREF_BOOL))
 802                 output_units.volume = CUFT;
 803         if (subsurface_get_conf("fahrenheit", PREF_BOOL))
 804                 output_units.temperature = FAHRENHEIT;
 805         if (subsurface_get_conf("lbs", PREF_BOOL))
 806                 output_units.weight = LBS;
 807         /* an unset key is FALSE - all these are hidden by default */
 808         visible_cols.cylinder = PTR_TO_BOOL(subsurface_get_conf("CYLINDER", PREF_BOOL));
 809         visible_cols.temperature = PTR_TO_BOOL(subsurface_get_conf("TEMPERATURE", PREF_BOOL));
 810         visible_cols.totalweight = PTR_TO_BOOL(subsurface_get_conf("TOTALWEIGHT", PREF_BOOL));
 811         visible_cols.suit = PTR_TO_BOOL(subsurface_get_conf("SUIT", PREF_BOOL));
 812         visible_cols.nitrox = PTR_TO_BOOL(subsurface_get_conf("NITROX", PREF_BOOL));
 813         visible_cols.otu = PTR_TO_BOOL(subsurface_get_conf("OTU", PREF_BOOL));
 814         visible_cols.sac = PTR_TO_BOOL(subsurface_get_conf("SAC", PREF_BOOL));
 815
 816         divelist_font = subsurface_get_conf("divelist_font", PREF_STRING);
 817
 818         default_dive_computer_vendor = subsurface_get_conf("dive_computer_vendor", PREF_STRING);
 819         default_dive_computer_product = subsurface_get_conf("dive_computer_product", PREF_STRING);
 820         default_dive_computer_device = subsurface_get_conf("dive_computer_device", PREF_STRING);
 821
 822         error_info_bar = NULL;
 823         win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 824         g_set_application_name ("subsurface");
 825         /* Let's check if the subsurface icon has been installed or if
 826          * we need to try to load it from the current directory */
 827         screen = gdk_screen_get_default();
 828         if (screen)
 829                 icon_theme = gtk_icon_theme_get_for_screen(screen);
 830         if (icon_theme) {
 831                 if (gtk_icon_theme_has_icon(icon_theme, "subsurface")) {
 832                         need_icon = FALSE;
 833                         gtk_window_set_default_icon_name ("subsurface");
 834                 }
 835         }
 836         if (need_icon) {
 837                 const char *icon_name = subsurface_icon_name();
 838                 if (!access(icon_name, R_OK))
 839                         gtk_window_set_icon_from_file(GTK_WINDOW(win), icon_name, NULL);
 840         }
 841         g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(on_delete), NULL);
 842         g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(on_destroy), NULL);
 843         main_window = win;
 844
 845         vbox = gtk_vbox_new(FALSE, 0);
 846         gtk_container_add(GTK_CONTAINER(win), vbox);
 847         main_vbox = vbox;
 848
 849         ui_manager = gtk_ui_manager_new();
 850         menubar = get_menubar_menu(win, ui_manager);
 851
 852         subsurface_ui_setup(settings, menubar, vbox, ui_manager);
 853
 854         vpane = gtk_vpaned_new();
 855         gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 3);
 856         hpane = gtk_hpaned_new();
 857         gtk_paned_add1(GTK_PANED(vpane), hpane);
 858         g_signal_connect_after(G_OBJECT(vbox), "realize", G_CALLBACK(view_three), NULL);
 859
 860         /* Notebook for dive info vs profile vs .. */
 861         notebook = gtk_notebook_new();
 862         scrolled = gtk_scrolled_window_new(NULL, NULL);
 863         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 864         gtk_paned_add1(GTK_PANED(hpane), scrolled);
 865         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), notebook);
 866         g_signal_connect(notebook, "switch-page", G_CALLBACK(switch_page), NULL);
 867
 868         /* Create the actual divelist */
 869         dive_list = dive_list_create();
 870         gtk_widget_set_name(dive_list, "Dive List");
 871         gtk_paned_add2(GTK_PANED(vpane), dive_list);
 872
 873         /* Frame for dive profile */
 874         dive_profile = dive_profile_widget();
 875         gtk_widget_set_name(dive_profile, "Dive Profile");
 876         gtk_paned_add2(GTK_PANED(hpane), dive_profile);
 877
 878         /* Frame for extended dive info */
 879         nb_page = extended_dive_info_widget();
 880         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Dive Notes"));
 881
 882         /* Frame for dive equipment */
 883         nb_page = equipment_widget(W_IDX_PRIMARY);
 884         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Equipment"));
 885
 886         /* Frame for single dive statistics */
 887         nb_page = single_stats_widget();
 888         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Dive Info"));
 889
 890         /* Frame for total dive statistics */
 891         nb_page = total_stats_widget();
 892         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Stats"));
 893
 894         gtk_widget_set_app_paintable(win, TRUE);
 895         gtk_widget_show_all(win);
 896
 897         return;
 898 }
 899
 900 void run_ui(void)
 901 {
 902         gtk_main();
 903 }
 904
 905 void exit_ui(void)
 906 {
 907         subsurface_close_conf();
 908 }
 909
 910 typedef struct {
 911         cairo_rectangle_int_t rect;
 912         const char *text;
 913 } tooltip_record_t;
 914
 915 static tooltip_record_t *tooltip_rects;
 916 static int tooltips;
 917
 918 void attach_tooltip(int x, int y, int w, int h, const char *text)
 919 {
 920         cairo_rectangle_int_t *rect;
 921         tooltip_rects = realloc(tooltip_rects, (tooltips + 1) * sizeof(tooltip_record_t));
 922         rect = &tooltip_rects[tooltips].rect;
 923         rect->x = x;
 924         rect->y = y;
 925         rect->width = w;
 926         rect->height = h;
 927         tooltip_rects[tooltips].text = text;
 928         tooltips++;
 929 }
 930
 931 #define INSIDE_RECT(_r,_x,_y)   ((_r.x <= _x) && (_r.x + _r.width >= _x) && \
 932                                 (_r.y <= _y) && (_r.y + _r.height >= _y))
 933
 934 static gboolean profile_tooltip (GtkWidget *widget, gint x, gint y,
 935                         gboolean keyboard_mode, GtkTooltip *tooltip, gpointer user_data)
 936 {
 937         int i;
 938         cairo_rectangle_int_t *drawing_area = user_data;
 939         gint tx = x - drawing_area->x; /* get transformed coordinates */
 940         gint ty = y - drawing_area->y;
 941
 942         /* are we over an event marker ? */
 943         for (i = 0; i < tooltips; i++) {
 944                 if (INSIDE_RECT(tooltip_rects[i].rect, tx, ty)) {
 945                         gtk_tooltip_set_text(tooltip,tooltip_rects[i].text);
 946                         return TRUE; /* show tooltip */
 947                 }
 948         }
 949         return FALSE; /* don't show tooltip */
 950 }
 951
 952 static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 953 {
 954         struct dive *dive = current_dive;
 955         struct graphics_context gc = { .printer = 0 };
 956         static cairo_rectangle_int_t drawing_area;
 957
 958         /* the drawing area gives TOTAL width * height - x,y is used as the topx/topy offset
 959          * so effective drawing area is width-2x * height-2y */
 960         drawing_area.width = widget->allocation.width;
 961         drawing_area.height = widget->allocation.height;
 962         drawing_area.x = drawing_area.width / 20.0;
 963         drawing_area.y = drawing_area.height / 20.0;
 964
 965         gc.cr = gdk_cairo_create(widget->window);
 966         g_object_set(widget, "has-tooltip", TRUE, NULL);
 967         g_signal_connect(widget, "query-tooltip", G_CALLBACK(profile_tooltip), &drawing_area);
 968         init_profile_background(&gc);
 969         cairo_paint(gc.cr);
 970
 971         if (dive) {
 972                 if (tooltip_rects) {
 973                         free(tooltip_rects);
 974                         tooltip_rects = NULL;
 975                 }
 976                 tooltips = 0;
 977                 plot(&gc, &drawing_area, dive);
 978         }
 979         cairo_destroy(gc.cr);
 980
 981         return FALSE;
 982 }
 983
 984 GtkWidget *dive_profile_widget(void)
 985 {
 986         GtkWidget *da;
 987
 988         da = gtk_drawing_area_new();
 989         gtk_widget_set_size_request(da, 350, 250);
 990         g_signal_connect(da, "expose_event", G_CALLBACK(expose_event), NULL);
 991
 992         return da;
 993 }
 994
 995 int process_ui_events(void)
 996 {
 997         int ret=0;
 998
 999         while (gtk_events_pending()) {
1000                 if (gtk_main_iteration_do(0)) {
1001                         ret = 1;
1002                         break;
1003                 }
1004         }
1005         return ret;
1006 }
1007
1008 static int fill_computer_list(GtkListStore *store)
1009 {
1010         int index = -1, i;
1011         GtkTreeIter iter;
1012         dc_iterator_t *iterator = NULL;
1013         dc_descriptor_t *descriptor = NULL;
1014
1015         i = 0;
1016         dc_descriptor_iterator(&iterator);
1017         while (dc_iterator_next (iterator, &descriptor) == DC_STATUS_SUCCESS) {
1018                 const char *vendor = dc_descriptor_get_vendor(descriptor);
1019                 const char *product = dc_descriptor_get_product(descriptor);
1020
1021                 gtk_list_store_append(store, &iter);
1022                 gtk_list_store_set(store, &iter,
1023                         0, descriptor,
1024                         -1);
1025                 if (is_default_dive_computer(vendor, product))
1026                         index = i;
1027                 i++;
1028         }
1029         dc_iterator_free(iterator);
1030         return index;
1031 }
1032
1033 void render_dive_computer(GtkCellLayout *cell,
1034                 GtkCellRenderer *renderer,
1035                 GtkTreeModel *model,
1036                 GtkTreeIter *iter,
1037                 gpointer data)
1038 {
1039         char buffer[40];
1040         dc_descriptor_t *descriptor = NULL;
1041         const char *vendor, *product;
1042
1043         gtk_tree_model_get(model, iter, 0, &descriptor, -1);
1044         vendor = dc_descriptor_get_vendor(descriptor);
1045         product = dc_descriptor_get_product(descriptor);
1046         snprintf(buffer, sizeof(buffer), "%s %s", vendor, product);
1047         g_object_set(renderer, "text", buffer, NULL);
1048 }
1049
1050
1051 static GtkComboBox *dive_computer_selector(GtkWidget *vbox)
1052 {
1053         GtkWidget *hbox, *combo_box, *frame;
1054         GtkListStore *model;
1055         GtkCellRenderer *renderer;
1056         int default_index;
1057
1058         hbox = gtk_hbox_new(FALSE, 6);
1059         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
1060
1061         model = gtk_list_store_new(1, G_TYPE_POINTER);
1062         default_index = fill_computer_list(model);
1063
1064         frame = gtk_frame_new("Dive computer");
1065         gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
1066
1067         combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
1068         gtk_container_add(GTK_CONTAINER(frame), combo_box);
1069
1070         renderer = gtk_cell_renderer_text_new();
1071         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
1072         gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo_box), renderer, render_dive_computer, NULL, NULL);
1073
1074         gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), default_index);
1075
1076         return GTK_COMBO_BOX(combo_box);
1077 }
1078
1079 const char *subsurface_device_name()
1080 {
1081         if (!default_dive_computer_device || !*default_dive_computer_device)
1082                 return subsurface_USB_name();
1083         else
1084                 return default_dive_computer_device;
1085 }
1086
1087 static GtkEntry *dive_computer_device(GtkWidget *vbox)
1088 {
1089         GtkWidget *hbox, *entry, *frame;
1090
1091         hbox = gtk_hbox_new(FALSE, 6);
1092         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
1093
1094         frame = gtk_frame_new("Device name");
1095         gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
1096
1097         entry = gtk_entry_new();
1098         gtk_container_add(GTK_CONTAINER(frame), entry);
1099         gtk_entry_set_text(GTK_ENTRY(entry), subsurface_device_name());
1100
1101         return GTK_ENTRY(entry);
1102 }
1103
1104 /* once a file is selected in the FileChooserButton we want to exit the import dialog */
1105 static void on_file_set(GtkFileChooserButton *widget, gpointer _data)
1106 {
1107         GtkDialog *main_dialog = _data;
1108
1109         gtk_dialog_response(main_dialog, GTK_RESPONSE_ACCEPT);
1110 }
1111
1112 static GtkWidget *xml_file_selector(GtkWidget *vbox, GtkWidget *main_dialog)
1113 {
1114         GtkWidget *hbox, *frame, *chooser, *dialog;
1115         GtkFileFilter *filter;
1116
1117         hbox = gtk_hbox_new(FALSE, 6);
1118         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
1119
1120         frame = gtk_frame_new("XML file name");
1121         gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
1122         dialog = gtk_file_chooser_dialog_new("Open XML File",
1123                 GTK_WINDOW(main_window),
1124                 GTK_FILE_CHOOSER_ACTION_OPEN,
1125                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1126                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1127                 NULL);
1128         gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
1129
1130         filter = gtk_file_filter_new();
1131         gtk_file_filter_add_pattern(filter, "*.xml");
1132         gtk_file_filter_add_pattern(filter, "*.XML");
1133         gtk_file_filter_add_pattern(filter, "*.sda");
1134         gtk_file_filter_add_pattern(filter, "*.SDA");
1135         gtk_file_filter_add_mime_type(filter, "text/xml");
1136         gtk_file_filter_set_name(filter, "XML file");
1137         gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1138
1139         chooser = gtk_file_chooser_button_new_with_dialog(dialog);
1140         g_signal_connect(G_OBJECT(chooser), "file-set", G_CALLBACK(on_file_set), main_dialog);
1141
1142         gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(chooser), 30);
1143         gtk_container_add(GTK_CONTAINER(frame), chooser);
1144
1145         return chooser;
1146 }
1147
1148 static void do_import_file(gpointer data, gpointer user_data)
1149 {
1150         GError *error = NULL;
1151         parse_file(data, &error);
1152
1153         if (error != NULL)
1154         {
1155                 report_error(error);
1156                 g_error_free(error);
1157                 error = NULL;
1158         }
1159 }
1160
1161 static GtkWidget *import_dive_computer(device_data_t *data, GtkDialog *dialog)
1162 {
1163         GError *error;
1164         GtkWidget *vbox, *info, *container, *label, *button;
1165
1166         error = do_import(data);
1167         if (!error)
1168                 return NULL;
1169
1170         button = gtk_dialog_get_widget_for_response(dialog, GTK_RESPONSE_ACCEPT);
1171         gtk_button_set_use_stock(GTK_BUTTON(button), 0);
1172         gtk_button_set_label(GTK_BUTTON(button), "Retry");
1173
1174         vbox = gtk_dialog_get_content_area(dialog);
1175
1176         info = gtk_info_bar_new();
1177         container = gtk_info_bar_get_content_area(GTK_INFO_BAR(info));
1178         label = gtk_label_new(error->message);
1179         gtk_container_add(GTK_CONTAINER(container), label);
1180         gtk_box_pack_start(GTK_BOX(vbox), info, FALSE, FALSE, 0);
1181         return info;
1182 }
1183
1184 void import_dialog(GtkWidget *w, gpointer data)
1185 {
1186         int result;
1187         GtkWidget *dialog, *hbox, *vbox, *label, *info = NULL;
1188         GtkComboBox *computer;
1189         GtkEntry *device;
1190         GtkWidget *XMLchooser;
1191         device_data_t devicedata = {
1192                 .devname = NULL,
1193         };
1194
1195         dialog = gtk_dialog_new_with_buttons("Import from dive computer",
1196                 GTK_WINDOW(main_window),
1197                 GTK_DIALOG_DESTROY_WITH_PARENT,
1198                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1199                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1200                 NULL);
1201
1202         vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1203         label = gtk_label_new("Import: \nLoad XML file or import directly from dive computer");
1204         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 3);
1205         XMLchooser = xml_file_selector(vbox, dialog);
1206         computer = dive_computer_selector(vbox);
1207         device = dive_computer_device(vbox);
1208         hbox = gtk_hbox_new(FALSE, 6);
1209         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3);
1210         devicedata.progress.bar = gtk_progress_bar_new();
1211         gtk_container_add(GTK_CONTAINER(hbox), devicedata.progress.bar);
1212
1213 repeat:
1214         gtk_widget_show_all(dialog);
1215         result = gtk_dialog_run(GTK_DIALOG(dialog));
1216         switch (result) {
1217                 dc_descriptor_t *descriptor;
1218                 GtkTreeIter iter;
1219                 GtkTreeModel *model;
1220                 GSList *list;
1221         case GTK_RESPONSE_ACCEPT:
1222                 /* what happened - did the user pick a file? In that case
1223                  * we ignore whether a dive computer model was picked */
1224                 if (info)
1225                         gtk_widget_destroy(info);
1226                 list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(XMLchooser));
1227                 if (g_slist_length(list) == 0) {
1228                         const char *vendor, *product;
1229
1230                         if (!gtk_combo_box_get_active_iter(computer, &iter))
1231                                 break;
1232                         model = gtk_combo_box_get_model(computer);
1233                         gtk_tree_model_get(model, &iter,
1234                                         0, &descriptor,
1235                                         -1);
1236
1237                         vendor = dc_descriptor_get_vendor(descriptor);
1238                         product = dc_descriptor_get_product(descriptor);
1239
1240                         devicedata.descriptor = descriptor;
1241                         devicedata.vendor = vendor;
1242                         devicedata.product = product;
1243                         devicedata.devname = gtk_entry_get_text(device);
1244                         set_default_dive_computer(vendor, product);
1245                         set_default_dive_computer_device(devicedata.devname);
1246                         info = import_dive_computer(&devicedata, GTK_DIALOG(dialog));
1247                         if (info)
1248                                 goto repeat;
1249                 } else {
1250                         g_slist_foreach(list,do_import_file,NULL);
1251                         g_slist_free(list);
1252                 }
1253                 break;
1254         default:
1255                 break;
1256         }
1257         gtk_widget_destroy(dialog);
1258
1259         report_dives(TRUE);
1260 }
1261
1262 void update_progressbar(progressbar_t *progress, double value)
1263 {
1264         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress->bar), value);
1265 }
1266
1267 void update_progressbar_text(progressbar_t *progress, const char *text)
1268 {
1269         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress->bar), text);
1270 }
1271
1272 void set_filename(const char *filename)
1273 {
1274         if (existing_filename)
1275                 free(existing_filename);
1276         existing_filename = NULL;
1277         if (filename)
1278                 existing_filename = strdup(filename);
1279 }