main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <time.h>
   4 #include <gtk/gtk.h>
   5 #include <gdk/gdk.h>
   6 #include <cairo.h>
   7
   8 #include "dive.h"
   9
  10 static void show_dive(int nr, struct dive *dive)
  11 {
  12         int i;
  13         struct tm *tm;
  14
  15         tm = gmtime(&dive->when);
  16
  17         printf("At %02d:%02d:%02d %04d-%02d-%02d  (%d ft max, %d minutes)\n",
  18                 tm->tm_hour, tm->tm_min, tm->tm_sec,
  19                 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
  20                 to_feet(dive->maxdepth), dive->duration.seconds / 60);
  21
  22         if (!verbose)
  23                 return;
  24
  25         for (i = 0; i < dive->samples; i++) {
  26                 struct sample *s = dive->sample + i;
  27
  28                 printf("%4d:%02d: %3d ft, %2d C, %4d PSI\n",
  29                         s->time.seconds / 60,
  30                         s->time.seconds % 60,
  31                         to_feet(s->depth),
  32                         to_C(s->temperature),
  33                         to_PSI(s->tankpressure));
  34         }
  35 }
  36
  37 static int sortfn(const void *_a, const void *_b)
  38 {
  39         const struct dive *a = *(void **)_a;
  40         const struct dive *b = *(void **)_b;
  41
  42         if (a->when < b->when)
  43                 return -1;
  44         if (a->when > b->when)
  45                 return 1;
  46         return 0;
  47 }
  48
  49 /*
  50  * This doesn't really report anything at all. We just sort the
  51  * dives, the GUI does the reporting
  52  */
  53 static void report_dives(void)
  54 {
  55         qsort(dive_table.dives, dive_table.nr, sizeof(struct dive *), sortfn);
  56 }
  57
  58 static void parse_argument(const char *arg)
  59 {
  60         const char *p = arg+1;
  61
  62         do {
  63                 switch (*p) {
  64                 case 'v':
  65                         verbose++;
  66                         continue;
  67                 default:
  68                         fprintf(stderr, "Bad argument '%s'\n", arg);
  69                         exit(1);
  70                 }
  71         } while (*++p);
  72 }
  73
  74 static void on_destroy(GtkWidget* w, gpointer data)
  75 {
  76         gtk_main_quit();
  77 }
  78
  79 static GtkTreeModel *fill_dive_list(void)
  80 {
  81         int i;
  82         GtkListStore *store;
  83         GtkTreeIter iter;
  84
  85         store = gtk_list_store_new(1, G_TYPE_STRING);
  86
  87         for (i = 0; i < dive_table.nr; i++) {
  88                 struct dive *dive = dive_table.dives[i];
  89
  90                 gtk_list_store_append(store, &iter);
  91                 gtk_list_store_set(store, &iter,
  92                         0, dive->name,
  93                         -1);
  94         }
  95
  96         return GTK_TREE_MODEL(store);
  97 }
  98
  99 static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 100 {
 101         struct dive *dive = dive_table.dives[0];
 102         cairo_t *cr;
 103         int i;
 104
 105         cr = gdk_cairo_create(widget->window);
 106         cairo_set_source_rgb(cr, 0, 0, 0);
 107         gdk_cairo_rectangle(cr, &event->area);
 108         cairo_fill(cr);
 109
 110         cairo_set_line_width(cr, 3);
 111         cairo_set_source_rgb(cr, 1, 1, 1);
 112
 113         if (dive->samples) {
 114                 struct sample *sample = dive->sample;
 115                 cairo_move_to(cr, sample->time.seconds / 5, to_feet(sample->depth) * 3);
 116                 for (i = 1; i < dive->samples; i++) {
 117                         sample++;
 118                         cairo_line_to(cr, sample->time.seconds / 5, to_feet(sample->depth) * 3);
 119                 }
 120                 cairo_stroke(cr);
 121         }
 122
 123         cairo_destroy(cr);
 124
 125         return FALSE;
 126 }
 127
 128 static GtkWidget *create_dive_list(void)
 129 {
 130         GtkWidget *list;
 131         GtkCellRenderer *renderer;
 132         GtkTreeModel *model;
 133
 134         list = gtk_tree_view_new();
 135
 136         renderer = gtk_cell_renderer_text_new();
 137         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(list),
 138                 -1, "Dive", renderer, "text", 0, NULL);
 139
 140         model = fill_dive_list();
 141         gtk_tree_view_set_model(GTK_TREE_VIEW(list), model);
 142         g_object_unref(model);
 143         return list;
 144 }
 145
 146 int main(int argc, char **argv)
 147 {
 148         int i;
 149         GtkWidget *win;
 150         GtkWidget *divelist;
 151         GtkWidget *vbox;
 152         GtkWidget *scrolled_window;
 153         GtkWidget *frame;
 154         GtkWidget *da;
 155
 156         parse_xml_init();
 157
 158         gtk_init(&argc, &argv);
 159
 160         for (i = 1; i < argc; i++) {
 161                 const char *a = argv[i];
 162
 163                 if (a[0] == '-') {
 164                         parse_argument(a);
 165                         continue;
 166                 }
 167                 parse_xml_file(a);
 168         }
 169
 170         report_dives();
 171
 172         win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 173         g_signal_connect(G_OBJECT(win), "destroy",      G_CALLBACK(on_destroy), NULL);
 174
 175         /* HBOX for the list of dives and cairo window */
 176         vbox=gtk_hbox_new(FALSE, 5);
 177         gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
 178         gtk_container_add(GTK_CONTAINER(win), vbox);
 179         gtk_widget_show(vbox);
 180
 181         /* Scrolled window for the list goes into the vbox.. */
 182         scrolled_window=gtk_scrolled_window_new(NULL, NULL);
 183         gtk_widget_set_usize(scrolled_window, 150, 350);
 184         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 185         gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
 186         gtk_widget_show(scrolled_window);
 187
 188         /* Frame for dive profile */
 189         frame = gtk_frame_new("Dive profile");
 190         gtk_container_add(GTK_CONTAINER(vbox), frame);
 191         gtk_widget_show(frame);
 192         da = gtk_drawing_area_new();
 193         gtk_widget_set_size_request(da, 450, 350);
 194         gtk_container_add(GTK_CONTAINER(frame), da);
 195         g_signal_connect(da, "expose_event", G_CALLBACK(expose_event), NULL);
 196
 197         /* Create the atual divelist */
 198         divelist = create_dive_list();
 199
 200         /* .. and connect it to the scrolled window */
 201         gtk_container_add(GTK_CONTAINER(scrolled_window), divelist);
 202
 203         gtk_widget_set_app_paintable(win, TRUE);
 204         gtk_widget_show_all(win);
 205
 206         gtk_main();
 207         return 0;
 208 }