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         /* did we have dives in the table and added more? */
 143         if (last && preexisting != dive_table.nr)
 144                 mark_divelist_changed(TRUE);
 145         dive_table.preexisting = dive_table.nr;
 146         dive_list_update_dives();
 147 }
 148
 149 static void parse_argument(const char *arg)
 150 {
 151         const char *p = arg+1;
 152
 153         do {
 154                 switch (*p) {
 155                 case 'v':
 156                         verbose++;
 157                         continue;
 158                 case '-':
 159                         /* long options with -- */
 160                         if (strcmp(arg,"--import") == 0) {
 161                                 /* mark the dives so far as the base,
 162                                  * everything after is imported */
 163                                 report_dives();
 164                                 return;
 165                         }
 166                         /* fallthrough */
 167                 default:
 168                         fprintf(stderr, "Bad argument '%s'\n", arg);
 169                         exit(1);
 170                 }
 171         } while (*++p);
 172 }
 173
 174 void update_dive(struct dive *new_dive)
 175 {
 176         static struct dive *buffered_dive;
 177         struct dive *old_dive = buffered_dive;
 178
 179         if (old_dive) {
 180                 flush_dive_info_changes(old_dive);
 181                 flush_dive_equipment_changes(old_dive);
 182                 flush_divelist(old_dive);
 183         }
 184         if (new_dive) {
 185                 show_dive_info(new_dive);
 186                 show_dive_equipment(new_dive);
 187         }
 188         buffered_dive = new_dive;
 189 }
 190
 191 void renumber_dives(int nr)
 192 {
 193         int i;
 194
 195         for (i = 0; i < dive_table.nr; i++) {
 196                 struct dive *dive = dive_table.dives[i];
 197                 dive->number = nr + i;
 198         }
 199         mark_divelist_changed(TRUE);
 200 }
 201
 202 int main(int argc, char **argv)
 203 {
 204         int i;
 205
 206         output_units = SI_units;
 207
 208         parse_xml_init();
 209
 210         init_ui(argc, argv);
 211
 212         for (i = 1; i < argc; i++) {
 213                 const char *a = argv[i];
 214
 215                 if (a[0] == '-') {
 216                         parse_argument(a);
 217                         continue;
 218                 }
 219                 GError *error = NULL;
 220                 parse_xml_file(a, &error);
 221
 222                 if (error != NULL)
 223                 {
 224                         report_error(error);
 225                         g_error_free(error);
 226                         error = NULL;
 227                 }
 228         }
 229
 230         report_dives();
 231
 232         run_ui();
 233         return 0;
 234 }