divelist.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <time.h>
   5
   6 #include "divelist.h"
   7 #include "dive.h"
   8 #include "display.h"
   9
  10 struct DiveList {
  11         GtkWidget    *tree_view;
  12         GtkWidget    *container_widget;
  13         GtkListStore *model;
  14         GtkTreeViewColumn *date, *depth, *duration, *location;
  15         GtkTreeViewColumn *temperature, *cylinder, *nitrox, *sac;
  16 };
  17
  18 static struct DiveList dive_list;
  19
  20 /*
  21  * The dive list has the dive data in both string format (for showing)
  22  * and in "raw" format (for sorting purposes)
  23  */
  24 enum {
  25         DIVE_INDEX = 0,
  26         DIVE_DATE,              /* time_t: dive->when */
  27         DIVE_DEPTH,             /* int: dive->maxdepth in mm */
  28         DIVE_DURATION,          /* int: in seconds */
  29         DIVE_LOCATION,          /* "2nd Cathedral, Lanai" */
  30         DIVE_TEMPERATURE,       /* int: in mkelvin */
  31         DIVE_CYLINDER,
  32         DIVE_NITROX,            /* int: in permille */
  33         DIVE_SAC,               /* int: in ml/min */
  34         DIVELIST_COLUMNS
  35 };
  36
  37
  38 static void selection_cb(GtkTreeSelection *selection, GtkTreeModel *model)
  39 {
  40         GtkTreeIter iter;
  41         GValue value = {0, };
  42
  43         if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
  44                 return;
  45
  46         gtk_tree_model_get_value(model, &iter, DIVE_INDEX, &value);
  47         selected_dive = g_value_get_int(&value);
  48         repaint_dive();
  49 }
  50
  51 const char *weekday(int wday)
  52 {
  53         static const char wday_array[7][4] = {
  54                 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  55         };
  56         return wday_array[wday];
  57 }
  58
  59 const char *monthname(int mon)
  60 {
  61         static const char month_array[12][4] = {
  62                 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  63                 "Jul", "Aug", "Oct", "Sep", "Nov", "Dec",
  64         };
  65         return month_array[mon];
  66 }
  67
  68 static void date_data_func(GtkTreeViewColumn *col,
  69                            GtkCellRenderer *renderer,
  70                            GtkTreeModel *model,
  71                            GtkTreeIter *iter,
  72                            gpointer data)
  73 {
  74         int val;
  75         struct tm *tm;
  76         time_t when;
  77         char buffer[40];
  78
  79         gtk_tree_model_get(model, iter, DIVE_DATE, &val, -1);
  80
  81         /* 2038 problem */
  82         when = val;
  83
  84         tm = gmtime(&when);
  85         snprintf(buffer, sizeof(buffer),
  86                 "%s, %s %d, %d %02d:%02d",
  87                 weekday(tm->tm_wday),
  88                 monthname(tm->tm_mon),
  89                 tm->tm_mday, tm->tm_year + 1900,
  90                 tm->tm_hour, tm->tm_min);
  91         g_object_set(renderer, "text", buffer, NULL);
  92 }
  93
  94 static void depth_data_func(GtkTreeViewColumn *col,
  95                             GtkCellRenderer *renderer,
  96                             GtkTreeModel *model,
  97                             GtkTreeIter *iter,
  98                             gpointer data)
  99 {
 100         int depth, integer, frac, len;
 101         char buffer[40];
 102
 103         gtk_tree_model_get(model, iter, DIVE_DEPTH, &depth, -1);
 104
 105         switch (output_units.length) {
 106         case METERS:
 107                 /* To tenths of meters */
 108                 depth = (depth + 49) / 100;
 109                 integer = depth / 10;
 110                 frac = depth % 10;
 111                 if (integer < 20)
 112                         break;
 113                 frac = -1;
 114                 /* Rounding? */
 115                 break;
 116         case FEET:
 117                 integer = mm_to_feet(depth) + 0.5;
 118                 frac = -1;
 119                 break;
 120         default:
 121                 return;
 122         }
 123         len = snprintf(buffer, sizeof(buffer), "%d", integer);
 124         if (frac >= 0)
 125                 len += snprintf(buffer+len, sizeof(buffer)-len, ".%d", frac);
 126
 127         g_object_set(renderer, "text", buffer, NULL);
 128 }
 129
 130 static void duration_data_func(GtkTreeViewColumn *col,
 131                                GtkCellRenderer *renderer,
 132                                GtkTreeModel *model,
 133                                GtkTreeIter *iter,
 134                                gpointer data)
 135 {
 136         unsigned int sec;
 137         char buffer[16];
 138
 139         gtk_tree_model_get(model, iter, DIVE_DURATION, &sec, -1);
 140         snprintf(buffer, sizeof(buffer), "%d:%02d", sec / 60, sec % 60);
 141
 142         g_object_set(renderer, "text", buffer, NULL);
 143 }
 144
 145 static void temperature_data_func(GtkTreeViewColumn *col,
 146                                   GtkCellRenderer *renderer,
 147                                   GtkTreeModel *model,
 148                                   GtkTreeIter *iter,
 149                                   gpointer data)
 150 {
 151         int value;
 152         char buffer[80];
 153
 154         gtk_tree_model_get(model, iter, DIVE_TEMPERATURE, &value, -1);
 155
 156         *buffer = 0;
 157         if (value) {
 158                 double deg;
 159                 switch (output_units.temperature) {
 160                 case CELSIUS:
 161                         deg = mkelvin_to_C(value);
 162                         break;
 163                 case FAHRENHEIT:
 164                         deg = mkelvin_to_F(value);
 165                         break;
 166                 default:
 167                         return;
 168                 }
 169                 snprintf(buffer, sizeof(buffer), "%.1f", deg);
 170         }
 171
 172         g_object_set(renderer, "text", buffer, NULL);
 173 }
 174
 175 static void nitrox_data_func(GtkTreeViewColumn *col,
 176                              GtkCellRenderer *renderer,
 177                              GtkTreeModel *model,
 178                              GtkTreeIter *iter,
 179                              gpointer data)
 180 {
 181         int value;
 182         char buffer[80];
 183
 184         gtk_tree_model_get(model, iter, DIVE_NITROX, &value, -1);
 185
 186         if (value)
 187                 snprintf(buffer, sizeof(buffer), "%.1f", value/10.0);
 188         else
 189                 strcpy(buffer, "air");
 190
 191         g_object_set(renderer, "text", buffer, NULL);
 192 }
 193
 194 /* Render the SAC data (integer value of "ml / min") */
 195 static void sac_data_func(GtkTreeViewColumn *col,
 196                           GtkCellRenderer *renderer,
 197                           GtkTreeModel *model,
 198                           GtkTreeIter *iter,
 199                           gpointer data)
 200 {
 201         int value;
 202         const double liters_per_cuft = 28.317;
 203         const char *fmt;
 204         char buffer[16];
 205         double sac;
 206
 207         gtk_tree_model_get(model, iter, DIVE_SAC, &value, -1);
 208
 209         if (!value) {
 210                 g_object_set(renderer, "text", "", NULL);
 211                 return;
 212         }
 213
 214         sac = value / 1000.0;
 215         switch (output_units.volume) {
 216         case LITER:
 217                 fmt = "%4.1f";
 218                 break;
 219         case CUFT:
 220                 fmt = "%4.2f";
 221                 sac /= liters_per_cuft;
 222                 break;
 223         }
 224         snprintf(buffer, sizeof(buffer), fmt, sac);
 225
 226         g_object_set(renderer, "text", buffer, NULL);
 227 }
 228
 229 /*
 230  * Return air usage (in liters).
 231  */
 232 static double calculate_airuse(struct dive *dive)
 233 {
 234         double airuse = 0;
 235         int i;
 236
 237         for (i = 0; i < MAX_CYLINDERS; i++) {
 238                 cylinder_t *cyl = dive->cylinder + i;
 239                 int size = cyl->type.size.mliter;
 240                 double kilo_atm;
 241
 242                 if (!size)
 243                         continue;
 244
 245                 kilo_atm = (cyl->start.mbar - cyl->end.mbar) / 1013250.0;
 246
 247                 /* Liters of air at 1 atm == milliliters at 1k atm*/
 248                 airuse += kilo_atm * size;
 249         }
 250         return airuse;
 251 }
 252
 253 static void get_sac(struct dive *dive, int *val)
 254 {
 255         double airuse, pressure, sac;
 256
 257         *val = 0;
 258         airuse = calculate_airuse(dive);
 259         if (!airuse)
 260                 return;
 261         if (!dive->duration.seconds)
 262                 return;
 263
 264         /* Mean pressure in atm: 1 atm per 10m */
 265         pressure = 1 + (dive->meandepth.mm / 10000.0);
 266         sac = airuse / pressure * 60 / dive->duration.seconds;
 267
 268         /* milliliters per minute.. */
 269         *val = sac * 1000;
 270 }
 271
 272 static void get_string(char **str, const char *s)
 273 {
 274         int len;
 275         char *n;
 276
 277         if (!s)
 278                 s = "";
 279         len = strlen(s);
 280         if (len > 40)
 281                 len = 40;
 282         n = malloc(len+1);
 283         memcpy(n, s, len);
 284         n[len] = 0;
 285         *str = n;
 286 }
 287
 288 static void get_location(struct dive *dive, char **str)
 289 {
 290         get_string(str, dive->location);
 291 }
 292
 293 static void get_cylinder(struct dive *dive, char **str)
 294 {
 295         get_string(str, dive->cylinder[0].type.description);
 296 }
 297
 298 static void fill_one_dive(struct dive *dive,
 299                           GtkTreeModel *model,
 300                           GtkTreeIter *iter)
 301 {
 302         int sac;
 303         char *location, *cylinder;
 304
 305         get_cylinder(dive, &cylinder);
 306         get_location(dive, &location);
 307         get_sac(dive, &sac);
 308
 309         /*
 310          * We only set the fields that changed: the strings.
 311          * The core data itself is unaffected by units
 312          */
 313         gtk_list_store_set(GTK_LIST_STORE(model), iter,
 314                 DIVE_LOCATION, location,
 315                 DIVE_CYLINDER, cylinder,
 316                 DIVE_SAC, sac,
 317                 -1);
 318 }
 319
 320 static gboolean set_one_dive(GtkTreeModel *model,
 321                              GtkTreePath *path,
 322                              GtkTreeIter *iter,
 323                              gpointer data)
 324 {
 325         GValue value = {0, };
 326         struct dive *dive;
 327
 328         /* Get the dive number */
 329         gtk_tree_model_get_value(model, iter, DIVE_INDEX, &value);
 330         dive = get_dive(g_value_get_int(&value));
 331         if (!dive)
 332                 return TRUE;
 333         if (data && dive != data)
 334                 return FALSE;
 335
 336         fill_one_dive(dive, model, iter);
 337         return dive == data;
 338 }
 339
 340 void flush_divelist(struct dive *dive)
 341 {
 342         GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model);
 343
 344         gtk_tree_model_foreach(model, set_one_dive, dive);
 345 }
 346
 347 void update_dive_list_units(void)
 348 {
 349         const char *unit;
 350         GtkTreeModel *model = GTK_TREE_MODEL(dive_list.model);
 351
 352         switch (output_units.length) {
 353         case METERS:
 354                 unit = "max/m";
 355                 break;
 356         case FEET:
 357                 unit = "max/ft";
 358                 break;
 359         }
 360         gtk_tree_view_column_set_title(dive_list.depth, unit);
 361
 362         switch (output_units.temperature) {
 363         case CELSIUS:
 364                 unit = "degC";
 365                 break;
 366         case FAHRENHEIT:
 367                 unit = "degF";
 368                 break;
 369         case KELVIN:
 370                 unit = "Kelvin";
 371                 break;
 372         }
 373         gtk_tree_view_column_set_title(dive_list.temperature, unit);
 374
 375         gtk_tree_model_foreach(model, set_one_dive, NULL);
 376 }
 377
 378 static void fill_dive_list(void)
 379 {
 380         int i;
 381         GtkTreeIter iter;
 382         GtkListStore *store;
 383
 384         store = GTK_LIST_STORE(dive_list.model);
 385
 386         for (i = 0; i < dive_table.nr; i++) {
 387                 struct dive *dive = dive_table.dives[i];
 388
 389                 gtk_list_store_append(store, &iter);
 390                 gtk_list_store_set(store, &iter,
 391                         DIVE_INDEX, i,
 392                         DIVE_DATE, dive->when,
 393                         DIVE_DEPTH, dive->maxdepth,
 394                         DIVE_DURATION, dive->duration.seconds,
 395                         DIVE_LOCATION, "location",
 396                         DIVE_TEMPERATURE, dive->watertemp.mkelvin,
 397                         DIVE_NITROX, dive->cylinder[0].gasmix.o2,
 398                         DIVE_SAC, 0,
 399                         -1);
 400         }
 401
 402         update_dive_list_units();
 403 }
 404
 405 void dive_list_update_dives(void)
 406 {
 407         gtk_list_store_clear(GTK_LIST_STORE(dive_list.model));
 408         fill_dive_list();
 409         repaint_dive();
 410 }
 411
 412 typedef void (*data_func_t)(GtkTreeViewColumn *col,
 413                             GtkCellRenderer *renderer,
 414                             GtkTreeModel *model,
 415                             GtkTreeIter *iter,
 416                             gpointer data);
 417
 418 static GtkTreeViewColumn *divelist_column(struct DiveList *dl, int index, const char *title,
 419                                         data_func_t data_func, int align_right, int expand)
 420 {
 421         GtkCellRenderer *renderer;
 422         GtkTreeViewColumn *col;
 423
 424         renderer = gtk_cell_renderer_text_new();
 425         col = gtk_tree_view_column_new();
 426
 427         gtk_tree_view_column_set_title(col, title);
 428         gtk_tree_view_column_set_sort_column_id(col, DIVE_DATE);
 429         gtk_tree_view_column_set_resizable(col, TRUE);
 430         gtk_tree_view_column_pack_start(col, renderer, TRUE);
 431         if (data_func)
 432                 gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, NULL, NULL);
 433         else
 434                 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
 435         if (align_right) {
 436                 gtk_object_set(GTK_OBJECT(renderer), "alignment", PANGO_ALIGN_RIGHT, NULL);
 437                 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), 1.0, 0.5);
 438         }
 439         gtk_tree_view_column_set_expand(col,expand);
 440         if (expand)
 441                 gtk_tree_view_column_set_min_width(col,50);
 442         gtk_tree_view_append_column(GTK_TREE_VIEW(dl->tree_view), col);
 443         return col;
 444 }
 445
 446 GtkWidget *dive_list_create(void)
 447 {
 448         GtkTreeSelection  *selection;
 449         PangoFontDescription *font_desc = pango_font_description_from_string("sans 8");
 450
 451         dive_list.model = gtk_list_store_new(DIVELIST_COLUMNS,
 452                                 G_TYPE_INT,                     /* index */
 453                                 G_TYPE_INT,                     /* Date */
 454                                 G_TYPE_INT,                     /* Depth */
 455                                 G_TYPE_INT,                     /* Duration */
 456                                 G_TYPE_STRING,                  /* Location */
 457                                 G_TYPE_INT,                     /* Temperature */
 458                                 G_TYPE_STRING,                  /* Cylinder */
 459                                 G_TYPE_INT,                     /* Nitrox */
 460                                 G_TYPE_INT                      /* SAC */
 461                                 );
 462         dive_list.tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dive_list.model));
 463         gtk_widget_modify_font(dive_list.tree_view, font_desc);
 464         pango_font_description_free(font_desc);
 465
 466         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dive_list.tree_view));
 467
 468         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
 469         gtk_widget_set_size_request(dive_list.tree_view, 200, 200);
 470
 471         dive_list.date = divelist_column(&dive_list, DIVE_DATE, "Date", date_data_func, 0, 0);
 472         dive_list.depth = divelist_column(&dive_list, DIVE_DEPTH, "max/ft", depth_data_func, 1, 0);
 473         dive_list.duration = divelist_column(&dive_list, DIVE_DURATION, "min", duration_data_func, 1, 0);
 474         dive_list.location = divelist_column(&dive_list, DIVE_LOCATION, "Location", NULL, 0, 1);
 475         dive_list.temperature = divelist_column(&dive_list, DIVE_TEMPERATURE, "degF", temperature_data_func, 1, 0);
 476         dive_list.cylinder = divelist_column(&dive_list, DIVE_CYLINDER, "Cyl", NULL, 0, 0);
 477         dive_list.nitrox = divelist_column(&dive_list, DIVE_NITROX, "O2%", nitrox_data_func, 1, 0);
 478         dive_list.sac = divelist_column(&dive_list, DIVE_NITROX, "SAC", sac_data_func, 1, 0);
 479
 480         fill_dive_list();
 481
 482         g_object_set(G_OBJECT(dive_list.tree_view), "headers-visible", TRUE,
 483                                           "search-column", 0,
 484                                           "rules-hint", TRUE,
 485                                           NULL);
 486
 487         g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), dive_list.model);
 488
 489         dive_list.container_widget = gtk_scrolled_window_new(NULL, NULL);
 490         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dive_list.container_widget),
 491                                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 492         gtk_container_add(GTK_CONTAINER(dive_list.container_widget), dive_list.tree_view);
 493
 494         return dive_list.container_widget;
 495 }