mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

Refactoring: move undo commands to top level

Browse source 
In the future we might want to use undo-commands for mobile as
well (even if not implementing undo).

Therefore, move the undo-command source from desktop-widgets
to their own commands top-level folder.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2019-11-13 15:08:40 +01:00 • committed by bstoeger
parent 685b92b9c2
commit 5e29245e68
34 changed files with 45 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

14
desktop-widgets/CMakeLists.txt
View file

@ -58,20 +58,6 @@ set(SUBSURFACE_INTERFACE
../map-widget/qmlmapwidgethelper.cpp
about.cpp
about.h
command.cpp
command.h
command_base.cpp
command_base.h
command_divelist.cpp
command_divelist.h
command_divesite.cpp
command_divesite.h
command_edit.cpp
command_edit.h
command_edit_trip.cpp
command_edit_trip.h
command_private.cpp
command_private.h
configuredivecomputerdialog.cpp
configuredivecomputerdialog.h
divecomputermanagementdialog.cpp

257
desktop-widgets/command.cpp
View file

@ -1,257 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command.h"
#include "command_divelist.h"
#include "command_divesite.h"
#include "command_edit.h"
#include "command_edit_trip.h"
namespace Command {
// Dive-list related commands
void addDive(dive *d, bool autogroup, bool newNumber)
{
execute(new AddDive(d, autogroup, newNumber));
}
void importDives(struct dive_table *dives, struct trip_table *trips, struct dive_site_table *sites, int flags, const QString &source)
{
execute(new ImportDives(dives, trips, sites, flags, source));
}
void deleteDive(const QVector<struct dive*> &divesToDelete)
{
execute(new DeleteDive(divesToDelete));
}
void shiftTime(const QVector<dive *> &changedDives, int amount)
{
execute(new ShiftTime(changedDives, amount));
}
void renumberDives(const QVector<QPair<dive *, int>> &divesToRenumber)
{
execute(new RenumberDives(divesToRenumber));
}
void removeDivesFromTrip(const QVector<dive *> &divesToRemove)
{
execute(new RemoveDivesFromTrip(divesToRemove));
}
void removeAutogenTrips()
{
execute(new RemoveAutogenTrips);
}
void addDivesToTrip(const QVector<dive *> &divesToAddIn, dive_trip *trip)
{
execute(new AddDivesToTrip(divesToAddIn, trip));
}
void createTrip(const QVector<dive *> &divesToAddIn)
{
execute(new CreateTrip(divesToAddIn));
}
void autogroupDives()
{
execute(new AutogroupDives);
}
void mergeTrips(dive_trip *trip1, dive_trip *trip2)
{
execute(new MergeTrips(trip1, trip2));
}
void splitDives(dive *d, duration_t time)
{
execute(new SplitDives(d, time));
}
void splitDiveComputer(dive *d, int dc_num)
{
execute(new SplitDiveComputer(d, dc_num));
}
void moveDiveComputerToFront(dive *d, int dc_num)
{
execute(new MoveDiveComputerToFront(d, dc_num));
}
void deleteDiveComputer(dive *d, int dc_num)
{
execute(new DeleteDiveComputer(d, dc_num));
}
void mergeDives(const QVector <dive *> &dives)
{
execute(new MergeDives(dives));
}
// Dive site related commands
void deleteDiveSites(const QVector <dive_site *> &sites)
{
execute(new DeleteDiveSites(sites));
}
void editDiveSiteName(dive_site *ds, const QString &value)
{
execute(new EditDiveSiteName(ds, value));
}
void editDiveSiteDescription(dive_site *ds, const QString &value)
{
execute(new EditDiveSiteDescription(ds, value));
}
void editDiveSiteNotes(dive_site *ds, const QString &value)
{
execute(new EditDiveSiteNotes(ds, value));
}
void editDiveSiteCountry(dive_site *ds, const QString &value)
{
execute(new EditDiveSiteCountry(ds, value));
}
void editDiveSiteLocation(dive_site *ds, location_t value)
{
execute(new EditDiveSiteLocation(ds, value));
}
void editDiveSiteTaxonomy(dive_site *ds, taxonomy_data &value)
{
execute(new EditDiveSiteTaxonomy(ds, value));
}
void addDiveSite(const QString &name)
{
execute(new AddDiveSite(name));
}
void importDiveSites(struct dive_site_table *sites, const QString &source)
{
execute(new ImportDiveSites(sites, source));
}
void mergeDiveSites(dive_site *ds, const QVector<dive_site *> &sites)
{
execute(new MergeDiveSites(ds, sites));
}
void purgeUnusedDiveSites()
{
execute(new PurgeUnusedDiveSites);
}
// Execute an edit-command and return number of edited dives
static int execute_edit(EditDivesBase *cmd)
{
int count = cmd->numDives();
return execute(cmd) ? count : 0;
}
// Dive editing related commands
int editNotes(const QString &newValue, bool currentDiveOnly)
{
return execute_edit(new EditNotes(newValue, currentDiveOnly));
}
int editMode(int index, int newValue, bool currentDiveOnly)
{
return execute_edit(new EditMode(index, newValue, currentDiveOnly));
}
int editNumber(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditNumber(newValue, currentDiveOnly));
}
int editSuit(const QString &newValue, bool currentDiveOnly)
{
return execute_edit(new EditSuit(newValue, currentDiveOnly));
}
int editRating(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditRating(newValue, currentDiveOnly));
}
int editVisibility(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditVisibility(newValue, currentDiveOnly));
}
int editAirTemp(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditAirTemp(newValue, currentDiveOnly));
}
int editWaterTemp(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditWaterTemp(newValue, currentDiveOnly));
}
int editAtmPress(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditAtmPress(newValue, currentDiveOnly));
}
int editDepth(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditDepth(newValue, currentDiveOnly));
}
int editDuration(int newValue, bool currentDiveOnly)
{
return execute_edit(new EditDuration(newValue, currentDiveOnly));
}
int editDiveSite(struct dive_site *newValue, bool currentDiveOnly)
{
return execute_edit(new EditDiveSite(newValue, currentDiveOnly));
}
int editDiveSiteNew(const QString &newName, bool currentDiveOnly)
{
return execute_edit(new EditDiveSiteNew(newName, currentDiveOnly));
}
int editTags(const QStringList &newList, bool currentDiveOnly)
{
return execute_edit(new EditTags(newList, currentDiveOnly));
}
int editBuddies(const QStringList &newList, bool currentDiveOnly)
{
return execute_edit(new EditBuddies(newList, currentDiveOnly));
}
int editDiveMaster(const QStringList &newList, bool currentDiveOnly)
{
return execute_edit(new EditDiveMaster(newList, currentDiveOnly));
}
void pasteDives(const dive *d, dive_components what)
{
execute(new PasteDives(d, what));
}
void replanDive(dive *d)
{
execute(new ReplanDive(d));
}
// Trip editing related commands
void editTripLocation(dive_trip *trip, const QString &s)
{
execute(new EditTripLocation(trip, s));
}
void editTripNotes(dive_trip *trip, const QString &s)
{
execute(new EditTripNotes(trip, s));
}
} // namespace Command

87
desktop-widgets/command.h
View file

@ -1,87 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#ifndef COMMAND_H
#define COMMAND_H
#include "core/dive.h"
#include <QVector>
#include <QAction>
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
// 1) General commands
void init(); // Setup signals to inform frontend of clean status.
void clear(); // Reset the undo stack. Delete all commands.
void setClean(); // Call after save - this marks a state where no changes need to be saved.
bool isClean(); // Any changes need to be saved?
QAction *undoAction(QObject *parent); // Create an undo action.
QAction *redoAction(QObject *parent); // Create an redo action.
// 2) Dive-list related commands
// If d->dive_trip is null and autogroup is true, dives within the auto-group
// distance are added to a trip. dive d is consumed (the structure is reset)!
// If newNumber is true, the dive is assigned a new number, depending on the
// insertion position.
void addDive(dive *d, const bool autogroup, bool newNumber);
void importDives(struct dive_table *dives, struct trip_table *trips,
struct dive_site_table *sites, int flags, const QString &source); // The tables are consumed!
void deleteDive(const QVector<struct dive*> &divesToDelete);
void shiftTime(const QVector<dive *> &changedDives, int amount);
void renumberDives(const QVector<QPair<dive *, int>> &divesToRenumber);
void removeDivesFromTrip(const QVector<dive *> &divesToRemove);
void removeAutogenTrips();
void addDivesToTrip(const QVector<dive *> &divesToAddIn, dive_trip *trip);
void createTrip(const QVector<dive *> &divesToAddIn);
void autogroupDives();
void mergeTrips(dive_trip *trip1, dive_trip *trip2);
void splitDives(dive *d, duration_t time);
void splitDiveComputer(dive *d, int dc_num);
void moveDiveComputerToFront(dive *d, int dc_num);
void deleteDiveComputer(dive *d, int dc_num);
void mergeDives(const QVector <dive *> &dives);
// 3) Dive-site related commands
void deleteDiveSites(const QVector <dive_site *> &sites);
void editDiveSiteName(dive_site *ds, const QString &value);
void editDiveSiteDescription(dive_site *ds, const QString &value);
void editDiveSiteNotes(dive_site *ds, const QString &value);
void editDiveSiteCountry(dive_site *ds, const QString &value);
void editDiveSiteLocation(dive_site *ds, location_t value);
void editDiveSiteTaxonomy(dive_site *ds, taxonomy_data &value); // value is consumed (i.e. will be erased after call)!
void addDiveSite(const QString &name);
void importDiveSites(struct dive_site_table *sites, const QString &source);
void mergeDiveSites(dive_site *ds, const QVector<dive_site *> &sites);
void purgeUnusedDiveSites();
// 4) Dive editing related commands
int editNotes(const QString &newValue, bool currentDiveOnly);
int editSuit(const QString &newValue, bool currentDiveOnly);
int editMode(int index, int newValue, bool currentDiveOnly);
int editNumber(int newValue, bool currentDiveOnly);
int editRating(int newValue, bool currentDiveOnly);
int editVisibility(int newValue, bool currentDiveOnly);
int editAirTemp(int newValue, bool currentDiveOnly);
int editWaterTemp(int newValue, bool currentDiveOnly);
int editAtmPress(int newValue, bool currentDiveOnly);
int editDepth(int newValue, bool currentDiveOnly);
int editDuration(int newValue, bool currentDiveOnly);
int editDiveSite(struct dive_site *newValue, bool currentDiveOnly);
int editDiveSiteNew(const QString &newName, bool currentDiveOnly);
int editTags(const QStringList &newList, bool currentDiveOnly);
int editBuddies(const QStringList &newList, bool currentDiveOnly);
int editDiveMaster(const QStringList &newList, bool currentDiveOnly);
void pasteDives(const dive *d, dive_components what);
void replanDive(dive *d); // dive computer(s) and cylinder(s) will be reset!
// 5) Trip editing commands
void editTripLocation(dive_trip *trip, const QString &s);
void editTripNotes(dive_trip *trip, const QString &s);
} // namespace Command
#endif // COMMAND_H

56
desktop-widgets/command_base.cpp
View file

@ -1,56 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command_base.h"
#include "core/qthelper.h" // for updateWindowTitle()
#include "core/subsurface-qt/DiveListNotifier.h"
namespace Command {
static QUndoStack undoStack;
// General commands
void init()
{
QObject::connect(&undoStack, &QUndoStack::cleanChanged, &updateWindowTitle);
}
void clear()
{
undoStack.clear();
}
void setClean()
{
undoStack.setClean();
}
bool isClean()
{
return undoStack.isClean();
}
QAction *undoAction(QObject *parent)
{
return undoStack.createUndoAction(parent, QCoreApplication::translate("Command", "&Undo"));
}
QAction *redoAction(QObject *parent)
{
return undoStack.createRedoAction(parent, QCoreApplication::translate("Command", "&Redo"));
}
bool execute(Base *cmd)
{
if (cmd->workToBeDone()) {
undoStack.push(cmd);
emit diveListNotifier.commandExecuted();
return true;
} else {
delete cmd;
return false;
}
}
} // namespace Command

178
desktop-widgets/command_base.h
View file

