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