main.c

   1 /* main.c */
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <time.h>
   6
   7 #include <gconf/gconf-client.h>
   8
   9 #include "dive.h"
  10 #include "divelist.h"
  11
  12 GConfClient *gconf;
  13 struct units output_units;
  14
  15 #define GCONF_NAME(x) "/apps/subsurface/" #x
  16
  17 /* random helper functions, used here or elsewhere */
  18 static int sortfn(const void *_a, const void *_b)
  19 {
  20         const struct dive *a = *(void **)_a;
  21         const struct dive *b = *(void **)_b;
  22
  23         if (a->when < b->when)
  24                 return -1;
  25         if (a->when > b->when)
  26                 return 1;
  27         return 0;
  28 }
  29
  30 const char *weekday(int wday)
  31 {
  32         static const char wday_array[7][4] = {
  33                 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  34         };
  35         return wday_array[wday];
  36 }
  37
  38 const char *monthname(int mon)
  39 {
  40         static const char month_array[12][4] = {
  41                 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  42                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
  43         };
  44         return month_array[mon];
  45 }
  46
  47 /*
  48  * When adding dives to the dive table, we try to renumber
  49  * the new dives based on any old dives in the dive table.
  50  *
  51  * But we only do it if:
  52  *
  53  *  - the last dive in the old dive table was numbered
  54  *
  55  *  - all the new dives are strictly at the end (so the
  56  *    "last dive" is at the same location in the dive table
  57  *    after re-sorting the dives.
  58  *
  59  *  - none of the new dives have any numbers
  60  *
  61  * This catches the common case of importing new dives from
  62  * a dive computer, and gives them proper numbers based on
  63  * your old dive list. But it tries to be very conservative
  64  * and not give numbers if there is *any* question about
  65  * what the numbers should be - in which case you need to do
  66  * a manual re-numbering.
  67  */
  68 static void try_to_renumber(struct dive *last, int preexisting)
  69 {
  70         int i, nr;
  71
  72         /*
  73          * If the new dives aren't all strictly at the end,
  74          * we're going to expect the user to do a manual
  75          * renumbering.
  76          */
  77         if (get_dive(preexisting-1) != last)
  78                 return;
  79
  80         /*
  81          * If any of the new dives already had a number,
  82          * we'll have to do a manual renumbering.
  83          */
  84         for (i = preexisting; i < dive_table.nr; i++) {
  85                 struct dive *dive = get_dive(i);
  86                 if (dive->number)
  87                         return;
  88         }
  89
  90         /*
  91          * Ok, renumber..
  92          */
  93         nr = last->number;
  94         for (i = preexisting; i < dive_table.nr; i++) {
  95                 struct dive *dive = get_dive(i);
  96                 dive->number = ++nr;
  97         }
  98 }
  99
 100 /*
 101  * This doesn't really report anything at all. We just sort the
 102  * dives, the GUI does the reporting
 103  */
 104 void report_dives(void)
 105 {
 106         int i;
 107         int preexisting = dive_table.preexisting;
 108         struct dive *last;
 109
 110         /* This does the right thing for -1: NULL */
 111         last = get_dive(preexisting-1);
 112
 113         qsort(dive_table.dives, dive_table.nr, sizeof(struct dive *), sortfn);
 114
 115         for (i = 1; i < dive_table.nr; i++) {
 116                 struct dive **pp = &dive_table.dives[i-1];
 117                 struct dive *prev = pp[0];
 118                 struct dive *dive = pp[1];
 119                 struct dive *merged;
 120
 121                 if (prev->when + prev->duration.seconds < dive->when)
 122                         continue;
 123
 124                 merged = try_to_merge(prev, dive);
 125                 if (!merged)
 126                         continue;
 127
 128                 free(prev);
 129                 free(dive);
 130                 *pp = merged;
 131                 dive_table.nr--;
 132                 memmove(pp+1, pp+2, sizeof(*pp)*(dive_table.nr - i));
 133
 134                 /* Redo the new 'i'th dive */
 135                 i--;
 136         }
 137
 138         /* Was the previous dive table state numbered? */
 139         if (last && last->number)
 140                 try_to_renumber(last, preexisting);
 141
 142         dive_table.preexisting = dive_table.nr;
 143         dive_list_update_dives();
 144 }
 145
 146 static void parse_argument(const char *arg)
 147 {
 148         const char *p = arg+1;
 149
 150         do {
 151                 switch (*p) {
 152                 case 'v':
 153                         verbose++;
 154                         continue;
 155                 default:
 156                         fprintf(stderr, "Bad argument '%s'\n", arg);
 157                         exit(1);
 158                 }
 159         } while (*++p);
 160 }
 161
 162 void update_dive(struct dive *new_dive)
 163 {
 164         static struct dive *buffered_dive;
 165         struct dive *old_dive = buffered_dive;
 166
 167         if (old_dive) {
 168                 flush_dive_info_changes(old_dive);
 169                 flush_dive_equipment_changes(old_dive);
 170                 flush_divelist(old_dive);
 171         }
 172         if (new_dive) {
 173                 show_dive_info(new_dive);
 174                 show_dive_equipment(new_dive);
 175         }
 176         buffered_dive = new_dive;
 177 }
 178
 179 void renumber_dives(int nr)
 180 {
 181         int i;
 182
 183         for (i = 0; i < dive_table.nr; i++) {
 184                 struct dive *dive = dive_table.dives[i];
 185                 dive->number = nr + i;
 186         }
 187 }
 188
 189 int main(int argc, char **argv)
 190 {
 191         int i;
 192
 193         output_units = SI_units;
 194
 195         parse_xml_init();
 196
 197         init_ui(argc, argv);
 198
 199         for (i = 1; i < argc; i++) {
 200                 const char *a = argv[i];
 201
 202                 if (a[0] == '-') {
 203                         parse_argument(a);
 204                         continue;
 205                 }
 206                 GError *error = NULL;
 207                 parse_xml_file(a, &error);
 208
 209                 if (error != NULL)
 210                 {
 211                         report_error(error);
 212                         g_error_free(error);
 213                         error = NULL;
 214                 }
 215         }
 216
 217         report_dives();
 218
 219         run_ui();
 220         return 0;
 221 }