@ -1,178 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_BASE_H
#define COMMAND_BASE_H
#include "core/divesite.h"
#include "core/trip.h"
#include <QUndoCommand>
#include <QCoreApplication> // For Q_DECLARE_TR_FUNCTIONS
#include <memory>
// The classes derived from Command::Base represent units-of-work, which can be exectuted / undone
// repeatedly. The command objects are collected in a linear list implemented in the QUndoStack class.
// They contain the information that is necessary to either perform or undo the unit-of-work.
// The usage is:
// constructor: generate information that is needed for executing the unit-of-work
// redo(): performs the unit-of-work and generates the information that is needed for undo()
// undo(): undos the unit-of-work and regenerates the initial information needed in redo()
// The needed information is mostly kept in pointers to dives and/or trips, which have to be added
// or removed.
// For this to work it is crucial that
// 1) Pointers to dives and trips remain valid as long as referencing command-objects exist.
// 2) The dive-table is not resorted, because dives are inserted at given indices.
//
// Thus, if a command deletes a dive or a trip, the actual object must not be deleted. Instead,
// the command object removes pointers to the dive/trip object from the backend and takes ownership.
// To reverse such a deletion, the object is re-injected into the backend and ownership is given up.
// Once ownership of a dive is taken, any reference to it was removed from the backend. Thus,
// subsequent redo()/undo() actions cannot access this object and integrity of the data is ensured.
//
// As an example, consider the following course of events: Dive 1 is renumbered and deleted, dive 2
// is added and renumbered. The undo list looks like this (---> non-owning, ***> owning pointers,
// ===> next item in list)
//
// Undo-List
// +-----------------+ +---------------+ +------------+ +-----------------+
// | Renumber dive 1 |====>| Delete dive 1 |====>| Add dive 2 |====>| Renumber dive 2 |
// +------------------ +---------------+ +------------+ +-----------------+
// | * | |
// | +--------+ * | +--------+ |
// +----->| Dive 1 |<****** +--->| Dive 2 |<------+
// +--------+ +--------+
// ^
// +---------+ *
// | Backend |****************
// +---------+
// Two points of note:
// 1) Every dive is owned by either the backend or exactly one command object.
// 2) All references to dive 1 are *before* the owner "delete dive 2", thus the pointer is always valid.
// 3) References by the backend are *always* owning.
//
// The user undos the last two commands. The situation now looks like this:
//
//
// Undo-List Redo-List
// +-----------------+ +---------------+ +------------+ +-----------------+
// | Renumber dive 1 |====>| Delete dive 1 | | Add dive 2 |<====| Renumber dive 2 |
// +------------------ +---------------+ +------------+ +-----------------+
// | * * |
// | +--------+ * * +--------+ |
// +----->| Dive 1 |<****** ****>| Dive 2 |<------+
// +--------+ +--------+
//
// +---------+
// | Backend |
// +---------+
// Again:
// 1) Every dive is owned by either the backend (here none) or exactly one command object.
// 2) All references to dive 1 are *before* the owner "delete dive 1", thus the pointer is always valid.
// 3) All references to dive 2 are *after* the owner "add dive 2", thus the pointer is always valid.
//
// The user undos one more command:
//
// Undo-List Redo-List
// +-----------------+ +---------------+ +------------+ +-----------------+
// | Renumber dive 1 | | Delete dive 1 |<====| Add dive 2 |<====| Renumber dive 2 |
// +------------------ +---------------+ +------------+ +-----------------+
// | | * |
// | +--------+ | * +--------+ |
// +----->| Dive 1 |<-----+ ****>| Dive 2 |<------+
// +--------+ +--------+
// ^
// * +---------+
// ***************| Backend |
// +---------+
// Same points as above.
// The user now adds a dive 3. The redo list will be deleted:
//
// Undo-List
// +-----------------+ +------------+
// | Renumber dive 1 |=============================================>| Add dive 3 |
// +------------------ +------------+
// | |
// | +--------+ +--------+ |
// +----->| Dive 1 | | Dive 3 |<---+
// +--------+ +--------+
// ^ ^
// * +---------+ *
// ***************| Backend |****************
// +---------+
// Note:
// 1) Dive 2 was deleted with the "add dive 2" command, because that was the owner.
// 2) Dive 1 was not deleted, because it is owned by the backend.
//
// To take ownership of dives/trips, the OnwingDivePtr and OwningTripPtr types are used. These
// are simply derived from std::unique_ptr and therefore use well-established semantics.
// Expressed in C-terms: std::unique_ptr<T> is exactly the same as T* with the following
// twists:
// 1) default-initialized to NULL.
// 2) if it goes out of scope (local scope or containing object destroyed), it does:
// if (ptr) free_function(ptr);
// whereby free_function can be configured (defaults to delete ptr).
// 3) assignment between two std::unique_ptr<T> compiles only if the source is reset (to NULL).
// (hence the name - there's a *unique* owner).
// While this sounds trivial, experience shows that this distinctly simplifies memory-management
// (it's not necessary to manually delete all vector items in the destructur, etc).
// Note that Qt's own implementation (QScoperPointer) is not up to the job, because it doesn't implement
// move-semantics and Qt's containers are incompatible, owing to COW semantics.
//
// Usage:
// OwningDivePtr dPtr; // Initialize to null-state: not owning any dive.
// OwningDivePtr dPtr(dive); // Take ownership of dive (which is of type struct dive *).
// // If dPtr goes out of scope, the dive will be freed with free_dive().
// struct dive *d = dPtr.release(); // Give up ownership of dive. dPtr is reset to null.
// struct dive *d = d.get(); // Get pointer dive, but don't release ownership.
// dPtr.reset(dive2); // Delete currently owned dive with free_dive() and get ownership of dive2.
// dPtr.reset(); // Delete currently owned dive and reset to null.
// dPtr2 = dPtr1; // Fails to compile.
// dPtr2 = std::move(dPtr1); // dPtr2 takes ownership, dPtr1 is reset to null.
// OwningDivePtr fun();
// dPtr1 = fun(); // Compiles. Simply put: the compiler knows that the result of fun() will
// // be trashed and therefore can be moved-from.
// std::vector<OwningDivePtr> v: // Define an empty vector of owning pointers.
// v.emplace_back(dive); // Take ownership of dive and add at end of vector
// // If the vector goes out of scope, all dives will be freed with free_dive().
// v.clear(v); // Reset the vector to zero length. If the elements weren't release()d,
// // the pointed-to dives are freed with free_dive()
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
// Classes used to automatically call free_dive()/free_trip for owning pointers that go out of scope.
struct DiveDeleter {
void operator()(dive *d) { free_dive(d); }
};
struct TripDeleter {
void operator()(dive_trip *t) { free_trip(t); }
};
struct DiveSiteDeleter {
void operator()(dive_site *ds) { free_dive_site(ds); }
};
// Owning pointers to dive and dive_trip objects.
typedef std::unique_ptr<dive, DiveDeleter> OwningDivePtr;
typedef std::unique_ptr<dive_trip, TripDeleter> OwningTripPtr;
typedef std::unique_ptr<dive_site, DiveSiteDeleter> OwningDiveSitePtr;
// This is the base class of all commands.
// It defines the Qt-translation functions
class Base : public QUndoCommand {
Q_DECLARE_TR_FUNCTIONS(Command)
public:
// Check whether work is to be done.
// TODO: replace by setObsolete (>Qt5.9)
virtual bool workToBeDone() = 0;
};
// Put a command on the undoStack (and take ownership), but test whether there
// is something to be done beforehand by calling the workToBeDone() function.
// If nothing is to be done, the command will be deleted and false is returned.
bool execute(Base *cmd);
} // namespace Command
#endif // COMMAND_BASE_H

999
desktop-widgets/command_divelist.cpp
View file

