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>
|
2011-09-03 20:19:26 +00:00
|
|
|
|
2011-09-05 20:14:53 +00:00
|
|
|
#include <glib.h>
|
2012-09-11 18:42:47 +00:00
|
|
|
#include <glib/gstdio.h>
|
2011-11-05 10:39:17 +00:00
|
|
|
#include <libxml/tree.h>
|
2012-11-25 19:44:27 +00:00
|
|
|
#include <openssl/sha.h>
|
2011-09-05 20:14:53 +00:00
|
|
|
|
2013-01-14 22:53:38 +00:00
|
|
|
#define O2_IN_AIR 209 // permille
|
|
|
|
|
#define N2_IN_AIR 781
|
|
|
|
|
#define O2_DENSITY 1429 // mg/Liter
|
|
|
|
|
#define N2_DENSITY 1251
|
|
|
|
|
#define HE_DENSITY 179
|
|
|
|
|
#define SURFACE_PRESSURE 1013 // mbar
|
|
|
|
|
#define SURFACE_PRESSURE_STRING "1013"
|
2013-01-14 00:24:58 +00:00
|
|
|
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
/*
|
|
|
|
|
* Some silly typedefs to make our units very explicit.
|
|
|
|
|
*
|
|
|
|
|
* Also, the units are chosen so that values can be expressible as
|
|
|
|
|
* integers, so that we never have FP rounding issues. And they
|
|
|
|
|
* are small enough that converting to/from imperial units doesn't
|
|
|
|
|
* really matter.
|
|
|
|
|
*
|
|
|
|
|
* We also strive to make '0' a meaningless number saying "not
|
|
|
|
|
* initialized", since many values are things that may not have
|
2011-09-04 03:31:18 +00:00
|
|
|
* been reported (eg cylinder pressure or temperature from dive
|
2011-08-31 01:23:59 +00:00
|
|
|
* computers that don't support them). But sometimes -1 is an even
|
|
|
|
|
* more explicit way of saying "not there".
|
|
|
|
|
*
|
|
|
|
|
* Thus "millibar" for pressure, for example, or "millikelvin" for
|
|
|
|
|
* temperatures. Doing temperatures in celsius or fahrenheit would
|
|
|
|
|
* make for loss of precision when converting from one to the other,
|
|
|
|
|
* and using millikelvin is SI-like but also means that a temperature
|
2011-09-04 03:31:18 +00:00
|
|
|
* of '0' is clearly just a missing temperature or cylinder pressure.
|
2011-08-31 01:23:59 +00:00
|
|
|
*
|
|
|
|
|
* Also strive to use units that can not possibly be mistaken for a
|
|
|
|
|
* valid value in a "normal" system without conversion. If the max
|
|
|
|
|
* depth of a dive is '20000', you probably didn't convert from mm on
|
|
|
|
|
* output, or if the max depth gets reported as "0.2ft" it was either
|
|
|
|
|
* a really boring dive, or there was some missing input conversion,
|
|
|
|
|
* and a 60-ft dive got recorded as 60mm.
|
|
|
|
|
*
|
|
|
|
|
* Doing these as "structs containing value" means that we always
|
|
|
|
|
* have to explicitly write out those units in order to get at the
|
|
|
|
|
* actual value. So there is hopefully little fear of using a value
|
|
|
|
|
* in millikelvin as Fahrenheit by mistake.
|
|
|
|
|
*
|
|
|
|
|
* We don't actually use these all yet, so maybe they'll change, but
|
|
|
|
|
* I made a number of types as guidelines.
|
|
|
|
|
*/
|
2012-11-25 02:50:21 +00:00
|
|
|
typedef gint64 timestamp_t;
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
typedef struct {
|
|
|
|
|
int seconds;
|
|
|
|
|
} duration_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int mm;
|
|
|
|
|
} depth_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int mbar;
|
|
|
|
|
} pressure_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int mkelvin;
|
|
|
|
|
} temperature_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int mliter;
|
|
|
|
|
} volume_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int permille;
|
|
|
|
|
} fraction_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
int grams;
|
|
|
|
|
} weight_t;
|
|
|
|
|
|
2012-12-05 17:59:52 +00:00
|
|
|
typedef struct {
|
|
|
|
|
int udeg;
|
|
|
|
|
} degrees_t;
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
volume_t size;
|
2011-09-04 03:31:18 +00:00
|
|
|
pressure_t workingpressure;
|
2011-09-04 18:32:30 +00:00
|
|
|
const char *description; /* "LP85", "AL72", "AL80", "HP100+" or whatever */
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_type_t;
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
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;
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_t;
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2011-12-24 03:41:16 +00:00
|
|
|
typedef struct {
|
|
|
|
|
weight_t weight;
|
|
|
|
|
const char *description; /* "integrated", "belt", "ankle" */
|
|
|
|
|
} weightsystem_t;
|
|
|
|
|
|
Fix missing save of (almost empty) cylinder information
If we have no explicit cylinder info at all (it's normal air, no size or
working pressure information, and no beginning/end pressure information),
we don't save the cylinders in question because that would be redundant.
Such non-saved cylinders may still show up in the equipment list because
there may be implicit mention of them elsewhere, notably due to sample
data, so not saving them is the right thing to do - there is nothing to
save.
However, we missed one case: if there were other cylinders that *did* have
explicit information in it following such an uninteresting cylinder, we do
need to save the cylinder information for the useless case - if only in
order to be able to save the non-useless information for subsequent
cylinders.
This patch does that. Now, if you had an air-filled cylinder with no
information as your first cylinder, and a 51% nitrox as your second one,
it will save that information as
<cylinder />
<cylinder o2='51.0%' />
rather than dropping the cylinder information entirely.
This bug has been there for a long time, and was hidden by the fact that
normally you'd fill in cylinder descriptions etc after importing new
dives. It also used to be that we saved the cylinder beginning/end
pressure even if that was generated from the sample data, so if you
imported from a air-integrated computer and had samples for that cylinder,
we used to save it even though it was technically redundant.
We stopped saving redundant air sample information in commit 0089dd8819b7
("Don't save cylinder start/end pressures unless set by hand").
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Removed start and end in save_cylinder_info(). These two variables are no
longer used.
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-09-21 21:06:57 +00:00
|
|
|
extern gboolean cylinder_nodata(cylinder_t *cyl);
|
|
|
|
|
extern gboolean cylinder_nosamples(cylinder_t *cyl);
|
2012-08-18 15:28:52 +00:00
|
|
|
extern gboolean cylinder_none(void *_data);
|
|
|
|
|
extern gboolean no_cylinders(cylinder_t *cyl);
|
|
|
|
|
extern gboolean no_weightsystems(weightsystem_t *ws);
|
|
|
|
|
extern gboolean weightsystems_equal(weightsystem_t *ws1, weightsystem_t *ws2);
|
2011-12-09 17:52:59 +00:00
|
|
|
|
2011-11-02 03:13:14 +00:00
|
|
|
extern int get_pressure_units(unsigned int mb, const char **units);
|
2011-09-21 19:12:54 +00:00
|
|
|
extern double get_depth_units(unsigned 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);
|
2011-09-21 19:12:54 +00:00
|
|
|
|
2011-12-24 03:41:16 +00:00
|
|
|
static inline double grams_to_lbs(int grams)
|
|
|
|
|
{
|
|
|
|
|
return grams / 453.6;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int lbs_to_grams(double lbs)
|
|
|
|
|
{
|
|
|
|
|
return lbs * 453.6 + 0.5;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-02 02:56:14 +00:00
|
|
|
static inline double ml_to_cuft(int ml)
|
|
|
|
|
{
|
2011-11-02 04:00:46 +00:00
|
|
|
return ml / 28316.8466;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-02 04:12:21 +00:00
|
|
|
static inline double cuft_to_l(double cuft)
|
2011-11-02 04:00:46 +00:00
|
|
|
{
|
|
|
|
|
return cuft * 28.3168466;
|
2011-11-02 02:56:14 +00:00
|
|
|
}
|
2011-09-21 19:12:54 +00:00
|
|
|
|
2011-09-20 01:52:23 +00:00
|
|
|
static inline double mm_to_feet(int mm)
|
|
|
|
|
{
|
|
|
|
|
return mm * 0.00328084;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-20 03:06:59 +00:00
|
|
|
static inline unsigned long feet_to_mm(double feet)
|
|
|
|
|
{
|
|
|
|
|
return feet * 304.8 + 0.5;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
static inline int to_feet(depth_t depth)
|
|
|
|
|
{
|
2011-09-20 01:52:23 +00:00
|
|
|
return mm_to_feet(depth.mm) + 0.5;
|
2011-08-31 01:23:59 +00:00
|
|
|
}
|
|
|
|
|
|
2012-06-20 03:06:59 +00:00
|
|
|
static inline double mkelvin_to_C(int mkelvin)
|
2011-09-19 20:32:10 +00:00
|
|
|
{
|
|
|
|
|
return (mkelvin - 273150) / 1000.0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-20 03:06:59 +00:00
|
|
|
static inline double mkelvin_to_F(int mkelvin)
|
2011-09-19 20:32:10 +00:00
|
|
|
{
|
|
|
|
|
return mkelvin * 9 / 5000.0 - 459.670;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-20 03:06:59 +00:00
|
|
|
static inline unsigned long F_to_mkelvin(double f)
|
|
|
|
|
{
|
|
|
|
|
return (f-32) * 1000 / 1.8 + 273150.5;
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-10 09:14:55 +00:00
|
|
|
static inline unsigned long C_to_mkelvin(double c)
|
|
|
|
|
{
|
|
|
|
|
return c * 1000 + 273150.5;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
static inline int to_C(temperature_t temp)
|
|
|
|
|
{
|
|
|
|
|
if (!temp.mkelvin)
|
|
|
|
|
return 0;
|
2011-09-19 20:32:10 +00:00
|
|
|
return mkelvin_to_C(temp.mkelvin) + 0.5;
|
2011-09-07 16:35:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int to_F(temperature_t temp)
|
|
|
|
|
{
|
|
|
|
|
if (!temp.mkelvin)
|
|
|
|
|
return 0;
|
2011-09-19 20:32:10 +00:00
|
|
|
return mkelvin_to_F(temp.mkelvin) + 0.5;
|
2011-09-07 16:35:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int to_K(temperature_t temp)
|
|
|
|
|
{
|
|
|
|
|
if (!temp.mkelvin)
|
|
|
|
|
return 0;
|
|
|
|
|
return (temp.mkelvin + 499)/1000;
|
2011-08-31 01:23:59 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-02 04:00:46 +00:00
|
|
|
static inline double psi_to_bar(double psi)
|
|
|
|
|
{
|
|
|
|
|
return psi / 14.5037738;
|
|
|
|
|
}
|
2012-06-20 03:06:59 +00:00
|
|
|
|
|
|
|
|
static inline unsigned long psi_to_mbar(double psi)
|
|
|
|
|
{
|
|
|
|
|
return psi_to_bar(psi)*1000 + 0.5;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
static inline int to_PSI(pressure_t pressure)
|
|
|
|
|
{
|
|
|
|
|
return pressure.mbar * 0.0145037738 + 0.5;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-02 04:12:21 +00:00
|
|
|
static inline double bar_to_atm(double bar)
|
|
|
|
|
{
|
2013-01-14 22:53:38 +00:00
|
|
|
return bar / SURFACE_PRESSURE * 1000;
|
2011-11-02 04:12:21 +00:00
|
|
|
}
|
|
|
|
|
|
2011-09-22 20:45:53 +00:00
|
|
|
static inline double to_ATM(pressure_t pressure)
|
|
|
|
|
{
|
2013-01-14 22:53:38 +00:00
|
|
|
return pressure.mbar / SURFACE_PRESSURE;
|
2011-09-22 20:45:53 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-02 03:13:14 +00:00
|
|
|
static inline int mbar_to_PSI(int mbar)
|
|
|
|
|
{
|
|
|
|
|
pressure_t p = {mbar};
|
|
|
|
|
return to_PSI(p);
|
|
|
|
|
}
|
|
|
|
|
|
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 */
|
|
|
|
|
double x = (double) a * (whole - part) + (double) b * part;
|
|
|
|
|
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;
|
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
|
|
|
int sensor; /* Cylinder pressure sensor index */
|
2012-12-01 21:02:30 +00:00
|
|
|
duration_t ndl;
|
|
|
|
|
duration_t stoptime;
|
|
|
|
|
depth_t stopdepth;
|
2012-12-31 02:11:01 +00:00
|
|
|
gboolean in_deco;
|
2012-12-08 04:08:29 +00:00
|
|
|
int cns;
|
|
|
|
|
int po2;
|
2011-08-31 01:23:59 +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;
|
2012-11-10 10:40:35 +00:00
|
|
|
gboolean 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;
|
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)
|
2011-12-24 03:41:16 +00:00
|
|
|
#define MAX_WEIGHTSYSTEMS (4)
|
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
|
|
|
|
2012-11-26 18:04:14 +00:00
|
|
|
typedef enum { TF_NONE, NO_TRIP, IN_TRIP, ASSIGNED_TRIP, NUM_TRIPFLAGS } tripflag_t;
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2012-09-20 03:42:11 +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;
|
2012-11-26 18:04:14 +00:00
|
|
|
unsigned expanded:1, selected:1, autogen: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;
|
Add special download modes to force updates from the divecomputer
This will hopefully not be something we need often, but if we improve
support for a divecomputer (either in libdivecomputer or in our native
Uemis code or even in the way we handle (and potentially discard) events),
then it is extremely useful to be able to say "re-download things
from the divecomputer and for things that were not edited in Subsurface,
don't try to merge the data (which gives BAD results if for example you
fixed a bug in the depth calculation in libdivecomputer) but instead
simply take the samples, the events and some of the other unedited data
straight from the download".
This commit implements just that - a "force download" checkbox in the
download dialog that makes us reimport all dives from the dive computer,
even the ones we already have, and an "always prefer downloaded dive"
checkbox that then tells Subsurface not to merge but simply to take the
data from the downloaded dive - without overwriting the things we have
already edited in Subsurface (like location, buddy, equipment, etc).
This, as a precaution, refuses to merge dives that don't have identical
start times. So if you have edited the date / time of a dive or if you
have previously merged your dive with a different dive computer (and
therefore modified samples and events) you are out of luck.
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-11-11 13:29:26 +00:00
|
|
|
gboolean downloaded;
|
2012-11-11 09:36:46 +00:00
|
|
|
int start, end;
|
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;
|
2011-08-31 01:23:59 +00:00
|
|
|
depth_t maxdepth, meandepth;
|
2012-11-10 18:18:10 +00:00
|
|
|
int salinity; // kg per 10000 l
|
2011-08-31 01:23:59 +00:00
|
|
|
duration_t duration, surfacetime;
|
2012-10-28 22:49:02 +00:00
|
|
|
int visibility; /* 0 - 5 star rating */
|
2011-08-31 01:23:59 +00:00
|
|
|
temperature_t airtemp, watertemp;
|
2012-11-10 08:37:23 +00:00
|
|
|
pressure_t surface_pressure;
|
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;
|
2012-11-24 02:51:27 +00:00
|
|
|
|
|
|
|
|
/* Eventually we'll do multiple dive computers */
|
|
|
|
|
struct divecomputer dc;
|
2011-08-31 01:23:59 +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) */
|
|
|
|
|
static inline int depth_to_mbar(int depth, struct dive *dive)
|
|
|
|
|
{
|
|
|
|
|
double specific_weight = 1.03 * 0.981;
|
2013-01-14 22:53:38 +00:00
|
|
|
int surface_pressure = SURFACE_PRESSURE;
|
2012-11-10 22:11:40 +00:00
|
|
|
if (dive->salinity)
|
|
|
|
|
specific_weight = dive->salinity / 10000.0 * 0.981;
|
|
|
|
|
if (dive->surface_pressure.mbar)
|
|
|
|
|
surface_pressure = dive->surface_pressure.mbar;
|
|
|
|
|
return depth / 10.0 * specific_weight + surface_pressure + 0.5;
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
if (dive->salinity)
|
|
|
|
|
specific_weight = dive->salinity / 10000.0 * 0.981;
|
|
|
|
|
/* whole mbar gives us cm precision */
|
|
|
|
|
cm = mbar / specific_weight + 0.5;
|
|
|
|
|
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;
|
|
|
|
|
|
2012-08-22 05:04:24 +00:00
|
|
|
extern gboolean autogroup;
|
|
|
|
|
/* 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 */
|
|
|
|
|
#define TRIP_THRESHOLD 3600*24*3
|
|
|
|
|
|
|
|
|
|
#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 *);
|
|
|
|
|
extern void remove_dive_from_trip(struct dive *);
|
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* We keep our internal data in well-specified units, but
|
|
|
|
|
* the input and output may come in some random format. This
|
|
|
|
|
* keeps track of those units.
|
|
|
|
|
*/
|
2011-10-29 01:46:53 +00:00
|
|
|
/* turns out in Win32 PASCAL is defined as a calling convention */
|
|
|
|
|
#ifdef WIN32
|
|
|
|
|
#undef PASCAL
|
|
|
|
|
#endif
|
2011-09-07 02:07:17 +00:00
|
|
|
struct units {
|
|
|
|
|
enum { METERS, FEET } length;
|
|
|
|
|
enum { LITER, CUFT } volume;
|
|
|
|
|
enum { BAR, PSI, PASCAL } pressure;
|
|
|
|
|
enum { CELSIUS, FAHRENHEIT, KELVIN } temperature;
|
|
|
|
|
enum { KG, LBS } weight;
|
|
|
|
|
};
|
|
|
|
|
|
2012-12-10 17:20:57 +00:00
|
|
|
/*
|
|
|
|
|
* We're going to default to SI units for input. Yes,
|
|
|
|
|
* technically the SI unit for pressure is Pascal, but
|
|
|
|
|
* we default to bar (10^5 pascal), which people
|
|
|
|
|
* actually use. Similarly, C instead of Kelvin.
|
|
|
|
|
* And kg instead of g.
|
|
|
|
|
*/
|
|
|
|
|
#define SI_UNITS { \
|
|
|
|
|
.length = METERS, \
|
|
|
|
|
.volume = LITER, \
|
|
|
|
|
.pressure = BAR, \
|
|
|
|
|
.temperature = CELSIUS, \
|
|
|
|
|
.weight = KG \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define IMPERIAL_UNITS { \
|
|
|
|
|
.length = FEET, \
|
|
|
|
|
.volume = CUFT, \
|
|
|
|
|
.pressure = PSI, \
|
|
|
|
|
.temperature = FAHRENHEIT, \
|
|
|
|
|
.weight = LBS \
|
|
|
|
|
}
|
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);
|
2011-08-31 01:40:25 +00:00
|
|
|
extern int verbose;
|
|
|
|
|
|
|
|
|
|
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))
|
|
|
|
|
|
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];
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-29 00:11:19 +00:00
|
|
|
static inline struct dive *get_dive_by_diveid(int diveid, int deviceid)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < dive_table.nr; i++)
|
|
|
|
|
if (dive_table.dives[i]->dc.diveid == diveid &&
|
|
|
|
|
dive_table.dives[i]->dc.deviceid == deviceid)
|
|
|
|
|
return dive_table.dives[i];
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-16 18:55:58 +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);
|
|
|
|
|
|
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.
|
|
|
|
|
*/
|
|
|
|
|
#define for_each_dive(_i,_x) \
|
|
|
|
|
for ((_i) = 0; ((_x) = get_dive(_i)) != NULL; (_i)++)
|
|
|
|
|
|
2011-08-31 17:20:46 +00:00
|
|
|
extern void parse_xml_init(void);
|
2012-11-30 20:56:10 +00:00
|
|
|
extern void parse_xml_buffer(const char *url, const char *buf, int size, GError **error);
|
2012-09-18 15:33:55 +00:00
|
|
|
extern void parse_xml_exit(void);
|
2012-09-10 19:27:00 +00:00
|
|
|
extern void set_filename(const char *filename, gboolean force);
|
2011-08-31 01:40:25 +00:00
|
|
|
|
2012-10-09 12:50:16 +00:00
|
|
|
extern void parse_file(const char *filename, GError **error, gboolean possible_default_filename);
|
2012-01-26 21:00:45 +00:00
|
|
|
|
2011-11-05 10:39:17 +00:00
|
|
|
#ifdef XSLT
|
|
|
|
|
extern xmlDoc *test_xslt_transforms(xmlDoc *doc);
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-09-10 00:10:17 +00:00
|
|
|
extern void show_dive_info(struct dive *);
|
|
|
|
|
|
2012-08-15 22:21:34 +00:00
|
|
|
extern void show_dive_equipment(struct dive *, int w_idx);
|
2012-09-10 21:32:55 +00:00
|
|
|
extern void clear_equipment_widgets(void);
|
2011-09-10 00:10:17 +00:00
|
|
|
|
2011-11-02 16:10:57 +00:00
|
|
|
extern void show_dive_stats(struct dive *);
|
2012-09-10 21:32:55 +00:00
|
|
|
extern void clear_stats_widgets(void);
|
2011-11-02 16:10:57 +00:00
|
|
|
|
2013-01-13 16:44:44 +00:00
|
|
|
extern void show_gps_locations(void);
|
|
|
|
|
|
2012-09-10 19:17:28 +00:00
|
|
|
extern void show_yearly_stats(void);
|
|
|
|
|
|
2011-09-10 22:26:51 +00:00
|
|
|
extern void update_dive(struct dive *new_dive);
|
2011-09-02 02:56:04 +00:00
|
|
|
extern void save_dives(const char *filename);
|
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-04-03 02:19:01 +00:00
|
|
|
extern void delete_dive(struct dive *dive);
|
2011-09-12 19:56:34 +00:00
|
|
|
|
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
|
|
|
|
Add special download modes to force updates from the divecomputer
This will hopefully not be something we need often, but if we improve
support for a divecomputer (either in libdivecomputer or in our native
Uemis code or even in the way we handle (and potentially discard) events),
then it is extremely useful to be able to say "re-download things
from the divecomputer and for things that were not edited in Subsurface,
don't try to merge the data (which gives BAD results if for example you
fixed a bug in the depth calculation in libdivecomputer) but instead
simply take the samples, the events and some of the other unedited data
straight from the download".
This commit implements just that - a "force download" checkbox in the
download dialog that makes us reimport all dives from the dive computer,
even the ones we already have, and an "always prefer downloaded dive"
checkbox that then tells Subsurface not to merge but simply to take the
data from the downloaded dive - without overwriting the things we have
already edited in Subsurface (like location, buddy, equipment, etc).
This, as a precaution, refuses to merge dives that don't have identical
start times. So if you have edited the date / time of a dive or if you
have previously merged your dive with a different dive computer (and
therefore modified samples and events) you are out of luck.
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-11-11 13:29:26 +00:00
|
|
|
extern void report_dives(gboolean imported, gboolean prefer_imported);
|
2011-09-03 20:19:26 +00:00
|
|
|
extern struct dive *fixup_dive(struct dive *dive);
|
Add special download modes to force updates from the divecomputer
This will hopefully not be something we need often, but if we improve
support for a divecomputer (either in libdivecomputer or in our native
Uemis code or even in the way we handle (and potentially discard) events),
then it is extremely useful to be able to say "re-download things
from the divecomputer and for things that were not edited in Subsurface,
don't try to merge the data (which gives BAD results if for example you
fixed a bug in the depth calculation in libdivecomputer) but instead
simply take the samples, the events and some of the other unedited data
straight from the download".
This commit implements just that - a "force download" checkbox in the
download dialog that makes us reimport all dives from the dive computer,
even the ones we already have, and an "always prefer downloaded dive"
checkbox that then tells Subsurface not to merge but simply to take the
data from the downloaded dive - without overwriting the things we have
already edited in Subsurface (like location, buddy, equipment, etc).
This, as a precaution, refuses to merge dives that don't have identical
start times. So if you have edited the date / time of a dive or if you
have previously merged your dive with a different dive computer (and
therefore modified samples and events) you are out of luck.
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-11-11 13:29:26 +00:00
|
|
|
extern struct dive *merge_dives(struct dive *a, struct dive *b, int offset, gboolean prefer_downloaded);
|
|
|
|
|
extern struct dive *try_to_merge(struct dive *a, struct dive *b, gboolean prefer_downloaded);
|
2011-09-03 20:19:26 +00:00
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
extern void renumber_dives(int nr);
|
2011-09-16 22:45:14 +00:00
|
|
|
|
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);
|
2011-09-23 01:02:54 +00:00
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
/* UI related protopypes */
|
|
|
|
|
|
2011-11-02 00:09:15 +00:00
|
|
|
extern void init_ui(int *argcp, char ***argvp);
|
2011-09-20 19:40:34 +00:00
|
|
|
|
|
|
|
|
extern void run_ui(void);
|
2012-05-02 17:03:48 +00:00
|
|
|
extern void exit_ui(void);
|
2011-09-20 19:40:34 +00:00
|
|
|
|
|
|
|
|
extern void report_error(GError* error);
|
|
|
|
|
|
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-23 06:47:19 +00:00
|
|
|
extern void add_people(const char *string);
|
|
|
|
|
extern void add_location(const char *string);
|
2012-08-14 23:07:25 +00:00
|
|
|
extern void add_suit(const char *string);
|
2011-10-25 07:29:19 +00:00
|
|
|
extern void remember_event(const char *eventname);
|
2011-10-25 09:51:16 +00:00
|
|
|
extern void evn_foreach(void (*callback)(const char *, int *, void *), void *data);
|
2011-10-23 06:47:19 +00:00
|
|
|
|
2012-06-27 20:11:54 +00:00
|
|
|
extern int add_new_dive(struct dive *dive);
|
2012-09-20 03:42:11 +00:00
|
|
|
extern gboolean edit_trip(dive_trip_t *trip);
|
2012-11-04 19:35:59 +00:00
|
|
|
extern int edit_dive_info(struct dive *dive, gboolean newdive);
|
2012-08-21 22:37:38 +00:00
|
|
|
extern int edit_multi_dive_info(struct dive *single_dive);
|
2011-09-20 19:40:34 +00:00
|
|
|
extern void dive_list_update_dives(void);
|
|
|
|
|
extern void flush_divelist(struct dive *dive);
|
|
|
|
|
|
2012-12-13 06:26:29 +00:00
|
|
|
extern void set_dc_nickname(struct dive *dive);
|
2012-12-26 21:47:54 +00:00
|
|
|
extern const char *get_dc_nickname(const char *model, uint32_t deviceid);
|
|
|
|
|
extern void remember_dc(const char *model, uint32_t deviceid, const char *nickname, gboolean change_conf);
|
2012-12-31 04:27:01 +00:00
|
|
|
extern gboolean dc_was_saved(struct divecomputer *dc);
|
|
|
|
|
extern void mark_dc_saved(struct divecomputer *dc);
|
2013-01-02 01:29:38 +00:00
|
|
|
extern void set_autogroup(gboolean value);
|
2013-01-02 20:16:42 +00:00
|
|
|
extern int total_weight(struct dive *);
|
2012-12-13 06:26:29 +00:00
|
|
|
|
2011-09-05 20:14:53 +00:00
|
|
|
#define DIVE_ERROR_PARSE 1
|
|
|
|
|
|
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"
|
|
|
|
|
#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"
|
|
|
|
|
#define ZERO_STARS UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR
|
|
|
|
|
#define ONE_STARS UTF8_BLACKSTAR UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR
|
|
|
|
|
#define TWO_STARS UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_WHITESTAR UTF8_WHITESTAR UTF8_WHITESTAR
|
|
|
|
|
#define THREE_STARS UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_WHITESTAR UTF8_WHITESTAR
|
|
|
|
|
#define FOUR_STARS UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_WHITESTAR
|
|
|
|
|
#define FIVE_STARS UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR UTF8_BLACKSTAR
|
|
|
|
|
extern const char *star_strings[];
|
2011-09-21 00:52:04 +00:00
|
|
|
|
2012-10-19 23:31:06 +00:00
|
|
|
/* enum holding list of OS features */
|
|
|
|
|
typedef enum {
|
|
|
|
|
UTF8_FONT_WITH_STARS
|
|
|
|
|
} os_feature_t;
|
|
|
|
|
|
2012-09-16 03:51:06 +00:00
|
|
|
extern const char *existing_filename;
|
2012-10-18 21:30:45 +00:00
|
|
|
extern const char *subsurface_gettext_domainpath(char *);
|
2012-10-19 23:31:06 +00:00
|
|
|
extern gboolean subsurface_os_feature_available(os_feature_t);
|
2013-01-14 23:20:29 +00:00
|
|
|
extern gboolean subsurface_launch_for_uri(const char *);
|
2012-10-04 00:44:47 +00:00
|
|
|
extern void subsurface_command_line_init(gint *, gchar ***);
|
|
|
|
|
extern void subsurface_command_line_exit(gint *, gchar ***);
|
2011-12-31 16:15:59 +00:00
|
|
|
|
2012-09-10 19:17:28 +00:00
|
|
|
#define FRACTION(n,x) ((unsigned)(n)/(x)),((unsigned)(n)%(x))
|
|
|
|
|
|
2013-01-08 14:37:41 +00:00
|
|
|
extern double add_segment(double pressure, struct gasmix *gasmix, int period_in_seconds, double 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-01-03 07:22:07 +00:00
|
|
|
extern unsigned int deco_allowed_depth(double tissues_tolerance, double surface_pressure, struct dive *dive, gboolean smooth);
|
2013-01-04 05:31:22 +00:00
|
|
|
extern void set_gf(double gflow, double gfhigh);
|
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;
|
|
|
|
|
int depth;
|
|
|
|
|
int o2;
|
|
|
|
|
int he;
|
|
|
|
|
struct divedatapoint *next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct diveplan {
|
|
|
|
|
timestamp_t when;
|
|
|
|
|
int surface_pressure;
|
|
|
|
|
struct divedatapoint *dp;
|
|
|
|
|
};
|
|
|
|
|
|
2013-01-07 06:09:12 +00:00
|
|
|
void plan(struct diveplan *diveplan, char **cache_datap, struct dive **divep);
|
2013-01-05 20:56:45 +00:00
|
|
|
void plan_add_segment(struct diveplan *diveplan, int duration, int depth, int o2, int he);
|
2013-01-07 16:13:23 +00:00
|
|
|
void add_duration_to_nth_dp(struct diveplan *diveplan, int idx, int duration, gboolean is_rel);
|
2013-01-07 06:09:12 +00:00
|
|
|
void add_depth_to_nth_dp(struct diveplan *diveplan, int idx, int depth);
|
|
|
|
|
void add_gas_to_nth_dp(struct diveplan *diveplan, int idx, int o2, int he);
|
|
|
|
|
void free_dps(struct divedatapoint *dp);
|
2013-01-05 07:11:42 +00:00
|
|
|
|
2012-09-26 15:30:37 +00:00
|
|
|
#ifdef DEBUGFILE
|
|
|
|
|
extern char *debugfilename;
|
|
|
|
|
extern FILE *debugfile;
|
|
|
|
|
#endif
|
2013-01-11 01:26:10 +00:00
|
|
|
|
|
|
|
|
#include "pref.h"
|
|
|
|
|
|
2011-08-31 01:23:59 +00:00
|
|
|
#endif /* DIVE_H */
|
