2011-08-31 01:23:59 +00:00
|
|
|
#ifndef DIVE_H
|
|
|
|
|
#define DIVE_H
|
|
|
|
|
|
2011-09-03 20:19:26 +00:00
|
|
|
#include <stdlib.h>
|
2012-11-25 19:44:27 +00:00
|
|
|
#include <stdint.h>
|
2011-09-03 20:19:26 +00:00
|
|
|
#include <time.h>
|
2013-01-08 23:48:23 +00:00
|
|
|
#include <math.h>
|
2013-12-19 13:00:50 +00:00
|
|
|
#include <zip.h>
|
2014-02-15 06:36:49 +00:00
|
|
|
#include <sqlite3.h>
|
2014-05-06 21:08:17 +00:00
|
|
|
#include <string.h>
|
2013-10-07 04:04:25 +00:00
|
|
|
|
|
|
|
|
/* Windows has no MIN/MAX macros - so let's just roll our own */
|
|
|
|
|
#define MIN(x, y) ({ \
|
2014-03-05 20:19:45 +00:00
|
|
|
typeof(x) _min1 = (x); \
|
|
|
|
|
typeof(y) _min2 = (y); \
|
|
|
|
|
(void) (&_min1 == &_min2); \
|
|
|
|
|
_min1 < _min2 ? _min1 : _min2; })
|
2013-10-07 04:04:25 +00:00
|
|
|
|
|
|
|
|
#define MAX(x, y) ({ \
|
2014-03-05 20:19:45 +00:00
|
|
|
typeof(x) _max1 = (x); \
|
|
|
|
|
typeof(y) _max2 = (y); \
|
|
|
|
|
(void) (&_max1 == &_max2); \
|
|
|
|
|
_max1 > _max2 ? _max1 : _max2; })
|
2011-09-03 20:19:26 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define IS_FP_SAME(_a, _b) (fabs((_a) - (_b)) < 0.000001 * MAX(fabs(_a), fabs(_b)))
|
2014-01-21 20:43:07 +00:00
|
|
|
|
2014-05-06 21:08:17 +00:00
|
|
|
static inline int same_string(const char *a, const char *b)
|
|
|
|
|
{
|
|
|
|
|
return !strcmp(a ? : "", b ? : "");
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-05 10:39:17 +00:00
|
|
|
#include <libxml/tree.h>
|
2013-03-10 08:24:49 +00:00
|
|
|
#include <libxslt/transform.h>
|
2013-02-16 01:03:42 +00:00
|
|
|
|
|
|
|
|
#include "sha1.h"
|
2014-05-10 23:42:27 +00:00
|
|
|
#include "units.h"
|
2011-09-05 20:14:53 +00:00
|
|
|
|
2013-04-01 10:51:49 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
2013-05-06 06:07:03 +00:00
|
|
|
#else
|
|
|
|
|
#include <stdbool.h>
|
2013-04-01 10:51:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
2011-09-12 16:47:55 +00:00
|
|
|
struct gasmix {
|
2011-08-31 01:23:59 +00:00
|
|
|
fraction_t o2;
|
Start parsing gas mixes
The suunto xml is just completely crazy. What's the helium percentage
companion to "o2pct"? Would it be "hepct"? No. It's "hepct_0".
Ok, so they didn't number the first o2pct, which could be seen as sane:
that's the only mix value that should always exist. And they clearly
started their indexing with 0. So with multiple mixes, you'd then
expect "o2pct_1" and "hepct_1", right?
Wrong! Because XML people are crazy, the second O2 mix percentage is
obviously "o2pct_2". So the O2 percentages are one-based, with an
implicit one. But the He percentages are zero-based with an explicit
zero. So the second mix is "o2pct_2" and "hepct_1".
I'd like to ask what drugs Suunto people are on, but hey, it's a Finnish
company. No need to ask. Vodka explains everything. LOTS AND LOTS OF
VODKA.
In comparison, the libdivecomputer output is nice and sane, and uses a
'gasmix' node. Of course, now we have so many different XML nesting
nodes to check that I just made it an array of different noces. That
also allows me to mark the suunto case, so that we only do the "check
for crazy alcoholic xml entries" when it's a suunto file.
The "type of file" thing is probably a good idea for deciding on default
units too. Some day.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-01 20:32:52 +00:00
|
|
|
fraction_t he;
|
2011-09-12 16:47:55 +00:00
|
|
|
};
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-08-31 01:23:59 +00:00
|
|
|
volume_t size;
|
2011-09-04 03:31:18 +00:00
|
|
|
pressure_t workingpressure;
|
2014-02-28 04:09:57 +00:00
|
|
|
const char *description; /* "LP85", "AL72", "AL80", "HP100+" or whatever */
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_type_t;
|
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-09-04 03:31:18 +00:00
|
|
|
cylinder_type_t type;
|
2011-09-12 16:47:55 +00:00
|
|
|
struct gasmix gasmix;
|
2011-11-09 15:37:25 +00:00
|
|
|
pressure_t start, end, sample_start, sample_end;
|
2013-11-12 02:12:43 +00:00
|
|
|
depth_t depth;
|
2014-01-11 14:57:06 +00:00
|
|
|
bool used;
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_t;
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-12-24 03:41:16 +00:00
|
|
|
weight_t weight;
|
2014-02-28 04:09:57 +00:00
|
|
|
const char *description; /* "integrated", "belt", "ankle" */
|
2011-12-24 03:41:16 +00:00
|
|
|
} weightsystem_t;
|
|
|
|
|
|
2011-11-02 03:13:14 +00:00
|
|
|
extern int get_pressure_units(unsigned int mb, const char **units);
|
2014-02-28 23:38:42 +00:00
|
|
|
extern double get_depth_units(int mm, int *frac, const char **units);
|
2012-08-07 18:24:40 +00:00
|
|
|
extern double get_volume_units(unsigned int ml, int *frac, const char **units);
|
|
|
|
|
extern double get_temp_units(unsigned int mk, const char **units);
|
|
|
|
|
extern double get_weight_units(unsigned int grams, int *frac, const char **units);
|
2013-10-04 05:57:48 +00:00
|
|
|
extern double get_vertical_speed_units(unsigned int mms, int *frac, const char **units);
|
2011-09-21 19:12:54 +00:00
|
|
|
|
2013-10-11 23:39:40 +00:00
|
|
|
extern unsigned int units_to_depth(double depth);
|
|
|
|
|
|
2013-02-25 23:23:16 +00:00
|
|
|
/* Volume in mliter of a cylinder at pressure 'p' */
|
|
|
|
|
extern int gas_volume(cylinder_t *cyl, pressure_t p);
|
2013-05-22 20:29:17 +00:00
|
|
|
extern int wet_volume(double cuft, pressure_t p);
|
2011-09-22 20:45:53 +00:00
|
|
|
|
2013-03-28 16:56:32 +00:00
|
|
|
static inline int get_o2(const struct gasmix *mix)
|
|
|
|
|
{
|
2014-02-28 04:09:57 +00:00
|
|
|
return mix->o2.permille ?: O2_IN_AIR;
|
2013-03-28 16:56:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int get_he(const struct gasmix *mix)
|
|
|
|
|
{
|
|
|
|
|
return mix->he.permille;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-05 07:29:09 +00:00
|
|
|
static inline bool is_air(int o2, int he)
|
2013-02-13 04:58:58 +00:00
|
|
|
{
|
|
|
|
|
return (he == 0) && (o2 == 0 || ((o2 >= O2_IN_AIR - 1) && (o2 <= O2_IN_AIR + 1)));
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-08 23:48:23 +00:00
|
|
|
/* Linear interpolation between 'a' and 'b', when we are 'part'way into the 'whole' distance from a to b */
|
|
|
|
|
static inline int interpolate(int a, int b, int part, int whole)
|
|
|
|
|
{
|
|
|
|
|
/* It is doubtful that we actually need floating point for this, but whatever */
|
2014-02-28 04:09:57 +00:00
|
|
|
double x = (double)a * (whole - part) + (double)b * part;
|
2013-01-08 23:48:23 +00:00
|
|
|
return rint(x / whole);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
struct sample {
|
|
|
|
|
duration_t time;
|
|
|
|
|
depth_t depth;
|
|
|
|
|
temperature_t temperature;
|
2011-09-04 03:31:18 +00:00
|
|
|
pressure_t cylinderpressure;
|
2014-02-28 04:09:57 +00:00
|
|
|
int sensor; /* Cylinder pressure sensor index */
|
2012-12-01 21:02:30 +00:00
|
|
|
duration_t ndl;
|
|
|
|
|
duration_t stoptime;
|
|
|
|
|
depth_t stopdepth;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool in_deco;
|
2012-12-08 04:08:29 +00:00
|
|
|
int cns;
|
|
|
|
|
int po2;
|
2014-01-17 22:00:28 +00:00
|
|
|
int heartbeat;
|
|
|
|
|
int bearing;
|
2011-08-31 01:23:59 +00:00
|
|
|
};
|
|
|
|
|
|
2013-11-02 01:12:42 +00:00
|
|
|
struct divetag {
|
|
|
|
|
/*
|
|
|
|
|
* The name of the divetag. If a translation is available, name contains
|
|
|
|
|
* the translated tag
|
|
|
|
|
*/
|
|
|
|
|
char *name;
|
|
|
|
|
/*
|
|
|
|
|
* If a translation is available, we write the original tag to source.
|
|
|
|
|
* This enables us to write a non-localized tag to the xml file.
|
|
|
|
|
*/
|
|
|
|
|
char *source;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct tag_entry {
|
|
|
|
|
struct divetag *tag;
|
|
|
|
|
struct tag_entry *next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* divetags are only stored once, each dive only contains
|
|
|
|
|
* a list of tag_entries which then point to the divetags
|
|
|
|
|
* in the global g_tag_list
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
extern struct tag_entry *g_tag_list;
|
|
|
|
|
|
Get rid of crazy empty tag_list element at the start
So this is totally unrelated to the git repository format, except for
the fact that I noticed it while writing the git saving code.
The subsurface divetag list handling is being stupid, and has a
initial dummy entry at the head of the list for no good reason.
I say "no good reason", because there *is* a reason for it: it allows
code to avoid the special case of empty list and adding entries to
before the first entry etc etc. But that reason is a really *bad*
reason, because it's valid only because people don't understand basic
list manipulation and pointers to pointers.
So get rid of the dummy element, and do things right instead - by
passing a *pointer* to the list, instead of the list. And then when
traversing the list and looking for a place to insert things, don't go
to the next entry - just update the "pointer to pointer" to point to
the address of the next entry. Each entry in a C linked list is no
different than the list itself, so you can use the pointer to the
pointer to the next entry as a pointer to the list.
This is a pet peeve of mine. The real beauty of pointers can never be
understood unless you understand the indirection they allow. People
who grew up with Pascal and were corrupted by that mindset are
mentally stunted. Niklaus Wirth has a lot to answer for!
But never fear. You too can overcome that mental limitation, it just
needs some brain exercise. Reading this patch may help. In particular,
contemplate the new "taglist_add_divetag()".
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-10 17:18:13 +00:00
|
|
|
struct divetag *taglist_add_tag(struct tag_entry **tag_list, const char *tag);
|
2013-11-02 01:12:42 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Writes all divetags in tag_list to buffer, limited by the buffer's (len)gth.
|
|
|
|
|
* Returns the characters written
|
|
|
|
|
*/
|
|
|
|
|
int taglist_get_tagstring(struct tag_entry *tag_list, char *buffer, int len);
|
|
|
|
|
|
|
|
|
|
void taglist_init_global();
|
Get rid of crazy empty tag_list element at the start
So this is totally unrelated to the git repository format, except for
the fact that I noticed it while writing the git saving code.
The subsurface divetag list handling is being stupid, and has a
initial dummy entry at the head of the list for no good reason.
I say "no good reason", because there *is* a reason for it: it allows
code to avoid the special case of empty list and adding entries to
before the first entry etc etc. But that reason is a really *bad*
reason, because it's valid only because people don't understand basic
list manipulation and pointers to pointers.
So get rid of the dummy element, and do things right instead - by
passing a *pointer* to the list, instead of the list. And then when
traversing the list and looking for a place to insert things, don't go
to the next entry - just update the "pointer to pointer" to point to
the address of the next entry. Each entry in a C linked list is no
different than the list itself, so you can use the pointer to the
pointer to the next entry as a pointer to the list.
This is a pet peeve of mine. The real beauty of pointers can never be
understood unless you understand the indirection they allow. People
who grew up with Pascal and were corrupted by that mindset are
mentally stunted. Niklaus Wirth has a lot to answer for!
But never fear. You too can overcome that mental limitation, it just
needs some brain exercise. Reading this patch may help. In particular,
contemplate the new "taglist_add_divetag()".
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-10 17:18:13 +00:00
|
|
|
void taglist_free(struct tag_entry *tag_list);
|
2013-11-02 01:12:42 +00:00
|
|
|
|
2011-09-23 01:02:54 +00:00
|
|
|
/*
|
|
|
|
|
* Events are currently pretty meaningless. This is
|
|
|
|
|
* just based on the random data that libdivecomputer
|
|
|
|
|
* gives us. I'm not sure what a real "architected"
|
|
|
|
|
* event model would actually look like, but right
|
|
|
|
|
* now you can associate a list of events with a dive,
|
|
|
|
|
* and we'll do something about it.
|
|
|
|
|
*/
|
|
|
|
|
struct event {
|
|
|
|
|
struct event *next;
|
|
|
|
|
duration_t time;
|
|
|
|
|
int type, flags, value;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool deleted;
|
2011-09-23 01:02:54 +00:00
|
|
|
char name[];
|
|
|
|
|
};
|
|
|
|
|
|
2012-11-25 19:44:27 +00:00
|
|
|
/*
|
|
|
|
|
* NOTE! The deviceid and diveid are model-specific *hashes* of
|
|
|
|
|
* whatever device identification that model may have. Different
|
|
|
|
|
* dive computers will have different identifying data, it could
|
|
|
|
|
* be a firmware number or a serial ID (in either string or in
|
|
|
|
|
* numeric format), and we do not care.
|
|
|
|
|
*
|
|
|
|
|
* The only thing we care about is that subsurface will hash
|
|
|
|
|
* that information the same way. So then you can check the ID
|
|
|
|
|
* of a dive computer by comparing the hashes for equality.
|
|
|
|
|
*
|
|
|
|
|
* A deviceid or diveid of zero is assumed to be "no ID".
|
|
|
|
|
*/
|
2012-11-24 02:51:27 +00:00
|
|
|
struct divecomputer {
|
2012-11-25 02:50:21 +00:00
|
|
|
timestamp_t when;
|
2013-01-23 18:25:31 +00:00
|
|
|
duration_t duration, surfacetime;
|
|
|
|
|
depth_t maxdepth, meandepth;
|
|
|
|
|
temperature_t airtemp, watertemp;
|
|
|
|
|
pressure_t surface_pressure;
|
|
|
|
|
int salinity; // kg per 10000 l
|
2012-11-25 19:44:27 +00:00
|
|
|
const char *model;
|
|
|
|
|
uint32_t deviceid, diveid;
|
2012-11-24 02:51:27 +00:00
|
|
|
int samples, alloc_samples;
|
|
|
|
|
struct sample *sample;
|
|
|
|
|
struct event *events;
|
2012-11-25 02:50:21 +00:00
|
|
|
struct divecomputer *next;
|
2012-11-24 02:51:27 +00:00
|
|
|
};
|
|
|
|
|
|
2011-09-04 21:29:57 +00:00
|
|
|
#define MAX_CYLINDERS (8)
|
2013-12-28 15:33:09 +00:00
|
|
|
#define MAX_WEIGHTSYSTEMS (6)
|
2012-08-15 22:21:34 +00:00
|
|
|
#define W_IDX_PRIMARY 0
|
|
|
|
|
#define W_IDX_SECONDARY 1
|
Start parsing gas mixes
The suunto xml is just completely crazy. What's the helium percentage
companion to "o2pct"? Would it be "hepct"? No. It's "hepct_0".
Ok, so they didn't number the first o2pct, which could be seen as sane:
that's the only mix value that should always exist. And they clearly
started their indexing with 0. So with multiple mixes, you'd then
expect "o2pct_1" and "hepct_1", right?
Wrong! Because XML people are crazy, the second O2 mix percentage is
obviously "o2pct_2". So the O2 percentages are one-based, with an
implicit one. But the He percentages are zero-based with an explicit
zero. So the second mix is "o2pct_2" and "hepct_1".
I'd like to ask what drugs Suunto people are on, but hey, it's a Finnish
company. No need to ask. Vodka explains everything. LOTS AND LOTS OF
VODKA.
In comparison, the libdivecomputer output is nice and sane, and uses a
'gasmix' node. Of course, now we have so many different XML nesting
nodes to check that I just made it an array of different noces. That
also allows me to mark the suunto case, so that we only do the "check
for crazy alcoholic xml entries" when it's a suunto file.
The "type of file" thing is probably a good idea for deciding on default
units too. Some day.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-01 20:32:52 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef enum {
|
|
|
|
|
TF_NONE,
|
|
|
|
|
NO_TRIP,
|
|
|
|
|
IN_TRIP,
|
|
|
|
|
ASSIGNED_TRIP,
|
|
|
|
|
NUM_TRIPFLAGS
|
|
|
|
|
} tripflag_t;
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct dive_trip
|
|
|
|
|
{
|
2012-09-20 19:30:58 +00:00
|
|
|
timestamp_t when;
|
2012-09-20 03:42:11 +00:00
|
|
|
char *location;
|
|
|
|
|
char *notes;
|
2012-11-26 02:53:15 +00:00
|
|
|
struct dive *dives;
|
2012-11-10 18:51:03 +00:00
|
|
|
int nrdives;
|
Allow overlapping (and disjoint) dive trips
We used to have the rule that a dive trip has to have all dives in it in
sequential order, even though our XML file really is much more flexible,
and allows arbitrary nesting of dives within a dive trip.
Put another way, the old model had fairly inflexible rules:
- the dive array is sorted by time
- a dive trip is always a contiguous slice of this sorted array
which makes perfect sense when you think of the dive and trip list as a
physical activity by one person, but leads to various very subtle issues
in the general case when there are no guarantees that the user then uses
subsurface that way.
In particular, if you load the XML files of two divers that have
overlapping dive trips, the end result is incredibly messy, and does not
conform to the above model at all.
There's two ways to enforce such conformance:
- disallow that kind of behavior entirely.
This is actually hard. Our XML files aren't date-based, they are
based on XML nesting rules, and even a single XML file can have
nesting that violates the date ordering. With multiple XML files,
it's trivial to do in practice, and while we could just fail at
loading, the failure would have to be a hard failure that leaves the
user no way to use the data at all.
- try to "fix it up" by sorting, splitting, and combining dive trips
automatically.
Dirk had a patch to do this, but it really does destroy the actual
dive data: if you load both mine and Dirk's dive trips, you ended up
with a result that followed the above two technical rules, but that
didn't actually make any *sense*.
So this patch doesn't try to enforce the rules, and instead just changes
them to be more generic:
- the dive array is still sorted by dive time
- a dive trip is just an arbitrary collection of dives.
The relaxed rules means that mixing dives and dive trips for two people
is trivial, and we can easily handle any XML file. The dive trip is
defined by the XML nesting level, and is totally independent of any
date-based sorting.
It does require a few things:
- when we save our dive data, we have to do it hierarchically by dive
trip, not just by walking the dive array linearly.
- similarly, when we create the dive tree model, we can't just blindly
walk the array of dives one by one, we have to look up the correct
trip (parent)
- when we try to merge two dives that are adjacent (by date sorting),
we can't do it if they are in different trips.
but apart from that, nothing else really changes.
NOTE! Despite the new relaxed model, creating totally disjoing dive
trips is not all that easy (nor is there any *reason* for it to be
easty). Our GUI interfaces still are "add dive to trip above" etc, and
the automatic adding of dives to dive trips is obviously still based on
date.
So this does not really change the expected normal usage, the relaxed
data structure rules just mean that we don't need to worry about the odd
cases as much, because we can just let them be.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-12-30 19:00:37 +00:00
|
|
|
int index;
|
2014-02-28 04:09:57 +00:00
|
|
|
unsigned expanded : 1, selected : 1, autogen : 1, fixup : 1;
|
2012-11-26 04:06:54 +00:00
|
|
|
struct dive_trip *next;
|
2012-09-20 03:42:11 +00:00
|
|
|
} dive_trip_t;
|
|
|
|
|
|
2012-11-26 04:06:54 +00:00
|
|
|
/* List of dive trips (sorted by date) */
|
|
|
|
|
extern dive_trip_t *dive_trip_list;
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
struct dive {
|
2011-09-11 18:36:33 +00:00
|
|
|
int number;
|
2012-08-22 05:04:24 +00:00
|
|
|
tripflag_t tripflag;
|
2012-09-20 03:42:11 +00:00
|
|
|
dive_trip_t *divetrip;
|
2012-11-26 02:53:15 +00:00
|
|
|
struct dive *next, **pprev;
|
2012-08-20 12:48:07 +00:00
|
|
|
int selected;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool downloaded;
|
2012-09-20 00:35:52 +00:00
|
|
|
timestamp_t when;
|
2011-09-02 02:56:04 +00:00
|
|
|
char *location;
|
|
|
|
|
char *notes;
|
2011-09-13 21:58:06 +00:00
|
|
|
char *divemaster, *buddy;
|
2011-12-07 19:58:16 +00:00
|
|
|
int rating;
|
2012-12-05 17:59:52 +00:00
|
|
|
degrees_t latitude, longitude;
|
2012-10-28 22:49:02 +00:00
|
|
|
int visibility; /* 0 - 5 star rating */
|
2011-09-04 03:31:18 +00:00
|
|
|
cylinder_t cylinder[MAX_CYLINDERS];
|
2011-12-24 03:41:16 +00:00
|
|
|
weightsystem_t weightsystem[MAX_WEIGHTSYSTEMS];
|
2012-08-14 23:07:25 +00:00
|
|
|
char *suit;
|
2012-12-11 05:18:48 +00:00
|
|
|
int sac, otu, cns, maxcns;
|
2013-02-09 00:15:18 +00:00
|
|
|
|
|
|
|
|
/* Calculated based on dive computer data */
|
2013-02-09 15:41:15 +00:00
|
|
|
temperature_t mintemp, maxtemp, watertemp, airtemp;
|
2013-02-09 14:50:53 +00:00
|
|
|
depth_t maxdepth, meandepth;
|
2013-02-09 00:15:18 +00:00
|
|
|
pressure_t surface_pressure;
|
2013-02-09 15:12:30 +00:00
|
|
|
duration_t duration;
|
2013-02-09 00:15:18 +00:00
|
|
|
int salinity; // kg per 10000 l
|
2012-11-24 02:51:27 +00:00
|
|
|
|
2014-01-07 01:30:01 +00:00
|
|
|
struct tag_entry *tag_list;
|
2012-11-24 02:51:27 +00:00
|
|
|
struct divecomputer dc;
|
2014-01-07 01:30:01 +00:00
|
|
|
int id; // unique ID for this dive
|
2011-08-31 01:23:59 +00:00
|
|
|
};
|
|
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
static inline int dive_has_gps_location(struct dive *dive)
|
2013-01-16 20:31:09 +00:00
|
|
|
{
|
|
|
|
|
return dive->latitude.udeg || dive->longitude.udeg;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
static inline void copy_gps_location(struct dive *from, struct dive *to)
|
|
|
|
|
{
|
|
|
|
|
if (from && to) {
|
|
|
|
|
to->latitude.udeg = from->latitude.udeg;
|
|
|
|
|
to->longitude.udeg = from->longitude.udeg;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-05 07:29:09 +00:00
|
|
|
static inline int get_surface_pressure_in_mbar(const struct dive *dive, bool non_null)
|
2013-02-09 00:15:18 +00:00
|
|
|
{
|
|
|
|
|
int mbar = dive->surface_pressure.mbar;
|
|
|
|
|
if (!mbar && non_null)
|
|
|
|
|
mbar = SURFACE_PRESSURE;
|
|
|
|
|
return mbar;
|
|
|
|
|
}
|
2013-02-08 20:49:12 +00:00
|
|
|
|
2012-11-10 22:11:40 +00:00
|
|
|
/* Pa = N/m^2 - so we determine the weight (in N) of the mass of 10m
|
|
|
|
|
* of water (and use standard salt water at 1.03kg per liter if we don't know salinity)
|
|
|
|
|
* and add that to the surface pressure (or to 1013 if that's unknown) */
|
2013-02-09 00:15:18 +00:00
|
|
|
static inline int calculate_depth_to_mbar(int depth, pressure_t surface_pressure, int salinity)
|
2012-11-10 22:11:40 +00:00
|
|
|
{
|
2013-02-09 00:15:18 +00:00
|
|
|
double specific_weight;
|
|
|
|
|
int mbar = surface_pressure.mbar;
|
|
|
|
|
|
|
|
|
|
if (!mbar)
|
|
|
|
|
mbar = SURFACE_PRESSURE;
|
|
|
|
|
if (!salinity)
|
|
|
|
|
salinity = SEAWATER_SALINITY;
|
|
|
|
|
specific_weight = salinity / 10000.0 * 0.981;
|
2014-02-12 22:19:53 +00:00
|
|
|
mbar += rint(depth / 10.0 * specific_weight);
|
2013-02-09 00:15:18 +00:00
|
|
|
return mbar;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int depth_to_mbar(int depth, struct dive *dive)
|
|
|
|
|
{
|
|
|
|
|
return calculate_depth_to_mbar(depth, dive->surface_pressure, dive->salinity);
|
2012-11-10 22:11:40 +00:00
|
|
|
}
|
|
|
|
|
|
2014-02-11 21:08:29 +00:00
|
|
|
static inline double depth_to_atm(int depth, struct dive *dive)
|
|
|
|
|
{
|
|
|
|
|
return mbar_to_atm(depth_to_mbar(depth, dive));
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-12 20:17:52 +00:00
|
|
|
/* for the inverse calculation we use just the relative pressure
|
|
|
|
|
* (that's the one that some dive computers like the Uemis Zurich
|
|
|
|
|
* provide - for the other models that do this libdivecomputer has to
|
|
|
|
|
* take care of this, but the Uemis we support natively */
|
|
|
|
|
static inline int rel_mbar_to_depth(int mbar, struct dive *dive)
|
|
|
|
|
{
|
|
|
|
|
int cm;
|
|
|
|
|
double specific_weight = 1.03 * 0.981;
|
2013-01-23 18:25:31 +00:00
|
|
|
if (dive->dc.salinity)
|
|
|
|
|
specific_weight = dive->dc.salinity / 10000.0 * 0.981;
|
2012-11-12 20:17:52 +00:00
|
|
|
/* whole mbar gives us cm precision */
|
2014-02-12 22:19:53 +00:00
|
|
|
cm = rint(mbar / specific_weight);
|
2012-11-12 20:17:52 +00:00
|
|
|
return cm * 10;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-11 09:36:46 +00:00
|
|
|
#define SURFACE_THRESHOLD 750 /* somewhat arbitrary: only below 75cm is it really diving */
|
|
|
|
|
|
2012-09-11 20:37:06 +00:00
|
|
|
/* this is a global spot for a temporary dive structure that we use to
|
|
|
|
|
* be able to edit a dive without unintended side effects */
|
|
|
|
|
extern struct dive edit_dive;
|
|
|
|
|
|
2013-04-07 03:49:06 +00:00
|
|
|
extern short autogroup;
|
2012-08-22 05:04:24 +00:00
|
|
|
/* random threashold: three days without diving -> new trip
|
|
|
|
|
* this works very well for people who usually dive as part of a trip and don't
|
|
|
|
|
* regularly dive at a local facility; this is why trips are an optional feature */
|
2014-02-28 04:09:57 +00:00
|
|
|
#define TRIP_THRESHOLD 3600 * 24 * 3
|
2012-08-22 05:04:24 +00:00
|
|
|
|
|
|
|
|
#define UNGROUPED_DIVE(_dive) ((_dive)->tripflag == NO_TRIP)
|
2012-09-20 03:42:11 +00:00
|
|
|
#define DIVE_IN_TRIP(_dive) ((_dive)->tripflag == IN_TRIP || (_dive)->tripflag == ASSIGNED_TRIP)
|
2012-09-07 17:12:31 +00:00
|
|
|
#define DIVE_NEEDS_TRIP(_dive) ((_dive)->tripflag == TF_NONE)
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2012-11-10 18:51:03 +00:00
|
|
|
extern void add_dive_to_trip(struct dive *, dive_trip_t *);
|
|
|
|
|
|
2012-11-11 06:49:19 +00:00
|
|
|
extern void delete_single_dive(int idx);
|
|
|
|
|
extern void add_single_dive(int idx, struct dive *dive);
|
|
|
|
|
|
2012-09-20 16:56:48 +00:00
|
|
|
extern void insert_trip(dive_trip_t **trip);
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2011-09-07 02:07:17 +00:00
|
|
|
|
|
|
|
|
extern const struct units SI_units, IMPERIAL_units;
|
2013-01-11 01:26:10 +00:00
|
|
|
extern struct units xml_parsing_units;
|
2011-09-07 02:07:17 +00:00
|
|
|
|
2013-01-11 01:26:10 +00:00
|
|
|
extern struct units *get_units(void);
|
2013-11-02 19:00:16 +00:00
|
|
|
extern int verbose, quit;
|
2011-08-31 01:40:25 +00:00
|
|
|
|
|
|
|
|
struct dive_table {
|
2011-10-05 15:31:31 +00:00
|
|
|
int nr, allocated, preexisting;
|
2011-08-31 01:40:25 +00:00
|
|
|
struct dive **dives;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern struct dive_table dive_table;
|
|
|
|
|
|
2011-09-11 19:53:59 +00:00
|
|
|
extern int selected_dive;
|
|
|
|
|
#define current_dive (get_dive(selected_dive))
|
2013-03-18 01:07:59 +00:00
|
|
|
#define current_dc (get_dive_dc(current_dive, dc_number))
|
2011-09-11 19:53:59 +00:00
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
static inline struct dive *get_gps_location(int nr, struct dive_table *table)
|
|
|
|
|
{
|
|
|
|
|
if (nr >= table->nr || nr < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
return table->dives[nr];
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-18 23:51:48 +00:00
|
|
|
static inline struct dive *get_dive(int nr)
|
2011-08-31 23:33:20 +00:00
|
|
|
{
|
2012-08-15 22:21:34 +00:00
|
|
|
if (nr >= dive_table.nr || nr < 0)
|
2011-08-31 23:33:20 +00:00
|
|
|
return NULL;
|
|
|
|
|
return dive_table.dives[nr];
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-17 15:19:09 +00:00
|
|
|
static inline unsigned int number_of_computers(struct dive *dive)
|
|
|
|
|
{
|
|
|
|
|
unsigned int total_number = 0;
|
|
|
|
|
struct divecomputer *dc = &dive->dc;
|
|
|
|
|
|
|
|
|
|
if (!dive)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
total_number++;
|
|
|
|
|
dc = dc->next;
|
|
|
|
|
} while (dc);
|
|
|
|
|
return total_number;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-18 01:07:59 +00:00
|
|
|
static inline struct divecomputer *get_dive_dc(struct dive *dive, int nr)
|
|
|
|
|
{
|
2014-03-17 15:19:09 +00:00
|
|
|
struct divecomputer *dc = &dive->dc;
|
|
|
|
|
|
|
|
|
|
while (nr-- > 0) {
|
2013-03-18 01:07:59 +00:00
|
|
|
dc = dc->next;
|
2014-03-17 15:19:09 +00:00
|
|
|
if (!dc)
|
|
|
|
|
return &dive->dc;
|
|
|
|
|
}
|
2013-03-18 01:07:59 +00:00
|
|
|
return dc;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-21 22:51:34 +00:00
|
|
|
/*
|
|
|
|
|
* Iterate over each dive, with the first parameter being the index
|
|
|
|
|
* iterator variable, and the second one being the dive one.
|
|
|
|
|
*
|
|
|
|
|
* I don't think anybody really wants the index, and we could make
|
|
|
|
|
* it local to the for-loop, but that would make us requires C99.
|
|
|
|
|
*/
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_dive(_i, _x) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for ((_i) = 0; ((_x) = get_dive(_i)) != NULL; (_i)++)
|
2012-08-21 22:51:34 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_dc(_dive, _dc) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for (_dc = &_dive->dc; _dc; _dc = _dc->next)
|
2013-02-09 00:15:18 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_gps_location(_i, _x) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for ((_i) = 0; ((_x) = get_gps_location(_i, &gps_location_table)) != NULL; (_i)++)
|
2013-01-31 03:09:16 +00:00
|
|
|
|
2014-05-12 17:10:13 +00:00
|
|
|
static inline struct dive *get_dive_by_uemis_diveid(uint32_t diveid, uint32_t deviceid)
|
2013-01-29 22:25:09 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct dive *dive;
|
|
|
|
|
|
|
|
|
|
for_each_dive(i, dive) {
|
|
|
|
|
struct divecomputer *dc = &dive->dc;
|
|
|
|
|
do {
|
|
|
|
|
if (dc->diveid == diveid && dc->deviceid == deviceid)
|
|
|
|
|
return dive;
|
|
|
|
|
} while ((dc = dc->next) != NULL);
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2014-05-12 17:10:13 +00:00
|
|
|
|
2014-05-18 21:38:37 +00:00
|
|
|
static inline struct dive *get_dive_by_uniq_id(int id)
|
2014-01-07 01:30:01 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct dive *dive = NULL;
|
|
|
|
|
|
|
|
|
|
for_each_dive(i, dive) {
|
|
|
|
|
if (dive->id == id)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-05-12 17:22:46 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
|
if(dive == NULL){
|
|
|
|
|
fprintf(stderr, "Invalid id %x passed to get_dive_by_diveid, try to fix the code\n", id);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2014-01-07 01:30:01 +00:00
|
|
|
return dive;
|
|
|
|
|
}
|
2014-01-27 13:44:26 +00:00
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-03-07 03:27:28 +00:00
|
|
|
extern int report_error(const char *fmt, ...);
|
2014-03-14 17:35:09 +00:00
|
|
|
extern const char *get_error_string(void);
|
2014-03-07 03:27:28 +00:00
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
extern struct dive *find_dive_including(timestamp_t when);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern bool dive_within_time_range(struct dive *dive, timestamp_t when, timestamp_t offset);
|
2013-01-31 03:09:16 +00:00
|
|
|
struct dive *find_dive_n_near(timestamp_t when, int n, timestamp_t offset);
|
2013-01-29 22:25:09 +00:00
|
|
|
|
|
|
|
|
/* Check if two dive computer entries are the exact same dive (-1=no/0=maybe/1=yes) */
|
|
|
|
|
extern int match_one_dc(struct divecomputer *a, struct divecomputer *b);
|
|
|
|
|
|
2011-08-31 17:20:46 +00:00
|
|
|
extern void parse_xml_init(void);
|
2014-03-14 18:26:07 +00:00
|
|
|
extern void parse_xml_buffer(const char *url, const char *buf, int size, struct dive_table *table, const char **params);
|
2012-09-18 15:33:55 +00:00
|
|
|
extern void parse_xml_exit(void);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern void set_filename(const char *filename, bool force);
|
2011-08-31 01:40:25 +00:00
|
|
|
|
2014-03-14 18:26:07 +00:00
|
|
|
extern int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
|
|
|
|
extern int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2013-03-05 05:10:39 +00:00
|
|
|
|
2014-03-14 18:26:07 +00:00
|
|
|
extern int parse_file(const char *filename);
|
|
|
|
|
extern int parse_csv_file(const char *filename, int time, int depth, int temp, int po2f, int cnsf, int stopdepthf, int sepidx, const char *csvtemplate, int units);
|
|
|
|
|
extern int parse_manual_file(const char *filename, int separator_index, int units, int number, int date, int time, int duration, int location, int gps, int maxdepth, int meandepth, int buddy, int notes, int weight, int tags);
|
2012-01-26 21:00:45 +00:00
|
|
|
|
2014-03-14 17:11:26 +00:00
|
|
|
extern int save_dives(const char *filename);
|
|
|
|
|
extern int save_dives_logic(const char *filename, bool select_only);
|
|
|
|
|
extern int save_dive(FILE *f, struct dive *dive);
|
2014-04-26 07:55:41 +00:00
|
|
|
extern int export_dives_xslt(const char *filename, const bool selected, const char *export_xslt);
|
2014-03-12 21:12:58 +00:00
|
|
|
|
2014-03-13 22:42:45 +00:00
|
|
|
struct git_oid;
|
2014-03-12 21:12:58 +00:00
|
|
|
struct git_repository;
|
2014-03-15 00:55:07 +00:00
|
|
|
#define dummy_git_repository ((git_repository *) 3ul) /* Random bogus pointer, not NULL */
|
2014-03-12 21:12:58 +00:00
|
|
|
extern struct git_repository *is_git_repository(const char *filename, const char **branchp);
|
|
|
|
|
extern int git_save_dives(struct git_repository *, const char *, bool select_only);
|
|
|
|
|
extern int git_load_dives(struct git_repository *, const char *);
|
2014-03-13 22:42:45 +00:00
|
|
|
extern const char *saved_git_id;
|
|
|
|
|
extern void clear_git_id(void);
|
|
|
|
|
extern void set_git_id(const struct git_oid *);
|
2013-03-10 08:24:49 +00:00
|
|
|
|
2014-04-14 21:33:46 +00:00
|
|
|
struct user_info {
|
|
|
|
|
const char *name;
|
|
|
|
|
const char *email;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern void subsurface_user_info(struct user_info *);
|
2014-02-16 21:25:02 +00:00
|
|
|
extern int subsurface_rename(const char *path, const char *newpath);
|
2013-12-19 13:00:50 +00:00
|
|
|
extern int subsurface_open(const char *path, int oflags, mode_t mode);
|
|
|
|
|
extern FILE *subsurface_fopen(const char *path, const char *mode);
|
|
|
|
|
extern void *subsurface_opendir(const char *path);
|
|
|
|
|
extern struct zip *subsurface_zip_open_readonly(const char *path, int flags, int *errorp);
|
|
|
|
|
extern int subsurface_zip_close(struct zip *zip);
|
2014-03-25 14:55:56 +00:00
|
|
|
extern void subsurface_console_init(bool dedicated);
|
|
|
|
|
extern void subsurface_console_exit(void);
|
2013-12-19 13:00:50 +00:00
|
|
|
|
2013-11-18 13:53:05 +00:00
|
|
|
extern void shift_times(const timestamp_t amount);
|
2014-03-20 20:57:49 +00:00
|
|
|
extern timestamp_t get_times();
|
2013-11-18 13:53:05 +00:00
|
|
|
|
2013-03-10 08:24:49 +00:00
|
|
|
extern xsltStylesheetPtr get_stylesheet(const char *name);
|
2011-09-01 23:27:52 +00:00
|
|
|
|
2012-09-20 00:35:52 +00:00
|
|
|
extern timestamp_t utc_mktime(struct tm *tm);
|
|
|
|
|
extern void utc_mkdate(timestamp_t, struct tm *tm);
|
2011-09-12 20:25:05 +00:00
|
|
|
|
2011-09-12 19:56:34 +00:00
|
|
|
extern struct dive *alloc_dive(void);
|
|
|
|
|
extern void record_dive(struct dive *dive);
|
|
|
|
|
|
2012-11-24 02:51:27 +00:00
|
|
|
extern struct sample *prepare_sample(struct divecomputer *dc);
|
|
|
|
|
extern void finish_sample(struct divecomputer *dc);
|
2011-09-12 19:56:34 +00:00
|
|
|
|
2014-04-24 20:58:39 +00:00
|
|
|
extern bool has_hr_data(struct divecomputer *dc);
|
|
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
extern void sort_table(struct dive_table *table);
|
2011-09-03 20:19:26 +00:00
|
|
|
extern struct dive *fixup_dive(struct dive *dive);
|
2014-05-11 01:18:37 +00:00
|
|
|
extern int dive_getUniqID(struct dive *d);
|
2013-02-14 23:18:48 +00:00
|
|
|
extern unsigned int dc_airtemp(struct divecomputer *dc);
|
2013-11-29 20:05:21 +00:00
|
|
|
extern unsigned int dc_watertemp(struct divecomputer *dc);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern struct dive *merge_dives(struct dive *a, struct dive *b, int offset, bool prefer_downloaded);
|
|
|
|
|
extern struct dive *try_to_merge(struct dive *a, struct dive *b, bool prefer_downloaded);
|
2011-09-20 19:40:34 +00:00
|
|
|
extern void renumber_dives(int nr);
|
2013-11-08 09:15:04 +00:00
|
|
|
extern void copy_events(struct dive *s, struct dive *d);
|
2013-11-07 08:25:42 +00:00
|
|
|
extern void copy_cylinders(struct dive *s, struct dive *d);
|
2013-09-19 04:33:39 +00:00
|
|
|
extern void copy_samples(struct dive *s, struct dive *d);
|
2011-09-16 22:45:14 +00:00
|
|
|
|
2013-11-13 12:44:18 +00:00
|
|
|
extern void fill_default_cylinder(cylinder_t *cyl);
|
First step in cleaning up cylinder pressure sensor logic
This clarifies/changes the meaning of our "cylinderindex" entry in our
samples. It has been rather confused, because different dive computers
have done things differently, and the naming really hasn't helped.
There are two totally different - and independent - cylinder "indexes":
- the pressure sensor index, which indicates which cylinder the sensor
data is from.
- the "active cylinder" index, which indicates which cylinder we actually
breathe from.
These two values really are totally independent, and have nothing
what-so-ever to do with each other. The sensor index may well be fixed:
many dive computers only support a single pressure sensor (whether
wireless or wired), and the sensor index is thus always zero.
Other dive computers may support multiple pressure sensors, and the gas
switch event may - or may not - indicate that the sensor changed too. A
dive computer might give the sensor data for *all* cylinders it can read,
regardless of which one is the one we're actively breathing. In fact, some
dive computers might give sensor data for not just *your* cylinder, but
your buddies.
This patch renames "cylinderindex" in the samples as "sensor", making it
quite clear that it's about which sensor index the pressure data in the
sample is about.
The way we figure out which is the currently active gas is with an
explicit has change event. If a computer (like the Uemis Zurich) joins the
two concepts together, then a sensor change should also create a gas
switch event. This patch also changes the Uemis importer to do that.
Finally, it should be noted that the plot info works totally separately
from the sample data, and is about what we actually *display*, not about
the sample pressures etc. In the plot info, the "cylinderindex" does in
fact mean the currently active cylinder, and while it is initially set to
match the sensor information from the samples, we then walk the gas change
events and fix it up - and if the active cylinder differs from the sensor
cylinder, we clear the sensor data.
[Dirk Hohndel: this conflicted with some of my recent changes - I think
I merged things correctly...]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-12-31 04:00:51 +00:00
|
|
|
extern void add_gas_switch_event(struct dive *dive, struct divecomputer *dc, int time, int idx);
|
2012-11-24 02:51:27 +00:00
|
|
|
extern void add_event(struct divecomputer *dc, int time, int type, int flags, int value, const char *name);
|
2013-11-20 06:50:02 +00:00
|
|
|
extern void per_cylinder_mean_depth(struct dive *dive, struct divecomputer *dc, int *mean, int *duration);
|
2013-11-20 18:52:17 +00:00
|
|
|
extern int get_cylinder_index(struct dive *dive, struct event *ev);
|
Initial implementation of git save format
This saves the dive data into a git object repository instead of a
single XML file.
We create a git object tree with each dive as a separate file,
hierarchically by trip and date.
NOTE 1: This largely duplicates the XML saving code, because trying to
share it seemed just too painful: the logic is very similar, but the
details of the actual strings end up differing sufficiently that there
are tons of trivial differences.
The git save format is line-based with minimal quoting, while XML quotes
everything with either "<..\>" or using single quotes around attributes.
NOTE 2: You currently need a dummy "file" to save to, which points to
the real save location: the git repository and branch to be used. We
should make this a config thing, but for testing, do something like
this:
echo git /home/torvalds/scuba:linus > git-test
to create that git information file, and when you use "Save To" and
specify "git-test" as the file to save to, subsurface will use the new
git save logic to save to the branch "linus" in the repository found at
"/home/torvalds/scuba".
NOTE 3: The git save format uses just the git object directory, it does
*not* check out the result in any git working tree or index. So after
you do a save, you can do
git log -p linus
to see what actually happened in that branch, but it will not affect any
actual checked-out state in the repository.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-06 21:28:39 +00:00
|
|
|
extern int nr_cylinders(struct dive *dive);
|
|
|
|
|
extern int nr_weightsystems(struct dive *dive);
|
2011-09-23 01:02:54 +00:00
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
/* UI related protopypes */
|
|
|
|
|
|
2013-10-05 07:29:09 +00:00
|
|
|
// extern void report_error(GError* error);
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2011-10-22 15:12:30 +00:00
|
|
|
extern void add_cylinder_description(cylinder_type_t *);
|
2012-08-06 21:03:24 +00:00
|
|
|
extern void add_weightsystem_description(weightsystem_t *);
|
2011-10-25 07:29:19 +00:00
|
|
|
extern void remember_event(const char *eventname);
|
2013-10-09 07:14:39 +00:00
|
|
|
|
|
|
|
|
#if WE_DONT_USE_THIS /* this is a missing feature in Qt - selecting which events to display */
|
|
|
|
|
extern int evn_foreach(void (*callback)(const char *, bool *, void *), void *data);
|
|
|
|
|
#endif /* WE_DONT_USE_THIS */
|
|
|
|
|
|
2013-01-31 13:07:04 +00:00
|
|
|
extern void clear_events(void);
|
2011-10-23 06:47:19 +00:00
|
|
|
|
2012-12-13 06:26:29 +00:00
|
|
|
extern void set_dc_nickname(struct dive *dive);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern void set_autogroup(bool value);
|
2013-01-02 20:16:42 +00:00
|
|
|
extern int total_weight(struct dive *);
|
2012-12-13 06:26:29 +00:00
|
|
|
|
2014-01-27 13:44:26 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-09-05 20:14:53 +00:00
|
|
|
#define DIVE_ERROR_PARSE 1
|
2013-02-13 23:03:25 +00:00
|
|
|
#define DIVE_ERROR_PLAN 2
|
2011-09-05 20:14:53 +00:00
|
|
|
|
2011-09-20 05:09:47 +00:00
|
|
|
const char *weekday(int wday);
|
|
|
|
|
const char *monthname(int mon);
|
|
|
|
|
|
2011-09-21 00:52:04 +00:00
|
|
|
#define UTF8_DEGREE "\xc2\xb0"
|
2013-09-25 00:07:07 +00:00
|
|
|
#define UTF8_DELTA "\xce\x94"
|
|
|
|
|
#define UTF8_UPWARDS_ARROW "\xE2\x86\x91"
|
|
|
|
|
#define UTF8_DOWNWARDS_ARROW "\xE2\x86\x93"
|
|
|
|
|
#define UTF8_AVERAGE "\xc3\xb8"
|
2011-09-21 00:52:04 +00:00
|
|
|
#define UTF8_SUBSCRIPT_2 "\xe2\x82\x82"
|
2011-12-07 19:58:16 +00:00
|
|
|
#define UTF8_WHITESTAR "\xe2\x98\x86"
|
|
|
|
|
#define UTF8_BLACKSTAR "\xe2\x98\x85"
|
2011-09-21 00:52:04 +00:00
|
|
|
|
2012-09-16 03:51:06 +00:00
|
|
|
extern const char *existing_filename;
|
2013-10-05 07:29:09 +00:00
|
|
|
extern void subsurface_command_line_init(int *, char ***);
|
|
|
|
|
extern void subsurface_command_line_exit(int *, char ***);
|
2011-12-31 16:15:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define FRACTION(n, x) ((unsigned)(n) / (x)), ((unsigned)(n) % (x))
|
2012-09-10 19:17:28 +00:00
|
|
|
|
2013-02-08 06:15:50 +00:00
|
|
|
extern double add_segment(double pressure, const struct gasmix *gasmix, int period_in_seconds, int setpoint, const struct dive *dive);
|
2013-01-04 04:45:20 +00:00
|
|
|
extern void clear_deco(double surface_pressure);
|
|
|
|
|
extern void dump_tissues(void);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern unsigned int deco_allowed_depth(double tissues_tolerance, double surface_pressure, struct dive *dive, bool smooth);
|
2013-11-20 15:11:22 +00:00
|
|
|
extern void set_gf(short gflow, short gfhigh, bool gf_low_at_maxdepth);
|
2013-01-06 19:13:46 +00:00
|
|
|
extern void cache_deco_state(double, char **datap);
|
|
|
|
|
extern double restore_deco_state(char *data);
|
2013-01-05 07:11:42 +00:00
|
|
|
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint {
|
|
|
|
|
int time;
|
2013-10-08 05:37:32 +00:00
|
|
|
unsigned int depth;
|
2013-01-05 20:56:45 +00:00
|
|
|
int o2;
|
|
|
|
|
int he;
|
2013-01-23 19:12:24 +00:00
|
|
|
int po2;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool entered;
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint *next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct diveplan {
|
|
|
|
|
timestamp_t when;
|
2013-02-27 18:22:51 +00:00
|
|
|
int lastdive_nr;
|
2014-02-28 04:09:57 +00:00
|
|
|
int surface_pressure; /* mbar */
|
|
|
|
|
int bottomsac; /* ml/min */
|
|
|
|
|
int decosac; /* ml/min */
|
2013-06-24 04:27:52 +00:00
|
|
|
short gflow;
|
|
|
|
|
short gfhigh;
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint *dp;
|
|
|
|
|
};
|
|
|
|
|
|
2014-03-12 15:49:42 +00:00
|
|
|
struct divedatapoint *plan_add_segment(struct diveplan *diveplan, int duration, int depth, int o2, int he, int po2, bool entered);
|
2013-03-18 01:07:59 +00:00
|
|
|
void get_gas_string(int o2, int he, char *buf, int len);
|
2013-06-24 01:04:35 +00:00
|
|
|
struct divedatapoint *create_dp(int time_incr, int depth, int o2, int he, int po2);
|
2014-04-17 02:56:42 +00:00
|
|
|
#if DEBUG_PLAN
|
2013-06-24 01:04:35 +00:00
|
|
|
void dump_plan(struct diveplan *diveplan);
|
2014-04-17 02:56:42 +00:00
|
|
|
#endif
|
2014-03-14 18:26:07 +00:00
|
|
|
void plan(struct diveplan *diveplan, char **cached_datap, struct dive **divep, bool add_deco);
|
2013-07-05 21:42:35 +00:00
|
|
|
void delete_single_dive(int idx);
|
2013-01-05 07:11:42 +00:00
|
|
|
|
2013-03-28 02:04:46 +00:00
|
|
|
struct event *get_next_event(struct event *event, char *name);
|
|
|
|
|
|
2013-04-15 18:04:35 +00:00
|
|
|
|
2013-05-24 01:38:45 +00:00
|
|
|
/* these structs holds the information that
|
|
|
|
|
* describes the cylinders / weight systems.
|
|
|
|
|
* they are global variables initialized in equipment.c
|
2013-04-15 18:04:35 +00:00
|
|
|
* used to fill the combobox in the add/edit cylinder
|
|
|
|
|
* dialog
|
|
|
|
|
*/
|
|
|
|
|
|
2013-09-10 18:44:49 +00:00
|
|
|
struct tank_info_t {
|
2013-04-15 18:04:35 +00:00
|
|
|
const char *name;
|
|
|
|
|
int cuft, ml, psi, bar;
|
|
|
|
|
};
|
2013-09-10 18:44:49 +00:00
|
|
|
extern struct tank_info_t tank_info[100];
|
2013-05-24 01:38:45 +00:00
|
|
|
|
2013-09-10 18:44:49 +00:00
|
|
|
struct ws_info_t {
|
2013-05-24 01:38:45 +00:00
|
|
|
const char *name;
|
|
|
|
|
int grams;
|
|
|
|
|
};
|
2013-09-10 18:44:49 +00:00
|
|
|
extern struct ws_info_t ws_info[100];
|
2013-04-15 18:04:35 +00:00
|
|
|
|
2013-05-22 17:02:28 +00:00
|
|
|
extern bool cylinder_nodata(cylinder_t *cyl);
|
|
|
|
|
extern bool cylinder_none(void *_data);
|
|
|
|
|
extern bool weightsystem_none(void *_data);
|
|
|
|
|
extern bool no_weightsystems(weightsystem_t *ws);
|
|
|
|
|
extern bool weightsystems_equal(weightsystem_t *ws1, weightsystem_t *ws2);
|
|
|
|
|
extern void remove_cylinder(struct dive *dive, int idx);
|
|
|
|
|
extern void remove_weightsystem(struct dive *dive, int idx);
|
|
|
|
|
|
2014-01-03 04:35:35 +00:00
|
|
|
/*
|
|
|
|
|
* String handling.
|
|
|
|
|
*/
|
2014-02-28 04:09:57 +00:00
|
|
|
#define STRTOD_NO_SIGN 0x01
|
|
|
|
|
#define STRTOD_NO_DOT 0x02
|
|
|
|
|
#define STRTOD_NO_COMMA 0x04
|
|
|
|
|
#define STRTOD_NO_EXPONENT 0x08
|
2014-01-08 06:51:22 +00:00
|
|
|
extern double strtod_flags(const char *str, const char **ptr, unsigned int flags);
|
2014-01-03 04:35:35 +00:00
|
|
|
|
|
|
|
|
#define STRTOD_ASCII (STRTOD_NO_COMMA)
|
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define ascii_strtod(str, ptr) strtod_flags(str, ptr, STRTOD_ASCII)
|
2014-01-03 04:35:35 +00:00
|
|
|
|
2014-04-11 06:17:35 +00:00
|
|
|
extern void set_save_userid_local(short value);
|
|
|
|
|
extern void set_userid(char* user_id);
|
|
|
|
|
|
2013-04-01 10:51:49 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-01-08 06:55:47 +00:00
|
|
|
extern weight_t string_to_weight(const char *str);
|
|
|
|
|
extern depth_t string_to_depth(const char *str);
|
2014-01-09 00:49:21 +00:00
|
|
|
extern pressure_t string_to_pressure(const char *str);
|
2014-01-09 02:34:25 +00:00
|
|
|
extern volume_t string_to_volume(const char *str, pressure_t workp);
|
2014-01-09 02:43:28 +00:00
|
|
|
extern fraction_t string_to_fraction(const char *str);
|
2014-04-26 15:29:40 +00:00
|
|
|
extern int average_depth(struct diveplan *dive);
|
2014-01-08 06:55:47 +00:00
|
|
|
|
2013-01-11 01:26:10 +00:00
|
|
|
#include "pref.h"
|
|
|
|
|
|
2014-02-11 18:14:46 +00:00
|
|
|
#endif // DIVE_H
|
