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