Refactoring: move undo commands to top level

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>

28 files changed, 13 insertions, 3868 deletions

diff --git a/desktop-widgets/CMakeLists.txt b/desktop-widgets/CMakeLists.txt
index 53aef5dbf..d798f8341 100644
--- a/desktop-widgets/CMakeLists.txt
+++ b/desktop-widgets/CMakeLists.txt
@@ -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
diff --git a/desktop-widgets/command.cpp b/desktop-widgets/command.cpp
deleted file mode 100644
index 4257324ec..000000000
--- a/desktop-widgets/command.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command.h b/desktop-widgets/command.h
deleted file mode 100644
index 8fbed5069..000000000
--- a/desktop-widgets/command.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_base.cpp b/desktop-widgets/command_base.cpp
deleted file mode 100644
index bef9da09c..000000000
--- a/desktop-widgets/command_base.cpp
+++ /dev/null
@@ -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
-
-
diff --git a/desktop-widgets/command_base.h b/desktop-widgets/command_base.h
deleted file mode 100644
index 9a2f6cf34..000000000
--- a/desktop-widgets/command_base.h
+++ /dev/null
@@ -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
-
diff --git a/desktop-widgets/command_divelist.cpp b/desktop-widgets/command_divelist.cpp
deleted file mode 100644
index 4b4ef4ab8..000000000
--- a/desktop-widgets/command_divelist.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_divelist.h b/desktop-widgets/command_divelist.h
deleted file mode 100644
index 20d031f54..000000000
--- a/desktop-widgets/command_divelist.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_divesite.cpp b/desktop-widgets/command_divesite.cpp
deleted file mode 100644
index b5fb46f91..000000000
--- a/desktop-widgets/command_divesite.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_divesite.h b/desktop-widgets/command_divesite.h
deleted file mode 100644
index 3fcf085ae..000000000
--- a/desktop-widgets/command_divesite.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_edit.cpp b/desktop-widgets/command_edit.cpp
deleted file mode 100644
index 638bfb792..000000000
--- a/desktop-widgets/command_edit.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_edit.h b/desktop-widgets/command_edit.h
deleted file mode 100644
index 8532523e2..000000000
--- a/desktop-widgets/command_edit.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_edit_trip.cpp b/desktop-widgets/command_edit_trip.cpp
deleted file mode 100644
index b25e3fcc5..000000000
--- a/desktop-widgets/command_edit_trip.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_edit_trip.h b/desktop-widgets/command_edit_trip.h
deleted file mode 100644
index ae41ca252..000000000
--- a/desktop-widgets/command_edit_trip.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_private.cpp b/desktop-widgets/command_private.cpp
deleted file mode 100644
index 714ffd9b6..000000000
--- a/desktop-widgets/command_private.cpp
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/command_private.h b/desktop-widgets/command_private.h
deleted file mode 100644
index 280654a93..000000000
--- a/desktop-widgets/command_private.h
+++ /dev/null
@@ -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
diff --git a/desktop-widgets/divelistview.cpp b/desktop-widgets/divelistview.cpp
index c012b9832..aa2195434 100644
--- a/desktop-widgets/divelistview.cpp
+++ b/desktop-widgets/divelistview.cpp
@@ -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"
diff --git a/desktop-widgets/divelogimportdialog.cpp b/desktop-widgets/divelogimportdialog.cpp
index 0f08b1ec5..1d6557697 100644
--- a/desktop-widgets/divelogimportdialog.cpp
+++ b/desktop-widgets/divelogimportdialog.cpp
@@ -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>
diff --git a/desktop-widgets/divesiteimportdialog.cpp b/desktop-widgets/divesiteimportdialog.cpp
index ad45d97a5..defb90617 100644
--- a/desktop-widgets/divesiteimportdialog.cpp
+++ b/desktop-widgets/divesiteimportdialog.cpp
@@ -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"
diff --git a/desktop-widgets/downloadfromdivecomputer.cpp b/desktop-widgets/downloadfromdivecomputer.cpp
index 484d15f83..a14a8a665 100644
--- a/desktop-widgets/downloadfromdivecomputer.cpp
+++ b/desktop-widgets/downloadfromdivecomputer.cpp
@@ -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"
diff --git a/desktop-widgets/locationinformation.cpp b/desktop-widgets/locationinformation.cpp
index b9146a178..bbf43ec5a 100644
--- a/desktop-widgets/locationinformation.cpp
+++ b/desktop-widgets/locationinformation.cpp
@@ -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>
diff --git a/desktop-widgets/mainwindow.cpp b/desktop-widgets/mainwindow.cpp
index bed142ecc..47306bad9 100644
--- a/desktop-widgets/mainwindow.cpp
+++ b/desktop-widgets/mainwindow.cpp
@@ -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"
 
diff --git a/desktop-widgets/mapwidget.cpp b/desktop-widgets/mapwidget.cpp
index f8f9b0b7b..07d440530 100644
--- a/desktop-widgets/mapwidget.cpp
+++ b/desktop-widgets/mapwidget.cpp
@@ -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"));
diff --git a/desktop-widgets/simplewidgets.cpp b/desktop-widgets/simplewidgets.cpp
index 5edc66e80..1c1cb953c 100644
--- a/desktop-widgets/simplewidgets.cpp
+++ b/desktop-widgets/simplewidgets.cpp
@@ -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
diff --git a/desktop-widgets/subsurfacewebservices.cpp b/desktop-widgets/subsurfacewebservices.cpp
index 57f3c2876..f9e359226 100644
--- a/desktop-widgets/subsurfacewebservices.cpp
+++ b/desktop-widgets/subsurfacewebservices.cpp
@@ -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"
diff --git a/desktop-widgets/tab-widgets/TabDiveEquipment.cpp b/desktop-widgets/tab-widgets/TabDiveEquipment.cpp
index 6f43fc5a2..f7e2d2667 100644
--- a/desktop-widgets/tab-widgets/TabDiveEquipment.cpp
+++ b/desktop-widgets/tab-widgets/TabDiveEquipment.cpp
@@ -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"
diff --git a/desktop-widgets/tab-widgets/TabDiveInformation.cpp b/desktop-widgets/tab-widgets/TabDiveInformation.cpp
index d4c5ae1a6..071551584 100644
--- a/desktop-widgets/tab-widgets/TabDiveInformation.cpp
+++ b/desktop-widgets/tab-widgets/TabDiveInformation.cpp
@@ -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"
diff --git a/desktop-widgets/tab-widgets/TabDiveSite.cpp b/desktop-widgets/tab-widgets/TabDiveSite.cpp
index e9eee0a88..d5591c152 100644
--- a/desktop-widgets/tab-widgets/TabDiveSite.cpp
+++ b/desktop-widgets/tab-widgets/TabDiveSite.cpp
@@ -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>
 
diff --git a/desktop-widgets/tab-widgets/maintab.cpp b/desktop-widgets/tab-widgets/maintab.cpp
index 417f9f91e..ec3957f47 100644
--- a/desktop-widgets/tab-widgets/maintab.cpp
+++ b/desktop-widgets/tab-widgets/maintab.cpp
@@ -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"