@ -1,999 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command_divelist.h"
#include "command_private.h"
#include "core/divelist.h"
#include "core/display.h" // for amount_selected
#include "core/qthelper.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include "qt-models/filtermodels.h"
#include "../profile-widget/profilewidget2.h"
#include <array>
namespace Command {
// This helper function removes a dive, takes ownership of the dive and adds it to a DiveToAdd structure.
// If the trip the dive belongs to becomes empty, it is removed and added to the tripsToAdd vector.
// It is crucial that dives are added in reverse order of deletion, so that the indices are correctly
// set and that the trips are added before they are used!
DiveToAdd DiveListBase::removeDive(struct dive *d, std::vector<OwningTripPtr> &tripsToAdd)
{
// If the dive was the current dive, reset the current dive. The calling
// command is responsible of finding a new dive.
if (d == current_dive)
current_dive = nullptr;
// remove dive from trip and site - if this is the last dive in the trip
// remove the whole trip.
DiveToAdd res;
res.trip = unregister_dive_from_trip(d);
if (d->dive_site)
diveSiteCountChanged(d->dive_site);
res.site = unregister_dive_from_dive_site(d);
if (res.trip && res.trip->dives.nr == 0) {
remove_trip(res.trip, &trip_table); // Remove trip from backend
tripsToAdd.emplace_back(res.trip); // Take ownership of trip
}
int idx = get_divenr(d);
if (idx < 0)
qWarning("Deletion of unknown dive!");
res.dive.reset(unregister_dive(idx)); // Remove dive from backend
return res;
}
void DiveListBase::diveSiteCountChanged(struct dive_site *ds)
{
if (std::find(sitesCountChanged.begin(), sitesCountChanged.end(), ds) == sitesCountChanged.end())
sitesCountChanged.push_back(ds);
}
// This helper function adds a dive and returns ownership to the backend. It may also add a dive trip.
// It is crucial that dives are added in reverse order of deletion (see comment above)!
// Returns pointer to added dive (which is owned by the backend!)
dive *DiveListBase::addDive(DiveToAdd &d)
{
if (d.trip)
add_dive_to_trip(d.dive.get(), d.trip);
if (d.site) {
add_dive_to_dive_site(d.dive.get(), d.site);
diveSiteCountChanged(d.site);
}
dive *res = d.dive.release(); // Give up ownership of dive
// Set the filter flag according to current filter settings
bool show = MultiFilterSortModel::instance()->showDive(res);
res->hidden_by_filter = !show;
int idx = dive_table_get_insertion_index(&dive_table, res);
add_to_dive_table(&dive_table, idx, res); // Return ownership to backend
invalidate_dive_cache(res); // Ensure that dive is written in git_save()
return res;
}
// Some signals are sent in batches per trip. To avoid writing the same loop
// twice, this template takes a vector of trip / dive pairs, sorts it
// by trip and then calls a function-object with trip and a QVector of dives in that trip.
// The dives are sorted by the dive_less_than() function defined in the core.
// Input parameters:
// - dives: a vector of trip,dive pairs, which will be sorted and processed in batches by trip.
// - action: a function object, taking a trip-pointer and a QVector of dives, which will be called for each batch.
template<typename Function>
void processByTrip(std::vector<std::pair<dive_trip *, dive *>> &dives, Function action)
{
// Sort lexicographically by trip then according to the dive_less_than() function.
std::sort(dives.begin(), dives.end(),
[](const std::pair<dive_trip *, dive *> &e1, const std::pair<dive_trip *, dive *> &e2)
{ return e1.first == e2.first ? dive_less_than(e1.second, e2.second) : e1.first < e2.first; });
// Then, process the dives in batches by trip
size_t i, j; // Begin and end of batch
for (i = 0; i < dives.size(); i = j) {
dive_trip *trip = dives[i].first;
for (j = i + 1; j < dives.size() && dives[j].first == trip; ++j)
; // pass
// Copy dives into a QVector. Some sort of "range_view" would be ideal, but Qt doesn't work this way.
QVector<dive *> divesInTrip(j - i);
for (size_t k = i; k < j; ++k)
divesInTrip[k - i] = dives[k].second;
// Finally, emit the signal
action(trip, divesInTrip);
}
}
// This helper function calls removeDive() on a list of dives to be removed and
// returns a vector of corresponding DiveToAdd objects, which can later be readded.
// Moreover, a vector of deleted trips is returned, if trips became empty.
// The passed in vector is cleared.
DivesAndTripsToAdd DiveListBase::removeDives(DivesAndSitesToRemove &divesAndSitesToDelete)
{
std::vector<DiveToAdd> divesToAdd;
std::vector<OwningTripPtr> tripsToAdd;
std::vector<OwningDiveSitePtr> sitesToAdd;
divesToAdd.reserve(divesAndSitesToDelete.dives.size());
sitesToAdd.reserve(divesAndSitesToDelete.sites.size());
// Make sure that the dive list is sorted. The added dives will be sent in a signal
// and the recipients assume that the dives are sorted the same way as they are
// in the core list.
std::sort(divesAndSitesToDelete.dives.begin(), divesAndSitesToDelete.dives.end(), dive_less_than);
for (dive *d: divesAndSitesToDelete.dives)
divesToAdd.push_back(removeDive(d, tripsToAdd));
divesAndSitesToDelete.dives.clear();
for (dive_site *ds: divesAndSitesToDelete.sites) {
int idx = unregister_dive_site(ds);
sitesToAdd.emplace_back(ds);
emit diveListNotifier.diveSiteDeleted(ds, idx);
}
divesAndSitesToDelete.sites.clear();
// We send one dives-deleted signal per trip (see comments in DiveListNotifier.h).
// Therefore, collect all dives in an array and sort by trip.
std::vector<std::pair<dive_trip *, dive *>> dives;
dives.reserve(divesToAdd.size());
for (const DiveToAdd &entry: divesToAdd)
dives.push_back({ entry.trip, entry.dive.get() });
// Send signals.
processByTrip(dives, [&](dive_trip *trip, const QVector<dive *> &divesInTrip) {
// Check if this trip is supposed to be deleted, by checking if it was marked as "add it".
bool deleteTrip = trip &&
std::find_if(tripsToAdd.begin(), tripsToAdd.end(), [trip](const OwningTripPtr &ptr)
{ return ptr.get() == trip; }) != tripsToAdd.end();
emit diveListNotifier.divesDeleted(trip, deleteTrip, divesInTrip);
});
return { std::move(divesToAdd), std::move(tripsToAdd), std::move(sitesToAdd) };
}
// This helper function is the counterpart fo removeDives(): it calls addDive() on a list
// of dives to be (re)added and returns a vector of the added dives. It does this in reverse
// order, so that trips are created appropriately and indexing is correct.
// The passed in vector is cleared.
DivesAndSitesToRemove DiveListBase::addDives(DivesAndTripsToAdd &toAdd)
{
std::vector<dive *> res;
std::vector<dive_site *> sites;
std::vector<std::pair<dive_trip *, dive *>> dives;
res.resize(toAdd.dives.size());
sites.reserve(toAdd.sites.size());
dives.reserve(toAdd.sites.size());
// Make sure that the dive list is sorted. The added dives will be sent in a signal
// and the recipients assume that the dives are sorted the same way as they are
// in the core list.
std::sort(toAdd.dives.begin(), toAdd.dives.end(),
[](const DiveToAdd &d, const DiveToAdd &d2)
{ return dive_less_than(d.dive.get(), d2.dive.get()); });
// Now, add the dives
// Note: the idiomatic STL-way would be std::transform, but let's use a loop since
// that is closer to classical C-style.
auto it2 = res.rbegin();
for (auto it = toAdd.dives.rbegin(); it != toAdd.dives.rend(); ++it, ++it2) {
*it2 = addDive(*it);
dives.push_back({ (*it2)->divetrip, *it2 });
}
toAdd.dives.clear();
// If the dives belong to new trips, add these as well.
// Remember the pointers so that we can later check if a trip was newly added
std::vector<dive_trip *> addedTrips;
addedTrips.reserve(toAdd.trips.size());
for (OwningTripPtr &trip: toAdd.trips) {
addedTrips.push_back(trip.get());
insert_trip(trip.release(), &trip_table); // Return ownership to backend
}
toAdd.trips.clear();
// Finally, add any necessary dive sites
for (OwningDiveSitePtr &ds: toAdd.sites) {
sites.push_back(ds.get());
int idx = register_dive_site(ds.release()); // Return ownership to backend
emit diveListNotifier.diveSiteAdded(sites.back(), idx);
}
toAdd.sites.clear();
// Send signals by trip.
processByTrip(dives, [&](dive_trip *trip, const QVector<dive *> &divesInTrip) {
// Now, let's check if this trip is supposed to be created, by checking if it was marked as "add it".
bool createTrip = trip && std::find(addedTrips.begin(), addedTrips.end(), trip) != addedTrips.end();
// Finally, emit the signal
emit diveListNotifier.divesAdded(trip, createTrip, divesInTrip);
});
return { res, sites };
}
// This helper function renumbers dives according to an array of id/number pairs.
// The old numbers are stored in the array, thus calling this function twice has no effect.
static void renumberDives(QVector<QPair<dive *, int>> &divesToRenumber)
{
QVector<dive *> dives;
dives.reserve(divesToRenumber.size());
for (auto &pair: divesToRenumber) {
dive *d = pair.first;
if (!d)
continue;
std::swap(d->number, pair.second);
dives.push_back(d);
invalidate_dive_cache(d);
}
// Send signals.
emit diveListNotifier.divesChanged(dives, DiveField::NR);
}
// This helper function moves a dive to a trip. The old trip is recorded in the
// passed-in structure. This means that calling the function twice on the same
// object is a no-op concerning the dive. If the old trip was deleted from the
// core, an owning pointer to the removed trip is returned, otherwise a null pointer.
static OwningTripPtr moveDiveToTrip(DiveToTrip &diveToTrip)
{
// Firstly, check if we move to the same trip and bail if this is a no-op.
if (diveToTrip.trip == diveToTrip.dive->divetrip)
return {};
// Remove from old trip
OwningTripPtr res;
// Remove dive from trip - if this is the last dive in the trip, remove the whole trip.
dive_trip *trip = unregister_dive_from_trip(diveToTrip.dive);
if (trip && trip->dives.nr == 0) {
remove_trip(trip, &trip_table); // Remove trip from backend
res.reset(trip);
}
// Store old trip and get new trip we should associate this dive with
std::swap(trip, diveToTrip.trip);
add_dive_to_trip(diveToTrip.dive, trip);
invalidate_dive_cache(diveToTrip.dive); // Ensure that dive is written in git_save()
return res;
}
// This helper function moves a set of dives between trips using the
// moveDiveToTrip function. Before doing so, it adds the necessary trips to
// the core. Trips that are removed from the core because they are empty
// are recorded in the passed in struct. The vectors of trips and dives
// are reversed. Thus, calling the function twice on the same object is
// a no-op.
static void moveDivesBetweenTrips(DivesToTrip &dives)
{
// We collect an array of created trips so that we can instruct
// the model to create a new entry
std::vector<dive_trip *> createdTrips;
createdTrips.reserve(dives.tripsToAdd.size());
// First, bring back the trip(s)
for (OwningTripPtr &trip: dives.tripsToAdd) {
dive_trip *t = trip.release(); // Give up ownership
createdTrips.push_back(t);
insert_trip(t, &trip_table); // Return ownership to backend
}
dives.tripsToAdd.clear();
for (DiveToTrip &dive: dives.divesToMove) {
OwningTripPtr tripToAdd = moveDiveToTrip(dive);
// register trips that we'll have to readd
if (tripToAdd)
dives.tripsToAdd.push_back(std::move(tripToAdd));
}
// We send one signal per from-trip/to-trip pair.
// First, collect all dives in a struct and sort by from-trip/to-trip.
struct DiveMoved {
dive_trip *from;
dive_trip *to;
dive *d;
};
std::vector<DiveMoved> divesMoved;
divesMoved.reserve(dives.divesToMove.size());
for (const DiveToTrip &entry: dives.divesToMove)
divesMoved.push_back({ entry.trip, entry.dive->divetrip, entry.dive });
// Sort lexicographically by from-trip, to-trip and by start-time.
// Use std::tie() for lexicographical sorting.
std::sort(divesMoved.begin(), divesMoved.end(), [] ( const DiveMoved &d1, const DiveMoved &d2)
{ return std::tie(d1.from, d1.to, d1.d->when) < std::tie(d2.from, d2.to, d2.d->when); });
// Now, process the dives in batches by trip
// TODO: this is a bit different from the cases above, so we don't use the processByTrip template,
// but repeat the loop here. We might think about generalizing the template, if more of such
// "special cases" appear.
size_t i, j; // Begin and end of batch
for (i = 0; i < divesMoved.size(); i = j) {
dive_trip *from = divesMoved[i].from;
dive_trip *to = divesMoved[i].to;
for (j = i + 1; j < divesMoved.size() && divesMoved[j].from == from && divesMoved[j].to == to; ++j)
; // pass
// Copy dives into a QVector. Some sort of "range_view" would be ideal, but Qt doesn't work this way.
QVector<dive *> divesInTrip(j - i);
for (size_t k = i; k < j; ++k)
divesInTrip[k - i] = divesMoved[k].d;
// Check if the from-trip was deleted: If yes, it was recorded in the tripsToAdd structure.
// Only set the flag if this is that last time this trip is featured.
bool deleteFrom = from &&
std::find_if(divesMoved.begin() + j, divesMoved.end(), // Is this the last occurence of "from"?
[from](const DiveMoved &entry) { return entry.from == from; }) == divesMoved.end() &&
std::find_if(dives.tripsToAdd.begin(), dives.tripsToAdd.end(), // Is "from" in tripsToAdd?
[from](const OwningTripPtr &trip) { return trip.get() == from; }) != dives.tripsToAdd.end();
// Check if the to-trip has to be created. For this purpose, we saved an array of trips to be created.
bool createTo = false;
if (to) {
// Check if the element is there...
auto it = std::find(createdTrips.begin(), createdTrips.end(), to);
// ...if it is - remove it as we don't want the model to create the trip twice!
if (it != createdTrips.end()) {
createTo = true;
// erase/remove would be more performant, but this is irrelevant in the big scheme of things.
createdTrips.erase(it);
}
}
// Finally, emit the signal
emit diveListNotifier.divesMovedBetweenTrips(from, to, deleteFrom, createTo, divesInTrip);
}
// Reverse the tripsToAdd and the divesToAdd, so that on undo/redo the operations
// will be performed in reverse order.
std::reverse(dives.tripsToAdd.begin(), dives.tripsToAdd.end());
std::reverse(dives.divesToMove.begin(), dives.divesToMove.end());
}
void DiveListBase::initWork()
{
}
void DiveListBase::finishWork()
{
for (dive_site *ds: sitesCountChanged)
emit diveListNotifier.diveSiteDiveCountChanged(ds);
}
void DiveListBase::undo()
{
auto marker = diveListNotifier.enterCommand();
initWork();
undoit();
finishWork();
}
void DiveListBase::redo()
{
auto marker = diveListNotifier.enterCommand();
initWork();
redoit();
finishWork();
}
AddDive::AddDive(dive *d, bool autogroup, bool newNumber)
{
setText(tr("add dive"));
// By convention, d is a pointer to "displayed dive" or a temporary variable and can be overwritten.
d->maxdepth.mm = 0;
d->dc.maxdepth.mm = 0;
fixup_dive(d);
// this only matters if undoit were called before redoit
currentDive = nullptr;
// Get an owning pointer to a moved dive.
OwningDivePtr divePtr(move_dive(d));
divePtr->selected = false; // If we clone a planned dive, it might have been selected.
// We have to clear the flag, as selections will be managed
// on dive-addition.
// If we alloc a new-trip for autogrouping, get an owning pointer to it.
OwningTripPtr allocTrip;
dive_trip *trip = divePtr->divetrip;
dive_site *site = divePtr->dive_site;
// We have to delete the pointers to trip and site, because this would prevent the core from adding to the
// trip or site and we would get the count-of-dives in the trip or site wrong. Yes, that's all horribly subtle!
divePtr->divetrip = nullptr;
divePtr->dive_site = nullptr;
if (!trip && autogroup) {
bool alloc;
trip = get_trip_for_new_dive(divePtr.get(), &alloc);
if (alloc)
allocTrip.reset(trip);
}
int idx = dive_table_get_insertion_index(&dive_table, divePtr.get());
if (newNumber)
divePtr->number = get_dive_nr_at_idx(idx);
divesToAdd.dives.push_back({ std::move(divePtr), trip, site });
if (allocTrip)
divesToAdd.trips.push_back(std::move(allocTrip));
}
bool AddDive::workToBeDone()
{
return true;
}
void AddDive::redoit()
{
// Remember selection so that we can undo it
selection = getDiveSelection();
currentDive = current_dive;
divesAndSitesToRemove = addDives(divesToAdd);
sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips
// Select the newly added dive
setSelection(divesAndSitesToRemove.dives, divesAndSitesToRemove.dives[0]);
}
void AddDive::undoit()
{
// Simply remove the dive that was previously added...
divesToAdd = removeDives(divesAndSitesToRemove);
sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips
// ...and restore the selection
setSelection(selection, currentDive);
}
ImportDives::ImportDives(struct dive_table *dives, struct trip_table *trips, struct dive_site_table *sites, int flags, const QString &source)
{
setText(tr("import %n dive(s) from %1", "", dives->nr).arg(source));
// this only matters if undoit were called before redoit
currentDive = nullptr;
struct dive_table dives_to_add = { 0 };
struct dive_table dives_to_remove = { 0 };
struct trip_table trips_to_add = { 0 };
struct dive_site_table sites_to_add = { 0 };
process_imported_dives(dives, trips, sites, flags, &dives_to_add, &dives_to_remove, &trips_to_add, &sites_to_add);
// Add trips to the divesToAdd.trips structure
divesToAdd.trips.reserve(trips_to_add.nr);
for (int i = 0; i < trips_to_add.nr; ++i)
divesToAdd.trips.emplace_back(trips_to_add.trips[i]);
// Add sites to the divesToAdd.sites structure
divesToAdd.sites.reserve(sites_to_add.nr);
for (int i = 0; i < sites_to_add.nr; ++i)
divesToAdd.sites.emplace_back(sites_to_add.dive_sites[i]);
// Add dives to the divesToAdd.dives structure
divesToAdd.dives.reserve(dives_to_add.nr);
for (int i = 0; i < dives_to_add.nr; ++i) {
OwningDivePtr divePtr(dives_to_add.dives[i]);
divePtr->selected = false; // See above in AddDive::AddDive()
dive_trip *trip = divePtr->divetrip;
divePtr->divetrip = nullptr; // See above in AddDive::AddDive()
dive_site *site = divePtr->dive_site;
divePtr->dive_site = nullptr; // See above in AddDive::AddDive()
divesToAdd.dives.push_back({ std::move(divePtr), trip, site });
}
// Add dive to be deleted to the divesToRemove structure
divesAndSitesToRemove.dives.reserve(dives_to_remove.nr);
for (int i = 0; i < dives_to_remove.nr; ++i)
divesAndSitesToRemove.dives.push_back(dives_to_remove.dives[i]);
}
bool ImportDives::workToBeDone()
{
return !divesToAdd.dives.empty();
}
void ImportDives::redoit()
{
// Remember selection so that we can undo it
currentDive = current_dive;
// Add new dives and sites
DivesAndSitesToRemove divesAndSitesToRemoveNew = addDives(divesToAdd);
// Remove old dives and sites
divesToAdd = removeDives(divesAndSitesToRemove);
// Select the newly added dives
setSelection(divesAndSitesToRemoveNew.dives, divesAndSitesToRemoveNew.dives.back());
// Remember dives and sites to remove
divesAndSitesToRemove = std::move(divesAndSitesToRemoveNew);
}
void ImportDives::undoit()
{
// Add new dives and sites
DivesAndSitesToRemove divesAndSitesToRemoveNew = addDives(divesToAdd);
// Remove old dives and sites
divesToAdd = removeDives(divesAndSitesToRemove);
// Remember dives and sites to remove
divesAndSitesToRemove = std::move(divesAndSitesToRemoveNew);
// ...and restore the selection
setSelection(selection, currentDive);
}
DeleteDive::DeleteDive(const QVector<struct dive*> &divesToDeleteIn)
{
divesToDelete.dives = divesToDeleteIn.toStdVector();
setText(tr("delete %n dive(s)", "", divesToDelete.dives.size()));
}
bool DeleteDive::workToBeDone()
{
return !divesToDelete.dives.empty();
}
void DeleteDive::undoit()
{
divesToDelete = addDives(divesToAdd);
sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips
// Select all re-added dives and make the first one current
dive *currentDive = !divesToDelete.dives.empty() ? divesToDelete.dives[0] : nullptr;
setSelection(divesToDelete.dives, currentDive);
}
void DeleteDive::redoit()
{
divesToAdd = removeDives(divesToDelete);
sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips
// Deselect all dives and select dive that was close to the first deleted dive
dive *newCurrent = nullptr;
if (!divesToAdd.dives.empty()) {
timestamp_t when = divesToAdd.dives[0].dive->when;
newCurrent = find_next_visible_dive(when);
}
if (newCurrent)
setSelection(std::vector<dive *>{ newCurrent }, newCurrent);
else
setSelection(std::vector<dive *>(), nullptr);
}
ShiftTime::ShiftTime(const QVector<dive *> &changedDives, int amount)
: diveList(changedDives), timeChanged(amount)
{
setText(tr("shift time of %n dives", "", changedDives.count()));
}
void ShiftTime::redoit()
{
std::vector<dive_trip *> trips;
for (dive *d: diveList) {
d->when += timeChanged;
if (d->divetrip && std::find(trips.begin(), trips.end(), d->divetrip) == trips.end())
trips.push_back(d->divetrip);
}
// Changing times may have unsorted the dive and trip tables
sort_dive_table(&dive_table);
sort_trip_table(&trip_table);
for (dive_trip *trip: trips)
sort_dive_table(&trip->dives); // Keep the trip-table in order
// Send signals
emit diveListNotifier.divesTimeChanged(timeChanged, diveList);
emit diveListNotifier.divesChanged(diveList, DiveField::DATETIME);
// Select the changed dives
setSelection(diveList.toStdVector(), diveList[0]);
// Negate the time-shift so that the next call does the reverse
timeChanged = -timeChanged;
}
bool ShiftTime::workToBeDone()
{
return !diveList.isEmpty();
}
void ShiftTime::undoit()
{
// Same as redoit(), since after redoit() we reversed the timeOffset
redoit();
}
RenumberDives::RenumberDives(const QVector<QPair<dive *, int>> &divesToRenumberIn) : divesToRenumber(divesToRenumberIn)
{
setText(tr("renumber %n dive(s)", "", divesToRenumber.count()));
}
void RenumberDives::undoit()
{
renumberDives(divesToRenumber);
// Select the changed dives
std::vector<dive *> dives;
dives.reserve(divesToRenumber.size());
for (const QPair<dive *, int> &item: divesToRenumber)
dives.push_back(item.first);
setSelection(dives, dives[0]);
}
bool RenumberDives::workToBeDone()
{
return !divesToRenumber.isEmpty();
}
void RenumberDives::redoit()
{
// Redo and undo do the same thing!
undoit();
}
bool TripBase::workToBeDone()
{
return !divesToMove.divesToMove.empty();
}
void TripBase::redoit()
{
moveDivesBetweenTrips(divesToMove);
sort_trip_table(&trip_table); // Though unlikely, moving dives may reorder trips
// Select the moved dives
std::vector<dive *> dives;
dives.reserve(divesToMove.divesToMove.size());
for (const DiveToTrip &item: divesToMove.divesToMove)
dives.push_back(item.dive);
setSelection(dives, dives[0]);
}
void TripBase::undoit()
{
// Redo and undo do the same thing!
redoit();
}
RemoveDivesFromTrip::RemoveDivesFromTrip(const QVector<dive *> &divesToRemove)
{
setText(tr("remove %n dive(s) from trip", "", divesToRemove.size()));
divesToMove.divesToMove.reserve(divesToRemove.size());
for (dive *d: divesToRemove) {
// If a user manually removes a dive from a trip, don't autogroup this dive.
// The flag will not be reset on undo, but that should be acceptable.
d->notrip = true;
divesToMove.divesToMove.push_back( {d, nullptr} );
}
}
RemoveAutogenTrips::RemoveAutogenTrips()
{
setText(tr("remove autogenerated trips"));
// TODO: don't touch core-innards directly
int i;
struct dive *dive;
for_each_dive(i, dive) {
if (dive->divetrip && dive->divetrip->autogen)
divesToMove.divesToMove.push_back( {dive, nullptr} );
}
}
AddDivesToTrip::AddDivesToTrip(const QVector<dive *> &divesToAddIn, dive_trip *trip)
{
setText(tr("add %n dives to trip", "", divesToAddIn.size()));
for (dive *d: divesToAddIn)
divesToMove.divesToMove.push_back( {d, trip} );
}
CreateTrip::CreateTrip(const QVector<dive *> &divesToAddIn)
{
setText(tr("create trip"));
if (divesToAddIn.isEmpty())
return;
dive_trip *trip = create_trip_from_dive(divesToAddIn[0]);
divesToMove.tripsToAdd.emplace_back(trip);
for (dive *d: divesToAddIn)
divesToMove.divesToMove.push_back( {d, trip} );
}
AutogroupDives::AutogroupDives()
{
setText(tr("autogroup dives"));
dive_trip *trip;
bool alloc;
int from, to;
for(int i = 0; (trip = get_dives_to_autogroup(&dive_table, i, &from, &to, &alloc)) != NULL; i = to) {
// If this is an allocated trip, take ownership
if (alloc)
divesToMove.tripsToAdd.emplace_back(trip);
for (int j = from; j < to; ++j)
divesToMove.divesToMove.push_back( { get_dive(j), trip } );
}
}
MergeTrips::MergeTrips(dive_trip *trip1, dive_trip *trip2)
{
if (trip1 == trip2)
return;
dive_trip *newTrip = combine_trips(trip1, trip2);
divesToMove.tripsToAdd.emplace_back(newTrip);
for (int i = 0; i < trip1->dives.nr; ++i)
divesToMove.divesToMove.push_back( { trip1->dives.dives[i], newTrip } );
for (int i = 0; i < trip2->dives.nr; ++i)
divesToMove.divesToMove.push_back( { trip2->dives.dives[i], newTrip } );
}
// std::array<dive *, 2> is the same as struct *dive[2], with the fundamental
// difference that it can be returned from functions. Thus, this constructor
// can be chained with the result of a function.
SplitDivesBase::SplitDivesBase(dive *d, std::array<dive *, 2> newDives)
{
// If either of the new dives is null, simply return. Empty arrays indicate that nothing is to be done.
if (!newDives[0] || !newDives[1])
return;
// Currently, the core code selects the dive -> this is not what we want, as
// we manually manage the selection post-command.
// TODO: Reset selection in core.
newDives[0]->selected = false;
newDives[1]->selected = false;
// The new dives will be registered to the dive site using the site member
// of the DiveToAdd structure. For this to work, we must set the dive's
// dive_site member to null. Yes, that's subtle!
newDives[0]->dive_site = nullptr;
newDives[1]->dive_site = nullptr;
diveToSplit.dives.push_back(d);
splitDives.dives.resize(2);
splitDives.dives[0].dive.reset(newDives[0]);
splitDives.dives[0].trip = d->divetrip;
splitDives.dives[0].site = d->dive_site;
splitDives.dives[1].dive.reset(newDives[1]);
splitDives.dives[1].trip = d->divetrip;
splitDives.dives[1].site = d->dive_site;
}
bool SplitDivesBase::workToBeDone()
{
return !diveToSplit.dives.empty();
}
void SplitDivesBase::redoit()
{
divesToUnsplit = addDives(splitDives);
unsplitDive = removeDives(diveToSplit);
// Select split dives and make first dive current
setSelection(divesToUnsplit.dives, divesToUnsplit.dives[0]);
}
void SplitDivesBase::undoit()
{
// Note: reverse order with respect to redoit()
diveToSplit = addDives(unsplitDive);
splitDives = removeDives(divesToUnsplit);
// Select unsplit dive and make it current
setSelection(diveToSplit.dives, diveToSplit.dives[0] );
}
static std::array<dive *, 2> doSplitDives(const dive *d, duration_t time)
{
// Split the dive
dive *new1, *new2;
if (time.seconds < 0)
split_dive(d, &new1, &new2);
else
split_dive_at_time(d, time, &new1, &new2);
return { new1, new2 };
}
SplitDives::SplitDives(dive *d, duration_t time) : SplitDivesBase(d, doSplitDives(d, time))
{
setText(tr("split dive"));
}
static std::array<dive *, 2> splitDiveComputer(const dive *d, int dc_num)
{
// Refuse to do anything if the dive has only one dive computer.
// Yes, this should have been checked by the UI, but let's just make sure.
if (!d->dc.next)
return { nullptr, nullptr};
dive *new1, *new2;
split_divecomputer(d, dc_num, &new1, &new2);
return { new1, new2 };
}
SplitDiveComputer::SplitDiveComputer(dive *d, int dc_num) : SplitDivesBase(d, splitDiveComputer(d, dc_num))
{
setText(tr("split dive computer"));
}
DiveComputerBase::DiveComputerBase(dive *old_dive, dive *new_dive, int dc_nr_after_in) : dc_nr_before(dc_number),
dc_nr_after(dc_nr_after_in)
{
if (!new_dive)
return;
diveToRemove.dives.push_back(old_dive);
// Currently, the core code selects the dive -> this is not what we want, as
// we manually manage the selection post-command.
// TODO: Reset selection in core.
new_dive->selected = false;
// Reset references to trip and site in the new dive, as the undo command
// will add the dive to the trip and site.
new_dive->divetrip = nullptr;
new_dive->dive_site = nullptr;
diveToAdd.dives.resize(1);
diveToAdd.dives[0].dive.reset(new_dive);
diveToAdd.dives[0].trip = old_dive->divetrip;
diveToAdd.dives[0].site = old_dive->dive_site;
}
bool DiveComputerBase::workToBeDone()
{
return !diveToRemove.dives.empty() || !diveToAdd.dives.empty();
}
void DiveComputerBase::redoit()
{
DivesAndSitesToRemove addedDive = addDives(diveToAdd);
diveToAdd = removeDives(diveToRemove);
diveToRemove = std::move(addedDive);
dc_number = dc_nr_after;
// Select added dive and make it current.
// This automatically replots the profile.
setSelection(diveToRemove.dives, diveToRemove.dives[0]);
std::swap(dc_nr_before, dc_nr_after);
}
void DiveComputerBase::undoit()
{
// Undo and redo do the same
redoit();
}
MoveDiveComputerToFront::MoveDiveComputerToFront(dive *d, int dc_num)
: DiveComputerBase(d, make_first_dc(d, dc_num), 0)
{
setText(tr("move dive computer to front"));
}
DeleteDiveComputer::DeleteDiveComputer(dive *d, int dc_num)
: DiveComputerBase(d, clone_delete_divecomputer(d, dc_num), std::min(count_divecomputers(d) - 1, dc_num))
{
setText(tr("delete dive computer"));
}
MergeDives::MergeDives(const QVector <dive *> &dives)
{
setText(tr("merge dive"));
// Just a safety check - if there's not two or more dives - do nothing
// The caller should have made sure that this doesn't happen.
if (dives.count() < 2) {
qWarning("Merging less than two dives");
return;
}
dive_trip *preferred_trip;
dive_site *preferred_site;
OwningDivePtr d(merge_dives(dives[0], dives[1], dives[1]->when - dives[0]->when, false, &preferred_trip, &preferred_site));
// Currently, the core code selects the dive -> this is not what we want, as
// we manually manage the selection post-command.
// TODO: Remove selection code from core.
d->selected = false;
// Set the preferred dive trip, so that for subsequent merges the better trip can be selected
d->divetrip = preferred_trip;
for (int i = 2; i < dives.count(); ++i) {
d.reset(merge_dives(d.get(), dives[i], dives[i]->when - d->when, false, &preferred_trip, &preferred_site));
// Set the preferred dive trip and site, so that for subsequent merges the better trip and site can be selected
d->divetrip = preferred_trip;
d->dive_site = preferred_site;
}
// We got our preferred trip and site, so now the references can be deleted from the newly generated dive
d->divetrip = nullptr;
d->dive_site = nullptr;
// The merged dive gets the number of the first dive with a non-zero number
for (const dive *dive: dives) {
if (dive->number) {
d->number = dive->number;
break;
}
}
// We will only renumber the remaining dives if the joined dives are consecutive.
// Otherwise all bets are off concerning what the user wanted and doing nothing seems
// like the best option.
int idx = get_divenr(dives[0]);
int num = dives.count();
if (idx < 0 || idx + num > dive_table.nr) {
// It was the callers responsibility to pass only known dives.
// Something is seriously wrong - give up.
qWarning("Merging unknown dives");
return;
}
// std::equal compares two ranges. The parameters are (begin_range1, end_range1, begin_range2).
// Here, we can compare C-arrays, because QVector guarantees contiguous storage.
if (std::equal(&dives[0], &dives[0] + num, &dive_table.dives[idx]) &&
dives[0]->number && dives.last()->number && dives[0]->number < dives.last()->number) {
// We have a consecutive set of dives. Rename all following dives according to the
// number of erased dives. This considers that there might be missing numbers.
// Comment copied from core/divelist.c:
// So if you had a dive list 1 3 6 7 8, and you
// merge 1 and 3, the resulting numbered list will
// be 1 4 5 6, because we assume that there were
// some missing dives (originally dives 4 and 5),
// that now will still be missing (dives 2 and 3
// in the renumbered world).
//
// Obviously the normal case is that everything is
// consecutive, and the difference will be 1, so the
// above example is not supposed to be normal.
int diff = dives.last()->number - dives[0]->number;
divesToRenumber.reserve(dive_table.nr - idx - num);
int previousnr = dives[0]->number;
for (int i = idx + num; i < dive_table.nr; ++i) {
int newnr = dive_table.dives[i]->number - diff;
// Stop renumbering if stuff isn't in order (see also core/divelist.c)
if (newnr <= previousnr)
break;
divesToRenumber.append(QPair<dive *,int>(dive_table.dives[i], newnr));
previousnr = newnr;
}
}
mergedDive.dives.resize(1);
mergedDive.dives[0].dive = std::move(d);
mergedDive.dives[0].trip = preferred_trip;
mergedDive.dives[0].site = preferred_site;
divesToMerge.dives = dives.toStdVector();
}
bool MergeDives::workToBeDone()
{
return !mergedDive.dives.empty();
}
void MergeDives::redoit()
{
renumberDives(divesToRenumber);
diveToUnmerge = addDives(mergedDive);
unmergedDives = removeDives(divesToMerge);
// Select merged dive and make it current
setSelection(diveToUnmerge.dives, diveToUnmerge.dives[0]);
}
void MergeDives::undoit()
{
divesToMerge = addDives(unmergedDives);
mergedDive = removeDives(diveToUnmerge);
renumberDives(divesToRenumber);
// Select unmerged dives and make first one current
setSelection(divesToMerge.dives, divesToMerge.dives[0]);
}
} // namespace Command

