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>

15 files changed, 3867 insertions, 0 deletions

diff --git a/commands/CMakeLists.txt b/commands/CMakeLists.txt
new file mode 100644
index 000000000..76ad42603
--- /dev/null
+++ b/commands/CMakeLists.txt
@@ -0,0 +1,26 @@
+# the undo-commands that perform undoable actions.
+
+# models used both mobile and desktop builds
+set(SUBSURFACE_GENERIC_COMMANDS_SRCS
+	command_base.cpp
+	command_base.h
+	command.cpp
+	command.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
+)
+if (SUBSURFACE_TARGET_EXECUTABLE MATCHES "DesktopExecutable")
+	add_library(subsurface_commands_desktop STATIC ${SUBSURFACE_GENERIC_COMMANDS_SRCS})
+	target_link_libraries(subsurface_commands_desktop ${QT_LIBRARIES})
+#elseif (SUBSURFACE_TARGET_EXECUTABLE MATCHES "MobileExecutable")
+#	add_library(subsurface_commands_mobile STATIC ${SUBSURFACE_GENERIC_COMMANDS_SRCS})
+#	target_link_libraries(subsurface_commands_mobile ${QT_LIBRARIES})
+endif()
diff --git a/commands/command.cpp b/commands/command.cpp
new file mode 100644
index 000000000..4257324ec
--- /dev/null
+++ b/commands/command.cpp
@@ -0,0 +1,257 @@
+// 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/commands/command.h b/commands/command.h
new file mode 100644
index 000000000..8fbed5069
--- /dev/null
+++ b/commands/command.h
@@ -0,0 +1,87 @@
+// 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/commands/command_base.cpp b/commands/command_base.cpp
new file mode 100644
index 000000000..bef9da09c
--- /dev/null
+++ b/commands/command_base.cpp
@@ -0,0 +1,56 @@
+// 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/commands/command_base.h b/commands/command_base.h
new file mode 100644
index 000000000..9a2f6cf34
--- /dev/null
+++ b/commands/command_base.h
@@ -0,0 +1,178 @@
+// 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/commands/command_divelist.cpp b/commands/command_divelist.cpp
new file mode 100644
index 000000000..4b4ef4ab8
--- /dev/null
+++ b/commands/command_divelist.cpp
@@ -0,0 +1,999 @@
+// 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/commands/command_divelist.h b/commands/command_divelist.h
new file mode 100644
index 000000000..20d031f54
--- /dev/null
+++ b/commands/command_divelist.h
@@ -0,0 +1,285 @@
+// 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/commands/command_divesite.cpp b/commands/command_divesite.cpp
new file mode 100644
index 000000000..b5fb46f91
--- /dev/null
+++ b/commands/command_divesite.cpp
@@ -0,0 +1,395 @@
+// 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/commands/command_divesite.h b/commands/command_divesite.h
new file mode 100644
index 000000000..3fcf085ae
--- /dev/null
+++ b/commands/command_divesite.h
@@ -0,0 +1,170 @@
+// 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/commands/command_edit.cpp b/commands/command_edit.cpp
new file mode 100644
index 000000000..638bfb792
--- /dev/null
+++ b/commands/command_edit.cpp
@@ -0,0 +1,848 @@
+// 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/commands/command_edit.h b/commands/command_edit.h
new file mode 100644
index 000000000..8532523e2
--- /dev/null
+++ b/commands/command_edit.h
@@ -0,0 +1,292 @@
+// 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/commands/command_edit_trip.cpp b/commands/command_edit_trip.cpp
new file mode 100644
index 000000000..b25e3fcc5
--- /dev/null
+++ b/commands/command_edit_trip.cpp
@@ -0,0 +1,83 @@
+// 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/commands/command_edit_trip.h b/commands/command_edit_trip.h
new file mode 100644
index 000000000..ae41ca252
--- /dev/null
+++ b/commands/command_edit_trip.h
@@ -0,0 +1,58 @@
+// 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/commands/command_private.cpp b/commands/command_private.cpp
new file mode 100644
index 000000000..714ffd9b6
--- /dev/null
+++ b/commands/command_private.cpp
@@ -0,0 +1,108 @@
+// 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/commands/command_private.h b/commands/command_private.h
new file mode 100644
index 000000000..280654a93
--- /dev/null
+++ b/commands/command_private.h
@@ -0,0 +1,25 @@
+// 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