Start handling dive events

[ext/subsurface.git] / dive.c

diff --git a/dive.c b/dive.c
index e899c6ccbab5d26cff741f7040da86fd45d96b04..67a78cc8ad309189dc14419501e1209b1997e637 100644 (file)
--- a/dive.c
+++ b/dive.c
@@ -1,8 +1,103 @@
+/* dive.c */
+/* maintains the internal dive list structure */
 #include <string.h>
 #include <stdio.h>
 
 #include "dive.h"
 
+void add_event(struct dive *dive, int time, int type, int flags, int value, const char *name)
+{
+       struct event *ev, **p;
+       unsigned int size, len = strlen(name);
+
+       size = sizeof(*ev) + len + 1;
+       ev = malloc(size);
+       if (!ev)
+               return;
+       memset(ev, 0, size);
+       memcpy(ev->name, name, len);
+       ev->time.seconds = time;
+       ev->type = type;
+       ev->flags = flags;
+       ev->value = value;
+       ev->next = NULL;
+
+       p = &dive->events;
+       while (*p)
+               p = &(*p)->next;
+       *p = ev;
+}
+
+double get_depth_units(unsigned int mm, int *frac, const char **units)
+{
+       int decimals;
+       double d;
+       const char *unit;
+
+       switch (output_units.length) {
+       case METERS:
+               d = mm / 1000.0;
+               unit = "m";
+               decimals = d < 20;
+               break;
+       case FEET:
+               d = mm_to_feet(mm);
+               unit = "ft";
+               decimals = 0;
+               break;
+       }
+       if (frac)
+               *frac = decimals;
+       if (units)
+               *units = unit;
+       return d;
+}
+
+struct dive *alloc_dive(void)
+{
+       const int initial_samples = 5;
+       unsigned int size;
+       struct dive *dive;
+
+       size = dive_size(initial_samples);
+       dive = malloc(size);
+       if (!dive)
+               exit(1);
+       memset(dive, 0, size);
+       dive->alloc_samples = initial_samples;
+       return dive;
+}
+
+struct sample *prepare_sample(struct dive **divep)
+{
+       struct dive *dive = *divep;
+       if (dive) {
+               int nr = dive->samples;
+               int alloc_samples = dive->alloc_samples;
+               struct sample *sample;
+               if (nr >= alloc_samples) {
+                       unsigned int size;
+
+                       alloc_samples = (alloc_samples * 3)/2 + 10;
+                       size = dive_size(alloc_samples);
+                       dive = realloc(dive, size);
+                       if (!dive)
+                               return NULL;
+                       dive->alloc_samples = alloc_samples;
+                       *divep = dive;
+               }
+               sample = dive->sample + nr;
+               memset(sample, 0, sizeof(*sample));
+               return sample;
+       }
+       return NULL;
+}
+
+void finish_sample(struct dive *dive, struct sample *sample)
+{
+       dive->samples++;
+}
+
 /*
  * So when we re-calculate maxdepth and meandepth, we will
  * not override the old numbers if they are close to the
@@ -72,7 +167,6 @@ struct dive *fixup_dive(struct dive *dive)
        int maxdepth = 0, mintemp = 0;
        int lastdepth = 0;
        int lasttemp = 0;
-       temperature_t *redundant_temp = NULL;
 
        for (i = 0; i < dive->samples; i++) {
                struct sample *sample = dive->sample + i;
@@ -96,17 +190,12 @@ struct dive *fixup_dive(struct dive *dive)
                        /*
                         * If we have consecutive identical
                         * temperature readings, throw away
-                        * the redundant ones. We care about
-                        * the "edges" only.
+                        * the redundant ones.
                         */
-                       if (lasttemp == temp) {
-                               if (redundant_temp)
-                                       redundant_temp->mkelvin = 0;
-                               redundant_temp = &sample->temperature;
-                       } else {
-                               redundant_temp = NULL;
+                       if (lasttemp == temp)
+                               sample->temperature.mkelvin = 0;
+                       else
                                lasttemp = temp;
-                       }
 
                        if (!mintemp || temp < mintemp)
                                mintemp = temp;
@@ -132,25 +221,17 @@ struct dive *fixup_dive(struct dive *dive)
 /* Don't pick a zero for MERGE_MIN() */
 #define MERGE_MAX(res, a, b, n) res->n = MAX(a->n, b->n)
 #define MERGE_MIN(res, a, b, n) res->n = (a->n)?(b->n)?MIN(a->n, b->n):(a->n):(b->n)
-
-static int alloc_samples;
+#define MERGE_TXT(res, a, b, n) res->n = merge_text(a->n, b->n)
 
 static struct dive *add_sample(struct sample *sample, int time, struct dive *dive)
 {
-       int nr = dive->samples;
-       struct sample *d;
-
-       if (nr >= alloc_samples) {
-               alloc_samples = (alloc_samples + 64) * 3 / 2;
-               dive = realloc(dive, dive_size(alloc_samples));
-               if (!dive)
-                       return NULL;
-       }
-       dive->samples = nr+1;
-       d = dive->sample + nr;
+       struct sample *p = prepare_sample(&dive);
 
-       *d = *sample;
-       d->time.seconds = time;
+       if (!p)
+               return NULL;
+       *p = *sample;
+       p->time.seconds = time;
+       finish_sample(dive, p);
        return dive;
 }
 
@@ -274,15 +355,14 @@ struct dive *try_to_merge(struct dive *a, struct dive *b)
        if (a->when != b->when)
                return NULL;
 
-       alloc_samples = 5;
-       res = malloc(dive_size(alloc_samples));
-       if (!res)
-               return NULL;
-       memset(res, 0, dive_size(alloc_samples));
+       res = alloc_dive();
 
        res->when = a->when;
-       res->location = merge_text(a->location, b->location);
-       res->notes = merge_text(a->notes, b->notes);
+       MERGE_TXT(res, a, b, location);
+       MERGE_TXT(res, a, b, notes);
+       MERGE_TXT(res, a, b, buddy);
+       MERGE_TXT(res, a, b, divemaster);
+       MERGE_MAX(res, a, b, number);
        MERGE_MAX(res, a, b, maxdepth.mm);
        res->meandepth.mm = 0;
        MERGE_MAX(res, a, b, duration.seconds);