285
desktop-widgets/command_divelist.h
View file

@ -1,285 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_DIVELIST_H
#define COMMAND_DIVELIST_H
#include "command_base.h"
#include <QVector>
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
// This helper structure describes a dive that we want to add.
struct DiveToAdd {
OwningDivePtr dive; // Dive to add
dive_trip *trip; // Trip the dive belongs to, may be null
dive_site *site; // Site the dive is associated with, may be null
};
// Multiple trips, dives and dive sites that have to be added for a command
struct DivesAndTripsToAdd {
std::vector<DiveToAdd> dives;
std::vector<OwningTripPtr> trips;
std::vector<OwningDiveSitePtr> sites;
};
// Dives and sites that have to be removed for a command
struct DivesAndSitesToRemove {
std::vector<dive *> dives;
std::vector<dive_site *> sites;
};
// This helper structure describes a dive that should be moved to / removed from
// a trip. If the "trip" member is null, the dive is removed from its trip (if
// it is in a trip, that is)
struct DiveToTrip
{
struct dive *dive;
dive_trip *trip;
};
// This helper structure describes a number of dives to add to / remove from /
// move between trips.
// It has ownership of the trips (if any) that have to be added before hand.
struct DivesToTrip
{
std::vector<DiveToTrip> divesToMove; // If dive_trip is null, remove from trip
std::vector<OwningTripPtr> tripsToAdd;
};
// All divelist commands derive from a common base class. It keeps track
// of dive site counts that may have changed.
// Derived classes implement the virtual methods redoit() and undoit()
// [Yes, the names could be more expressive].
class DiveListBase : public Base {
protected:
// These are helper functions to add / remove dive from the C-core structures.
DiveToAdd removeDive(struct dive *d, std::vector<OwningTripPtr> &tripsToAdd);
dive *addDive(DiveToAdd &d);
DivesAndTripsToAdd removeDives(DivesAndSitesToRemove &divesAndSitesToDelete);
DivesAndSitesToRemove addDives(DivesAndTripsToAdd &toAdd);
// Register dive sites where counts changed so that we can signal the frontend later.
void diveSiteCountChanged(struct dive_site *ds);
private:
// Keep track of dive sites where the number of dives changed
std::vector<dive_site *> sitesCountChanged;
void initWork();
void finishWork(); // update dive site counts
void undo() override;
void redo() override;
virtual void redoit() = 0;
virtual void undoit() = 0;
};
class AddDive : public DiveListBase {
public:
AddDive(dive *dive, bool autogroup, bool newNumber);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo
// Note: we a multi-dive structure even though we add only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
DivesAndTripsToAdd divesToAdd;
// For undo
DivesAndSitesToRemove divesAndSitesToRemove;
std::vector<dive *> selection;
dive * currentDive;
};
class ImportDives : public DiveListBase {
public:
// Note: dives and trips are consumed - after the call they will be empty.
ImportDives(struct dive_table *dives, struct trip_table *trips, struct dive_site_table *sites, int flags, const QString &source);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo and undo
DivesAndTripsToAdd divesToAdd;
DivesAndSitesToRemove divesAndSitesToRemove;
// For redo
std::vector<OwningDiveSitePtr> sitesToAdd;
// For undo
std::vector<dive_site *> sitesToRemove;
std::vector<dive *> selection;
dive * currentDive;
};
class DeleteDive : public DiveListBase {
public:
DeleteDive(const QVector<dive *> &divesToDelete);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo
DivesAndSitesToRemove divesToDelete;
std::vector<OwningTripPtr> tripsToAdd;
DivesAndTripsToAdd divesToAdd;
};
class ShiftTime : public DiveListBase {
public:
ShiftTime(const QVector<dive *> &changedDives, int amount);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo and undo
QVector<dive *> diveList;
int timeChanged;
};
class RenumberDives : public DiveListBase {
public:
RenumberDives(const QVector<QPair<dive *, int>> &divesToRenumber);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo and undo: pairs of dive-id / new number
QVector<QPair<dive *, int>> divesToRenumber;
};
// The classes RemoveDivesFromTrip, RemoveAutogenTrips, CreateTrip, AutogroupDives
// and MergeTrips all do the same thing, just the intialization differs.
// Therefore, define a base class with the proper data-structures, redo()
// and undo() functions and derive to specialize the initialization.
class TripBase : public DiveListBase {
protected:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo and undo
DivesToTrip divesToMove;
};
struct RemoveDivesFromTrip : public TripBase {
RemoveDivesFromTrip(const QVector<dive *> &divesToRemove);
};
struct RemoveAutogenTrips : public TripBase {
RemoveAutogenTrips();
};
struct AddDivesToTrip : public TripBase {
AddDivesToTrip(const QVector<dive *> &divesToAdd, dive_trip *trip);
};
struct CreateTrip : public TripBase {
CreateTrip(const QVector<dive *> &divesToAdd);
};
struct AutogroupDives : public TripBase {
AutogroupDives();
};
struct MergeTrips : public TripBase {
MergeTrips(dive_trip *trip1, dive_trip *trip2);
};
class SplitDivesBase : public DiveListBase {
protected:
SplitDivesBase(dive *old, std::array<dive *, 2> newDives);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo
// For each dive to split, we remove one from and put two dives into the backend
// Note: we use a vector even though we split only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
DivesAndSitesToRemove diveToSplit;
DivesAndTripsToAdd splitDives;
// For undo
// For each dive to unsplit, we remove two dives from and add one into the backend
// Note: we use a multi-dive structure even though we unsplit only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
DivesAndTripsToAdd unsplitDive;
DivesAndSitesToRemove divesToUnsplit;
};
class SplitDives : public SplitDivesBase {
public:
// If time is < 0, split at first surface interval
SplitDives(dive *d, duration_t time);
};
class SplitDiveComputer : public SplitDivesBase {
public:
// If time is < 0, split at first surface interval
SplitDiveComputer(dive *d, int dc_num);
};
// When manipulating dive computers (moving, deleting) we go the ineffective,
// but simple and robust way: We keep two full copies of the dive (before and after).
// Removing and readding assures that the dive stays at the correct
// position in the list (the dive computer list is used for sorting dives).
class DiveComputerBase : public DiveListBase {
protected:
// old_dive must be a dive known to the core.
// new_dive must be new dive whose ownership is taken.
DiveComputerBase(dive *old_dive, dive *new_dive, int dc_nr_after);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
protected:
// For redo and undo
DivesAndTripsToAdd diveToAdd;
DivesAndSitesToRemove diveToRemove;
int dc_nr_before, dc_nr_after;
};
class MoveDiveComputerToFront : public DiveComputerBase {
public:
MoveDiveComputerToFront(dive *d, int dc_num);
};
class DeleteDiveComputer : public DiveComputerBase {
public:
DeleteDiveComputer(dive *d, int dc_num);
};
class MergeDives : public DiveListBase {
public:
MergeDives(const QVector<dive *> &dives);
private:
void undoit() override;
void redoit() override;
bool workToBeDone() override;
// For redo
// Add one and remove a batch of dives
// Note: we use a multi-dives structure even though we add only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
DivesAndTripsToAdd mergedDive;
DivesAndSitesToRemove divesToMerge;
// For undo
// Remove one and add a batch of dives
// Note: we use a vector even though we remove only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
DivesAndSitesToRemove diveToUnmerge;
DivesAndTripsToAdd unmergedDives;
// For undo and redo
QVector<QPair<dive *, int>> divesToRenumber;
};
} // namespace Command
#endif // COMMAND_DIVELIST_H

