divelist.c

   1 /* divelist.c */
   2 /* this creates the UI for the dive list -
   3  * controlled through the following interfaces:
   4  *
   5  * void flush_divelist(struct dive *dive)
   6  * GtkWidget dive_list_create(void)
   7  * void dive_list_update_dives(void)
   8  * void update_dive_list_units(void)
   9  * void set_divelist_font(const char *font)
  10  * void mark_divelist_changed(int changed)
  11  * int unsaved_changes()
  12  */
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <time.h>
  17 #include <math.h>
  18
  19 #include "divelist.h"
  20 #include "dive.h"
  21 #include "display.h"
  22 #include "display-gtk.h"
  23
  24 struct DiveList {
  25         GtkWidget    *tree_view;
  26         GtkWidget    *container_widget;
  27         GtkListStore *model;
  28         GtkTreeViewColumn *nr, *date, *stars, *depth, *duration, *location;
  29         GtkTreeViewColumn *temperature, *cylinder, *totalweight, *suit, *nitrox, *sac, *otu;
  30         int changed;
  31 };
  32
  33 static struct DiveList dive_list;
  34
  35 /*
  36  * The dive list has the dive data in both string format (for showing)
  37  * and in "raw" format (for sorting purposes)
  38  */
  39 enum {
  40         DIVE_INDEX = 0,
  41         DIVE_NR,                /* int: dive->nr */
  42         DIVE_DATE,              /* time_t: dive->when */
  43         DIVE_RATING,            /* int: 0-5 stars */
  44         DIVE_DEPTH,             /* int: dive->maxdepth in mm */
  45         DIVE_DURATION,          /* int: in seconds */
  46         DIVE_TEMPERATURE,       /* int: in mkelvin */
  47         DIVE_TOTALWEIGHT,       /* int: in grams */
  48         DIVE_SUIT,              /* "wet, 3mm" */
  49         DIVE_CYLINDER,
  50         DIVE_NITROX,            /* int: dummy */
  51         DIVE_SAC,               /* int: in ml/min */
  52         DIVE_OTU,               /* int: in OTUs */
  53         DIVE_LOCATION,          /* "2nd Cathedral, Lanai" */
  54         DIVELIST_COLUMNS
  55 };
  56
  57 static GList *selected_dives;
  58
  59 static void selection_cb(GtkTreeSelection *selection, GtkTreeModel *model)
  60 {
  61         GtkTreeIter iter;
  62         GValue value = {0, };
  63         GtkTreePath *path;
  64
  65         int nr_selected = gtk_tree_selection_count_selected_rows(selection);
  66
  67         if (selected_dives) {
  68                 g_list_foreach (selected_dives, (GFunc) gtk_tree_path_free, NULL);
  69                 g_list_free (selected_dives);
  70         }
  71         selected_dives = gtk_tree_selection_get_selected_rows(selection, NULL);
  72
  73         switch (nr_selected) {
  74         case 0: /* keep showing the last selected dive */
  75                 return;
  76         case 1:
  77                 /* just pick that dive as selected */
  78                 amount_selected = 1;
  79                 path = g_list_nth_data(selected_dives, 0);
  80                 if (gtk_tree_model_get_iter(model, &iter, path)) {
  81                         gtk_tree_model_get_value(model, &iter, DIVE_INDEX, &value);
  82                         selected_dive = g_value_get_int(&value);
  83                         repaint_dive();
  84                 }
  85                 return;
  86         default: /* multiple selections - what now? At this point I
  87                   * don't want to change the selected dive unless
  88                   * there is exactly one dive selected; not sure this
  89                   * is the most intuitive solution.
  90                   * I do however want to keep around which dives have
  91                   * been selected */
  92                 amount_selected = g_list_length(selected_dives);
  93                 process_selected_dives(selected_dives, model);
  94                 repaint_dive();
  95                 return;
  96         }
  97 }
  98
  99 const char *star_strings[] = {
 100         ZERO_STARS,
 101         ONE_STARS,
 102         TWO_STARS,
 103         THREE_STARS,
 104         FOUR_STARS,
 105         FIVE_STARS
 106 };
 107
 108 static void star_data_func(GtkTreeViewColumn *col,
 109                            GtkCellRenderer *renderer,
 110                            GtkTreeModel *model,
 111                            GtkTreeIter *iter,
 112                            gpointer data)
 113 {
 114         int nr_stars;
 115         char buffer[40];
 116
 117         gtk_tree_model_get(model, iter, DIVE_RATING, &nr_stars, -1);
 118         if (nr_stars < 0 || nr_stars > 5)
 119                 nr_stars = 0;
 120         snprintf(buffer, sizeof(buffer), "%s", star_strings[nr_stars]);
 121         g_object_set(renderer, "text", buffer, NULL);
 122 }
 123
 124 static void date_data_func(GtkTreeViewColumn *col,
 125                            GtkCellRenderer *renderer,
 126                            GtkTreeModel *model,
 127                            GtkTreeIter *iter,
 128                            gpointer data)
 129 {
 130         int val;
 131         struct tm *tm;
 132         time_t when;
 133         char buffer[40];
 134
 135         gtk_tree_model_get(model, iter, DIVE_DATE, &val, -1);
 136
 137         /* 2038 problem */
 138         when = val;
 139
 140         tm = gmtime(&when);
 141         snprintf(buffer, sizeof(buffer),
 142                 "%s, %s %d, %d %02d:%02d",
 143                 weekday(tm->tm_wday),
 144                 monthname(tm->tm_mon),
 145                 tm->tm_mday, tm->tm_year + 1900,
 146                 tm->tm_hour, tm->tm_min);
 147         g_object_set(renderer, "text", buffer, NULL);
 148 }
 149
 150 static void depth_data_func(GtkTreeViewColumn *col,
 151                             GtkCellRenderer *renderer,
 152                             GtkTreeModel *model,
 153                             GtkTreeIter *iter,
 154                             gpointer data)
 155 {
 156         int depth, integer, frac, len;
 157         char buffer[40];
 158
 159         gtk_tree_model_get(model, iter, DIVE_DEPTH, &depth, -1);
 160
 161         switch (output_units.length) {
 162         case METERS:
 163                 /* To tenths of meters */
 164                 depth = (depth + 49) / 100;
 165                 integer = depth / 10;
 166                 frac = depth % 10;
 167                 if (integer < 20)
 168                         break;
 169                 if (frac >= 5)
 170                         integer++;
 171                 frac = -1;
 172                 break;
 173         case FEET:
 174                 integer = mm_to_feet(depth) + 0.5;
 175                 frac = -1;
 176                 break;
 177         default:
 178                 return;
 179         }
 180         len = snprintf(buffer, sizeof(buffer), "%d", integer);
 181         if (frac >= 0)
 182                 len += snprintf(buffer+len, sizeof(buffer)-len, ".%d", frac);
 183
 184         g_object_set(renderer, "text", buffer, NULL);
 185 }
 186
 187 static void duration_data_func(GtkTreeViewColumn *col,
 188                                GtkCellRenderer *renderer,
 189                                GtkTreeModel *model,
 190                                GtkTreeIter *iter,
 191                                gpointer data)
 192 {
 193         unsigned int sec;
 194         char buffer[16];
 195
 196         gtk_tree_model_get(model, iter, DIVE_DURATION, &sec, -1);
 197         snprintf(buffer, sizeof(buffer), "%d:%02d", sec / 60, sec % 60);
 198
 199         g_object_set(renderer, "text", buffer, NULL);
 200 }
 201
 202 static void temperature_data_func(GtkTreeViewColumn *col,
 203                                   GtkCellRenderer *renderer,
 204                                   GtkTreeModel *model,
 205                                   GtkTreeIter *iter,
 206                                   gpointer data)
 207 {
 208         int value;
 209         char buffer[80];
 210
 211         gtk_tree_model_get(model, iter, DIVE_TEMPERATURE, &value, -1);
 212
 213         *buffer = 0;
 214         if (value) {
 215                 double deg;
 216                 switch (output_units.temperature) {
 217                 case CELSIUS:
 218                         deg = mkelvin_to_C(value);
 219                         break;
 220                 case FAHRENHEIT:
 221                         deg = mkelvin_to_F(value);
 222                         break;
 223                 default:
 224                         return;
 225                 }
 226                 snprintf(buffer, sizeof(buffer), "%.1f", deg);
 227         }
 228
 229         g_object_set(renderer, "text", buffer, NULL);
 230 }
 231
 232 /*
 233  * Get "maximal" dive gas for a dive.
 234  * Rules:
 235  *  - Trimix trumps nitrox (highest He wins, O2 breaks ties)
 236  *  - Nitrox trumps air (even if hypoxic)
 237  * These are the same rules as the inter-dive sorting rules.
 238  */
 239 static void get_dive_gas(struct dive *dive, int *o2_p, int *he_p, int *o2low_p)
 240 {
 241         int i;
 242         int maxo2 = -1, maxhe = -1, mino2 = 1000;
 243
 244         for (i = 0; i < MAX_CYLINDERS; i++) {
 245                 cylinder_t *cyl = dive->cylinder + i;
 246                 struct gasmix *mix = &cyl->gasmix;
 247                 int o2 = mix->o2.permille;
 248                 int he = mix->he.permille;
 249
 250                 if (cylinder_none(cyl))
 251                         continue;
 252                 if (!o2)
 253                         o2 = AIR_PERMILLE;
 254                 if (o2 < mino2)
 255                         mino2 = o2;
 256                 if (he > maxhe)
 257                         goto newmax;
 258                 if (he < maxhe)
 259                         continue;
 260                 if (o2 <= maxo2)
 261                         continue;
 262 newmax:
 263                 maxhe = he;
 264                 maxo2 = o2;
 265         }
 266         /* All air? Show/sort as "air"/zero */
 267         if (!maxhe && maxo2 == AIR_PERMILLE && mino2 == maxo2)
 268                 maxo2 = mino2 = 0;
 269         *o2_p = maxo2;
 270         *he_p = maxhe;
 271         *o2low_p = mino2;
 272 }
 273
 274 static int total_weight(struct dive *dive)
 275 {
 276         int i, total_grams = 0;
 277
 278         if (dive)
 279                 for (i=0; i< MAX_WEIGHTSYSTEMS; i++)
 280                         total_grams += dive->weightsystem[i].weight.grams;
 281         return total_grams;
 282 }
 283
 284 static void weight_data_func(GtkTreeViewColumn *col,
 285                              GtkCellRenderer *renderer,
 286                              GtkTreeModel *model,
 287                              GtkTreeIter *iter,
 288                              gpointer data)
 289 {
 290         int indx, decimals;
 291         double value;
 292         char buffer[80];
 293         struct dive *dive;
 294
 295         gtk_tree_model_get(model, iter, DIVE_INDEX, &indx, -1);
 296         dive = get_dive(indx);
 297         value = get_weight_units(total_weight(dive), &decimals, NULL);
 298         if (value == 0.0)
 299                 *buffer = '\0';
 300         else
 301                 snprintf(buffer, sizeof(buffer), "%.*f", decimals, value);
 302
 303         g_object_set(renderer, "text", buffer, NULL);
 304 }
 305
 306 static gint nitrox_sort_func(GtkTreeModel *model,
 307         GtkTreeIter *iter_a,
 308         GtkTreeIter *iter_b,
 309         gpointer user_data)
 310 {
 311         int index_a, index_b;
 312         struct dive *a, *b;
 313         int a_o2, b_o2;
 314         int a_he, b_he;
 315         int a_o2low, b_o2low;
 316
 317         gtk_tree_model_get(model, iter_a, DIVE_INDEX, &index_a, -1);
 318         gtk_tree_model_get(model, iter_b, DIVE_INDEX, &index_b, -1);
 319         a = get_dive(index_a);
 320         b = get_dive(index_b);
 321         get_dive_gas(a, &a_o2, &a_he, &a_o2low);
 322         get_dive_gas(b, &b_o2, &b_he, &b_o2low);
 323
 324         /* Sort by Helium first, O2 second */
 325         if (a_he == b_he) {
 326                 if (a_o2 == b_o2)
 327                         return a_o2low - b_o2low;
 328                 return a_o2 - b_o2;
 329         }
 330         return a_he - b_he;
 331 }
 332
 333 #define UTF8_ELLIPSIS "\xE2\x80\xA6"
 334
 335 static void nitrox_data_func(GtkTreeViewColumn *col,
 336                              GtkCellRenderer *renderer,
 337                              GtkTreeModel *model,
 338                              GtkTreeIter *iter,
 339                              gpointer data)
 340 {
 341         int index, o2, he, o2low;
 342         char buffer[80];
 343         struct dive *dive;
 344
 345         gtk_tree_model_get(model, iter, DIVE_INDEX, &index, -1);
 346         dive = get_dive(index);
 347         get_dive_gas(dive, &o2, &he, &o2low);
 348         o2 = (o2 + 5) / 10;
 349         he = (he + 5) / 10;
 350         o2low = (o2low + 5) / 10;
 351
 352         if (he)
 353                 snprintf(buffer, sizeof(buffer), "%d/%d", o2, he);
 354         else if (o2)
 355                 if (o2 == o2low)
 356                         snprintf(buffer, sizeof(buffer), "%d", o2);
 357                 else
 358                         snprintf(buffer, sizeof(buffer), "%d" UTF8_ELLIPSIS "%d", o2low, o2);
 359         else
 360                 strcpy(buffer, "air");
 361
 362         g_object_set(renderer, "text", buffer, NULL);
 363 }
 364
 365 /* Render the SAC data (integer value of "ml / min") */
 366 static void sac_data_func(GtkTreeViewColumn *col,
 367                           GtkCellRenderer *renderer,
 368                           GtkTreeModel *model,
 369                           GtkTreeIter *iter,
 370                           gpointer data)
 371 {
 372         int value;
 373         const char *fmt;
 374         char buffer[16];
 375         double sac;
 376
 377         gtk_tree_model_get(model, iter, DIVE_SAC, &value, -1);
 378
 379         if (!value) {
 380                 g_object_set(renderer, "text", "", NULL);
 381                 return;
 382         }
 383
 384         sac = value / 1000.0;
 385         switch (output_units.volume) {
 386         case LITER:
 387                 fmt = "%4.1f";
 388                 break;
 389         case CUFT:
 390                 fmt = "%4.2f";
 391                 sac = ml_to_cuft(sac * 1000);
 392                 break;
 393         }
 394         snprintf(buffer, sizeof(buffer), fmt, sac);
 395
 396         g_object_set(renderer, "text", buffer, NULL);
 397 }
 398
 399 /* Render the OTU data (integer value of "OTU") */
 400 static void otu_data_func(GtkTreeViewColumn *col,
 401                           GtkCellRenderer *renderer,
 402                           GtkTreeModel *model,
 403                           GtkTreeIter *iter,
 404                           gpointer data)
 405 {
 406         int value;
 407         char buffer[16];
 408
 409         gtk_tree_model_get(model, iter, DIVE_OTU, &value, -1);
 410
 411         if (!value) {
 412                 g_object_set(renderer, "text", "", NULL);
 413                 return;
 414         }
 415
 416         snprintf(buffer, sizeof(buffer), "%d", value);
 417
 418         g_object_set(renderer, "text", buffer, NULL);
 419 }
 420
 421 /* calculate OTU for a dive */
 422 static int calculate_otu(struct dive *dive)
 423 {
 424         int i;
 425         double otu = 0.0;
 426
 427         for (i = 1; i < dive->samples; i++) {
 428                 int t;
 429                 double po2;
 430                 struct sample *sample = dive->sample + i;
 431                 struct sample *psample = sample - 1;
 432                 t = sample->time.seconds - psample->time.seconds;
 433                 int o2 = dive->cylinder[sample->cylinderindex].gasmix.o2.permille;
 434                 if (!o2)
 435                         o2 = AIR_PERMILLE;
 436                 po2 = o2 / 1000.0 * (sample->depth.mm + 10000) / 10000.0;
 437                 if (po2 >= 0.5)
 438                         otu += pow(po2 - 0.5, 0.83) * t / 30.0;
 439         }
 440         return otu + 0.5;
 441 }
 442 /*
 443  * Return air usage (in liters).
 444  */
 445 static double calculate_airuse(struct dive *dive)
 446 {
 447         double airuse = 0;
 448         int i;
 449
 450         for (i = 0; i < MAX_CYLINDERS; i++) {
 451                 pressure_t start, end;
 452                 cylinder_t *cyl = dive->cylinder + i;
 453                 int size = cyl->type.size.mliter;
 454                 double kilo_atm;
 455
 456                 if (!size)
 457                         continue;
 458
 459                 start = cyl->start.mbar ? cyl->start : cyl->sample_start;
 460                 end = cyl->end.mbar ? cyl->end : cyl->sample_end;
 461                 kilo_atm = (to_ATM(start) - to_ATM(end)) / 1000.0;
 462
 463                 /* Liters of air at 1 atm == milliliters at 1k atm*/
 464                 airuse += kilo_atm * size;
 465         }
 466         return airuse;
 467 }
 468
 469 static int calculate_sac(struct dive *dive)
 470 {
 471         double airuse, pressure, sac;
 472         int duration, i;
 473
 474         airuse = calculate_airuse(dive);
 475         if (!airuse)
 476                 return 0;
 477         if (!dive->duration.seconds)
 478                 return 0;
 479
 480         /* find and eliminate long surface intervals */
 481         duration = dive->duration.seconds;
 482         for (i = 0; i < dive->samples; i++) {
 483                 if (dive->sample[i].depth.mm < 100) { /* less than 10cm */
 484                         int end = i + 1;
 485                         while (end < dive->samples && dive->sample[end].depth.mm < 100)
 486                                 end++;
 487                         /* we only want the actual surface time during a dive */
 488                         if (end < dive->samples) {
 489                                 end--;
 490                                 duration -= dive->sample[end].time.seconds -
 491                                                 dive->sample[i].time.seconds;
 492                                 i = end + 1;
 493                         }
 494                 }
 495         }
 496         /* Mean pressure in atm: 1 atm per 10m */
 497         pressure = 1 + (dive->meandepth.mm / 10000.0);
 498         sac = airuse / pressure * 60 / duration;
 499
 500         /* milliliters per minute.. */
 501         return sac * 1000;
 502 }
 503
 504 void update_cylinder_related_info(struct dive *dive)
 505 {
 506         if (dive != NULL) {
 507                 dive->sac = calculate_sac(dive);
 508                 dive->otu = calculate_otu(dive);
 509         }
 510 }
 511
 512 static void get_string(char **str, const char *s)
 513 {
 514         int len;
 515         char *n;
 516
 517         if (!s)
 518                 s = "";
 519         len = strlen(s);
 520         if (len > 60)
 521                 len = 60;
 522         n = malloc(len+1);
 523         memcpy(n, s, len);
 524         n[len] = 0;
 525         *str = n;
 526 }
 527
 528 static void get_location(struct dive *dive, char **str)
 529 {
 530         get_string(str, dive->location);
 531 }
 532
 533 static void get_cylinder(struct dive *dive, char **str)
 534 {
 535         get_string(str, dive->cylinder[0].type.description);
 536 }
 537
 538 static void get_suit(struct dive *dive, char **str)
 539 {
 540         get_string(str, dive->suit);
 541 }
 542
 543 /*
 544  * Set up anything that could have changed due to editing
 545  * of dive information
 546  */
 547 static void fill_one_dive(struct dive *dive,
 548                           GtkTreeModel *model,
 549                           GtkTreeIter *iter)
 550 {
 551         char *location, *cylinder, *suit;
 552
 553         get_cylinder(dive, &cylinder);
 554         get_location(dive, &location);
 555         get_suit(dive, &suit);
 556
 557         gtk_list_store_set(GTK_LIST_STORE(model), iter,
 558                 DIVE_NR, dive->number,
 559                 DIVE_LOCATION, location,
 560                 DIVE_CYLINDER, cylinder,
 561                 DIVE_RATING, dive->rating,
 562                 DIVE_SAC, dive->sac,
 563                 DIVE_OTU, dive->otu,
 564                 DIVE_TOTALWEIGHT, total_weight(dive),
 565                 DIVE_SUIT, suit,
 566                 -1);
 567
 568         /* this will create a merge conflict with the memory leak patches */
 569         free(suit);
 570 }
 571
 572 static gboolean set_one_dive(GtkTreeModel *model,
 573                              GtkTreePath *path,
 574                              GtkTreeIter *iter,
 575                              gpointer data)
 576 {
 577         GValue value = {0, };
 578         struct dive *dive;
 579
 580         /* Get the dive number */
 581         gtk_tree_model_get_value(model, iter, DIVE_INDEX, &value);
 582         dive = get_dive(g_value_get_int(&value));
 583         if (!dive)
 584                 return TRUE;
 585         if (data && dive != data)
 586                 return FALSE;
 587
 588         fill_one_dive(dive, model, iter);
 589         return dive == data;
 590 }
 591
 592 void flush_divelist(struct dive *dive)
 593 {
 594         GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model);
 595
 596         gtk_tree_model_foreach(model, set_one_dive, dive);
 597 }
 598
 599 void set_divelist_font(const char *font)
 600 {
 601         PangoFontDescription *font_desc = pango_font_description_from_string(font);
 602         gtk_widget_modify_font(dive_list.tree_view, font_desc);
 603         pango_font_description_free(font_desc);
 604 }
 605
 606 void update_dive_list_units(void)
 607 {
 608         const char *unit;
 609         GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model);
 610
 611         (void) get_depth_units(0, NULL, &unit);
 612         gtk_tree_view_column_set_title(dive_list.depth, unit);
 613
 614         (void) get_temp_units(0, &unit);
 615         gtk_tree_view_column_set_title(dive_list.temperature, unit);
 616
 617         (void) get_weight_units(0, NULL, &unit);
 618         gtk_tree_view_column_set_title(dive_list.totalweight, unit);
 619
 620         gtk_tree_model_foreach(model, set_one_dive, NULL);
 621 }
 622
 623 void update_dive_list_col_visibility(void)
 624 {
 625         gtk_tree_view_column_set_visible(dive_list.cylinder, visible_cols.cylinder);
 626         gtk_tree_view_column_set_visible(dive_list.temperature, visible_cols.temperature);
 627         gtk_tree_view_column_set_visible(dive_list.totalweight, visible_cols.totalweight);
 628         gtk_tree_view_column_set_visible(dive_list.suit, visible_cols.suit);
 629         gtk_tree_view_column_set_visible(dive_list.nitrox, visible_cols.nitrox);
 630         gtk_tree_view_column_set_visible(dive_list.sac, visible_cols.sac);
 631         gtk_tree_view_column_set_visible(dive_list.otu, visible_cols.otu);
 632         return;
 633 }
 634
 635 static void fill_dive_list(void)
 636 {
 637         int i;
 638         GtkTreeIter iter;
 639         GtkListStore *store;
 640
 641         store = GTK_LIST_STORE(dive_list.model);
 642
 643         i = dive_table.nr;
 644         while (--i >= 0) {
 645                 struct dive *dive = dive_table.dives[i];
 646
 647                 update_cylinder_related_info(dive);
 648                 gtk_list_store_append(store, &iter);
 649                 gtk_list_store_set(store, &iter,
 650                         DIVE_INDEX, i,
 651                         DIVE_NR, dive->number,
 652                         DIVE_DATE, dive->when,
 653                         DIVE_DEPTH, dive->maxdepth,
 654                         DIVE_DURATION, dive->duration.seconds,
 655                         DIVE_LOCATION, "location",
 656                         DIVE_TEMPERATURE, dive->watertemp.mkelvin,
 657                         DIVE_TOTALWEIGHT, 0,
 658                         DIVE_SUIT, dive->suit,
 659                         DIVE_SAC, 0,
 660                         -1);
 661         }
 662
 663         update_dive_list_units();
 664         if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dive_list.model), &iter)) {
 665                 GtkTreeSelection *selection;
 666                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view));
 667                 gtk_tree_selection_select_iter(selection, &iter);
 668         }
 669 }
 670
 671 void dive_list_update_dives(void)
 672 {
 673         gtk_list_store_clear(GTK_LIST_STORE(dive_list.model));
 674         fill_dive_list();
 675         repaint_dive();
 676 }
 677
 678 static struct divelist_column {
 679         const char *header;
 680         data_func_t data;
 681         sort_func_t sort;
 682         unsigned int flags;
 683         int *visible;
 684 } dl_column[] = {
 685         [DIVE_NR] = { "#", NULL, NULL, ALIGN_RIGHT | UNSORTABLE },
 686         [DIVE_DATE] = { "Date", date_data_func, NULL, ALIGN_LEFT },
 687         [DIVE_RATING] = { UTF8_BLACKSTAR, star_data_func, NULL, ALIGN_LEFT },
 688         [DIVE_DEPTH] = { "ft", depth_data_func, NULL, ALIGN_RIGHT },
 689         [DIVE_DURATION] = { "min", duration_data_func, NULL, ALIGN_RIGHT },
 690         [DIVE_TEMPERATURE] = { UTF8_DEGREE "F", temperature_data_func, NULL, ALIGN_RIGHT, &visible_cols.temperature },
 691         [DIVE_TOTALWEIGHT] = { "lbs", weight_data_func, NULL, ALIGN_RIGHT, &visible_cols.totalweight },
 692         [DIVE_SUIT] = { "Suit", NULL, NULL, ALIGN_LEFT, &visible_cols.suit },
 693         [DIVE_CYLINDER] = { "Cyl", NULL, NULL, 0, &visible_cols.cylinder },
 694         [DIVE_NITROX] = { "O" UTF8_SUBSCRIPT_2 "%", nitrox_data_func, nitrox_sort_func, 0, &visible_cols.nitrox },
 695         [DIVE_SAC] = { "SAC", sac_data_func, NULL, 0, &visible_cols.sac },
 696         [DIVE_OTU] = { "OTU", otu_data_func, NULL, 0, &visible_cols.otu },
 697         [DIVE_LOCATION] = { "Location", NULL, NULL, ALIGN_LEFT },
 698 };
 699
 700
 701 static GtkTreeViewColumn *divelist_column(struct DiveList *dl, struct divelist_column *col)
 702 {
 703         int index = col - &dl_column[0];
 704         const char *title = col->header;
 705         data_func_t data_func = col->data;
 706         sort_func_t sort_func = col->sort;
 707         unsigned int flags = col->flags;
 708         int *visible = col->visible;
 709         GtkWidget *tree_view = dl->tree_view;
 710         GtkListStore *model = dl->model;
 711         GtkTreeViewColumn *ret;
 712
 713         if (visible && !*visible)
 714                 flags |= INVISIBLE;
 715         ret = tree_view_column(tree_view, index, title, data_func, flags);
 716         if (sort_func)
 717                 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model), index, sort_func, NULL, NULL);
 718         return ret;
 719 }
 720
 721 /*
 722  * This is some crazy crap. The only way to get default focus seems
 723  * to be to grab focus as the widget is being shown the first time.
 724  */
 725 static void realize_cb(GtkWidget *tree_view, gpointer userdata)
 726 {
 727         gtk_widget_grab_focus(tree_view);
 728 }
 729
 730 static void row_activated_cb(GtkTreeView *tree_view,
 731                         GtkTreePath *path,
 732                         GtkTreeViewColumn *column,
 733                         GtkTreeModel *model)
 734 {
 735         int index;
 736         GtkTreeIter iter;
 737
 738         if (!gtk_tree_model_get_iter(model, &iter, path))
 739                 return;
 740         gtk_tree_model_get(model, &iter, DIVE_INDEX, &index, -1);
 741         edit_dive_info(get_dive(index));
 742 }
 743
 744 void add_dive_cb(GtkWidget *menuitem, gpointer data)
 745 {
 746         struct dive *dive;
 747
 748         dive = alloc_dive();
 749         if (add_new_dive(dive)) {
 750                 record_dive(dive);
 751                 report_dives(TRUE);
 752                 return;
 753         }
 754         free(dive);
 755 }
 756
 757 static void popup_divelist_menu(GtkTreeView *tree_view, GtkTreeModel *model, int button)
 758 {
 759         GtkWidget *menu, *menuitem;
 760
 761         menu = gtk_menu_new();
 762         menuitem = gtk_menu_item_new_with_label("Add dive");
 763         g_signal_connect(menuitem, "activate", G_CALLBACK(add_dive_cb), model);
 764         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 765         gtk_widget_show_all(menu);
 766
 767         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
 768                 button, gtk_get_current_event_time());
 769 }
 770
 771 static void popup_menu_cb(GtkTreeView *tree_view,
 772                         GtkTreeModel *model)
 773 {
 774         popup_divelist_menu(tree_view, model, 0);
 775 }
 776
 777 static gboolean button_press_cb(GtkWidget *treeview, GdkEventButton *event, GtkTreeModel *model)
 778 {
 779         /* Right-click? Bring up the menu */
 780         if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3) {
 781                 popup_divelist_menu(GTK_TREE_VIEW(treeview), model, 3);
 782                 return TRUE;
 783         }
 784         return FALSE;
 785 }
 786
 787 GtkWidget *dive_list_create(void)
 788 {
 789         GtkTreeSelection  *selection;
 790
 791         dive_list.model = gtk_list_store_new(DIVELIST_COLUMNS,
 792                                 G_TYPE_INT,                     /* index */
 793                                 G_TYPE_INT,                     /* nr */
 794                                 G_TYPE_INT,                     /* Date */
 795                                 G_TYPE_INT,                     /* Star rating */
 796                                 G_TYPE_INT,                     /* Depth */
 797                                 G_TYPE_INT,                     /* Duration */
 798                                 G_TYPE_INT,                     /* Temperature */
 799                                 G_TYPE_INT,                     /* Total weight */
 800                                 G_TYPE_STRING,                  /* Suit */
 801                                 G_TYPE_STRING,                  /* Cylinder */
 802                                 G_TYPE_INT,                     /* Nitrox */
 803                                 G_TYPE_INT,                     /* SAC */
 804                                 G_TYPE_INT,                     /* OTU */
 805                                 G_TYPE_STRING                   /* Location */
 806                                 );
 807         dive_list.tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dive_list.model));
 808         set_divelist_font(divelist_font);
 809
 810         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view));
 811
 812         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
 813         gtk_widget_set_size_request(dive_list.tree_view, 200, 200);
 814
 815         dive_list.nr = divelist_column(&dive_list, dl_column + DIVE_NR);
 816         dive_list.date = divelist_column(&dive_list, dl_column + DIVE_DATE);
 817         dive_list.stars = divelist_column(&dive_list, dl_column + DIVE_RATING);
 818         dive_list.depth = divelist_column(&dive_list, dl_column + DIVE_DEPTH);
 819         dive_list.duration = divelist_column(&dive_list, dl_column + DIVE_DURATION);
 820         dive_list.temperature = divelist_column(&dive_list, dl_column + DIVE_TEMPERATURE);
 821         dive_list.totalweight = divelist_column(&dive_list, dl_column + DIVE_TOTALWEIGHT);
 822         dive_list.suit = divelist_column(&dive_list, dl_column + DIVE_SUIT);
 823         dive_list.cylinder = divelist_column(&dive_list, dl_column + DIVE_CYLINDER);
 824         dive_list.nitrox = divelist_column(&dive_list, dl_column + DIVE_NITROX);
 825         dive_list.sac = divelist_column(&dive_list, dl_column + DIVE_SAC);
 826         dive_list.otu = divelist_column(&dive_list, dl_column + DIVE_OTU);
 827         dive_list.location = divelist_column(&dive_list, dl_column + DIVE_LOCATION);
 828
 829         fill_dive_list();
 830
 831         g_object_set(G_OBJECT(dive_list.tree_view), "headers-visible", TRUE,
 832                                           "search-column", DIVE_LOCATION,
 833                                           "rules-hint", TRUE,
 834                                           NULL);
 835
 836         g_signal_connect_after(dive_list.tree_view, "realize", G_CALLBACK(realize_cb), NULL);
 837         g_signal_connect(dive_list.tree_view, "row-activated", G_CALLBACK(row_activated_cb), dive_list.model);
 838         g_signal_connect(dive_list.tree_view, "button-press-event", G_CALLBACK(button_press_cb), dive_list.model);
 839         g_signal_connect(dive_list.tree_view, "popup-menu", G_CALLBACK(popup_menu_cb), dive_list.model);
 840         g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), dive_list.model);
 841
 842         dive_list.container_widget = gtk_scrolled_window_new(NULL, NULL);
 843         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dive_list.container_widget),
 844                                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 845         gtk_container_add(GTK_CONTAINER(dive_list.container_widget), dive_list.tree_view);
 846
 847         dive_list.changed = 0;
 848
 849         return dive_list.container_widget;
 850 }
 851
 852 void mark_divelist_changed(int changed)
 853 {
 854         dive_list.changed = changed;
 855 }
 856
 857 int unsaved_changes()
 858 {
 859         return dive_list.changed;
 860 }