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