395
desktop-widgets/command_divesite.cpp
View file

@ -1,395 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command_divesite.h"
#include "command_private.h"
#include "core/divesite.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include "core/qthelper.h"
#include "core/subsurface-string.h"
#include "qt-models/divelocationmodel.h"
#include "qt-models/filtermodels.h"
namespace Command {
// Helper functions to add / remove a set of dive sites
// Add a set of dive sites to the core. The dives that were associated with
// that dive site will be restored to that dive site.
static std::vector<dive_site *> addDiveSites(std::vector<OwningDiveSitePtr> &sites)
{
std::vector<dive_site *> res;
QVector<dive *> changedDives;
res.reserve(sites.size());
for (OwningDiveSitePtr &ds: sites) {
// Readd the dives that belonged to this site
for (int i = 0; i < ds->dives.nr; ++i) {
// TODO: send dive site changed signal
struct dive *d = ds->dives.dives[i];
d->dive_site = ds.get();
changedDives.push_back(d);
}
// Add dive site to core, but remember a non-owning pointer first.
res.push_back(ds.get());
int idx = register_dive_site(ds.release()); // Return ownership to backend.
emit diveListNotifier.diveSiteAdded(res.back(), idx); // Inform frontend of new dive site.
}
emit diveListNotifier.divesChanged(changedDives, DiveField::DIVESITE);
// Clear vector of unused owning pointers
sites.clear();
return res;
}
// Remove a set of dive sites. Get owning pointers to them. The dives are set to
// being at no dive site, but the dive site will retain a list of dives, so
// that the dives can be readded to the site on undo.
static std::vector<OwningDiveSitePtr> removeDiveSites(std::vector<dive_site *> &sites)
{
std::vector<OwningDiveSitePtr> res;
QVector<dive *> changedDives;
res.reserve(sites.size());
for (dive_site *ds: sites) {
// Reset the dive_site field of the affected dives
for (int i = 0; i < ds->dives.nr; ++i) {
struct dive *d = ds->dives.dives[i];
d->dive_site = nullptr;
changedDives.push_back(d);
}
// Remove dive site from core and take ownership.
int idx = unregister_dive_site(ds);
res.emplace_back(ds);
emit diveListNotifier.diveSiteDeleted(ds, idx); // Inform frontend of removed dive site.
}
emit diveListNotifier.divesChanged(changedDives, DiveField::DIVESITE);
sites.clear();
return res;
}
AddDiveSite::AddDiveSite(const QString &name)
{
setText(tr("add dive site"));
sitesToAdd.emplace_back(alloc_dive_site());
sitesToAdd.back()->name = copy_qstring(name);
}
bool AddDiveSite::workToBeDone()
{
return true;
}
void AddDiveSite::redo()
{
sitesToRemove = addDiveSites(sitesToAdd);
}
void AddDiveSite::undo()
{
sitesToAdd = removeDiveSites(sitesToRemove);
}
ImportDiveSites::ImportDiveSites(struct dive_site_table *sites, const QString &source)
{
setText(tr("import dive sites from %1").arg(source));
for (int i = 0; i < sites->nr; ++i) {
struct dive_site *new_ds = sites->dive_sites[i];
// Don't import dive sites that already exist. Currently we only check for
// the same name. We might want to be smarter here and merge dive site data, etc.
struct dive_site *old_ds = get_same_dive_site(new_ds);
if (old_ds) {
free_dive_site(new_ds);
continue;
}
sitesToAdd.emplace_back(new_ds);
}
// All site have been consumed
sites->nr = 0;
}
bool ImportDiveSites::workToBeDone()
{
return !sitesToAdd.empty();
}
void ImportDiveSites::redo()
{
sitesToRemove = addDiveSites(sitesToAdd);
}
void ImportDiveSites::undo()
{
sitesToAdd = removeDiveSites(sitesToRemove);
}
DeleteDiveSites::DeleteDiveSites(const QVector<dive_site *> &sites) : sitesToRemove(sites.toStdVector())
{
setText(tr("delete %n dive site(s)", "", sites.size()));
}
bool DeleteDiveSites::workToBeDone()
{
return !sitesToRemove.empty();
}
void DeleteDiveSites::redo()
{
sitesToAdd = removeDiveSites(sitesToRemove);
}
void DeleteDiveSites::undo()
{
sitesToRemove = addDiveSites(sitesToAdd);
}
PurgeUnusedDiveSites::PurgeUnusedDiveSites()
{
setText(tr("purge unused dive sites"));
for (int i = 0; i < dive_site_table.nr; ++i) {
dive_site *ds = dive_site_table.dive_sites[i];
if (ds->dives.nr == 0)
sitesToRemove.push_back(ds);
}
}
bool PurgeUnusedDiveSites::workToBeDone()
{
return !sitesToRemove.empty();
}
void PurgeUnusedDiveSites::redo()
{
sitesToAdd = removeDiveSites(sitesToRemove);
}
void PurgeUnusedDiveSites::undo()
{
sitesToRemove = addDiveSites(sitesToAdd);
}
// Helper function: swap C and Qt string
static void swap(char *&c, QString &q)
{
QString s = c;
free(c);
c = copy_qstring(q);
q = s;
}
EditDiveSiteName::EditDiveSiteName(dive_site *dsIn, const QString &name) : ds(dsIn),
value(name)
{
setText(tr("Edit dive site name"));
}
bool EditDiveSiteName::workToBeDone()
{
return value != QString(ds->name);
}
void EditDiveSiteName::redo()
{
swap(ds->name, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::NAME); // Inform frontend of changed dive site.
}
void EditDiveSiteName::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteDescription::EditDiveSiteDescription(dive_site *dsIn, const QString &description) : ds(dsIn),
value(description)
{
setText(tr("Edit dive site description"));
}
bool EditDiveSiteDescription::workToBeDone()
{
return value != QString(ds->description);
}
void EditDiveSiteDescription::redo()
{
swap(ds->description, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::DESCRIPTION); // Inform frontend of changed dive site.
}
void EditDiveSiteDescription::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteNotes::EditDiveSiteNotes(dive_site *dsIn, const QString &notes) : ds(dsIn),
value(notes)
{
setText(tr("Edit dive site notes"));
}
bool EditDiveSiteNotes::workToBeDone()
{
return value != QString(ds->notes);
}
void EditDiveSiteNotes::redo()
{
swap(ds->notes, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::NOTES); // Inform frontend of changed dive site.
}
void EditDiveSiteNotes::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteCountry::EditDiveSiteCountry(dive_site *dsIn, const QString &country) : ds(dsIn),
value(country)
{
setText(tr("Edit dive site country"));
}
bool EditDiveSiteCountry::workToBeDone()
{
return !same_string(qPrintable(value), taxonomy_get_country(&ds->taxonomy));
}
void EditDiveSiteCountry::redo()
{
QString old = taxonomy_get_country(&ds->taxonomy);
taxonomy_set_country(&ds->taxonomy, copy_qstring(value), taxonomy_origin::GEOMANUAL);
value = old;
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::TAXONOMY); // Inform frontend of changed dive site.
}
void EditDiveSiteCountry::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteLocation::EditDiveSiteLocation(dive_site *dsIn, const location_t location) : ds(dsIn),
value(location)
{
setText(tr("Edit dive site location"));
}
bool EditDiveSiteLocation::workToBeDone()
{
bool ok = has_location(&value);
bool old_ok = has_location(&ds->location);
if (ok != old_ok)
return true;
return ok && !same_location(&value, &ds->location);
}
void EditDiveSiteLocation::redo()
{
std::swap(value, ds->location);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::LOCATION); // Inform frontend of changed dive site.
}
void EditDiveSiteLocation::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteTaxonomy::EditDiveSiteTaxonomy(dive_site *dsIn, taxonomy_data &taxonomy) : ds(dsIn),
value(taxonomy)
{
// We did a dumb copy. Erase the source to remove double references to strings.
memset(&taxonomy, 0, sizeof(taxonomy));
setText(tr("Edit dive site taxonomy"));
}
EditDiveSiteTaxonomy::~EditDiveSiteTaxonomy()
{
free_taxonomy(&value);
}
bool EditDiveSiteTaxonomy::workToBeDone()
{
// TODO: Apparently we have no way of comparing taxonomies?
return true;
}
void EditDiveSiteTaxonomy::redo()
{
std::swap(value, ds->taxonomy);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::TAXONOMY); // Inform frontend of changed dive site.
}
void EditDiveSiteTaxonomy::undo()
{
// Undo and redo do the same
redo();
}
MergeDiveSites::MergeDiveSites(dive_site *dsIn, const QVector<dive_site *> &sites) : ds(dsIn)
{
setText(tr("merge dive sites"));
sitesToRemove.reserve(sites.size());
for (dive_site *site: sites) {
if (site != ds)
sitesToRemove.push_back(site);
}
}
bool MergeDiveSites::workToBeDone()
{
return !sitesToRemove.empty();
}
void MergeDiveSites::redo()
{
// First, remove all dive sites
sitesToAdd = removeDiveSites(sitesToRemove);
// Remember which dives changed so that we can send a single dives-edited signal
QVector<dive *> divesChanged;
// The dives of the above dive sites were reset to no dive sites.
// Add them to the merged-into dive site. Thankfully, we remember
// the dives in the sitesToAdd vector.
for (const OwningDiveSitePtr &site: sitesToAdd) {
for (int i = 0; i < site->dives.nr; ++i) {
add_dive_to_dive_site(site->dives.dives[i], ds);
divesChanged.push_back(site->dives.dives[i]);
}
}
emit diveListNotifier.divesChanged(divesChanged, DiveField::DIVESITE);
}
void MergeDiveSites::undo()
{
// Remember which dives changed so that we can send a single dives-edited signal
QVector<dive *> divesChanged;
// Before readding the dive sites, unregister the corresponding dives so that they can be
// readded to their old dive sites.
for (const OwningDiveSitePtr &site: sitesToAdd) {
for (int i = 0; i < site->dives.nr; ++i) {
unregister_dive_from_dive_site(site->dives.dives[i]);
divesChanged.push_back(site->dives.dives[i]);
}
}
sitesToRemove = addDiveSites(sitesToAdd);
emit diveListNotifier.divesChanged(divesChanged, DiveField::DIVESITE);
}
} // namespace Command

