mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-28 05:00:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/dive.h

229 lines
9.1 KiB
C
Raw Normal View History

Add SPDX header to remaining core files Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-04-27 18:24:53 +00:00
// SPDX-License-Identifier: GPL-2.0
Split up dive data structure declarations into 'dive.h' The dive parser should eventually be just a part of the program, not the whole thing. So start preparing for that. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-08-31 01:23:59 +00:00
#ifndef DIVE_H
#define DIVE_H
Core: introduce new subsurface-string header First small step to shrinking dive.h. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-05-11 15:25:41 +00:00
// dive and dive computer related structures and helpers
Cleanup: move planner/deco related declarations planner/deco.h Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-05 18:43:06 +00:00
#include "divemode.h"
cleanup: split out divecomputer functions from dive.c Since dive.c is so huge, split out divecomputer-related functions into divecomputer.[c|h], sample.[c|h] and extradata.[c|h]. This does not give huge compile time improvements, since struct dive contains a struct divecomputer and therefore dive.h has to include divecomputer.h. However, it make things distinctly more clear. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-10-25 12:28:55 +00:00
#include "divecomputer.h"
core: convert weightsystem_t and weightsystem_table to C++ As for cylinders, this had to be done simultaneously, Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 05:03:03 +00:00
#include "equipment.h"
core: turn event-list of divecomputer into std::vector<> This is a rather long commit, because it refactors lots of the event code from pointer to value semantics: pointers to entries in an std::vector<> are not stable, so better use indexes. To step through the event-list at diven time stamps, add *_loop classes, which encapsulate state that had to be manually handled before by the caller. I'm not happy about the interface, but it tries to mirror the one we had before. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-25 06:16:57 +00:00
#include "picture.h" // TODO: remove
core: port tag-list to C++ Also adds a new test, which tests merging of two tag-lists. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 15:57:48 +00:00
#include "tag.h"
Report errors when opening files Signed-off-by: Nathan Samson <nathansamson@gmail.com>
2011-09-05 20:14:53 +00:00
core: make split_dive() and related functions return unique_ptrs This prepares for turning the dive table into a list of owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 19:50:08 +00:00
#include <array>
fulltext: replace plain pointer by std::unique_ptr<> This was a plain pointer owing to C compatibility. Replacing it by a unique_ptr<> allows us to make it 'self-desctruct' in the constructor. However, we do this with a special twist: the data is _not_ copied when copying the dive, since the copied dive is not registered in the fulltext system. Hackish, but it should(!) work. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 17:09:43 +00:00
#include <memory>
core: convert taxonomy.c to C++ Since the taxonomy is now a real C++ struct with constructor and destructor, dive_site has to be converted to C++ as well. A bit hairy for now, but will ultimately be distinctly simpler. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-04 11:39:04 +00:00
#include <string>
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
#include <vector>
core: remove __cplusplus ifdefs Since all source files are now C++, this is redundant. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-04 15:55:50 +00:00
Make special backup when switching XML versions Since the last few dozen commits change the format in irreversible ways and could therefore be destructive and lose data for testers of the development version, let's try to be extra careful and create "special" backup files that aren't overwritten by subsequent backups. At least this way people can go back to the previous state. Of course people using the git backend don't have to worry about this as they always can go back to any earlier save. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-02-13 07:35:52 +00:00
extern int last_xml_version;
Distinguish between user and internal divemode names The former should be translated but not those that go to xml/git. ... and fix capitalization of pSCR. Suggested-by: Stefan Fuchs <sfuchs@gmx.de> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-05-17 08:04:41 +00:00
extern const char *divemode_text_ui[];
Refactor dctype -> divemode ... and repair a failed rebase (sorry). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-10 23:01:15 +00:00
extern const char *divemode_text[];
Provide for a dive_computer_type variable within dc structure This patch lays the foundation for differentiating between open-circuit(OC)dives and rebreather dives (CCR). The following were done: 1) In dive.h add an enum type dive_computer_type 2) In dive.h add two more fields to the dc structure: a) dctype (an enum field indicating dc type) b) no_o2sensor (indicating number of o2 sensors for this dc) 3) In parse-xml.c add a function trimspace that strips any whitespace from a string. This is used by two functions: utf8_string as well as by get_dc_type, described below. The pointer to buffer is not changed in order to ensure consistency when the buffer is freed. 4) In parse-xml.c add a function get_dc_type. This parses the dc_type string from xml and assigns an enum value which will later be returned to the function that parses the dc variables. Signed-off-by: Willem Ferguson <willemferguson@zoology.up.ac.za> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-11 17:48:48 +00:00
Dive sites: prepare for dive site ref-counting Add a dive site table to each dive site to keep track of dives that have been added to a dive site. Add two functions to add dives to / remove dives from dive sites. Since dive sites now contain a dive table, the order of includes had to be changed: "divesite.h" now includes "dive.h" and not vice-versa. This caused some include churn. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-03-04 22:20:29 +00:00
struct dive_site;
cleanup: move dive_table from dive.h to divelist.h This allows us to decouple dive.h and divelist.h, a small step in include disentangling. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-05-01 11:43:52 +00:00
struct dive_table;
Cleanup: move trip-related functions into own translation unit These functions were spread out over dive.c and divelist.c. Move them into their own file to make all this a bit less monolithic. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-05-31 14:09:14 +00:00
struct dive_trip;
filter: index/unindex dives on loading or clearing logs When loading dive data, populate the fulltext index. When clearing dive data, free the fulltext index. When deleting a dive, remove it from the fulltext index. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-02-16 21:26:47 +00:00
struct full_text_cache;
cleanup: split out divecomputer functions from dive.c Since dive.c is so huge, split out divecomputer-related functions into divecomputer.[c|h], sample.[c|h] and extradata.[c|h]. This does not give huge compile time improvements, since struct dive contains a struct divecomputer and therefore dive.h has to include divecomputer.h. However, it make things distinctly more clear. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-10-25 12:28:55 +00:00
struct event;
struct trip_table;
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
fulltext: replace plain pointer by std::unique_ptr<> This was a plain pointer owing to C compatibility. Replacing it by a unique_ptr<> allows us to make it 'self-desctruct' in the constructor. However, we do this with a special twist: the data is _not_ copied when copying the dive, since the copied dive is not registered in the fulltext system. Hackish, but it should(!) work. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 17:09:43 +00:00
/* A unique_ptr that will not be copied if the parent class is copied.
* This is used to keep a pointer to the fulltext cache and avoid
* having it copied when the dive is copied, since the new dive is
* not (yet) registered in the fulltext system. Quite hackish.
*/
template<typename T>
struct non_copying_unique_ptr : public std::unique_ptr<T> {
using std::unique_ptr<T>::unique_ptr;
using std::unique_ptr<T>::operator=;
non_copying_unique_ptr(const non_copying_unique_ptr<T> &) { }
void operator=(const non_copying_unique_ptr<T> &) { }
};
Split up dive data structure declarations into 'dive.h' The dive parser should eventually be just a part of the program, not the whole thing. So start preparing for that. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-08-31 01:23:59 +00:00
struct dive {
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
struct dive_trip *divetrip = nullptr;
timestamp_t when = 0;
struct dive_site *dive_site = nullptr;
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
std::string notes;
std::string diveguide, buddy;
std::string suit;
core: convert weightsystem_t and weightsystem_table to C++ As for cylinders, this had to be done simultaneously, Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 05:03:03 +00:00
cylinder_table cylinders;
weightsystem_table weightsystems;
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
int number = 0;
int rating = 0;
int wavesize = 0, current = 0, visibility = 0, surge = 0, chill = 0; /* 0 - 5 star ratings */
int sac = 0, otu = 0, cns = 0, maxcns = 0;
Do more dive fixup for each dive computer In commit b6c9301e5847 ("Move more dive computer filled data to the divecomputer structure") we moved the fields that get filled in by the dive computers to be per-divecomputer data structures. This patch re-creates some of those fields back in the "struct dive", but now the fields are initialized to be a reasonable average from the dive computer data. We already did some of this for the temperature min/max fields for the statistics, so this just continues that trend. The goal is to make it easy to look at "dive values" without having to iterate over dive computers every time you do. Just do it once in "fixup_dive()" instead. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-09 00:15:18 +00:00
/* Calculated based on dive computer data */
Finish removing accesses to first divecomputer instead of dive This adds watertemp and airtemp to the dive, populates them in fixup and uses them elsewhere in the code. WARNING: as a sideeffect we now edit the airtemp in the dive, but we never display this in the DIve Info notebook (as that always displays the data from the specific selected divecomputer). This is likely to cause confusion. It's consistent behavior, but... odd. This brings back the desire to have a view of "best data available" for a dive, in addition to the "per divecomputer" view. This would also allow us to consolidate the different pressure graphs we may be getting from different divecomputers (consider the case where you dive with multiple air integrated computers that are connected to different tanks - now we could have one profile with all the correct tank pressure plots overlayed - and the best available (or edited) data in the corresponding Dive Info notebook. This commit also fixes a few remaining accesses to the first divecomputer that fell through the cracks earlier and does a couple of other related cleanups. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-09 15:41:15 +00:00
temperature_t mintemp, maxtemp, watertemp, airtemp;
Add a meandepth to the dive structure This is currently only used in one place (in statistics.c), but it certainly is consistent with the other recent changes to avoid using only the first divecomputer when trying to make statements about a dive. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-09 14:50:53 +00:00
depth_t maxdepth, meandepth;
Do more dive fixup for each dive computer In commit b6c9301e5847 ("Move more dive computer filled data to the divecomputer structure") we moved the fields that get filled in by the dive computers to be per-divecomputer data structures. This patch re-creates some of those fields back in the "struct dive", but now the fields are initialized to be a reasonable average from the dive computer data. We already did some of this for the temperature min/max fields for the statistics, so this just continues that trend. The goal is to make it easy to look at "dive values" without having to iterate over dive computers every time you do. Just do it once in "fixup_dive()" instead. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-09 00:15:18 +00:00
pressure_t surface_pressure;
Move duration to dive structure and replace accessor function When starting on this quest to stop using the first divecomputer instead of data for the whole dive in commit eb73b5a528c8 ("Duration of a dive is the maximum duration from all divecomputers") I introduced an accessor function that calculates the dive duration on the fly as the maximum of the durations in the divecomputers. Since then Linus and I have added quite a few of the variables back to the dive data structure and it makes perfect sense to do the same thing for the duration as well and simply do the calculation once during fixup. This commit also replaces accesses to the first divecomputer in likely_same_dive to use the maxdepth and meandepth of the dive (those two slipped through the cracks in the previous commits, it seems). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-09 15:12:30 +00:00
duration_t duration;
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
int salinity = 0; // kg per 10000 l
int user_salinity = 0; // water density reflecting a user-specified type
Move events and samples into a 'struct divecomputer' For now we only have one fixed divecomputer associated with each dive, so this doesn't really change any current semantics. But it will make it easier for us to associate a dive with multiple dive computers. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-11-24 02:51:27 +00:00
core: port tag-list to C++ Also adds a new test, which tests merging of two tag-lists. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 15:57:48 +00:00
tag_list tags;
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
std::vector<divecomputer> dcs; // Attn: pointers to divecomputers are not stable!
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
int id = 0; // unique ID for this dive
core: turn picture-table into std::vector<> Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-30 13:00:28 +00:00
picture_table pictures;
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
unsigned char git_id[20] = {};
bool notrip = false; /* Don't autogroup this dive to a trip */
bool selected = false;
bool hidden_by_filter = false;
fulltext: replace plain pointer by std::unique_ptr<> This was a plain pointer owing to C compatibility. Replacing it by a unique_ptr<> allows us to make it 'self-desctruct' in the constructor. However, we do this with a special twist: the data is _not_ copied when copying the dive, since the copied dive is not registered in the fulltext system. Hackish, but it should(!) work. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 17:09:43 +00:00
non_copying_unique_ptr<full_text_cache> full_text; /* word cache for full text search */
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
bool invalid = false;
dive();
~dive();
core: make split_dive() and related functions return unique_ptrs This prepares for turning the dive table into a list of owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 19:50:08 +00:00
dive(const dive &);
core: use std::vector<> to store divecomputer samples This is a hairy one, because the sample code is rather tricky. There was a pattern of looping through pairs of adjacent samples, for interpolation purposes. Add an range adapter to generalize such loops. Removes the finish_sample() function: The code would call prepare_sample() to start parsing of samples and then finish_sample() to actuall add it. I.e. a kind of commit(). Since, with one exception, all users of prepare_sample() called finish_sample() in all code paths, we might just add the sample in the first place. The exception was sample_end() in parse.cpp. This brings a small change: samples are now added, even if they could only be parsed partially. I doubt that this makes any difference, since it will only happen for broken divelogs anyway. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-19 10:38:38 +00:00
dive(dive &&);
dive &operator=(const dive &);
core: move functions into struct dive Nothing against free-standing functions, but in the case of dc_watertemp(), dc_airtemp(), endtime() and totaltime(), it seems natural to move this into the dive class and avoid polution of the global name space. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-05 15:02:40 +00:00
timestamp_t endtime() const; /* maximum over divecomputers (with samples) */
duration_t totaltime() const; /* maximum over divecomputers (with samples) */
temperature_t dc_airtemp() const; /* average over divecomputers */
temperature_t dc_watertemp() const; /* average over divecomputers */
bool is_planned() const;
bool is_logged() const;
Add stubs for the main methods that will operate on pictures. add, remove, get count, and picture_load_exif_data. Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 19:56:02 +00:00
};
Dive list: move sort-functionality into core To make sorting more controlled, move all sorting functions into the core. For this, introduce a "dive_or_trip" structure, which represents a top-level item. Adapt the DiveTripModel accordingly. There are now three sorting functions: 1) dive_less_than 2) trip_less_than 3) dive_or_trip_less_than These should be used by all sorting code. By moving them to a single place, the mess can hopefully be cleaned up. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-10 08:07:42 +00:00
/* For the top-level list: an entry is either a dive or a trip */
struct dive_or_trip {
struct dive *dive;
struct dive_trip *trip;
};
Uninline functions in dive.h There were numerous inlined functions in dive.h. For many of them inlining is dubious. Let's uninline most of them, with the exception of trivial accessors and interpolate(). On current master, this gave a size reduction of 5 pages: -rwxrwxr-x 1 bs bs 5863656 Jul 18 20:57 subsurface-inline -rwxrwxr-x 1 bs bs 5843176 Jul 18 20:48 subsurface-noinline ----------------------------------------------------------- 20480 Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-18 18:47:19 +00:00
extern void invalidate_dive_cache(struct dive *dive);
extern bool dive_cache_is_valid(const struct dive *dive);
Don't write back dive data that hasn't changed in git This caches the git ID for the dive on load, and avoids building the dive directory and hashing it on save as long as nothing has invalidated the git ID cache. That should make it much faster to write back data to the git repository, since the dive tree structure and the divecomputer blobs in particular are the bulk of it (due to all the sample data). It's not actually the git operations that are all that expensive, it's literally generating the big blob with all the snprintf() calls for the data. The git save used to be a fairly expensive with large data sets, especially noticeable on mobile with much weaker CPU's. This should speed things up by at least a factor of two. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-04-03 22:31:59 +00:00
Cleanup: const-ify functions taking pointers to events This is another entry in the series to make more things "const-clean" with the ultimate goal of merge_dive() take const pointers. This concerns functions taking pointers to events and the fallout from making these const. The somewhat debatable part of this commit might be that get_next_event() is split in a two distinct (const and non-const) versions with different names, since C doesn't allow overloading. The linker should recognize that these functions are identical and remove one of them. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:58:30 +00:00
extern int get_cylinder_idx_by_use(const struct dive *dive, enum cylinderuse cylinder_use_type);
core: return unique_ptr<> from merge-dive functions Try to remove plain owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-04 11:22:25 +00:00
extern void cylinder_renumber(struct dive &dive, int mapping[]);
core: convert cylinder_t and cylinder_table to C++ This had to be done simultaneously, because the table macros do not work properly with C++ objects. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-28 19:31:11 +00:00
extern int same_gasmix_cylinder(const cylinder_t &cyl, int cylid, const struct dive *dive, bool check_unused);
Calculate nitrogen and helium gas pressures for CCR after import from CSV Currently the gas pressures stored in structures of pressure are calculated using the gasmix composition of the currently selected cylinder. But with CCR dives the default cylinder is the oxygen cylinder (here, index 0). However, the gas pressures need to be calculated using gasmix data from cylinder 1 (the diluent cylinder). This patch allows setting the appropriate cylinder for calculating the values in the structures of pressure. It also allows for correctly calculating gas pressures for any open circuit cylinders (e.g. bailout) that a CCR diver may use. This is performed as follows: 1) In dive.h create an enum variable {oxygen, diluent, bailout} 2) Within the definition of cylinder_t, add a member: cylinder_use_type This stores an enum variable, one of the above. 3) In file.c where the Poseidon CSV data are read in, assign the appropriate enum values to each of the cylinders. 4) Within the definition of structure dive, add two members: int oxygen_cylinder_index int diluent_cylinder_index This will keep the indices of the two main CCR cylinders. 5) In dive.c create a function get_cylinder_use(). This scans the cylinders for that dive, looking for a cylinder that has a particular cylinder_use_type and returns that cylinder index. 6) In dive.c create a function fixup_cylinder_use() that stores the indices of the oxygen and diluent cylinders in the variables dive->oxygen_cylinder_index and dive->diluent_cylinder_index, making use of the function in 4) above. 7) In profile.c, modify function calculate_gas_information_new() to use the above functions for CCR dives to find the oxygen and diluent cylinders and to calculate partail gas pressures based on the diluent cylinder gas mix. This results in the correct calculation of gas partial pressures in the case of CCR dives, displaying the correct partial pressure graphs in the dive profile widget. Signed-off-by: willem ferguson <willemferguson@zoology.up.ac.za> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-03 20:11:00 +00:00
Cut'n'paste for dive data: implement some infrastructure This commit doesn't do anything, yet. It just puts in place helper infrastructure that will later allow us to cut and paste parts of the data of one dive into another dive (or set of dives). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-16 13:55:31 +00:00
/* when selectively copying dive information, which parts should be copied? */
struct dive_components {
Switch components for cut/paste dive to dive site logic Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-02-13 04:58:03 +00:00
unsigned int divesite : 1;
Cut'n'paste for dive data: implement some infrastructure This commit doesn't do anything, yet. It just puts in place helper infrastructure that will later allow us to cut and paste parts of the data of one dive into another dive (or set of dives). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-16 13:55:31 +00:00
unsigned int notes : 1;
core: replace dive master by dive guide In general, replace "dive master" by "dive guide". However, do not change written dive logs for now. On reading, accept both versions. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-02-12 13:03:18 +00:00
unsigned int diveguide : 1;
Cut'n'paste for dive data: implement some infrastructure This commit doesn't do anything, yet. It just puts in place helper infrastructure that will later allow us to cut and paste parts of the data of one dive into another dive (or set of dives). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-16 13:55:31 +00:00
unsigned int buddy : 1;
unsigned int suit : 1;
unsigned int rating : 1;
unsigned int visibility : 1;
Desktop: add additional star widgets to Information tab Connect the UI to the underlying dive structure. Enable proper initialisation and management of star widgets while Information tab is active. Enable undo for the addtional star widgets. Signed-off-by: willemferguson <willemferguson@zoology.up.ac.za> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2019-11-28 19:04:52 +00:00
unsigned int wavesize : 1;
unsigned int current : 1;
unsigned int surge : 1;
unsigned int chill : 1;
Cut'n'paste for dive data: implement some infrastructure This commit doesn't do anything, yet. It just puts in place helper infrastructure that will later allow us to cut and paste parts of the data of one dive into another dive (or set of dives). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-16 13:55:31 +00:00
unsigned int tags : 1;
unsigned int cylinders : 1;
unsigned int weights : 1;
desktop: Add the capability to copy / paste dive number and date / time. This is adding the capability to select 'Dive number' and 'Date / Time' in the 'Copy dive components' dialog, and then copy them into the clipboard. When using 'Paste dive components, these values will then be pasted into the selected dive(s). This is intended to help with workflows that import dive information from two different sources, like general information from another logging program, and CCR ppO2 sensor readings from a unit log, and then stitch them together into one cohesive entry with all data per dive. Copied data is also output into formatted text when pasting the clipboard outside of the application: ``` Dive number: 401 Date / time: Sun 2 May 2021 12:00 AM ``` No translations have been added as of now - I could not find any information on how strings are translated for this project. Signed-off-by: Michael Keller <github@ike.ch>
2021-05-16 03:39:47 +00:00
unsigned int number : 1;
unsigned int when : 1;
Cut'n'paste for dive data: implement some infrastructure This commit doesn't do anything, yet. It just puts in place helper infrastructure that will later allow us to cut and paste parts of the data of one dive into another dive (or set of dives). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-16 13:55:31 +00:00
};
Cleanup: const-ify functions taking pointers to events This is another entry in the series to make more things "const-clean" with the ultimate goal of merge_dive() take const pointers. This concerns functions taking pointers to events and the fallout from making these const. The somewhat debatable part of this commit might be that get_next_event() is split in a two distinct (const and non-const) versions with different names, since C doesn't allow overloading. The linker should recognize that these functions are identical and remove one of them. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:58:30 +00:00
extern bool has_gaschange_event(const struct dive *dive, const struct divecomputer *dc, int idx);
extern int explicit_first_cylinder(const struct dive *dive, const struct divecomputer *dc);
Add stubs for the main methods that will operate on pictures. add, remove, get count, and picture_load_exif_data. Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 19:56:02 +00:00
cylindermodel: remove in_planner() use in_planner() is problematic, since it is uses desktop-only application state. Since the cylinder-model already has an appropriate inPlanner flag, use this instead. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-10-27 22:04:24 +00:00
extern fraction_t best_o2(depth_t depth, const struct dive *dive, bool in_planner);
Planner: Add option to treat O2 as narcotic When computing the best mix for a target depth, for helium, one can either require that the partial pressure of N2 is the same as at the target depth or the partial pressure of N2 plus O2. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2019-10-29 16:57:34 +00:00
extern fraction_t best_he(depth_t depth, const struct dive *dive, bool o2narcotic, fraction_t fo2);
Add functions to calculate best mix Best mix O2 calculated based on planner Bottom O2 preference Best mix He calculated based on EAD of 30m (should be made user-configurable) Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-05-21 09:32:07 +00:00
Uninline functions in dive.h There were numerous inlined functions in dive.h. For many of them inlining is dubious. Let's uninline most of them, with the exception of trivial accessors and interpolate(). On current master, this gave a size reduction of 5 pages: -rwxrwxr-x 1 bs bs 5863656 Jul 18 20:57 subsurface-inline -rwxrwxr-x 1 bs bs 5843176 Jul 18 20:48 subsurface-noinline ----------------------------------------------------------- 20480 Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-18 18:47:19 +00:00
extern int get_surface_pressure_in_mbar(const struct dive *dive, bool non_null);
Cleanup: const-ify parameters to trivial accessor functions Accessor-functions without noticeable logic, such as depth_to_bar() can trivially be made "const-clean". Moreover, let get_dive_location() return a "const char *". The non-const version must have been an oversight, as the caller must not free() or overwrite the string. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:36:51 +00:00
extern int depth_to_mbar(int depth, const struct dive *dive);
Round gas depth properly The D in MOD, EAD, END, and EADD stands for "depth" and as such these should be mm in int rather than double. The intermediate fn2 and fhe2, however, as intermediate value should not be rounded to an integer. The upshot of this is a litle more numerical stability. It should lead to more stable values in TestProfile when run on architectures with different floating point precision. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2021-12-03 13:59:36 +00:00
extern double depth_to_mbarf(int depth, const struct dive *dive);
Cleanup: const-ify parameters to trivial accessor functions Accessor-functions without noticeable logic, such as depth_to_bar() can trivially be made "const-clean". Moreover, let get_dive_location() return a "const char *". The non-const version must have been an oversight, as the caller must not free() or overwrite the string. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:36:51 +00:00
extern double depth_to_bar(int depth, const struct dive *dive);
extern double depth_to_atm(int depth, const struct dive *dive);
extern int rel_mbar_to_depth(int mbar, const struct dive *dive);
extern int mbar_to_depth(int mbar, const struct dive *dive);
extern depth_t gas_mod(struct gasmix mix, pressure_t po2_limit, const struct dive *dive, int roundto);
extern depth_t gas_mnd(struct gasmix mix, depth_t end, const struct dive *dive, int roundto);
Add function to calculate gas maximum narcotic depth Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-07-06 12:40:31 +00:00
Cleanup: const-ify parameters to trivial accessor functions Accessor-functions without noticeable logic, such as depth_to_bar() can trivially be made "const-clean". Moreover, let get_dive_location() return a "const char *". The non-const version must have been an oversight, as the caller must not free() or overwrite the string. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:36:51 +00:00
extern struct dive_site *get_dive_site_for_dive(const struct dive *dive);
core: convert taxonomy.c to C++ Since the taxonomy is now a real C++ struct with constructor and destructor, dive_site has to be converted to C++ as well. A bit hairy for now, but will ultimately be distinctly simpler. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-04 11:39:04 +00:00
extern std::string get_dive_country(const struct dive *dive);
core: convert divesite strings to std::string Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-04 15:18:08 +00:00
extern std::string get_dive_location(const struct dive *dive);
Cleanup: const-ify parameters to trivial accessor functions Accessor-functions without noticeable logic, such as depth_to_bar() can trivially be made "const-clean". Moreover, let get_dive_location() return a "const char *". The non-const version must have been an oversight, as the caller must not free() or overwrite the string. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:36:51 +00:00
extern unsigned int number_of_computers(const struct dive *dive);
Uninline functions in dive.h There were numerous inlined functions in dive.h. For many of them inlining is dubious. Let's uninline most of them, with the exception of trivial accessors and interpolate(). On current master, this gave a size reduction of 5 pages: -rwxrwxr-x 1 bs bs 5863656 Jul 18 20:57 subsurface-inline -rwxrwxr-x 1 bs bs 5843176 Jul 18 20:48 subsurface-noinline ----------------------------------------------------------- 20480 Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-18 18:47:19 +00:00
extern struct divecomputer *get_dive_dc(struct dive *dive, int nr);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
extern const struct divecomputer *get_dive_dc(const struct dive *dive, int nr);
Be much more careful about merging dives This patch changes the dive merging to be much more careful about things, because it turns out that we had several small oddities that caused big merge issues. The oddities are: - the dive "duration" is actually how long we spend under water. But that means that when we do "dive->when + dive.duration.seconds" to calculate the end of the dive, that is nonsensical if you came up to the surface in the middle of a dive. Now, normally you don't see profiles like that, but once you start merging dives together, it can go from "small detail" to "dominant factor". - We have two different cases of merging: the automatic "merge new dive computer download if it looks like the same dive" (which always has a merge offset of 0, since we merge it as a new dive computer) and the "merge two different dives into one longer dive. The code assumed that it could look at the "downloaded" flag for the dive to check one or the other, but that doesn't really work. Reading a dive from an XML file isn't any different from downloading it. So we need to change the logic to determine what kind of merge it is to actually check the passed-in time offset. With this, Stuart Vernon's test-case of eight dives with short surface intervals in between end up merging correctly into one dive. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Reported-by: Stuart Vernon <stuartv@force2.net> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 19:32:27 +00:00
core: make clone_* functions return a unique_ptr<> Don't use plain pointers for owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-04 05:10:22 +00:00
extern std::unique_ptr<dive> clone_make_first_dc(const struct dive &d, int dc_number);
extern std::unique_ptr<dive> clone_delete_divecomputer(const struct dive &d, int dc_number);
core: make split_dive() and related functions return unique_ptrs This prepares for turning the dive table into a list of owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 19:50:08 +00:00
extern std::array<std::unique_ptr<dive>, 2> split_divecomputer(const struct dive &src, int num);
Add ability to make a dive computer the first dive computer of a dive If a dive has multiple dive computers we enable a special context menu when the user right-clicks on the dive computer name AND is not already showing the first dive computer. In that case we offer to make the currently shown dive computer the first one. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-19 05:39:34 +00:00
Cleanup: const-ify parameters to trivial accessor functions Accessor-functions without noticeable logic, such as depth_to_bar() can trivially be made "const-clean". Moreover, let get_dive_location() return a "const char *". The non-const version must have been an oversight, as the caller must not free() or overwrite the string. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:36:51 +00:00
extern bool dive_site_has_gps_location(const struct dive_site *ds);
extern int dive_has_gps_location(const struct dive *dive);
Dive site: create new dive site at location from GPS data Some dive computers save GPS data. Currently, this is stored by libdivecomputer in an "extra field". When generating a new dive site for a dive try to use this data to place the dive site. To do so, create a "dive_get_gps_location()" function. This function can be extended later to use e.g. event. When creating a dive site, use the result of this function over a potential pre-existing dive site. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-04-24 21:59:59 +00:00
extern location_t dive_get_gps_location(const struct dive *d);
Uninline functions in dive.h There were numerous inlined functions in dive.h. For many of them inlining is dubious. Let's uninline most of them, with the exception of trivial accessors and interpolate(). On current master, this gave a size reduction of 5 pages: -rwxrwxr-x 1 bs bs 5863656 Jul 18 20:57 subsurface-inline -rwxrwxr-x 1 bs bs 5843176 Jul 18 20:48 subsurface-noinline ----------------------------------------------------------- 20480 Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-18 18:47:19 +00:00
cleanup: constify time_during_dive_with_offset() function There is no reason to pass a non-const dive pointer as first argument. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-05-22 20:14:24 +00:00
extern bool time_during_dive_with_offset(const struct dive *dive, timestamp_t when, timestamp_t offset);
Make 'get_dive_by_diveid()' work even for non-primary dive computers It's only used by the Uemis importer, and Dirk always seems to import his Uemis data first, so it wasn't very noticeable. But if the Uemis data wasn't the first dive computer, it would not find the dive. Side note: just comparing deviceid is not correct. We should pass in the device model too. But again, that will realistically never really matter, since non-Uemis importers will generate complex SHA1 hashes of the dive data for the dive ID, so a collision with the Uemis numbers is very unlikely. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 22:25:09 +00:00
error handling: return errors for save functions Note! This just returns the error (and uses "report_error()" to generate a string that is currently printed to stderr). Nothing actually *uses* that error return yet, and we don't show the error string in the GUI. Baby steps. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-14 17:11:26 +00:00
extern int save_dives(const char *filename);
Optional anonymization upon export Add a checkbox that triggers replacement of all English characters by x's in notes, buddy, dive guide and (while we are at it) suit. This is ment for people sharing logs for debugging that are concious about privacy issues. It leaves the lenth of strings in tact as well as special charcters as those might be needed to track down a particular parsing problem. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-09-10 12:47:56 +00:00
extern int save_dives_logic(const char *filename, bool select_only, bool anonymize);
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
extern int save_dive(FILE *f, const struct dive &dive, bool anonymize);
Cleanup: remove const bool parameters and return types These just make no sense. Since the value is copied, it has no meaning to the caller whether the function can change the value (and vice versa for return types). Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-02-06 21:56:10 +00:00
extern int export_dives_xslt(const char *filename, bool selected, const int units, const char *export_xslt, bool anonymize);
Stop using the "git descriptor file" model Instead, just encode the git repository information in the filename. We want to make it much harder to make it match a real filename, but to still allow easy browsing with the file manager interface. So the git repository "filename" format is the path to the git repository directory, with the branch name encoded as "[branch]" at the end rather than the "path:branch" format that we used in the descriptor file. [ For example, on Windows, a filename like "c:\my.xml" could be interpreted as the branchame "\my.xml" in the repository in the directory "c" ] In particular, with this model, no filename that ends with ".xml" could possibly ever be considered a git repository name, since the last character of a git pathname is always ']'. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-12 21:12:58 +00:00
Export: move dive site selection logic to C++ When exporting dive sites, the dive sites to be selected were collected in the C-core. But that doesn't have access to the selected dive sites if in dive site mode. Therefore, collect the dive sites in C++ and pass down to the core. Use a std::vector to avoid memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-09-21 12:10:53 +00:00
extern int save_dive_sites_logic(const char *filename, const struct dive_site *sites[], int nr_sites, bool anonymize);
Add export option to export dive sites. Selecting "Selected dives" exports the dive sites for the selected dives. Selecting "All dives" exports all dive sites. XML format is the subsection of the divelog XML that describes the sites headed with a <divesites> section like: <divesites program='subsurface' version='3'> </divesites> Signed-off-by: Doug Junkins <junkins@foghead.com>
2019-04-06 19:05:18 +00:00
Rename helper function and make it global save_one_dive_to_mb() is very useful (but there was a namespace collision with another helper in save_git.c) Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-28 18:27:36 +00:00
struct membuffer;
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
extern void save_one_dive_to_mb(struct membuffer *b, const struct dive &dive, bool anonymize);
Rename helper function and make it global save_one_dive_to_mb() is very useful (but there was a namespace collision with another helper in save_git.c) Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-28 18:27:36 +00:00
general: remove (void) function parameter declarations To my understanding, declaring empty parameter lists using "(void)" is an artifact from the bad old K&R times, when functions were declared without(!) parameters. Which in hindsight was an absolute recipe for disaster. So for backwards compatibility, functions without parameters had to be declared using "(void)" as "()" could also mean "any function". That was 40 years ago. Meanwhile, C++ introduced references, which made it a necessity to declare the function parameters. So "(void)" is redundant and inconsistent in C++ code and just makes no sense. Remove it. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-04 16:53:41 +00:00
extern void subsurface_console_init();
extern void subsurface_console_exit();
extern bool subsurface_user_is_root();
Files: add wrappers for certain open() methods Due to filepath encoding issues on win32 we need wrappers for: - open() - fopen() - opendir() - zip_open() (this is readonly on win32) Patch only declares/defines the wrappers in dive.h, windows.c, linux.c, macos.c. Suggestions-by: Thiago Macieira <thiago@macieira.org> Suggestions-by: Jef Driesen <jefdriesen@telenet.be> Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-19 13:00:50 +00:00
UI restructure: add helper function to copy and clear a dive This way we can safely copy around dives (specifically, copy the dive to be displayed / edited into the displayed_dive). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-02 22:29:02 +00:00
extern void clear_dive(struct dive *dive);
Cleanup: const-ify functions taking dives and divecomputers Another small step in making things const-clean. See also commit 605e1e19ed0c52a16580c95e36ae79e71b539351. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-23 17:18:43 +00:00
extern void copy_dive(const struct dive *s, struct dive *d);
extern void selective_copy_dive(const struct dive *s, struct dive *d, struct dive_components what, bool clear);
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
extern struct std::unique_ptr<dive> move_dive(struct dive *s);
Abstract out dive/sample allocation a bit We're going to start to want to allocate dives and samples for the libdivecomputer import too, so let's clean things up a bit for that. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-12 19:56:34 +00:00
Cleanup: const-ify functions taking dives and divecomputers Another small step in making things const-clean. See also commit 605e1e19ed0c52a16580c95e36ae79e71b539351. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-23 17:18:43 +00:00
extern int legacy_format_o2pressures(const struct dive *dive, const struct divecomputer *dc);
Abstract out dive/sample allocation a bit We're going to start to want to allocate dives and samples for the libdivecomputer import too, so let's clean things up a bit for that. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-12 19:56:34 +00:00
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
extern bool dive_less_than(const struct dive &a, const struct dive &b);
extern bool dive_less_than_ptr(const struct dive *a, const struct dive *b);
Dive list: move sort-functionality into core To make sorting more controlled, move all sorting functions into the core. For this, introduce a "dive_or_trip" structure, which represents a top-level item. Adapt the DiveTripModel accordingly. There are now three sorting functions: 1) dive_less_than 2) trip_less_than 3) dive_or_trip_less_than These should be used by all sorting code. By moving them to a single place, the mess can hopefully be cleaned up. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-10 08:07:42 +00:00
extern bool dive_or_trip_less_than(struct dive_or_trip a, struct dive_or_trip b);
Add various dive fixups, and show pressure (if any) in the plot Now the dive profile plot *really* needs some units. The pressure is just a random line otherwise. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-03 20:19:26 +00:00
extern struct dive *fixup_dive(struct dive *dive);
Convert the atmospheric pressure in the Information Tab to an editable field The Information tab shows the atmospheric pressure. Make this value editable and also ensure that changes to it are undo-able. Signed-off-by: willemferguson <willemferguson@zoology.up.ac.za>
2019-04-30 10:42:33 +00:00
extern pressure_t calculate_surface_pressure(const struct dive *dive);
extern pressure_t un_fixup_surface_pressure(const struct dive *d);
Grantlee: Add salinity and water type to grantlee variables These can be useful in a printed divelog, especially if the log entry is also showing weight and exposure suit. Signed-off-by: Monty Taylor <mordred@inaugust.com>
2020-05-04 13:54:58 +00:00
extern int get_dive_salinity(const struct dive *dive);
Cleanup: simplify dive_getUniqID() dive_getUniqID() is used to create unique dive ids, which are stable during application lifetime. It was passed a dive, checked that the id was not set (if it was that it is know to the application) and set a new id (in contradiction to its name!) if it hadn't any. There were three callers: alloc_dive(): called the function on a zeroed dive struct. fixup_dive(): called the function only if the dive had a 0 id. MainWindow::setupForAddAndPlan(): called the function on a zeroed dive struct. Thus, in all three callers the id is guaranteed to be zero and the whole keeping-track-of-ids logic is moot. Remove the logic, don't pass a dive struct to dive_getUniqID() and move the function to the C-backend. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-17 21:05:03 +00:00
extern int dive_getUniqID();
core: make split_dive() and related functions return unique_ptrs This prepares for turning the dive table into a list of owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-03 19:50:08 +00:00
extern std::array<std::unique_ptr<dive>, 2> split_dive(const struct dive &dive);
extern std::array<std::unique_ptr<dive>, 2> split_dive_at_time(const struct dive &dive, duration_t time);
core: return unique_ptr<> from merge-dive functions Try to remove plain owning pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-04 11:22:25 +00:00
struct merge_result {
std::unique_ptr<struct dive> dive;
dive_trip *trip;
dive_site *site;
};
extern merge_result merge_dives(const struct dive &a, const struct dive &b, int offset, bool prefer_downloaded);
extern std::unique_ptr<dive> try_to_merge(const struct dive &a, const struct dive &b, bool prefer_downloaded);
Planner: Fix Editing of Plans in Multi-Divecomputer Dives. Currently editing of planned dives that have been merged with actual (logged) dives only works if the 'Planned dive' divecomputer is the first divecomputer, and this divecomputer is selected when clicking 'Edit planned dive'. In other cases the profile of the first divecomputer is overlaid with the profile of the planned dive, and the first divecomputer's profile is overwritten when saving the dive plan. Fix this problem. Triggered by @SeppoTakalo's comment (https://github.com/subsurface/subsurface/issues/1913#issuecomment-2075562119): Users don't like that planned dives show up as their own entries in the dive list, so being able to merge them with the actual dive after it has been executed is a good feature - but this wasn't working well until now. Signed-off-by: Michael Keller <github@ike.ch>
2024-04-25 20:16:08 +00:00
extern void copy_events_until(const struct dive *sd, struct dive *dd, int dcNr, int time);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
extern void copy_used_cylinders(const struct dive *s, struct dive *d, bool used_only);
Cleanup: const-ify functions taking dives and divecomputers Another small step in making things const-clean. See also commit 605e1e19ed0c52a16580c95e36ae79e71b539351. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-23 17:18:43 +00:00
extern bool is_cylinder_used(const struct dive *dive, int idx);
extern bool is_cylinder_prot(const struct dive *dive, int idx);
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);
core: turn event-list of divecomputer into std::vector<> This is a rather long commit, because it refactors lots of the event code from pointer to value semantics: pointers to entries in an std::vector<> are not stable, so better use indexes. To step through the event-list at diven time stamps, add *_loop classes, which encapsulate state that had to be manually handled before by the caller. I'm not happy about the interface, but it tries to mirror the one we had before. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-25 06:16:57 +00:00
extern struct event create_gas_switch_event(struct dive *dive, struct divecomputer *dc, int seconds, int idx);
Cleanup: const-ify functions taking dives and divecomputers Another small step in making things const-clean. See also commit 605e1e19ed0c52a16580c95e36ae79e71b539351. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-23 17:18:43 +00:00
extern void per_cylinder_mean_depth(const struct dive *dive, struct divecomputer *dc, int *mean, int *duration);
core: turn event-list of divecomputer into std::vector<> This is a rather long commit, because it refactors lots of the event code from pointer to value semantics: pointers to entries in an std::vector<> are not stable, so better use indexes. To step through the event-list at diven time stamps, add *_loop classes, which encapsulate state that had to be manually handled before by the caller. I'm not happy about the interface, but it tries to mirror the one we had before. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-25 06:16:57 +00:00
extern int get_cylinder_index(const struct dive *dive, const struct event &ev);
extern struct gasmix get_gasmix_from_event(const struct dive *, const struct event &ev);
core: add a function to test for sensors of a given cylinder We want to prevent the user from accidentally deleting a cylinder with sensor readings. Therefore, we need such a function. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2021-09-02 16:39:17 +00:00
extern bool cylinder_with_sensor_sample(const struct dive *dive, int cylinder_id);
Start handling dive events Parse them, save them, take them from libdivecomputer. This doesn't merge them or show them in the profile yet, though. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-23 01:02:54 +00:00
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
/* UI related protopypes */
Don't write back dive data that hasn't changed in git This caches the git ID for the dive on load, and avoids building the dive directory and hashing it on save as long as nothing has invalidated the git ID cache. That should make it much faster to write back data to the git repository, since the dive tree structure and the divecomputer blobs in particular are the bulk of it (due to all the sample data). It's not actually the git operations that are all that expensive, it's literally generating the big blob with all the snprintf() calls for the data. The git save used to be a fairly expensive with large data sets, especially noticeable on mobile with much weaker CPU's. This should speed things up by at least a factor of two. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-04-03 22:31:59 +00:00
extern void invalidate_dive_cache(struct dive *dc);
Disable unused function I am not removing this but leaving it around as this is useful for a feature that we still need to enable - the ability to filter out which events to display. This existed in 3.1 but is missing in the Qt version. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-09 07:14:39 +00:00
Cleanup: const-ify functions taking dives and divecomputers Another small step in making things const-clean. See also commit 605e1e19ed0c52a16580c95e36ae79e71b539351. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-23 17:18:43 +00:00
extern int total_weight(const struct dive *);
Add the ability to set a nickname for a dive computer We maintain a list of dive computers that we know about (by deviceid) and their nicknames in our config. If the user downloads dive from a dive computer that we haven't seen before, we give them the option to set a nickname for that dive computer. That nickname is displayed in the profile (and stored in the XML file, assuming it is not the same as the model). This implementation attempts to make sure that it correctly deals with utf8 nicknames. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-12-13 06:26:29 +00:00
Cleanup: unify get_gas_at_time() and get_gasmix() There were two functions for getting gas-mixes at a certain timestamp: - get_gasmix() for repeated queries. - get_gas_at_time() for a single query. Since the latter is a special case of the former, simply call the former in the latter. Moreover, rename to get_gasmix_at_time() for consistency. Replace on get_gasmix() call, which was outside of a loop by the corresponding get_gasmix_at_time() call. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 15:11:51 +00:00
/* Get gasmix at a given time */
core: turn event-list of divecomputer into std::vector<> This is a rather long commit, because it refactors lots of the event code from pointer to value semantics: pointers to entries in an std::vector<> are not stable, so better use indexes. To step through the event-list at diven time stamps, add *_loop classes, which encapsulate state that had to be manually handled before by the caller. I'm not happy about the interface, but it tries to mirror the one we had before. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-25 06:16:57 +00:00
extern struct gasmix get_gasmix_at_time(const struct dive &dive, const struct divecomputer &dc, duration_t time);
Cleanup: unify get_gas_at_time() and get_gasmix() There were two functions for getting gas-mixes at a certain timestamp: - get_gasmix() for repeated queries. - get_gas_at_time() for a single query. Since the latter is a special case of the former, simply call the former in the latter. Moreover, rename to get_gasmix_at_time() for consistency. Replace on get_gasmix() call, which was outside of a loop by the corresponding get_gasmix_at_time() call. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 15:11:51 +00:00
Cleanup: const-ify functions taking pointers to events This is another entry in the series to make more things "const-clean" with the ultimate goal of merge_dive() take const pointers. This concerns functions taking pointers to events and the fallout from making these const. The somewhat debatable part of this commit might be that get_next_event() is split in a two distinct (const and non-const) versions with different names, since C doesn't allow overloading. The linker should recognize that these functions are identical and remove one of them. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-16 22:58:30 +00:00
extern void update_setpoint_events(const struct dive *dive, struct divecomputer *dc);
Cleanup: make "struct dive *" and "struct dive_trip *" Qt metatypes Just as we did for pointer to struct dive_site, make pointers to struct dive and struct dive_trip "Qt metatypes". This means that they can be passed through QVariants without taking a detour via void *. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-22 07:06:07 +00:00
Cleanup: remove dive_table and dive_site_table Q_METATYPEs These are not passed through QML anymore. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-09-25 19:28:46 +00:00
/* Make pointers to dive and dive_trip "Qt metatypes" so that they can be passed through
* QVariants and through QML.
*/
Dive sites: prepare for dive site ref-counting Add a dive site table to each dive site to keep track of dives that have been added to a dive site. Add two functions to add dives to / remove dives from dive sites. Since dive sites now contain a dive table, the order of includes had to be changed: "divesite.h" now includes "dive.h" and not vice-versa. This caused some include churn. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-03-04 22:20:29 +00:00
#include <QObject>
Cleanup: make "struct dive *" and "struct dive_trip *" Qt metatypes Just as we did for pointer to struct dive_site, make pointers to struct dive and struct dive_trip "Qt metatypes". This means that they can be passed through QVariants without taking a detour via void *. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-22 07:06:07 +00:00
Q_DECLARE_METATYPE(struct dive *);
core: turn existing_filename into std::string Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-16 15:06:39 +00:00
extern std::string existing_filename;
Put include guard to every header * ensure include guard to every header * comment endif guard block Signed-off-by: Boris Barbulovski <bbarbulovski@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-11 18:14:46 +00:00
#endif // DIVE_H
Reference in a new issue Copy permalink