mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-29 21:50:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/divelist.h

71 lines
2.6 KiB
C
Raw Normal View History

Add SPDX header to core C files Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-04-27 18:18:03 +00:00
// SPDX-License-Identifier: GPL-2.0
Open File works. I refactored the code and introduced a new type. I never used it as a pointer (their was no real reason), but I'm not really satisfied. Signed-off-by: Nathan Samson <nathansamson@gmail.com>
2011-09-05 19:12:58 +00:00
#ifndef DIVELIST_H
#define DIVELIST_H
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 "dive.h"
Have some C++ file in the project Rename gtk-gui.c to qt-gui.cpp, and make the necessary changes so that the project still builds. Signed-off-by: Alberto Mardegan <mardy@users.sourceforge.net>
2013-04-01 10:51:49 +00:00
#ifdef __cplusplus
extern "C" {
MSVC is c89 In case someone wants to compile this with an outdated C compiler... Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-24 23:52:18 +00:00
#endif
Split report_dives into UI and logic and move to divelist files Functionality is unchanged, except we now have a nice process_dives function that deals with all the logic and that gets called from report_dives from the Gtk code. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-24 23:33:29 +00:00
Track minimum datafile version Add infrastructure and helper functions to track minimum datafile version. To make this information useful we need to keep the XML and git data format versions in track moving forward. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 13:45:12 +00:00
/* this is used for both git and xml format */
#define DATAFORMAT_VERSION 3
Make sure SAC and OTU get recalculated after cylinder info was changed Also fixed minor coding style issues (prevent useless code from being executed). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-13 17:29:07 +00:00
extern void update_cylinder_related_info(struct dive *);
Turn dive_list_changed into bool All callers of mark_divelist_changed() were passing a bool. Therefore, let mark_divelist_changed() take a bool and make dive_list_changed a bool. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2017-12-11 21:23:52 +00:00
extern void mark_divelist_changed(bool);
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
extern int unsaved_changes(void);
Localize global planner state For UI responsiveness, we need to be able to run the planner in the background. This needs the planner state to be localized (and we need to pass a pointer around). In order to not let too many lines overrun (and to save typing in the future) I have renamed instances of struct deco_state to ds. Yes this should have gone to a separate commit but I accidentally commit --amend'ed it. Computing of planner variations is temporarily disabled. Unlock the planner when returning early So we don't deadlock in add dive and recreational mode (which use the planner without actually planning). Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-11-22 19:42:33 +00:00
extern int init_decompression(struct deco_state *ds, struct dive *dive);
Separate Gtk related code from core logic: divelist This is simplistic & brute force: any function that touches Gtk related data structures is moved to divelist-gtk.c, everything else stays in divelist.c. Header files have been adjusted so that this still compiles and appears to work. More thought is needed to truly abstract this out, but this seems to be a good point to commit this change. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-07 03:49:06 +00:00
/* divelist core logic functions */
Core: split process_dives() in post-import and post-load versions process_dives() is used to post-process the dive table after loading or importing. The first parameter states whether this was after load or import. Especially in the light of undo, load and import are fundamentally different things. Notably, that latter should be undo-able, whereas the former is not. Therefore, as a first step to make import undo-able, split the function in two versions and remove the first parameter. It turns out the the load-version is very light. It only sets the DC nicknames and sorts the dive-table. There seems to be no reason to merge dives. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-09-23 10:53:35 +00:00
extern void process_loaded_dives();
Import: control process_imported_dives() by flags process_imported_dives() takes four boolean parameters. Replace these by flags. This makes the function calls much more descriptive. Morover, it becomes easier to add or remove flags. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-01-13 20:53:57 +00:00
/* flags for process_imported_dives() */
#define IMPORT_PREFER_IMPORTED (1 << 0)
#define IMPORT_IS_DOWNLOADED (1 << 1)
#define IMPORT_MERGE_ALL_TRIPS (1 << 2)
#define IMPORT_ADD_TO_NEW_TRIP (1 << 3)
Undo: make undo-system dive site-aware As opposed to dive trips, dive sites were always directly added to the global table, even on import. Instead, parse the divesites into a distinct table and merge them on import. Currently, this does not do any merging of dive sites, i.e. dive sites are considered as either equal or different. Nevertheless, merging of data should be rather easy to implement and simply follow the code of the dive merging. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-03-03 14:12:22 +00:00
extern void add_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, struct dive_site_table *import_sites_table,
int flags);
extern void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, struct dive_site_table *import_sites_table,
int flags,
Import: split process_imported_dives() function Split the process_imported_dives() function in two: 1) process_imported_dives() processes the dives and generates a list of dives and trips to be added and removed. 2) add_imported_dives() calls process_imported_dives() and does the actual removal / addition of dives and trips. The goal is to split preparation and actual work, to make dive import undo-able. The code adds extra checks to never merge into the same dive twice, as this would lead to a double-free() bug. This should in principle never happen, as dives that compare equal according to is_same_dive() are merged in the imported-dives list, but perhaps in some pathologival corner-cases is_same_dive() turns out to be non-transitive. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-12-23 21:08:00 +00:00
struct dive_table *dives_to_add, struct dive_table *dives_to_remove,
Undo: make undo-system dive site-aware As opposed to dive trips, dive sites were always directly added to the global table, even on import. Instead, parse the divesites into a distinct table and merge them on import. Currently, this does not do any merging of dive sites, i.e. dive sites are considered as either equal or different. Nevertheless, merging of data should be rather easy to implement and simply follow the code of the dive merging. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-03-03 14:12:22 +00:00
struct trip_table *trips_to_add, struct dive_site_table *sites_to_add);
Cleanup: constify get_dive_gas() and get_dive_gas_string() There's no reason for the dive input-parameter being non-const. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-13 20:32:53 +00:00
extern char *get_dive_gas_string(const struct dive *dive);
Remove even more code and declarations There's lots more stuff that can go. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-07 20:43:17 +00:00
Core: Rename functions to more generic names Rename - dive_get_insertion_index() -> dive_table_get_insertion_index() - unregister_dive_from_table() -> remove_from_dive_table() - get_idx_in_table() -> get_idx_in_dive_table() - sort_table() -> sort_dive_table() This will make it more straight-forward to generate these functions from macros. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-11-24 09:11:07 +00:00
extern int dive_table_get_insertion_index(struct dive_table *table, struct dive *dive);
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
extern void add_to_dive_table(struct dive_table *table, int idx, struct dive *dive);
Core: turn add_single_dive() to append_dive() The only external caller of add_single_dive() used it to append a dive to the global dive list. Rename the function accordingly and remove the index parameter. The internal caller can use the local insert_dive() function, which doesn't consider selection. That shouldn't be a problem, as the caller is doing import. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-04-14 13:37:19 +00:00
extern void append_dive(struct dive *dive);
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
extern void insert_dive(struct dive_table *table, struct dive *d);
Cleanup: constify get_dive_gas() and get_dive_gas_string() There's no reason for the dive input-parameter being non-const. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-13 20:32:53 +00:00
extern void get_dive_gas(const struct dive *dive, int *o2_p, int *he_p, int *o2low_p);
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 get_divenr(const struct dive *dive);
Dive site: inform model of dive site addition / deletion Introduce two DiveListNotifier signals which are sent by the undo commands if dives are added to / removed from the core. The signal has the dive site and the index in the global dive site table as payload. Thus, the model has only to remove the appropriate rows. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-03-11 23:25:31 +00:00
extern int remove_dive(const struct dive *dive, struct dive_table *table);
Only offer to merge dives if they are consecutive in the divelist You cannot merge dives if there is another, unselected dive "between" them. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-09-24 10:42:40 +00:00
extern bool consecutive_selected();
Undo: select dives after add, remove, merge, split dive commands Select the proper dives after the add, remove, split and merge dives commands on undo *and* redo. Generally, select the added dives. For undo of add, remember the pre-addition selection. For redo of remove, select the closest dive to the first removed dive. The biggest part of the commit is the signal-interface between the dive commands and the dive-list model and dive-list view. This is done in two steps: 1) To the DiveTripModel in batches of trips. The dive trip model transforms the dives into indices. 2) To the DiveListView. The DiveListView has to translate the DiveTripModel indexes to actual indexes via its QSortFilterProxy- model. For code-reuse, derive all divelist-changing commands from a new base-class, which has a flag that describes whether the divelist changed. The helper functions which add and remove dives are made members of the base class and set the flag is a selected dive is added or removed. To properly detect when the current dive was deleted it became necessary to turn the current dive from an index to a pointer, because indices are not stable. Unfortunately, in some cases an index was expected and these places now have to transform the dive into an index. These should be converted in due course. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-03 09:35:43 +00:00
extern void select_dive(struct dive *dive);
extern void deselect_dive(struct dive *dive);
Deselect dives that are no longer shown as the dive list is filtered This cleans up the way we ensure that all dives are handled as the dive list is filtered. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-12 06:59:04 +00:00
extern void filter_dive(struct dive *d, bool shown);
Add some helper functions First step towards getting the "add to trip" logic in the divelist context menu to be consistent and correct. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-24 15:27:42 +00:00
extern struct dive *first_selected_dive();
extern struct dive *last_selected_dive();
Undo: implement undo of manual dive-creation Play manual addition of dives via an UndoCommand. Since this does in large parts the same thing as undo/redo of dive deletion (just the other way round and only a single instead of multiple dive), factor out the functions that add/delete dives and take care of trips. The UI-interaction is just mindless copy&paste and will have to be adapted. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-19 20:35:25 +00:00
extern int get_dive_nr_at_idx(int idx);
Planner: assign a dive number if the right number seems obvious Use the same logic as we do for newly added dives. As a side effect this patch appears to fix the issues with getting the newly planned dive selected. Fixes #692 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-18 19:12:05 +00:00
extern void set_dive_nr_for_current_dive();
Dive information: fix surface interval calculation The old surface interval calculation had fundamental issues: 1) process_all_dives(), which calculates the statistics over *all* dives was used to get the pointer to the previous dive. 2) If two dives in the table had the same time, one of those would have been considered the "previous" dive. 3) If the dive, for which the surface interval is calculated is not yet in the table, no previous dive would be determined. Fix all this by creating a get_surface_interval() function and removing the "get previous dive" functionality of process_all_dives(). Remove the process_all_dives() call from TabDiveInformation::updateData(). Reported-by: Jan Mulder <jlmulder@xs4all.nl> Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-10-06 07:21:27 +00:00
extern timestamp_t get_surface_interval(timestamp_t when);
Import: pass a dive table to process_imported_dives() Dives were directly imported into the global dive table and then merged in process_imported_dives(). Make this interface more flexible, by passing an independent dive table. The dive table of the to-be-imported dives will be sorted and merged. Then each dive is inserted in a one-by-one manner to into the global dive table. This actually introduces (at least) two functional changes: 1) If a new dive spans two old dives, it will only be merged to the first dive. But this seems like a pathological case, which is of dubious value anyway. 2) Dives unrelated to the import will not be merged. The old code would happily merge dives that were not even close to the newly imported dives. A surprising behavior. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-09-28 08:21:23 +00:00
extern void delete_dive_from_table(struct dive_table *table, int idx);
Undo: select dives after add, remove, merge, split dive commands Select the proper dives after the add, remove, split and merge dives commands on undo *and* redo. Generally, select the added dives. For undo of add, remember the pre-addition selection. For redo of remove, select the closest dive to the first removed dive. The biggest part of the commit is the signal-interface between the dive commands and the dive-list model and dive-list view. This is done in two steps: 1) To the DiveTripModel in batches of trips. The dive trip model transforms the dives into indices. 2) To the DiveListView. The DiveListView has to translate the DiveTripModel indexes to actual indexes via its QSortFilterProxy- model. For code-reuse, derive all divelist-changing commands from a new base-class, which has a flag that describes whether the divelist changed. The helper functions which add and remove dives are made members of the base class and set the flag is a selected dive is added or removed. To properly detect when the current dive was deleted it became necessary to turn the current dive from an index to a pointer, because indices are not stable. Unfortunately, in some cases an index was expected and these places now have to transform the dive into an index. These should be converted in due course. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-03 09:35:43 +00:00
extern struct dive *find_next_visible_dive(timestamp_t when);
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
extern int comp_dives(const struct dive *a, const struct dive *b);
Separate Gtk related code from core logic: divelist This is simplistic & brute force: any function that touches Gtk related data structures is moved to divelist-gtk.c, everything else stays in divelist.c. Header files have been adjusted so that this still compiles and appears to work. More thought is needed to truly abstract this out, but this seems to be a good point to commit this change. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-07 03:49:06 +00:00
Track minimum datafile version Add infrastructure and helper functions to track minimum datafile version. To make this information useful we need to keep the XML and git data format versions in track moving forward. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 13:45:12 +00:00
int get_min_datafile_version();
void reset_min_datafile_version();
void report_datafile_version(int version);
Add helper to find the dive closest to a given time If we want to keep the selected dive "close" to where it was before an operation (whether a delete, or a reload, or something like that), then the most intuitive thing to do appears to be to select either the same dive again (if it still exists), or one very close to it in time. This helper allows us to identify the dive in the current dive list that is closest to the given time. We do this in the C code to ensure that we look at all dives in the dive_table - based on the id that is returned the UI can then figure out where this dive is currently shown. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-04-14 12:34:19 +00:00
int get_dive_id_closest_to(timestamp_t when);
QML UI: make sure the dive list is empty before loading dives When testing subsurface-mobile on the desktop from an account that had a default file set up in the Subsurface preferences that file would already be loaded creating rather confusing output. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-24 20:18:30 +00:00
void clear_dive_file_data();
Cleanup: generate clear_*_table() functions by macro In analogy to the other table functions, generate these by a macro as well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-06-04 18:59:08 +00:00
void clear_dive_table(struct dive_table *table);
Track minimum datafile version Add infrastructure and helper functions to track minimum datafile version. To make this information useful we need to keep the XML and git data format versions in track moving forward. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 13:45:12 +00:00
Separate Gtk related code from core logic: divelist This is simplistic & brute force: any function that touches Gtk related data structures is moved to divelist-gtk.c, everything else stays in divelist.c. Header files have been adjusted so that this still compiles and appears to work. More thought is needed to truly abstract this out, but this seems to be a good point to commit this change. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-07 03:49:06 +00:00
#ifdef DEBUG_TRIP
extern void dump_selection(void);
#endif
Have some C++ file in the project Rename gtk-gui.c to qt-gui.cpp, and make the necessary changes so that the project still builds. Signed-off-by: Alberto Mardegan <mardy@users.sourceforge.net>
2013-04-01 10:51:49 +00:00
#ifdef __cplusplus
}
#endif
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 // DIVELIST_H
Reference in a new issue Copy permalink