170
desktop-widgets/command_divesite.h
View file

@ -1,170 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_DIVESITE_H
#define COMMAND_DIVESITE_H
#include "command_base.h"
#include <QVector>
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
class AddDiveSite : public Base {
public:
AddDiveSite(const QString &name);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
// Note: we only add one dive site. Nevertheless, we use vectors so that we
// can reuse the dive site deletion code.
// For undo
std::vector<dive_site *> sitesToRemove;
// For redo
std::vector<OwningDiveSitePtr> sitesToAdd;
};
class ImportDiveSites : public Base {
public:
// Note: the dive site table is consumed after the call it will be empty.
ImportDiveSites(struct dive_site_table *sites, const QString &source);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
// For undo
std::vector<dive_site *> sitesToRemove;
// For redo
std::vector<OwningDiveSitePtr> sitesToAdd;
};
class DeleteDiveSites : public Base {
public:
DeleteDiveSites(const QVector<dive_site *> &sites);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
// For redo
std::vector<dive_site *> sitesToRemove;
// For undo
std::vector<OwningDiveSitePtr> sitesToAdd;
};
class PurgeUnusedDiveSites : public Base {
public:
PurgeUnusedDiveSites();
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
// For redo
std::vector<dive_site *> sitesToRemove;
// For undo
std::vector<OwningDiveSitePtr> sitesToAdd;
};
class EditDiveSiteName : public Base {
public:
EditDiveSiteName(dive_site *ds, const QString &name);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
QString value; // Value to be set
};
class EditDiveSiteDescription : public Base {
public:
EditDiveSiteDescription(dive_site *ds, const QString &description);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
QString value; // Value to be set
};
class EditDiveSiteNotes : public Base {
public:
EditDiveSiteNotes(dive_site *ds, const QString &notes);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
QString value; // Value to be set
};
class EditDiveSiteCountry : public Base {
public:
EditDiveSiteCountry(dive_site *ds, const QString &country);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
QString value; // Value to be set
};
class EditDiveSiteLocation : public Base {
public:
EditDiveSiteLocation(dive_site *ds, location_t location);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
location_t value; // Value to be set
};
class EditDiveSiteTaxonomy : public Base {
public:
EditDiveSiteTaxonomy(dive_site *ds, taxonomy_data &taxonomy);
~EditDiveSiteTaxonomy(); // free taxonomy
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
taxonomy_data value; // Value to be set
};
class MergeDiveSites : public Base {
public:
MergeDiveSites(dive_site *ds, const QVector<dive_site *> &sites);
private:
bool workToBeDone() override;
void undo() override;
void redo() override;
dive_site *ds;
// For redo
std::vector<dive_site *> sitesToRemove;
// For undo
std::vector<OwningDiveSitePtr> sitesToAdd;
};
} // namespace Command
#endif // COMMAND_DIVESITE_H

848
desktop-widgets/command_edit.cpp
View file

