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/selection.h

63 lines
2.3 KiB
C
Raw Normal View History

Undo: update dive list after edit command The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-11 14:34:43 +00:00
// SPDX-License-Identifier: GPL-2.0
Selection: move commands/command_private.* to core/selection.* The file command_private.cpp had functions concerning selections only. To make these functions accessible from outside the undo machinery, turn it into a part of the core-library. Currently, only C++ functions are exported. We might think about also exporting a C interface. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 12:26:29 +00:00
// Selection related functions
Undo: update dive list after edit command The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-11 14:34:43 +00:00
Selection: move commands/command_private.* to core/selection.* The file command_private.cpp had functions concerning selections only. To make these functions accessible from outside the undo machinery, turn it into a part of the core-library. Currently, only C++ functions are exported. We might think about also exporting a C interface. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 12:26:29 +00:00
#ifndef SELECTION_H
#define SELECTION_H
Undo: update dive list after edit command The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-11 14:34:43 +00:00
Selection: move selection functions from divelist.c to selection.c Since we now have a selection.c translation unit, put the selection- related functions there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 14:02:34 +00:00
struct dive;
extern int amount_selected;
selection: move current dive and divecomputer to selection.cpp This tries to encapsulate the management of the current dive and divecomputer in the selection code. The current dive is alreay set by setSelection(). Add a new parameter to also set the current divecomputer. If -1 is passed, then the current computer number is remained. This will allow us to audit the code. Because for now, the whole "current dive computer" thing seems to be ill-defined. This fixes a bug: the dive-computer number wasn't validated when making a new dive the current dive. The new code has some drawbacks though: when selecting a whole trip, the validation will be called for all dives in the trip and thus the dive computer number will depend on the dive with the lowest amount of dive computers in the trip. This will need to be fixed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-04-04 16:57:28 +00:00
extern struct dive *current_dive;
Selection: move selection functions from divelist.c to selection.c Since we now have a selection.c translation unit, put the selection- related functions there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 14:02:34 +00:00
/*** C and C++ functions ***/
extern "C" {
extern struct dive *first_selected_dive(void);
extern struct dive *last_selected_dive(void);
extern bool consecutive_selected(void);
Selection: move selection of "first" dive to core The DiveListView has a function to select the first dive. Move this to the core to be able to call it from all parts (not only desktop) of the code. Currently, this has a (small?) UI regression: when filtering dives and no selected dive is visible anymore, the old code would select the first dive in the list. The new code selects the newest dive, which might not be the first if some sort-criterion is active. To revert to the old behavior, it will be necessary to move the sorting function likewise to the core. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-25 18:00:38 +00:00
extern void select_newest_visible_dive();
Selection: provide convenience function for single-dive selection Currently, selecting a single dive or deselecting all dives was quite awkward: One had to pass in a single-dive vector and the dive itself (as current dive). Provide a convenience function that selects a single dive or deselects all dives if null is passed in. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-12-06 08:47:59 +00:00
extern void select_single_dive(struct dive *d); // wrapper for setSelection() with a single dive. NULL clears the selection.
selection: add selection flag for trips In analogy to dives add a selection flag for trips. The reason being that search for a selected trip can be painfully slow when we do it through Qt's proxy model. Make sure to deselect trips when they are removed from the core. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-05-02 12:34:40 +00:00
extern void select_trip(struct dive_trip *trip);
extern void deselect_trip(struct dive_trip *trip);
selection: create global single_selected_trip() function The DiveListView had a singleSelectedTrip function that returns the selected trip if exactly one trip is selected. This could be very slow if numerous non-trip items were selected, because all the selection indices were back- translated by the proxy model. This could make selection changes very slow, because the MainTab used said function to determine whether it should show trip or dive data.. Indeed, with a 3500 dive test log, when selecting all dives in tree mode, the updating of the TabWidgets is sped up from 130 ms to 5 ms this commit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-05-02 16:14:44 +00:00
extern struct dive_trip *single_selected_trip(); // returns trip if exactly one trip is selected, NULL otherwise.
selection: introduce clear_selection() function The DiveListView would touch the selection-innards directly. Let's encapsulate that. Moreover, take care to reset the trip selection when resetting the core data. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-05-02 12:41:52 +00:00
extern void clear_selection(void);
Selection: move selection functions from divelist.c to selection.c Since we now have a selection.c translation unit, put the selection- related functions there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 14:02:34 +00:00
#if DEBUG_SELECTION_TRACKING
extern void dump_selection(void);
#endif
}
Selection: move commands/command_private.* to core/selection.* The file command_private.cpp had functions concerning selections only. To make these functions accessible from outside the undo machinery, turn it into a part of the core-library. Currently, only C++ functions are exported. We might think about also exporting a C interface. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 12:26:29 +00:00
/*** C++-only functions ***/
Undo: move selection function into command_private.cpp file Undo of editing should probably also restore the old selection and current dive. Therefore, move the functions that set and restore the selection and the current dive from the command_divelist.cpp into the command_private.cpp translation unit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-17 09:18:00 +00:00
Undo: update dive list after edit command The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-11 14:34:43 +00:00
#include <vector>
selection: avoid select_dive() and deselect_dive calls in dive list Each of these calls recalculates the current dive and divecomputer. Instead, collect the dives to be selected/deselected and (de)select them at once. This needs some code refactoring in the core, because we need a function that 1) doesn't send a signal by itself. 2) doesn't clear the trip-selection. This contains some reorganization of the selection functions signatures: The filter code is the only caller that keeps the selected dive and the only caller that cares about whether the current dive changed. So let only the function that keeps the selected dive return whether the current dive changed. It's all very fragile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 18:38:17 +00:00
#include <QVector>
Undo: update dive list after edit command The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-11 14:34:43 +00:00
Undo: move selection function into command_private.cpp file Undo of editing should probably also restore the old selection and current dive. Therefore, move the functions that set and restore the selection and the current dive from the command_divelist.cpp into the command_private.cpp translation unit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-17 09:18:00 +00:00
// Reset the selection to the dives of the "selection" vector and send the appropriate signals.
selection: move current dive and divecomputer to selection.cpp This tries to encapsulate the management of the current dive and divecomputer in the selection code. The current dive is alreay set by setSelection(). Add a new parameter to also set the current divecomputer. If -1 is passed, then the current computer number is remained. This will allow us to audit the code. Because for now, the whole "current dive computer" thing seems to be ill-defined. This fixes a bug: the dive-computer number wasn't validated when making a new dive the current dive. The new code has some drawbacks though: when selecting a whole trip, the validation will be called for all dives in the trip and thus the dive computer number will depend on the dive with the lowest amount of dive computers in the trip. This will need to be fixed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-04-04 16:57:28 +00:00
// Set the current dive to "currentDive" and the current dive computer to "currentDc".
// "currentDive" must be an element of "selection" (or null if "seletion" is empty).
// If "currentDc" is negative, an attempt will be made to keep the current computer number.
selection: avoid select_dive() and deselect_dive calls in dive list Each of these calls recalculates the current dive and divecomputer. Instead, collect the dives to be selected/deselected and (de)select them at once. This needs some code refactoring in the core, because we need a function that 1) doesn't send a signal by itself. 2) doesn't clear the trip-selection. This contains some reorganization of the selection functions signatures: The filter code is the only caller that keeps the selected dive and the only caller that cares about whether the current dive changed. So let only the function that keeps the selected dive return whether the current dive changed. It's all very fragile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 18:38:17 +00:00
// Returns the list of selected dives
selection: move current dc logic to profile widget The current dc global makes no sense on mobile. Therefore, move the logic of the currently displayed dive computer to the profile widget and remove the dc_number global variable. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-09-17 17:07:35 +00:00
QVector<dive *> setSelectionCore(const std::vector<dive *> &selection, dive *currentDive);
selection: avoid select_dive() and deselect_dive calls in dive list Each of these calls recalculates the current dive and divecomputer. Instead, collect the dives to be selected/deselected and (de)select them at once. This needs some code refactoring in the core, because we need a function that 1) doesn't send a signal by itself. 2) doesn't clear the trip-selection. This contains some reorganization of the selection functions signatures: The filter code is the only caller that keeps the selected dive and the only caller that cares about whether the current dive changed. So let only the function that keeps the selected dive return whether the current dive changed. It's all very fragile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 18:38:17 +00:00
// As above, but sends a signal to inform the frontend of the changed selection.
filter: set dive selection at once For each selected dive that is hidden by the filter, unselect_dive() was called, which led to a recalculation of the current dive and divecomputer. Instead, collect all deselected dives and deselect them at the end. Thus, these calculations are performed only once. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 11:14:47 +00:00
// Returns true if the current dive changed.
selection: avoid select_dive() and deselect_dive calls in dive list Each of these calls recalculates the current dive and divecomputer. Instead, collect the dives to be selected/deselected and (de)select them at once. This needs some code refactoring in the core, because we need a function that 1) doesn't send a signal by itself. 2) doesn't clear the trip-selection. This contains some reorganization of the selection functions signatures: The filter code is the only caller that keeps the selected dive and the only caller that cares about whether the current dive changed. So let only the function that keeps the selected dive return whether the current dive changed. It's all very fragile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 18:38:17 +00:00
void setSelection(const std::vector<dive *> &selection, dive *currentDive, int currentDc);
Undo: move selection function into command_private.cpp file Undo of editing should probably also restore the old selection and current dive. Therefore, move the functions that set and restore the selection and the current dive from the command_divelist.cpp into the command_private.cpp translation unit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-17 09:18:00 +00:00
filter: set dive selection at once For each selected dive that is hidden by the filter, unselect_dive() was called, which led to a recalculation of the current dive and divecomputer. Instead, collect all deselected dives and deselect them at the end. Thus, these calculations are performed only once. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 11:14:47 +00:00
// Set selection, but try to keep the current dive. If current dive is not in selection,
// find the nearest current dive in the selection
// Returns true if the current dive changed.
selection: avoid select_dive() and deselect_dive calls in dive list Each of these calls recalculates the current dive and divecomputer. Instead, collect the dives to be selected/deselected and (de)select them at once. This needs some code refactoring in the core, because we need a function that 1) doesn't send a signal by itself. 2) doesn't clear the trip-selection. This contains some reorganization of the selection functions signatures: The filter code is the only caller that keeps the selected dive and the only caller that cares about whether the current dive changed. So let only the function that keeps the selected dive return whether the current dive changed. It's all very fragile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 18:38:17 +00:00
// Does not send a signal.
bool setSelectionKeepCurrent(const std::vector<dive *> &selection);
filter: set dive selection at once For each selected dive that is hidden by the filter, unselect_dive() was called, which led to a recalculation of the current dive and divecomputer. Instead, collect all deselected dives and deselect them at the end. Thus, these calculations are performed only once. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 11:14:47 +00:00
selection: trickle down trip selection The trip selection code was an awkward layering violation. Whereas dive selections due to dive undo-commands trickled down via DiveTripModel-->MultiFilterSortModel-->DiveListView, for trip editing, the DiveListView directly intercepted the TripEdited signal. Instead, mimic the dive-selection code. This is a bit longer but more consistent and logical. The undo/redo of trip changes is now also a "programmatical" change of the selection. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-08-27 15:28:34 +00:00
// Select all dive in a trip and sends a trip-selected signal
void setTripSelection(dive_trip *trip, dive *currentDive);
filter: set dive selection at once For each selected dive that is hidden by the filter, unselect_dive() was called, which led to a recalculation of the current dive and divecomputer. Instead, collect all deselected dives and deselect them at the end. Thus, these calculations are performed only once. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 11:14:47 +00:00
// Get currently selected dives
Undo: move selection function into command_private.cpp file Undo of editing should probably also restore the old selection and current dive. Therefore, move the functions that set and restore the selection and the current dive from the command_divelist.cpp into the command_private.cpp translation unit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-17 09:18:00 +00:00
std::vector<dive *> getDiveSelection();
filter: set dive selection at once For each selected dive that is hidden by the filter, unselect_dive() was called, which led to a recalculation of the current dive and divecomputer. Instead, collect all deselected dives and deselect them at the end. Thus, these calculations are performed only once. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-05-21 11:14:47 +00:00
bool diveInSelection(const std::vector<dive *> &selection, const dive *d);
void updateSelection(std::vector<dive *> &selection, const std::vector<dive *> &add, const std::vector<dive *> &remove);
Undo: move selection function into command_private.cpp file Undo of editing should probably also restore the old selection and current dive. Therefore, move the functions that set and restore the selection and the current dive from the command_divelist.cpp into the command_private.cpp translation unit. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-02-17 09:18:00 +00:00
Selection: move commands/command_private.* to core/selection.* The file command_private.cpp had functions concerning selections only. To make these functions accessible from outside the undo machinery, turn it into a part of the core-library. Currently, only C++ functions are exported. We might think about also exporting a C interface. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-11-24 12:26:29 +00:00
#endif // SELECTION_H
Reference in a new issue Copy permalink