@ -1,848 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command_edit.h"
#include "command_private.h"
#include "core/divelist.h"
#include "core/qthelper.h" // for copy_qstring
#include "core/subsurface-string.h"
#include "core/tag.h"
namespace Command {
static std::vector<dive *> getDives(bool currentDiveOnly)
{
if (currentDiveOnly)
return current_dive ? std::vector<dive *> { current_dive }
: std::vector<dive *> { };
std::vector<dive *> res;
struct dive *d;
int i;
for_each_dive (i, d) {
if (d->selected)
res.push_back(d);
}
return res;
}
EditDivesBase::EditDivesBase(bool currentDiveOnly) :
dives(getDives(currentDiveOnly)),
selectedDives(getDiveSelection()),
current(current_dive)
{
}
EditDivesBase::EditDivesBase(dive *d) :
dives({ d }),
selectedDives(getDiveSelection()),
current(current_dive)
{
}
int EditDivesBase::numDives() const
{
return dives.size();
}
template<typename T>
EditBase<T>::EditBase(T newValue, bool currentDiveOnly) :
EditDivesBase(currentDiveOnly),
value(std::move(newValue))
{
}
template<typename T>
EditBase<T>::EditBase(T newValue, dive *d) :
EditDivesBase(d),
value(std::move(newValue))
{
}
// This is quite hackish: we can't use virtual functions in the constructor and
// therefore can't initialize the list of dives [the values of the dives are
// accessed by virtual functions]. Therefore, we (mis)use the fact that workToBeDone()
// is called exactly once before adding the Command to the system and perform this here.
// To be more explicit about this, we might think about renaming workToBeDone() to init().
template<typename T>
bool EditBase<T>::workToBeDone()
{
// First, let's fetch the old value, i.e. the value of the current dive.
// If no current dive exists, bail.
if (!current)
return false;
old = data(current);
// If there is no change - do nothing.
if (old == value)
return false;
std::vector<dive *> divesNew;
divesNew.reserve(dives.size());
for (dive *d: dives) {
if (data(d) == old)
divesNew.push_back(d);
}
dives = std::move(divesNew);
// Create a text for the menu entry. In the case of multiple dives add the number
size_t num_dives = dives.size();
if (num_dives > 0)
//: remove the part in parentheses for %n = 1
setText(tr("Edit %1 (%n dive(s))", "", num_dives).arg(fieldName()));
return num_dives > 0;
}
template<typename T>
void EditBase<T>::undo()
{
if (dives.empty()) {
qWarning("Edit command called with empty dives list (shouldn't happen)");
return;
}
for (dive *d: dives) {
set(d, value);
invalidate_dive_cache(d); // Ensure that dive is written in git_save()
}
std::swap(old, value);
// Send signals.
DiveField id = fieldId();
emit diveListNotifier.divesChanged(QVector<dive *>::fromStdVector(dives), id);
setSelection(selectedDives, current);
}
// We have to manually instantiate the constructors of the EditBase class,
// because the base class is never constructed and the derived classes
// don't have their own constructor. They simply delegate to the base
// class by virtue of a "using" declaration.
template
EditBase<QString>::EditBase(QString newValue, bool currentDiveOnly);
template
EditBase<int>::EditBase(int newValue, bool currentDiveOnly);
template
EditBase<struct dive_site *>::EditBase(struct dive_site *newValue, bool currentDiveOnly);
// Undo and redo do the same as just the stored value is exchanged
template<typename T>
void EditBase<T>::redo()
{
// Note: here, we explicitly call the undo function of EditBase<T> and don't do
// virtual dispatch. Thus, derived classes can call this redo function without
// having their own undo() function called.
EditBase<T>::undo();
}
// Implementation of virtual functions
// ***** Notes *****
void EditNotes::set(struct dive *d, QString s) const
{
free(d->notes);
d->notes = strdup(qPrintable(s));
}
QString EditNotes::data(struct dive *d) const
{
return QString(d->notes);
}
QString EditNotes::fieldName() const
{
return tr("notes");
}
DiveField EditNotes::fieldId() const
{
return DiveField::NOTES;
}
// ***** Suit *****
void EditSuit::set(struct dive *d, QString s) const
{
free(d->suit);
d->suit = strdup(qPrintable(s));
}
QString EditSuit::data(struct dive *d) const
{
return QString(d->suit);
}
QString EditSuit::fieldName() const
{
return tr("suit");
}
DiveField EditSuit::fieldId() const
{
return DiveField::SUIT;
}
// ***** Rating *****
void EditRating::set(struct dive *d, int value) const
{
d->rating = value;
}
int EditRating::data(struct dive *d) const
{
return d->rating;
}
QString EditRating::fieldName() const
{
return tr("rating");
}
DiveField EditRating::fieldId() const
{
return DiveField::RATING;
}
// ***** Visibility *****
void EditVisibility::set(struct dive *d, int value) const
{
d->visibility = value;
}
int EditVisibility::data(struct dive *d) const
{
return d->visibility;
}
QString EditVisibility::fieldName() const
{
return tr("visibility");
}
DiveField EditVisibility::fieldId() const
{
return DiveField::VISIBILITY;
}
// ***** Air Temperature *****
void EditAirTemp::set(struct dive *d, int value) const
{
d->airtemp.mkelvin = value > 0 ? (uint32_t)value : 0u;
}
int EditAirTemp::data(struct dive *d) const
{
return (int)d->airtemp.mkelvin;
}
QString EditAirTemp::fieldName() const
{
return tr("air temperature");
}
DiveField EditAirTemp::fieldId() const
{
return DiveField::AIR_TEMP;
}
// ***** Water Temperature *****
void EditWaterTemp::set(struct dive *d, int value) const
{
d->watertemp.mkelvin = value > 0 ? (uint32_t)value : 0u;
// re-populate the temperatures - easiest way to do this is by calling fixup_dive
fixup_dive(d);
}
int EditWaterTemp::data(struct dive *d) const
{
return (int)d->watertemp.mkelvin;
}
QString EditWaterTemp::fieldName() const
{
return tr("water temperature");
}
DiveField EditWaterTemp::fieldId() const
{
return DiveField::WATER_TEMP;
}
// ***** Atmospheric pressure *****
void EditAtmPress::set(struct dive *d, int value) const
{
d->surface_pressure.mbar = value > 0 ? (uint32_t)value : 0u;
}
int EditAtmPress::data(struct dive *d) const
{
return (int)d->surface_pressure.mbar;
}
QString EditAtmPress::fieldName() const
{
return tr("Atm. pressure");
}
DiveField EditAtmPress::fieldId() const
{
return DiveField::ATM_PRESS;
}
// ***** Duration *****
void EditDuration::set(struct dive *d, int value) const
{
d->dc.duration.seconds = value;
d->duration = d->dc.duration;
d->dc.meandepth.mm = 0;
d->dc.samples = 0;
}
int EditDuration::data(struct dive *d) const
{
return d->duration.seconds;
}
QString EditDuration::fieldName() const
{
return tr("duration");
}
DiveField EditDuration::fieldId() const
{
return DiveField::DURATION;
}
// ***** Depth *****
void EditDepth::set(struct dive *d, int value) const
{
d->dc.maxdepth.mm = value;
d->maxdepth = d->dc.maxdepth;
d->dc.meandepth.mm = 0;
d->dc.samples = 0;
}
int EditDepth::data(struct dive *d) const
{
return d->maxdepth.mm;
}
QString EditDepth::fieldName() const
{
return tr("depth");
}
DiveField EditDepth::fieldId() const
{
return DiveField::DEPTH;
}
// ***** DiveSite *****
void EditDiveSite::set(struct dive *d, struct dive_site *dive_site) const
{
unregister_dive_from_dive_site(d);
add_dive_to_dive_site(d, dive_site);
}
struct dive_site *EditDiveSite::data(struct dive *d) const
{
return d->dive_site;
}
QString EditDiveSite::fieldName() const
{
return tr("dive site");
}
DiveField EditDiveSite::fieldId() const
{
return DiveField::DIVESITE;
}
void EditDiveSite::undo()
{
// Do the normal undo thing, then send dive site changed signals
EditBase<dive_site *>::undo();
if (value)
emit diveListNotifier.diveSiteDivesChanged(value);
if (old)
emit diveListNotifier.diveSiteDivesChanged(old);
}
void EditDiveSite::redo()
{
EditDiveSite::undo(); // Undo and redo do the same
}
static struct dive_site *createDiveSite(const QString &name)
{
struct dive_site *ds = alloc_dive_site();
struct dive_site *old = current_dive ? current_dive->dive_site : nullptr;
if (old) {
copy_dive_site(old, ds);
free(ds->name); // Free name, as we will overwrite it with our own version
}
// If the current dive has a location, use that as location for the new dive site
if (current_dive) {
location_t loc = dive_get_gps_location(current_dive);
if (has_location(&loc))
ds->location = loc;
}
ds->name = copy_qstring(name);
return ds;
}
EditDiveSiteNew::EditDiveSiteNew(const QString &newName, bool currentDiveOnly) :
EditDiveSite(createDiveSite(newName), currentDiveOnly),
diveSiteToAdd(value),
diveSiteToRemove(nullptr)
{
}
void EditDiveSiteNew::undo()
{
EditDiveSite::undo();
int idx = unregister_dive_site(diveSiteToRemove);
diveSiteToAdd.reset(diveSiteToRemove);
emit diveListNotifier.diveSiteDeleted(diveSiteToRemove, idx); // Inform frontend of removed dive site.
diveSiteToRemove = nullptr;
}
void EditDiveSiteNew::redo()
{
diveSiteToRemove = diveSiteToAdd.get();
int idx = register_dive_site(diveSiteToAdd.release()); // Return ownership to backend.
emit diveListNotifier.diveSiteAdded(diveSiteToRemove, idx); // Inform frontend of new dive site.
EditDiveSite::redo();
}
// ***** Mode *****
// Editing the dive mode has very peculiar semantics for historic reasons:
// Since the dive-mode depends on the dive computer, the i-th dive computer
// of each dive will be edited. If the dive has less than i dive computers,
// the default dive computer will be edited.
// The index "i" will be stored as an additional payload with the command.
// Thus, we need an explicit constructor. Since the actual handling is done
// by the base class, which knows nothing about this index, it will not be
// sent via signals. Currently this is not needed. Should it turn out to
// become necessary, then we might either
// - Not derive EditMode from EditBase.
// - Change the semantics of the mode-editing.
// The future will tell.
EditMode::EditMode(int indexIn, int newValue, bool currentDiveOnly)
: EditBase(newValue, currentDiveOnly), index(indexIn)
{
}
void EditMode::set(struct dive *d, int i) const
{
get_dive_dc(d, index)->divemode = (enum divemode_t)i;
update_setpoint_events(d, get_dive_dc(d, index));
}
int EditMode::data(struct dive *d) const
{
return get_dive_dc(d, index)->divemode;
}
QString EditMode::fieldName() const
{
return tr("dive mode");
}
DiveField EditMode::fieldId() const
{
return DiveField::MODE;
}
// ***** Number *****
void EditNumber::set(struct dive *d, int number) const
{
d->number = number;
}
int EditNumber::data(struct dive *d) const
{
return d->number;
}
QString EditNumber::fieldName() const
{
return tr("number");
}
DiveField EditNumber::fieldId() const
{
return DiveField::NR;
}
// ***** Tag based commands *****
EditTagsBase::EditTagsBase(const QStringList &newListIn, bool currentDiveOnly) :
EditDivesBase(currentDiveOnly),
newList(newListIn)
{
}
// Two helper functions: returns true if first list contains any tag or
// misses any tag of second list.
static bool containsAny(const QStringList &tags1, const QStringList &tags2)
{
return std::any_of(tags2.begin(), tags2.end(), [&tags1](const QString &tag)
{ return tags1.contains(tag); });
}
static bool missesAny(const QStringList &tags1, const QStringList &tags2)
{
return std::any_of(tags2.begin(), tags2.end(), [&tags1](const QString &tag)
{ return !tags1.contains(tag); });
}
// This is quite hackish: we can't use virtual functions in the constructor and
// therefore can't initialize the list of dives [the values of the dives are
// accessed by virtual functions]. Therefore, we (mis)use the fact that workToBeDone()
// is called exactly once before adding the Command to the system and perform this here.
// To be more explicit about this, we might think about renaming workToBeDone() to init().
bool EditTagsBase::workToBeDone()
{
// changing the tags on multiple dives is semantically strange - what's the right thing to do?
// here's what I think... add the tags that were added to the displayed dive and remove the tags
// that were removed from it
// If there is no current dive, bail.
if (!current)
return false;
// Calculate tags to add and tags to remove
QStringList oldList = data(current);
for (const QString &s: newList) {
if (!oldList.contains(s))
tagsToAdd.push_back(s);
}
for (const QString &s: oldList) {
if (!newList.contains(s))
tagsToRemove.push_back(s);
}
// Now search for all dives that either
// - miss a tag to be added
// - have a tag to be removed
std::vector<dive *> divesNew;
divesNew.reserve(dives.size());
for (dive *d: dives) {
QStringList tags = data(d);
if (missesAny(tags, tagsToAdd) || containsAny(tags, tagsToRemove))
divesNew.push_back(d);
}
dives = std::move(divesNew);
// Create a text for the menu entry. In the case of multiple dives add the number
size_t num_dives = dives.size();
if (num_dives > 0)
//: remove the part in parentheses for %n = 1
setText(tr("Edit %1 (%n dive(s))", "", num_dives).arg(fieldName()));
return num_dives != 0;
}
void EditTagsBase::undo()
{
if (dives.empty()) {
qWarning("Edit command called with empty dives list (shouldn't happen)");
return;
}
for (dive *d: dives) {
QStringList tags = data(d);
for (const QString &tag: tagsToRemove)
tags.removeAll(tag);
for (const QString &tag: tagsToAdd) {
if (!tags.contains(tag))
tags.push_back(tag);
}
invalidate_dive_cache(d); // Ensure that dive is written in git_save()
set(d, tags);
}
std::swap(tagsToAdd, tagsToRemove);
// Send signals.
DiveField id = fieldId();
emit diveListNotifier.divesChanged(QVector<dive *>::fromStdVector(dives), id);
setSelection(selectedDives, current);
}
// Undo and redo do the same as just the stored value is exchanged
void EditTagsBase::redo()
{
undo();
}
// ***** Tags *****
QStringList EditTags::data(struct dive *d) const
{
QStringList res;
for (const struct tag_entry *tag = d->tag_list; tag; tag = tag->next)
res.push_back(tag->tag->name);
return res;
}
void EditTags::set(struct dive *d, const QStringList &v) const
{
taglist_free(d->tag_list);
d->tag_list = NULL;
for (const QString &tag: v)
taglist_add_tag(&d->tag_list, qPrintable(tag));
taglist_cleanup(&d->tag_list);
}
QString EditTags::fieldName() const
{
return tr("tags");
}
DiveField EditTags::fieldId() const
{
return DiveField::TAGS;
}
// String list helper
static QStringList stringToList(const QString &s)
{
QStringList res = s.split(",", QString::SkipEmptyParts);
for (QString &str: res)
str = str.trimmed();
return res;
}
// ***** Buddies *****
QStringList EditBuddies::data(struct dive *d) const
{
return stringToList(d->buddy);
}
void EditBuddies::set(struct dive *d, const QStringList &v) const
{
QString text = v.join(", ");
free(d->buddy);
d->buddy = copy_qstring(text);
}
QString EditBuddies::fieldName() const
{
return tr("buddies");
}
DiveField EditBuddies::fieldId() const
{
return DiveField::BUDDY;
}
// ***** DiveMaster *****
QStringList EditDiveMaster::data(struct dive *d) const
{
return stringToList(d->divemaster);
}
void EditDiveMaster::set(struct dive *d, const QStringList &v) const
{
QString text = v.join(", ");
free(d->divemaster);
d->divemaster = copy_qstring(text);
}
QString EditDiveMaster::fieldName() const
{
return tr("dive master");
}
DiveField EditDiveMaster::fieldId() const
{
return DiveField::DIVEMASTER;
}
static void swapCandQString(QString &q, char *&c)
{
QString tmp(c);
free(c);
c = copy_qstring(q);
q = std::move(tmp);
}
PasteState::PasteState(dive *dIn, const dive *data, dive_components what) : d(dIn),
tags(nullptr)
{
memset(&cylinders, 0, sizeof(cylinders));
memset(&weightsystems, 0, sizeof(weightsystems));
if (what.notes)
notes = data->notes;
if (what.divemaster)
divemaster = data->divemaster;
if (what.buddy)
buddy = data->buddy;
if (what.suit)
suit = data->suit;
if (what.rating)
rating = data->rating;
if (what.visibility)
visibility = data->visibility;
if (what.divesite)
divesite = data->dive_site;
if (what.tags)
tags = taglist_copy(data->tag_list);
if (what.cylinders)
copy_cylinders(&data->cylinders, &cylinders);
if (what.weights)
copy_weights(&data->weightsystems, &weightsystems);
}
PasteState::~PasteState()
{
taglist_free(tags);
clear_cylinder_table(&cylinders);
clear_weightsystem_table(&weightsystems);
free(weightsystems.weightsystems);
}
void PasteState::swap(dive_components what)
{
if (what.notes)
swapCandQString(notes, d->notes);
if (what.divemaster)
swapCandQString(divemaster, d->divemaster);
if (what.buddy)
swapCandQString(buddy, d->buddy);
if (what.suit)
swapCandQString(suit, d->suit);
if (what.rating)
std::swap(rating, d->rating);
if (what.visibility)
std::swap(visibility, d->visibility);
if (what.divesite)
std::swap(divesite, d->dive_site);
if (what.tags)
std::swap(tags, d->tag_list);
if (what.cylinders)
std::swap(cylinders, d->cylinders);
if (what.weights)
std::swap(weightsystems, d->weightsystems);
}
// ***** Paste *****
PasteDives::PasteDives(const dive *data, dive_components whatIn) : what(whatIn),
current(current_dive)
{
std::vector<dive *> selection = getDiveSelection();
dives.reserve(selection.size());
for (dive *d: selection)
dives.emplace_back(d, data, what);
setText(tr("Paste onto %n dive(s)", "", dives.size()));
}
bool PasteDives::workToBeDone()
{
return !dives.empty();
}
void PasteDives::undo()
{
QVector<dive *> divesToNotify; // Remember dives so that we can send signals later
divesToNotify.reserve(dives.size());
for (PasteState &state: dives) {
divesToNotify.push_back(state.d);
state.swap(what);
invalidate_dive_cache(state.d); // Ensure that dive is written in git_save()
}
// Send signals.
DiveField fields(DiveField::NONE);
fields.notes = what.notes;
fields.divemaster = what.divemaster;
fields.buddy = what.buddy;
fields.suit = what.suit;
fields.rating = what.rating;
fields.visibility = what.visibility;
fields.divesite = what.divesite;
fields.tags = what.tags;
emit diveListNotifier.divesChanged(divesToNotify, fields);
if (what.cylinders)
emit diveListNotifier.cylindersReset(divesToNotify);
if (what.weights)
emit diveListNotifier.weightsystemsReset(divesToNotify);
}
// Redo and undo do the same
void PasteDives::redo()
{
undo();
}
// ***** Paste *****
ReplanDive::ReplanDive(dive *source) : d(current_dive),
dc({ 0 }),
notes(nullptr)
{
memset(&cylinders, 0, sizeof(cylinders));
if (!d)
return;
when = source->when;
maxdepth = source->maxdepth;
meandepth = source->meandepth;
notes = copy_string(source->notes);
duration = source->duration;
salinity = source->salinity;
surface_pressure = source->surface_pressure;
// This resets the dive computers and cylinders of the source dive, avoiding deep copies.
std::swap(source->cylinders, cylinders);
std::swap(source->dc, dc);
setText(tr("Replan dive"));
}
ReplanDive::~ReplanDive()
{
clear_cylinder_table(&cylinders);
free_dive_dcs(&dc);
free(notes);
}
bool ReplanDive::workToBeDone()
{
return !!d;
}
void ReplanDive::undo()
{
std::swap(d->when, when);
std::swap(d->maxdepth, maxdepth);
std::swap(d->meandepth, meandepth);
std::swap(d->cylinders, cylinders);
std::swap(d->dc, dc);
std::swap(d->notes, notes);
std::swap(d->surface_pressure, surface_pressure);
std::swap(d->duration, duration);
std::swap(d->salinity, salinity);
fixup_dive(d);
QVector<dive *> divesToNotify = { d };
// Note that we have to emit cylindersReset before divesChanged, because the divesChanged
// updates the DivePlotDataModel, which is out-of-sync and gets confused.
emit diveListNotifier.cylindersReset(divesToNotify);
emit diveListNotifier.divesChanged(divesToNotify, DiveField::DATETIME | DiveField::DURATION | DiveField::DEPTH | DiveField::MODE |
DiveField::NOTES | DiveField::SALINITY | DiveField::ATM_PRESS);
}
// Redo and undo do the same
void ReplanDive::redo()
{
undo();
}
} // namespace Command

292
desktop-widgets/command_edit.h
View file

@ -1,292 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_EDIT_H
#define COMMAND_EDIT_H
#include "command_base.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include <QVector>
// These are commands that edit individual fields of a set of dives.
// The implementation is very OO-style. Out-of-fashion and certainly
// not elegant, but in line with Qt's OO-based design.
// The actual code is in a common base class "Command::EditBase". To
// read and set the fields, the base class calls virtual functions of
// the derived classes.
//
// To deal with different data types, the base class is implemented
// as a template. The template parameter is the type to be read or
// set. Thus, switch-cascades and union trickery can be avoided.
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
// Base class for commands that have a list of dives.
// This is used for extracting the number of dives and show a
// warning message when multiple dives are edited.
class EditDivesBase : public Base {
protected:
EditDivesBase(bool currentDiveOnly);
EditDivesBase(dive *d);
std::vector<dive *> dives; // Dives to be edited.
// On undo, we set the selection and current dive at the time of the operation.
std::vector<dive *> selectedDives;
struct dive *current;
public:
int numDives() const;
};
template <typename T>
class EditBase : public EditDivesBase {
protected:
T value; // Value to be set
T old; // Previous value
void undo() override;
void redo() override;
bool workToBeDone() override;
public:
EditBase(T newValue, bool currentDiveOnly);
EditBase(T newValue, dive *d);
protected:
// Get and set functions to be overriden by sub-classes.
virtual void set(struct dive *d, T) const = 0;
virtual T data(struct dive *d) const = 0;
virtual QString fieldName() const = 0; // Name of the field, used to create the undo menu-entry
virtual DiveField fieldId() const = 0;
};
class EditNotes : public EditBase<QString> {
public:
using EditBase<QString>::EditBase; // Use constructor of base class.
void set(struct dive *d, QString s) const override;
QString data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditSuit : public EditBase<QString> {
public:
using EditBase<QString>::EditBase; // Use constructor of base class.
void set(struct dive *d, QString s) const override;
QString data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditRating : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditVisibility : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditAirTemp : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditWaterTemp : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditAtmPress : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditDuration : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditDepth : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int value) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditDiveSite : public EditBase<struct dive_site *> {
public:
using EditBase<struct dive_site *>::EditBase; // Use constructor of base class.
void set(struct dive *d, struct dive_site *value) const override;
struct dive_site *data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
// We specialize these so that we can send dive-site changed signals.
void undo() override;
void redo() override;
};
// Edit dive site, but add a new dive site first. Reuses the code of EditDiveSite by
// deriving from it and hooks into undo() and redo() to add / remove the dive site.
class EditDiveSiteNew : public EditDiveSite {
public:
OwningDiveSitePtr diveSiteToAdd;
struct dive_site *diveSiteToRemove;
EditDiveSiteNew(const QString &newName, bool currentDiveOnly);
void undo() override;
void redo() override;
};
class EditMode : public EditBase<int> {
int index;
public:
EditMode(int indexIn, int newValue, bool currentDiveOnly);
void set(struct dive *d, int i) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditNumber : public EditBase<int> {
public:
using EditBase<int>::EditBase; // Use constructor of base class.
void set(struct dive *d, int number) const override;
int data(struct dive *d) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
// Fields that work with tag-lists (tags, buddies, divemasters) work differently and therefore
// have their own base class. In this case, it's not a template, as all these lists are base
// on strings.
class EditTagsBase : public EditDivesBase {
bool workToBeDone() override;
QStringList newList; // Temporary until initialized
public:
EditTagsBase(const QStringList &newList, bool currentDiveOnly);
protected:
QStringList tagsToAdd;
QStringList tagsToRemove;
void undo() override;
void redo() override;
// Getters, setters and parsers to be overriden by sub-classes.
virtual QStringList data(struct dive *d) const = 0;
virtual void set(struct dive *d, const QStringList &v) const = 0;
virtual QString fieldName() const = 0; // Name of the field, used to create the undo menu-entry
virtual DiveField fieldId() const = 0;
};
class EditTags : public EditTagsBase {
public:
using EditTagsBase::EditTagsBase; // Use constructor of base class.
QStringList data(struct dive *d) const override;
void set(struct dive *d, const QStringList &v) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditBuddies : public EditTagsBase {
public:
using EditTagsBase::EditTagsBase; // Use constructor of base class.
QStringList data(struct dive *d) const override;
void set(struct dive *d, const QStringList &v) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
class EditDiveMaster : public EditTagsBase {
public:
using EditTagsBase::EditTagsBase; // Use constructor of base class.
QStringList data(struct dive *d) const override;
void set(struct dive *d, const QStringList &v) const override;
QString fieldName() const override;
DiveField fieldId() const override;
};
// Fields we have to remember to undo paste
struct PasteState {
dive *d;
dive_site *divesite;
QString notes;
QString divemaster;
QString buddy;
QString suit;
int rating;
int visibility;
tag_entry *tags;
struct cylinder_table cylinders;
struct weightsystem_table weightsystems;
PasteState(dive *d, const dive *data, dive_components what); // Read data from dive data for dive d
~PasteState();
void swap(dive_components what); // Exchange values here and in dive
};
class PasteDives : public Base {
dive_components what;
std::vector<PasteState> dives;
dive *current;
public:
PasteDives(const dive *d, dive_components what);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
};
class ReplanDive : public Base {
dive *d;
// Exchange these data with current dive
timestamp_t when;
depth_t maxdepth, meandepth;
struct cylinder_table cylinders;
struct divecomputer dc;
char *notes;
pressure_t surface_pressure;
duration_t duration;
int salinity;
public:
ReplanDive(dive *source); // Dive computer(s) and cylinders(s) of the source dive will be reset!
~ReplanDive();
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
};
} // namespace Command
#endif

83
desktop-widgets/command_edit_trip.cpp
View file

@ -1,83 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
#include "command_edit_trip.h"
#include "command_private.h"
#include "core/qthelper.h"
namespace Command {
EditTripBase::EditTripBase(dive_trip *tripIn, const QString &newValue) : trip(tripIn),
value(newValue)
{
}
// Note: Virtual functions cannot be called in the constructor.
// Therefore, setting of the title is done here.
bool EditTripBase::workToBeDone()
{
setText(tr("Edit %1").arg(fieldName()));
return data(trip) != value;
}
void EditTripBase::undo()
{
QString old = data(trip);
set(trip, value);
value = old;
emit diveListNotifier.tripChanged(trip, fieldId());
}
// Undo and redo do the same as just the stored value is exchanged
void EditTripBase::redo()
{
undo();
}
// Implementation of virtual functions
// ***** Location *****
void EditTripLocation::set(dive_trip *t, const QString &s) const
{
free(t->location);
t->location = copy_qstring(s);
}
QString EditTripLocation::data(dive_trip *t) const
{
return QString(t->location);
}
QString EditTripLocation::fieldName() const
{
return tr("trip location");
}
TripField EditTripLocation::fieldId() const
{
return TripField::LOCATION;
}
// ***** Notes *****
void EditTripNotes::set(dive_trip *t, const QString &s) const
{
free(t->notes);
t->notes = copy_qstring(s);
}
QString EditTripNotes::data(dive_trip *t) const
{
return QString(t->notes);
}
QString EditTripNotes::fieldName() const
{
return tr("trip notes");
}
TripField EditTripNotes::fieldId() const
{
return TripField::NOTES;
}
} // namespace Command

58
desktop-widgets/command_edit_trip.h
View file

@ -1,58 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_EDIT_TRIP_H
#define COMMAND_EDIT_TRIP_H
#include "command_base.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include <QVector>
// These are commands that edit individual fields of a a trip.
// The implementation follows the (rather verbose) OO-style of the dive-edit commands.
// But here, no template is used as the two fields are both of string type.
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
class EditTripBase : public Base {
bool workToBeDone() override;
dive_trip *trip; // Trip to be edited.
public:
EditTripBase(dive_trip *trip, const QString &newValue);
protected:
QString value; // Value to be set
void undo() override;
void redo() override;
// Get and set functions to be overriden by sub-classes.
virtual void set(struct dive_trip *t, const QString &) const = 0;
virtual QString data(struct dive_trip *t) const = 0;
virtual QString fieldName() const = 0; // Name of the field, used to create the undo menu-entry
virtual TripField fieldId() const = 0;
};
class EditTripLocation : public EditTripBase {
public:
using EditTripBase::EditTripBase; // Use constructor of base class.
void set(dive_trip *t, const QString &s) const override;
QString data(dive_trip *t) const override;
QString fieldName() const override;
TripField fieldId() const override;
};
class EditTripNotes : public EditTripBase {
public:
using EditTripBase::EditTripBase; // Use constructor of base class.
void set(dive_trip *t, const QString &s) const override;
QString data(dive_trip *t) const override;
QString fieldName() const override;
TripField fieldId() const override;
};
} // namespace Command
#endif

108
desktop-widgets/command_private.cpp
View file

@ -1,108 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Helper functions for the undo-commands
#include "command_private.h"
#include "core/divelist.h"
#include "core/display.h" // for amount_selected
#include "core/subsurface-qt/DiveListNotifier.h"
namespace Command {
// Set the current dive either from a list of selected dives,
// or a newly selected dive. In both cases, try to select the
// dive that is newer that is newer than the given date.
// This mimics the old behavior when the current dive changed.
static void setClosestCurrentDive(timestamp_t when, const std::vector<dive *> &selection)
{
// Start from back until we get the first dive that is before
// the supposed-to-be selected dive. (Note: this mimics the
// old behavior when the current dive changed).
for (auto it = selection.rbegin(); it < selection.rend(); ++it) {
if ((*it)->when > when && !(*it)->hidden_by_filter) {
current_dive = *it;
return;
}
}
// We didn't find a more recent selected dive -> try to
// find *any* visible selected dive.
for (dive *d: selection) {
if (!d->hidden_by_filter) {
current_dive = d;
return;
}
}
// No selected dive is visible! Take the closest dive. Note, this might
// return null, but that just means unsetting the current dive (as no
// dive is visible anyway).
current_dive = find_next_visible_dive(when);
}
// Reset the selection to the dives of the "selection" vector and send the appropriate signals.
// Set the current dive to "currentDive". "currentDive" must be an element of "selection" (or
// null if "seletion" is empty). Return true if the selection or current dive changed.
void setSelection(const std::vector<dive *> &selection, dive *currentDive)
{
// To do so, generate vectors of dives to be selected and deselected.
// We send signals batched by trip, so keep track of trip/dive pairs.
QVector<dive *> divesToSelect;
divesToSelect.reserve(selection.size());
// TODO: We might want to keep track of selected dives in a more efficient way!
int i;
dive *d;
amount_selected = 0; // We recalculate amount_selected
for_each_dive(i, d) {
// We only modify dives that are currently visible.
if (d->hidden_by_filter) {
d->selected = false; // Note, not necessary, just to be sure
// that we get amount_selected right
continue;
}
// Search the dive in the list of selected dives.
// TODO: By sorting the list in the same way as the backend, this could be made more efficient.
bool newState = std::find(selection.begin(), selection.end(), d) != selection.end();
if (newState) {
++amount_selected;
divesToSelect.push_back(d);
}
// TODO: Instead of using select_dive() and deselect_dive(), we set selected directly.
// The reason is that deselect() automatically sets a new current dive, which we
// don't want, as we set it later anyway.
// There is other parts of the C++ code that touches the innards directly, but
// ultimately this should be pushed down to C.
d->selected = newState;
}
// We cannot simply change the current dive to the given dive.
// It might be hidden by a filter and thus not be selected.
current_dive = currentDive;
if (current_dive && !currentDive->selected) {
// Current not visible -> find a different dive.
setClosestCurrentDive(currentDive->when, selection);
}
// Send the new selection
emit diveListNotifier.divesSelected(divesToSelect, current_dive);
}
// Turn current selection into a vector.
// TODO: This could be made much more efficient if we kept a sorted list of selected dives!
std::vector<dive *> getDiveSelection()
{
std::vector<dive *> res;
res.reserve(amount_selected);
int i;
dive *d;
for_each_dive(i, d) {
if (d->selected)
res.push_back(d);
}
return res;
}
} // namespace Command

25
desktop-widgets/command_private.h
View file

@ -1,25 +0,0 @@
// SPDX-License-Identifier: GPL-2.0
// Private definitions for the command-objects
#ifndef COMMAND_PRIVATE_H
#define COMMAND_PRIVATE_H
#include "core/dive.h"
#include <vector>
#include <utility>
#include <QVector>
namespace Command {
// Reset the selection to the dives of the "selection" vector and send the appropriate signals.
// Set the current dive to "currentDive". "currentDive" must be an element of "selection" (or
// null if "seletion" is empty). Return true if the selection or current dive changed.
void setSelection(const std::vector<dive *> &selection, dive *currentDive);
// Get currently selectd dives
std::vector<dive *> getDiveSelection();
} // namespace Command
#endif // COMMAND_PRIVATE_H

2
desktop-widgets/divelistview.cpp
View file

@ -19,10 +19,10 @@
#include <QStandardPaths>
#include <QMessageBox>
#include <QHeaderView>
#include "commands/command.h"
#include "core/errorhelper.h"
#include "core/qthelper.h"
#include "core/trip.h"
#include "desktop-widgets/command.h"
#include "desktop-widgets/divelistview.h"
#include "qt-models/divepicturemodel.h"
#include "core/metrics.h"

2
desktop-widgets/divelogimportdialog.cpp
View file

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
#include "desktop-widgets/divelogimportdialog.h"
#include "desktop-widgets/mainwindow.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include "core/color.h"
#include "ui_divelogimportdialog.h"
#include <QShortcut>

2
desktop-widgets/divesiteimportdialog.cpp
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0
#include "desktop-widgets/divesiteimportdialog.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include "core/display.h"
#include "core/qthelper.h"
#include "core/metrics.h"

2
desktop-widgets/downloadfromdivecomputer.cpp
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0
#include "desktop-widgets/downloadfromdivecomputer.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include "core/display.h"
#include "core/qthelper.h"
#include "core/divelist.h"

2
desktop-widgets/locationinformation.cpp
View file

@ -9,9 +9,9 @@
#include "core/divesitehelpers.h"
#include "desktop-widgets/modeldelegates.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include "command.h"
#include "core/taxonomy.h"
#include "core/settings/qPrefUnit.h"
#include "commands/command.h"
#include <QDebug>
#include <QShowEvent>

2
desktop-widgets/mainwindow.cpp
View file

@ -41,7 +41,6 @@
#include "core/subsurface-qt/DiveListNotifier.h"
#include "desktop-widgets/about.h"
#include "desktop-widgets/command.h"
#include "desktop-widgets/divecomputermanagementdialog.h"
#include "desktop-widgets/divelistview.h"
#include "desktop-widgets/divelogexportdialog.h"
@ -57,6 +56,7 @@
#include "desktop-widgets/updatemanager.h"
#include "desktop-widgets/usersurvey.h"
#include "desktop-widgets/simplewidgets.h"
#include "commands/command.h"
#include "profile-widget/profilewidget2.h"

2
desktop-widgets/mapwidget.cpp
View file

@ -11,7 +11,7 @@
#include "qt-models/divelocationmodel.h"
#include "mainwindow.h"
#include "divelistview.h"
#include "command.h"
#include "commands/command.h"
static const QUrl urlMapWidget = QUrl(QStringLiteral("qrc:/qml/MapWidget.qml"));
static const QUrl urlMapWidgetError = QUrl(QStringLiteral("qrc:/qml/MapWidgetError.qml"));

2
desktop-widgets/simplewidgets.cpp
View file

@ -20,7 +20,7 @@
#include "desktop-widgets/divelistview.h"
#include "core/display.h"
#include "profile-widget/profilewidget2.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include "core/metadata.h"
#include "core/tag.h"
#include "core/divelist.h" // for mark_divelist_changed

2
desktop-widgets/subsurfacewebservices.cpp
View file

@ -4,8 +4,8 @@
#include "core/webservice.h"
#include "core/settings/qPrefCloudStorage.h"
#include "desktop-widgets/mainwindow.h"
#include "desktop-widgets/command.h"
#include "desktop-widgets/usersurvey.h"
#include "commands/command.h"
#include "core/trip.h"
#include "core/errorhelper.h"
#include "core/file.h"

2
desktop-widgets/tab-widgets/TabDiveEquipment.cpp
View file

@ -4,7 +4,7 @@
#include "desktop-widgets/mainwindow.h" // TODO: Only used temporarilly for edit mode changes
#include "desktop-widgets/simplewidgets.h" // For isGnome3Session()
#include "desktop-widgets/modeldelegates.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include "profile-widget/profilewidget2.h"
#include "qt-models/cylindermodel.h"

2
desktop-widgets/tab-widgets/TabDiveInformation.cpp
View file

@ -4,9 +4,9 @@
#include "desktop-widgets/mainwindow.h" // TODO: Only used temporarilly for edit mode changes
#include "profile-widget/profilewidget2.h"
#include "../tagwidget.h"
#include "commands/command.h"
#include "core/units.h"
#include "core/dive.h"
#include "desktop-widgets/command.h"
#include "core/qthelper.h"
#include "core/statistics.h"
#include "core/display.h"

2
desktop-widgets/tab-widgets/TabDiveSite.cpp
View file

@ -4,7 +4,7 @@
#include "core/divesite.h"
#include "qt-models/divelocationmodel.h"
#include "qt-models/filtermodels.h"
#include "desktop-widgets/command.h"
#include "commands/command.h"
#include <qt-models/divecomputerextradatamodel.h>

2
desktop-widgets/tab-widgets/maintab.cpp
View file

@ -24,8 +24,8 @@
#include "core/subsurface-string.h"
#include "core/gettextfromc.h"
#include "desktop-widgets/locationinformation.h"
#include "desktop-widgets/command.h"
#include "desktop-widgets/simplewidgets.h"
#include "commands/command.h"
#include "TabDiveEquipment.h"
#include "TabDiveExtraInfo.h"